类 Class

  • 类是最常见的一种引用类型

    1. class YourClassName
    2. {
    3. }

    对象初始化器

  • 对象如何可访问的字段/属性在构建之后，可以通过对象初始化器直接为其设定值 ```csharp public class Rectangle { public readonly float Width, Height; public Rectangle(){} }

Rectangle = new Rectangle() {Width = 1, Height = 2};//大括号内为对象初始化器

  1. <a name="x8kAI"></a>
  2. ## 静态类
  4. - 类也可以是静态的
  5. - 其成员必须全是静态
  6. - 不可以有子类
  7. - 例如
  8.    - System.Console
  9.    - System.Math
  10. <a name="U6STT"></a>
  11. ## 局部类 Partial type
  13. - 允许一个类型的定义分布在多个地方（文件）
  14. - 典型应用：一个类的一部分是自动生成的，另一部分需要手动写代码
  15. ```csharp
  16. //FormGen.cs
  17. partial class Form{}
  18. //Form.cs
  19. partial class Form{}
  • 每个分布的类都必须使用partial来声明
  • 每个分布类成员不能冲突，不能有同样参数的构造函数
  • 分布类完全靠编译器来解析，必须在一个程序集里面
  • 如果有弗雷，可以在一个或者多个分布类上指明，但必须一致

  • 编译器无法保证各个分布类的字段的初始化顺序

    继承

  • 一个类可以继承另外一个类，从而对原有的类进行扩展和自定义

  • 子类可以重用父类的功能

  • C#不允许多继承

    1. public class Person
    2. {
    3. }
    4. public class Student : Person
    5. {
    6. }

    多态

  • 引用是多态的，类型为x的变量引用子类对象

  • 因为子类具有父类的所有特性，所以参数可以是子类 ```csharp public static void Display(Person son){}

Display(new Student());

  1. <a name="dG1GS"></a>
  2. ## 抽象类和抽象成员
  4. - 使用abstract声明的类是抽象类
  5. - 抽象类不可以被实例化，只有其局的的子类才可以实例化
  6. - 抽象类可以定义抽象成员
  7. - 抽象成员和virtual成员很小，但是不提供具体的实现。子类必须提供实现，除非子类抽象
  8. ```csharp
  9. public abstract Person
  10. {
  11.     public abstract string name { get; }
  12. }
  14. public Student : Person
  15. {
  16.     public override string name => "x";
  17. }

隐藏被继承的成员

  • 子类和父类拥有相同的属性
  • 按照以下规则进行解析：
    • 编译时对A的引用会绑定到A.Counter
    • 编译时对B的引用会绑定到B.Counter
  • 编译时会警告
  • 故意异常父类成员可以在子类成员前加上new ```csharp class A { public int Counter = 1; }

class B : A { public int Counter = 2; //public new int Counter = 2; 故意隐藏父类成员可以加上new修饰符，new 仅仅是一致编译器警告而已 }

A a = new A(); //Counter 1 B b = new B(); // 2 A x = new B(); // 1

  1. <a name="2cmQW"></a>
  2. ### 隐藏和重写区别
  3. ```csharp
  4. Overrider over = new Overrider();
  5. BaseClass b1 = over;
  6. over.Foo();                //Overrider.Foo
  7. b1.Foo();                //Overrider.Foo
  9. Hider h = new Hider();
  10. BaseClass b2 = h;
  11. h.Foo();                //Hider.Foo
  12. b2.Foo();                //BaseClass.Foo

引用转换

  • 一个对象的引用可以隐式转换到其弗雷的引用（向上转换）
  • 转换到子类的引用需要显示转换（向下转换）

  • 引用转换：创建了一个新的引用，它也引用同一个对象

    向上转换

  • 子类引用创建父类引用

    1. Student s = new Student();
    2. Person p = s;
    3. Console.WriteLine(s == p)    //True 都指向子类对象

  • 父类对象引用指向子类对象的时候，父类对象可视范围更小，它只能调用父类的属性

    向下转换

  • 从父类的引用创建出子类的引用

    1. Student s = new Student();
    2. Person p = s;
    3. Student s1 = (Student) p;

  • 底层对象不会收到影响

  • 需要显式转换，可能失败

    操作符 As

  • as操作符会执行向下转换，如果转换失败不会抛出异常，值会变成null

    1. Person p = new Person();
    2. Student s = p as Student;

    操作符 Is

  • is操作符会检验引用的转换是否成功。换句话说，判断对象是否派生于某个类（或者实现了某个接口）

  • 通常用于向下转换之前的验证

  • C#7里，使用is操作符可以引入一个变量

    1. if (new Student() is Person)
    2.   ...
    3. if (p is Student s)
    4.   ...

    接口

  • 接口与class类似，但是它职位其成员提供了规格，而没有提供具体的实现

  • 接口的成员都是隐式抽象的
  • 一个class或者struct可以实现多个接口
  • 接口的成员都是隐式public的，不可以声明访问修饰符
  • 实现接口对他所有成员进行public的实现
  • 可以隐式的把一个对象转化成它实现的接口
  • 接口可以继承其他接口
  • 实现多个接口可能会造成成员签名的冲突，文明可以显示实现接口成员来解决该问题
  • 隐式实现的接口成员默认是sealed的
  • 如果想要进行重写的话，必须在基类中把成员标记为virtual或者abstract
  • 显示实现的接口成员不可以被标记为virtual，不可以重写，但是可以重新实现
  • 子类可以重新实现父类实现的接口成员
  • 最好办法是设计一个无需重新实现的基类：
    • 隐式实现成员的时候，按需标记virtual
    • 显示实现成员的时候，可以这样做
      1. public class TextBox : IUndoable
      2. {
      3. void IUndoable.Undo() => Undo();
      4. protected virtual void Undo() => ...;
      5. }
      1. public interface Ienumerator
      2. {
      3. bool MoveNext();
      4. object Current { get;}
      5. void Reset();
      6. }

字段 Field

  • 字段是Class或Struct的成员，它是一个变量

    1. class Person
    2. {
    3.   string name;    //Name是一个字段
    4.   int Age = 18;    //Age也是一个字段
    5. }

    初始化

  • 字段可以选择是否初始化

  • 未被初始化的字段会有一个默认值
  • 字段的初始化在构造函数之前运行

  • 可以同时声明多个字段

    1. static readonly int legs = 2,
    2.                   eyes = 2;

    属性 Properties

  • 属性的声明和字段声明很像，但多了一个get set块 ```csharp class Person { int y; string name { 

    1.   get{} 
    2.   set{}

    } int x {

    1.   get => x * x;
    2.   set => x = y / x;

    } int y { get; set; } = 123 //自动属性，属性初始化器

}

  1. <a name="9fSmM"></a>
  2. # 属性和字段的区别
  4. - 属性赋予了实现这对获取和复制的完全控制权。
  5. - 这种控制权限允许是现在选择容易所需的内部表示，不向属性的使用者公开内部细节
  6. <a name="fE289"></a>
  7. # 索引器
  9. - 索引器提供访问封装了列表之或字典值的**class**/**struct**的元素的一种语法，比如字符串
  10. - 语法与数组类似，但是索引的参数任意
  11. - 一个类型可以声明多个索引器，参数类型有不同
  12. - 一个索引器可以有多个参数
  13. <a name="762pV"></a>
  14. ## 实现索引器
  16. - 定义一个this属性，并通过中括号指定参数
  17. ```csharp
  18. class Sentence
  19. {
  20.     string[] words = "hello world";
  21.     public string this[int wordNum]
  22.     {
  23.         get { return words[wordNum]; }
  24.         set { words[wordNum] = value; }
  25.     }
  26.     public string this[int wordNum] => words[wordNum]; //只读索引器
  27. }

修饰符 Readonly

  • readonly 修饰符防止字段在构造之后呗改变

  • 被 readonly 修饰符修饰后的字段，只能声明的时候被赋值，或在构造函数里被赋值

    1. class Person
    2. {
    3.   static readonly int legs = 2;
    4. }

    修饰符 Virtual

  • 标记为virtual的函数可以被子类重写， 包括方法、属性、索引器、事件 ```csharp public class Asset { public string Name; public virtual decimal Liablility => 0; }

public House : Asset { public decimal Mortgage; public override decimal Liability => Mortgage; }

  1. <a name="wMXPD"></a>
  2. # 密封Sealed
  4. - 重写的成员，可以使用sealed关键字把它“密封”起来，以防被子类重写
  5. - 也可以sealed类本身
  6. - 应用于某个类时，`sealed` 修饰符可阻止其他类继承自该类。 在下面的示例中，类 `B` 继承自类 `A`，但没有类可以继承自类 `B`
  7. ```csharp
  8. class A {}
  9. sealed class B : A {}

重写 Override

  • virtual方法和重写方法的签名、返回类型、可访问程度必须是一样的

  • 重写方法里使用base关键字可以调用父类的实现

    注意

  • 构造函数里调用virtual方法可能比较危险，因为编写子类的开发人员可能不知道他们在重写方法的时候，面对的是一个未完全初始化的对象

  • 重写的方法可能会访问用来与还未被构造函数初始化的字段属性或方法

    方法 Method

  • 通常有一些语句，用来执行某个动作（一般做一件事，提高聚合度）

  • 参数
  • 返回类型
  • void（无返回）

  • ref/out

    签名

  • 类型内方法的签名必须唯一

  • 签名：方法名、参数类型（顺序，但参数名称和返回类型无关）

    1. class Person{
    2.   void Eat(Food food){    
    3.   }
    4.   void Eat(Food food){    //签名不唯一报错
    5.   }
    6.   void Eat(Food foods){    //签名与参数名称无关，故签名相同报错
    7.   }
    8.   void Eat(Foods food){    //签名参数类型不一样，不报错
    9.   }
    10.   string Eat(Food food){    //签名与返回类型无关，故签名相同报错
    11.   }
    12. }

    表达式体 Expression-Bodied

  • C#6.0语法糖，当方法执行单一任务，或者返回计算结果不涉及额外逻辑可以简写方法体

    1. int Sum(int x, int y){
    2.   return x + y;
    3. }
    4. //改进后
    5. int Sum(int x, int y) => x + y;

    重载 Overload

  • 类里面的方法可以进行重载（允许多个同名的方法同时存在），只要方法的签名不同即可 ```csharp void Foo(int x) {} void Foo(double x) {} void Foo(int x, float y) {}

void Foo(int x) {} float Foo(int x) {} //编译报错，签名相同

void Goo(int[] x) {} void Goo(params int[] x) {} //与params修饰符无关

void Foo(int x) {} void Foo(ref int x) {} //传递方式不一样 void Foo(out int x) {} //和前面一样 都是按引用传递

  1. <a name="LwZqe"></a>
  2. ## 本地方法
  4. - 不可以使用Static
  5. ```csharp
  6. void Do(){
  7.     int Calculate(int x) => x * x;
  8.     //作用域在Do方法里
  9.     //可以访问函数内的变量
  10. }

构造方法

  • 在class或struct上初始化代码
  • 返回类型和类型一致，并且返回类型省略不写
  • C#7之后允许但语句的构造函数写成expression-bodied成员的形式 ```csharp public class Panda { string name; public Panda(string n) => name = n;

}

  2. - class或struct可以重载构造函数
  3. - 调用重载构造函数时使用this
  4. - 同一类型下构造函数A调用B的时候，B先执行
  5. - 可以把表达式传递给另一个构造函数，但函数内不能使用this引用类中非静态方法，因为此时对象未被初始化
  6. ```csharp
  7. public class Panda
  8. {
  9.     string name;
  10.     int old;
  11.     public Panda(string n) => name = n;
  12.     public Panda(string n, int o):this(n)
  13.     {
  14.         this.old = o;
  15.         this.Do();
  16.     }
  18.     public static Do(){}
  20. }

静态构造方法

  • 静态构造函数，每个类型执行一次
  • 非静态构造函数，每个实例执行一次
  • 一个类型只能定义一个静态构造函数
    • 必须无参
    • 方法名与类型一致
  • 类型使用之前的一瞬间，编译器会自动调用类型的静态构造函数：
    • 实例化一个类型
    • 访问一个类型的静态成员
  • 只能使用unsafe和extern修饰符
    1. class Test
    2. {
    3.   static Test() {Console.Write("Test");}
    4. }

终结器 Finalizer

  • Finalizer是class专有的方法
  • 在GC回收未引用对象的内存之前运行
  • 其实就是对object的Finalize()方法重写的一种语法

  • 可以用表达式体

    1. class Test
    2. {
    3.   ~Test()
    4.   {
    5.   }
    6. }

    初始化顺序

  • 静态字段的初始化器在静态构造函数被调用之前的一瞬间运行

  • 如果没有静态构造函数，静态字段初始化器在类型被使用之前的一瞬间执行，或者更早

  • 静态字段的初始化顺序与字段顺序一致

    Deconstructor C#7

  • 作用与构造函数相反，把字段反复制给一堆变量

  • 方法名必须为Deconstruct
  • 可以被重载

  • 可以为扩展方法 ```csharp public class Rectangle { public readonly float Width, Height public Rectangle(float width, float height) {

    1.   Width = width;
    2.   Height = height;

    }

    public void Deconstruct(out float width, out float height) {

    1.   width = Width;
    2.   height = Height;

    }

}

class Test { public static void Main(string[] args) { var rect = new Rectangle(3, 4); (float width, float height) = rect; //rect.Deconstruct(out width, out height); //rect.Deconstruct(var out width, var out height);

  1. }

}

  1. <a name="d1pgZ"></a>
  2. # Object 类型
  4. - object（System.Object）是所有类型的终极父类
  5. - object是引用类型
  6. - 值类型可以转化为object，反之亦然
  7. - 值类型和object之间转化的时候，CLR会执行一些特殊的工作，以弥装箱和拆箱
  8. ```csharp
  9. int x = 0;
  10. object o = x;     //box the int
  11. int y = (int) o;//unbox the int

Enum 枚举

  • 枚举是一种特殊的值类型，它可以让你指定一组命名的数值常量
  • 每个枚举都对应一个底层整型数值（Enum.GetUndelyingType()）。默认
    • 为int
    • 0，1，2…按照声明顺序自动赋值
  • 可以指定其他作为枚举类型
    • public enum Borderside : byte {Left, Right, Top, Bottom}
  • 可以单独指定枚举成员对应的整数值

  • 也可以指定部分，然后未被赋值的成员按照它签名已经赋值的成员的值递增

    1. public enum Borderside{Left, Right, Top, Bottom}

    Flags Enum 组合枚举

  • 可以对枚举的成员进行组合

  • 为了避免起义，枚举成员的需要显示赋值。典型用2的乘幂
  • flags enum，可以使用位操作符 ```csharp [Flags] public enum Borderside{None=0, Left=1, Right=2, Top=4, Bottom=8}

Borderside leftRight = Borderside.Left | Borderside.Rigth; //底层原理 //top： 0000 0001

//rigth：0000 0010

```