事件：

发布者

订阅者

事件触发

事件注册

用程序语言解释:事件发生时，通知订阅者，就是调用订阅者的注册函数。注册，就是告诉发布者调用哪一个注册函数

事件声明：

delegate void Handler（）；

public event Handler NewDog;

事件订阅：

NewDog+=方法 ；

NewDog-=方法

方法可以是，实例方法，静态方法，匿名方法，Lambda表达式

事件触发

if(NewDog!=null)

{

    NewDog();

}

事件可以理解成是一种封装的受限制的委托

匿名方法：

delegate void ActCute();

ActCute del;

del=delegate(){……}

Lambda表达式

del=delegate(){……}；

del=()=>{……}；

委托：就是持有一个或者多个方法的对象！并且该对象可以执行，可以传递。

可以声明，它是一种引用类型。

delegate void ActCute();

既然是中类型，就可以定义该类型的对象。

ActCute actCute；

给委托对象赋值

字典Dictionary<TKey,Tvalue>

字典容器存储的是一系列的键值对，每个值对应一个唯一的键。键的意义在于，我们可以通过键相对高效的访问到值。

字典操作

1. 数量 Count

2. 添加 Add(key,value)

3. 删除 Remove

4. 访问 [key]

栈：先进后出，后进先出的一种容器

栈的操作：

1. 出栈： Pop

2. 入栈： Push

3. 获取栈顶元素： Peek

队列：先进先出的容器。

队列的操作：

1. 出队 Dequeye

2. 入队 Enqueue

集合：就是一种存放多个数据的容器类型，比如之前学过的数组Array（完整的类型是System.Array）。

预定义的常用集合：

1. 动态数组：ArrayList

2. 列表：List

3. 字典：Dictionary

4. 队列：Queue

5. 栈：Stack

使用集合的原因：比数组更为强大，实现了更加丰富的功能。可以提高我们的开发效率。

动态数组ArrayList:

1. 初始化，可以不指定大小

2. 获取长度，使用Count属性

3. 添加Add

4. 删除Remove，RemoveAt

5. 访问[index]

比起数组，内存耗费多，存取速度数组快；在拆箱装箱的时候，会有性能的损耗。

List<T>

减去拆箱装箱的性能问题。

泛型接口允许我们将接口成员的参数和返回类型设置为泛型参数的接口

语法：

interface IMyself<T>{

    T Myself(T self);

}

约束：就是控制泛型这匹烈马的缰绳！缩小泛型参数的范围。

约束的意义：只有添加了约束，才能调用泛型参数中（比如T）的方法。

约束的类型：类名，class，struct，接口名，new（    ）

约束叠加规则：

1. 主约束：只能有一个

2. 接口约束：任意多个

3. 构造约束
   

泛型方法：

就是方法的模型，给定具体的类型，就可以实例化出一个操作该类型的具体方法。

语法：

class Dog{

    void DogIsHappy<T>(T target){

    ……    

    }

}

泛型类就是一个模子，装入类型的材料，可以塑造出想要的产品。

class Cage<T>{

    T[] petsArray;

    public void PutIn(T pet){……}

    public T TakeOut(int index){……}

}

为什么需要泛型

用基类或者公共的接口，甚至是所有类的基类object，也可以实现一个Cage类，但是类型太宽泛，需要显示转换类型，并且判断真实类型是什么。

优势

1. 代码量更小，无论多少种笼子，我们只需要一个实现

2. 只有需要的类型才会被实例化

3. 易于维护，修改模板，所有的实例都将改变

   
   

重载运算符：利用现有的某种运算符，针对自定义类或者结构，定义某种运算操作。

原因：利用现有运算符，简化自定义类型的操作。最好是，该运算符和该操作，具有一定以相关性。

语法细节：
public static Dog(返回值) operator +(Dog male,Dog female)

{

……

return new Dog();

}

重载运算符不能做：

1. 创造新运算符

2. 改变运算符语法

3. 重定义运算符如何处理预定义类型

4. 改变运算符的优先级和结合性
   

自定义转换：为自己的结构或者类定义显示或隐式转换。

原因：为了让我们自己的结构或者类可以变成一个预期相关的类型，并且是这种转换更加简单。

隐式转换语法：

public static implicit operator Dog(Cat cat)

{

……

}

显示转换语法：

public static explicit operator Dog(Cat cat)

{

……

}

装箱：根据值类型的值，在堆上创建一个完整的引用类型对象，并返回对象的引用，是一种隐式转换。

装箱的原因：有时候需要将值类型转换为引用类型来进行统一的操作和统一的存储。

装箱的本质：就是在堆上创建了引用类型的副本，新创建的引用类型和原来的值类型相互独立。

例子：

int i=3;

object oi=i;

Console.WriteLine("i="+i+"oi="+oi.ToString());

oi=10;

i=7;

Console.WriteLine("i="+i+"oi="+oi.ToString());

输出结果是：i=3oi=3

                    i=7oi=10

拆箱：讲装箱后的对象转换回值类型的过程，是一种显示转换。

例子：

int i=3;

object oi=i;

int j=(int) oi;

静态类

1. 如果类只包含了静态的方法和属性，并且标识为static

2. 静态类不能创建实例，不能被继承

3. 可以为静态类定义一个静态构造函数

静态类主要用于基础类库（如数学库）和扩展方法。

如何扩展方法：

1. 如果有源代码，直接添加一个新方法。

2. 如果不能修改但不是密闭类，可以派生子类扩展

3. 如果以上条件都不满足，可以使用静态类扩展方法

总结扩展要求：

1. 扩展方法所属的类，必须是static类

2. 扩展方法本身必须是static方法

3. 扩展方法的第一个参数类型，必须是this+类名

类的静态成员：标识为static的字段，方法，属性，构造函数，事件，就是静态成员。

class Dog

{

    static int Num;

}

意义：静态成员将被类的所有实例共享，所有实例都访问同一内存位置。

静态成员将直接通过类名访问。

独立于任何实例，没有实例也可以访问。其初始化语句在任何静态成员使用之前调用。

静态函数也独立于任何实例，没有实例也可以调用。静态函数不能访问实例成员，仅能访问其他静态成员。

静态构造函数：

1. 静态构造函数用于初始化静态字段。

2. 在引用任何静态成员之前，和创建任何实例之前调用。

3. 与类同名，使用static，无参数，无访问修饰符。