C#一些基础知识

• 1. break、continue、goto：跳出循环
• 2. 函数
  • 2.1. 1、函数声明
  • 2.2. 2、函数调用
• 3. C#封装
  • 3.1. C#中访问权限修饰符：
• 4. C#继承
  • 4.1. 1、基类和派生类（父类和子类）
• 5. C#多态
• 6. 结构体和类
  • 6.1. 类/结构体
• 7. 枚举（enum）
• 8. 构造函数
• 9. C#反射（Reflection）
• 10. C#特性
• 11. ref out in
  • 11.1. ref、out、in的共同点：
  • 11.2. ref、out、in的不同点是：

1. break、continue、goto：跳出循环

break:如果是在嵌套循环中使用，例如在内层的循环中使用 break 语句，那么程序只会跳出内层的循环，并不会影响到外层循环的执行。
continue C# 中 continue 语句的工作原理与 break 语句类似，但是 continue 语句并不会跳出整个循环，而是跳过本次循环继续执行下一次的循环。
**注意:**break和continue都只会跳出当前这层循环不能越级跳出。

---

2. 函数

2.1. 1、函数声明

访问权限修饰符 返回值类型 函数名称(){
    函数主体(函数实现具体功能部分)
    返回语句(注意返回值类型)
}

2.2. 2、函数调用

    对象.函数名()

• 函数在定义时参数列表中定义了若干参数，那么在调用时也应该在函数名后面的括号中填入相应数量的参数，并且与参数列表中的参数类型一一对应；(函数有几个参数都要一一对应)
• 若函数在定义时没有定义参数列表，那么在调用函数时也不需要在函数名后面填入参数；(没有参数就不用参数了)
• 对于有返回值的函数，在调用函数时可以使用一个变量（可选）来接收函数的返回值，变量的类型要与函数返回值的类型相同。(有返回值，可以拿一个变量存储)

---

3. C#封装

C#是一门面向对象的语言，面向对象编程语言的三大特性"封装、继承、多态"
封装\： 就是将一个或者多个函数(方法)集合在一个单元中(类)，我们可以通过权限修饰符来规范类的成员的可见性。

3.1. C#中访问权限修饰符：

• public（公共类）：我们可以从类的外部访问类中的公共成员（使用 public 修饰的类成员）。
• private （私有类）：只有在同一个类的函数才能访问到这个类。
• protected （保护类）：只有当前类的子类和自己可以访问，也就是说基类(父类)中使用protected修饰的方法，只有他自己和继承于基类(他的子类)才可以使用。
• internal（内部类）：使用internal修饰的成员，可以被同一命名空间下的任何类访问。

---

4. C#继承

在创建一个新类时，我们可以使用这个新定义的类继承一个已有的类，通过继承可以在创建新类时重用、扩展和修改被继承类中定义的成员。被继承的类称为“基类（父类）”，继承基类的类称为“派生类（子类）”。
C# 中只支持单继承，

4.1. 1、基类和派生类（父类和子类）

    class 父类 : 子类{
    ... ...
}

C#不能多继承，所以用接口来实现多重继承

 // 基类
    class Shape{
        protected int width, height;
        public void setWidth(int w){
            width = w;
        }
        public void setHeight(int h){
            height = h;
        }
    }
    // 定义接口
    public interface Perimeter{
        int getGirth();
    }
    // 派生类
    class Rectangle : Shape, Perimeter{
        public int getArea(){
            return width*height;
        }
        public int getGirth(){
            return (width+height)*2;
        }
    }

---

5. C#多态

C#中具有两种多态
1、编译时的多态：通过方法重载和运算符来实现编译时多态。

class Demo
{
    void print(int i){
        Console.WriteLine("打印 int 类型的数据：{0}", i);
    }
    void print(double d){
        Console.WriteLine("打印 double 类型的数据：{0}", d);
    }
    void print(string s){
        Console.WriteLine("打印 string 类型的数据：{0}", s);
    }
}

2、运行时多态：通过方法重载实现的运行时多态，也称为动态绑定或后期绑定。

• C# 允许您使用 abstract 关键字来创建抽象类，抽象类用于实现部分接口。另外，抽象类包含抽象方法，可以在派生类中实现。（看代码吧）
  一些有关抽象类的规则：
• 不能创建一个抽象类的实例；
• 不能在一个抽象类外部声明抽象方法；
• 通过在类定义时使用 sealed 关键字，可以将类声明为密封类，密封类不能被继承，因此抽象类中不能声明密封类。(密封（sealed）不能继承，抽象又需要继承所以不能用)

    //抽象类
    abstract class Shape{
        public abstract int area();
    }
    //继承了抽象类
    class Rectangle : Shape{
        private int width, height;
        public Rectangle(int w, int h){
            width = w;
            height = h;
        }
        //重写抽象类方法
        public override int area(){
            return (width * height);
        }
    }

总结：就只要看到两个或者多个同名的函数(方法)就行

6. 结构体和类

在 C# 中，结构体也被称为结构类型（“structure type”或“struct type”），它是一种可封装数据和相关功能的值类型，在语法上结构体与类（class）非常相似，它们都可以用来封装数据，并且都可以包含成员属性和成员方法。
声明一个Book的结构体：

struct Books {
    public string title;
    public string author;
    public string subject;
    public int book_id;
};

• 结构体中可以具有方法、字段、索引、属性、运算符方法和事件；
• 结构可定义构造函数，但不能定义析构函数。但是，您不能为结构定义无参构造函数。
• 结构体不能继承与其他结构体
• 结构可实现一个或多个接口。
• 结构成员不能指定为 abstract、virtual 或 protected。(这三个都需要子类，和结构体不能继承像悖)
• 结构体不能被New实例化
• 只要在所有字段被赋值后才能使用（类在new之后可以选择赋值，结构体需要所有赋值才能使用）

6.1. 类/结构体

• 类是引用类型，结构是值类型。
• 结构不支持继承。
• 结构不能声明默认的构造函数。

struct Books
{
   private string title;
   private string author;
   private string subject;
   private int book_id;
   //如果函数名为Books会报错，结构不能声明默认的构造函数。
   public void SetValues(string t, string a, string s, int id)
   {
      title = t;
      author = a;
      subject = s;
      book_id =id;
   }
   public void display()
   {
      Console.WriteLine("Title : {0}", title);
      Console.WriteLine("Author : {0}", author);
      Console.WriteLine("Subject : {0}", subject);
      Console.WriteLine("Book_id :{0}", book_id);
   }

};  

---

7. 枚举（enum）

http://c.biancheng.net/csharp/enum.html
很简单了解一下就行

---

8. 构造函数

在 C# 中，构造函数就是与类（或结构体）具有相同名称的成员函数，它在类中的地位比较特殊，不需要我们主动调用，当创建一个类的对象时会自动调用类中的构造函数。
通常用来初始化类中的属性

    public class Person{
    private string name;
    private int age;
    public Person(string n, int a)//同名
    {
        name = n;
        age = a;
    }
}

---

9. C#反射（Reflection）

文章教程
bilibili
比较抽象慢慢来

---

10. C#特性

文章教程
搭配反射一起折磨

---

11. ref out in

在方法进行参数传递时，我们可以使用ref、out、in关键字对参数进行修饰。当参数使用ref、out、in修饰后，参数则会按引用传递，而非按值传递。

11.1. ref、out、in的共同点：

• 需要在方法定义与方法调用处显示的使用关键字。
• 参数按引用传递，而非值传递。

11.2. ref、out、in的不同点是：

• ref：参数变量需要初始化，参数在方法中可以修改或不修改。(因为在方法中可以选择修改或者不修改所以需要初始化，不然会出现使用空的值)
• out：参数变量无需初始化，参数在方法中必须进行赋值。(因为参数在方法中一定会被赋值，所以可以不用初始化)
• in：参数变量需要初始化，参数在方法中不能进行修改。