委托、匿名方法、Lambda表达式、泛型委托(自定义、Func、Action、Predicate)、约束泛型类和方法、多窗体传递消息、事件、异步编程、二次控件开发

1.匿名方法

　　没有具体名称，只有委托关键字、方法参数、方法体，所以称之为匿名方法

　　匿名方法允许将代码块（方法体部分）通过委托变量作为参数传递，以代替独立定义的方法

  总结：

　　方法体要以delegate开头，其后是参数列表，后面紧跟花括号编写方法体，最后以分号结尾

　　匿名方法是将方法定义与委托变量两个步骤合在一起，省略了方法的单独定义

　　如果一个方法有一个委托类型的参数，可以直接将匿名方法作为实参。

        //声明委托
        public delegate int MyDelegate(int a, int b);

        static void Main(string[] args)
        {//匿名方法
            MyDelegate objDel = delegate (int a, int b)
            {
                return a + b;
            };
            Console.WriteLine(objDel(10, 20));
            Console.ReadLine();
        }

2.lambda表达式

　　C#3.0引入lambda表达式，lambda表达式是匿名方法更简介使用的一种方式

　　(参数列表) => {方法体}  =>读作goes to

　　lambda表达式参数列表中的参数类型可以是“明确”类型或者是“推断类型”（可以省略参数类型）

　　如果是推断类型，参数数据类型将由编译器根据上下文自动推断出来

　　一般情况下还是写参数类型的好，方便自己和他人理解

　　如果参数只有一个可以省略();如果方法体只有一行代码可以省略{}

3.lambda表达式总结

　　两种方式：(input args)=>表达式          (input args)=>{语句1；语句2；......}

　　举例1：只有一个参数的时候，括号可选   Func<int,bool> del1=(x)=>{return x>0;};

　　举例2：可简化为   Func<int,bool> del2=x=>x>0;

　　举例3：两个或更多输入参数由逗号分隔    Func<int,int,bool> del3=(x,y)=>x==y;

　　举例4：没有参数时，直接输入一个空的括号　　Action del4=()=>{...}

        //声明委托
        public delegate int MyDelegate(int a, int b);
        static void Main(string[] args)
        {
            //一条语句未省略{}
            MyDelegate objDel0 = (int a, int b) => { return a + b; };
            //一条语句省略{}
            MyDelegate objDel1 = (int a, int b) => a + b;
            Console.WriteLine(objDel0(10, 20));
            Console.WriteLine(objDel1(10, 20));
            Console.ReadLine();
        }

4.lambda与匿名方法比较

　　Lambda表达式本身就是匿名方法

　　Lambda表达式的参数可以允许不指明参数类型，而匿名方法的参数必须明确指明参数类型

　　Lambda表达式方法体允许由单一表达式或多条语句组成，而匿名方法不允许单一表达式形式

5.委托引入

　　委托本质：是一个类，继承自System.MulticastDelegate，里面内置了几个方法（Invoke()、BeginInvoke()、EndInvoke()）

　　委托的声明：public delegate void MyDelete(int num);   细看委托的声明，如果把delegate去掉就是一个方法的声明。

　　委托的实例化：实例化委托之前必须写好委托实例传入的方法，这个方法和委托声明必须有相同的返回值和参数。

　　委托的调用：Invoke()也可以直接调用。

　　委托的三大作用：【1】逻辑解耦，减少重复代码【2】异步多线程【3】多播委托，基于观察者模式

//【1】委托声明
public delegate void NoReturnWithPara(int para);

//【2】委托传入的方法
private void TheMethod(int num)
{
    Console.WriteLine($"我就是那个数{num}");
}

public void Show()
{
    //【3】实例化委托
    NoReturnWithPara noReturnWithPara = new NoReturnWithPara(TheMethod);
    //【4】调用委托实例
    noReturnWithPara.Invoke(22);
    noReturnWithPara(11);
}

//【5】委托：可以把方法当成参数进行传递

/* 委托解耦的实例说明
 * 背景：一群学生，姓名、年龄、住址各异，要求筛选出特定条件的学生个数。
 * 例如筛选出名字为2个字的学生、年龄大于20的学生、家住昆山的学生、和满足以上所有的学生
 * 最笨的方法(暂不考虑linq)，【1】先新建一个list、【2】foreach挨个遍历、【3】判断条件满足、【4】加入list、【5】输出list个数
 * 细分析以上5个步骤：只有步骤3判断条件满足这里不一样，别的四个步骤都一样
 * 四个一样的步骤叫共有逻辑、3判断条件满足叫独有逻辑，解耦解的是这两者之间的耦合关系，在3判断条件满足这里使用委托
 */
public class DelegateTest
    {
        //准备数据
        public List<Student> students = new List<Student>()
        {
            new Student()
            {
                Name="张三",
                Age=36,
                Address="昆山高新区"
            },
            new Student()
            {
                Name="李四平",
                Age=32,
                Address="昆山开发区"
            },
            new Student()
            {
                Name="王麻子",
                Age=18,
                Address="上海青浦区"
            },
            new Student()
            {
                Name="赵六",
                Age=36,
                Address="天津黑芝麻胡同"
            }
        };

        //【1】定义委托
        public delegate bool JudgeDele(Student student);

        //【2】准备判断条件
        public bool JudgeNameEqual2(Student student)
        {
            return student.Name.Length == 2;
        }
        public bool JudgeAgeUp20(Student student)
        {
            return student.Age >= 20;
        }
        public bool JudgeAddressInKun(Student student)
        {
            return student.Address.Contains("昆山");
        }
        public bool JudgeAll(Student student)
        {
            return student.Name.Length == 2 && student.Age >= 20 && student.Address.Contains("昆山");
        }

        //判断逻辑传递进来+实现共用逻辑,委托解耦，减少重复代码
        public int GetStudents(List<Student> students, JudgeDele dele)
        {
            List<Student> listStu = new List<Student>();
            foreach (Student student in students)
            {
                if (dele.Invoke(student))//【4】利用委托代替判断方法
                {
                    listStu.Add(student);
                }
            }
            return listStu.Count();
        }
    }


                //【3】实例化委托
                DelegateTest delegateTest = new DelegateTest();
                int NameEqual2 = delegateTest.GetStudents(delegateTest.students, delegateTest.JudgeNameEqual2);
                int AgeUp20 = delegateTest.GetStudents(delegateTest.students, delegateTest.JudgeAgeUp20);
                int AddressInKun = delegateTest.GetStudents(delegateTest.students, delegateTest.JudgeAddressInKun);
                int JudgeAll = delegateTest.GetStudents(delegateTest.students, delegateTest.JudgeAll);
                Console.WriteLine($"NameEqual2：{NameEqual2}");
                Console.WriteLine($"AgeUp20：{AgeUp20}");
                Console.WriteLine($"AddressInKun：{AddressInKun}");
                Console.WriteLine($"JudgeAll：{JudgeAll}");

int LingNameEqual2 = (from Student student in delegateTest.students
                      where student.Name.Length == 2
                      select student).Count();
int LingAgeUp20 = (from Student student in delegateTest.students
                   where student.Age > 20
                   select student).Count();
int LingAddressInKun = (from Student student in delegateTest.students
                        where student.Address.Contains("昆山")
                        select student).Count();
int LingJudgeAll = (from Student student in delegateTest.students
                    where student.Name.Length == 2 && student.Age > 20 && student.Address.Contains("昆山")
                    select student).Count();
Console.WriteLine($"LingNameEqual2：{LingNameEqual2}");
Console.WriteLine($"LingAgeUp20：{LingAgeUp20}");
Console.WriteLine($"LingAddressInKun：{LingAddressInKun}");
Console.WriteLine($"LingJudgeAll：{LingJudgeAll}");

5.多播委托

　　多播委托【+=】：为委托实例按顺序增加方法，形成方法链，Invoke时，按顺序依次执行。

　　多播委托【-=】：为委托实例按顺序移除方法，从方法链的尾部开始匹配，遇到第一个完全吻合的，移除且只移除一个，没有也不异常。移除时不是同一个实例的方法移除不了。多播委托不能异步（BeginInvoke和EndInvoke）多播委托带返回值Invoke以最后的结果为准。

　　多播委托的价值：一个变量保存多个方法，可以增减：invoke的时候可以按顺序执行。

//【1】定位委托
public delegate int WithReturnNoPara();

//【2】多播委托的三个方法
private int GetInt1()
{
    return 1;
}
private int GetInt2()
{
    return 2;
}
private int GetInt3()
{
    return 3;
}

public void Show()
{
    //【3】实例化委托
    WithReturnNoPara withReturnNoPara = new WithReturnNoPara(GetInt1);
    //【4】添加多播委托
    withReturnNoPara += new WithReturnNoPara(GetInt2);
    withReturnNoPara += new WithReturnNoPara(GetInt3);
    foreach (WithReturnNoPara dele in withReturnNoPara.GetInvocationList())
    {//遍历多播委托
        Console.WriteLine($"遍历结果  {dele.Invoke()}");
    }
    Console.WriteLine($"Invoke()方法返回值：{withReturnNoPara.Invoke()}");//多播委托带返回值Invoke以最后的结果为准
    //【5】减去多播委托的一个方法
    withReturnNoPara -= new WithReturnNoPara(GetInt3);
    foreach (WithReturnNoPara dele in withReturnNoPara.GetInvocationList())
    {
        Console.WriteLine($"遍历结果  -=之后{dele.Invoke()}");
    }
    Console.WriteLine($"Invoke()方法返回值：-=之后{withReturnNoPara.Invoke()}");
}

/* 多播委托应用举例，引入事件
 * 场景：一直神奇的猫，在它叫了一声之后会其他引发一系列的行为
 */
//【1】定义委托
public delegate void MiaoDelegate();
public class Cat
{
    //不适用多播委托和事件
    //直接调用别的实例别的方法，如果有一系列增删改，会让此方法不稳定
    public void Miao()
    {
        Console.WriteLine("{0} Miao", this.GetType().Name);
        new Mouse().Run();
        new Baby().Cry();
        new Mother().Wispher();
        new Brother().Turn();
        new Father().Roar();
        new Neighbor().Awake();
        new Stealer().Hide();
        new Dog().Wang();
    }

    //分析场景：猫叫了一声，引发一系列后续动作
    //可以用多播委托将一系列动作封装出去【甩锅的概念】
    //【2】定义委托实例
    public MiaoDelegate MiaoDelegateHandler = null;
    public void MiaoNew()
    {
        Console.WriteLine($"{this.GetType().Name}   叫了一声");
        if (MiaoDelegateHandler != null)
        {
            MiaoDelegateHandler.Invoke();
        }
    }

    //事件的引入
    public event MiaoDelegate MiaoDelegateHandlerEvent = null;
    public void MiaoNewEvent()
    {
        Console.WriteLine($"{this.GetType().Name}   叫了一声");
        if (MiaoDelegateHandlerEvent != null)
        {
            MiaoDelegateHandlerEvent.Invoke();
        }
    }
}


//多播委托应用
Cat cat = new Cat();
Console.WriteLine("~~~~~~~~~~~~~多播委托~~~~~~~~~~~~~");
cat.MiaoDelegateHandler += new MiaoDelegate(new Mouse().Run);
cat.MiaoDelegateHandler += new MiaoDelegate(new Baby().Cry);
cat.MiaoDelegateHandler += new MiaoDelegate(new Mother().Wispher);
cat.MiaoDelegateHandler += new MiaoDelegate(new Brother().Turn);
cat.MiaoDelegateHandler += new MiaoDelegate(new Father().Roar);
cat.MiaoDelegateHandler += new MiaoDelegate(new Neighbor().Awake);
cat.MiaoDelegateHandler += new MiaoDelegate(new Stealer().Hide);
cat.MiaoDelegateHandler += new MiaoDelegate(new Dog().Wang);
cat.MiaoNew();

5.事件event

 　　事件是带event关键字的委托的实例，event可以限制变量被外部调用/直接赋值，子类也不能调用。并且事件只能由声明者才能调用。

/* 多播委托应用举例，引入事件
 * 场景：一直神奇的猫，在它叫了一声之后会其他引发一系列的行为
 */
//【1】定义委托
public delegate void MiaoDelegate();
public class Cat
{
    //分析场景：猫叫了一声，引发一系列后续动作
    //可以用多播委托将一系列动作封装出去【甩锅的概念】
    //【2】定义委托实例
    public MiaoDelegate MiaoDelegateHandler = null;
    public void MiaoNew()
    {
        Console.WriteLine($"{this.GetType().Name}   叫了一声");
        if (MiaoDelegateHandler != null)
        {
            MiaoDelegateHandler.Invoke();
        }
    }

    //事件的引入
    public event MiaoDelegate MiaoDelegateHandlerEvent = null;
    public void MiaoNewEvent()
    {
        Console.WriteLine($"{this.GetType().Name}   叫了一声");
        if (MiaoDelegateHandlerEvent != null)
        {
            MiaoDelegateHandlerEvent.Invoke();
        }
    }
}


Cat cat = new Cat();
Console.WriteLine("~~~~~~~~~~~~~多播委托~~~~~~~~~~~~~");
cat.MiaoDelegateHandler += new MiaoDelegate(new Mouse().Run);
cat.MiaoDelegateHandler += new MiaoDelegate(new Baby().Cry);
cat.MiaoDelegateHandler += new MiaoDelegate(new Mother().Wispher);
cat.MiaoDelegateHandler += new MiaoDelegate(new Brother().Turn);
cat.MiaoDelegateHandler += new MiaoDelegate(new Father().Roar);
cat.MiaoDelegateHandler += new MiaoDelegate(new Neighbor().Awake);
cat.MiaoDelegateHandler += new MiaoDelegate(new Stealer().Hide);
cat.MiaoDelegateHandler += new MiaoDelegate(new Dog().Wang);
cat.MiaoNew();
Console.WriteLine("~~~~~~~~~~~~~事件~~~~~~~~~~~~~");
cat.MiaoDelegateHandlerEvent += new MiaoDelegate(new Mouse().Run);
cat.MiaoDelegateHandlerEvent += new MiaoDelegate(new Baby().Cry);
cat.MiaoDelegateHandlerEvent += new MiaoDelegate(new Mother().Wispher);
cat.MiaoDelegateHandlerEvent += new MiaoDelegate(new Brother().Turn);
cat.MiaoDelegateHandlerEvent += new MiaoDelegate(new Father().Roar);
cat.MiaoDelegateHandlerEvent += new MiaoDelegate(new Neighbor().Awake);
cat.MiaoDelegateHandlerEvent += new MiaoDelegate(new Stealer().Hide);
cat.MiaoDelegateHandlerEvent += new MiaoDelegate(new Dog().Wang);
cat.MiaoNewEvent();

　　委托与事件的区别和联系？委托是一个类型，事件是委托的一个实例。事件是带event关键字的委托的实例，event可以限制变量被外部调用/直接赋值

5.事情与程序架构

　　事件：可以把一堆可变的动作/行为封装出去，交给第三方来指定。和预定义一样，程序设计的时候，可以把程序分成两部分：一部分是固定的，直接写死；还有不固定的，通过一个事件去开放接口，外部可以随意扩展动作。

　　框架：完成固定或通用部分，把可变部分留出扩展点，支持自定义。　　

5.自定义泛型委托

　　当一类相同方法类似，但方法的参数类型不一致的时候可以考虑使用泛型委托

　　因为是泛型，所以在定义委托时用T表示参数类型，在定义委托变量时再指定方法类型

//1.定义泛型委托 
public delegate T MyDele<T>(T obj1, T obj2);
class Program
{
    //2.定义委托方法
    static int Add(int a, int b) => a + b;
    static double Sub(double a, double b) => a - b;
    static void Main(string[] args)
    {
         //3.定义委托变量
         MyDele<int> objIntDele = Add;
         MyDele<double> objDouDele = Sub;
         //4.使用委托变量
         Console.WriteLine(objIntDele(10, 20));
         Console.WriteLine(objDouDele(2.2, 5.7));
         Console.ReadLine();//使用新特性 using static System.Console;
    }
}

    //定义泛型委托
    public delegate T MyGenericDeleage<T>(T obj1, T obj2);
    class Program
    {
        static int Add(int a, int b)
        {
            return a + b;
        }
        static double Sub(double a, double b)
        {
            return a - b;
        }

        //泛型委托：匿名方法、Lambda表达式
        static void Main(string[] args)
        {
            //【1】使用委托
            MyGenericDeleage<int> objDelegate1 = Add;
            MyGenericDeleage<double > objDelegate2 = Sub;

            Console.WriteLine(objDelegate1(10,20));
            Console.WriteLine(objDelegate2(10, 20));
            Console.WriteLine("-----------------");

            //【2】使用匿名方法
            MyGenericDeleage<int> objDelegate3 = delegate(int a, int b) { return a + b; };
            MyGenericDeleage<double > objDelegate4 = delegate(double  a, double  b) { return a - b; };

            Console.WriteLine(objDelegate3(10, 20));
            Console.WriteLine(objDelegate4(10, 20));
            Console.WriteLine("-----------------");

            //【3】使用Lambda表达式
            MyGenericDeleage<int> objDelegate5 = (a, b) => a + b;
            MyGenericDeleage<double> objDelegate6 = (a, b) => a - b;

            Console.WriteLine(objDelegate5(10, 20));
            Console.WriteLine(objDelegate6(10, 20));
            Console.ReadLine();
        }
    }

 6.Func<T>委托 ：最后一个参数为返回值类型

　　Func<>委托是微软自定义好的泛型委托

　　Func委托声明的最后一个泛型类型是委托所接受方法的返回值类型

        static double Add(int a, int b)
        {
            return a + b;
        }
        static void Main(string[] args)
        {
            Func<int, int, double> func0 = Add;
            double result = func0(10, 20);
            //使用Lambda表达式
            Func<int, int, double> func1 = (a, b) => a + b;
            Console.WriteLine(func0(10, 20));
            Console.WriteLine(func1(10, 20));
            Console.ReadLine();
        } 

Func<int,int,string> func = (x,y) => (x*y).ToString();
Consle.WriteLine(func(5,20));

7.编写一个方法，从数组中指定位置抽取3个数，求和、求积  int[] nums={10,9,8,7,6,5,4,3,2};

        static void Main(string[] args)
        {
            int[] nums = { 10, 9, 8, 7, 6, 5, 4, 3, 2 };
            Console.WriteLine("------不使用委托-------");
            Console.WriteLine(GetAdd(nums, 0, 3));
            Console.WriteLine(GetMulti(nums, 0, 3));
            Console.WriteLine("------使用Func委托-------");
            Console.WriteLine(CommmonCalcu(Add, nums, 0, 3));
            Console.WriteLine(CommmonCalcu(Multi, nums, 0, 3));
            Console.WriteLine("------使用Func委托+Lambda表达式-------");
            Console.WriteLine(CommmonCalcu((int a, int b) => a + b, nums, 0, 3));
            Console.WriteLine(CommmonCalcu((int a, int b) => a * b, nums, 0, 3));
            Console.ReadLine();
        }

        static int CommmonCalcu(Func<int,int,int> openation,int[] nums,int from,int to)
        {
            int result = nums[from]; //无论加乘，都需要使用第一个元素
            for (int i = from+1; i <= to; i++)
            {
                result = openation(result, nums[i]);
            }
            return result;
        }

        static int Add(int a, int b)
        {
            return a + b;
        }

        static int Multi(int a, int b)
        {
            return a * b;
        }

        static int GetAdd(int[] nums, int from, int to)
        {
            int result = 0;
            for (int i = from; i <= to; i++)
            {
                result += nums[i];
            }
            return result;
        }

        static int GetMulti(int[] nums, int from, int to)
        {
            int result = 1;
            for (int i = from; i <= to; i++)
            {
                result *= nums[i];
            }
            return result;
        }

　　Func委托引用一个有返回值的方法，也就是将方法作为另一个方法的“参数”

8.Action委托

　　Func委托必须要求接受的方法有一个返回值

　　Action委托接受一个没有返回值的方法，返回值为void

　　应用：在跨线程访问可视化控件的时候经常使用Action委托

9.Predicate委托

　　Predicate<T>委托定义如下：

　　public delegate bool Predicate<T>(T obj);

　　Predicate<T>委托变量引用一个“判断条件函数”，条件满足返回true。

        static void Main(string[] args)
        {
            List<Student> ListAll = new List<Student>()
            {
                new Student(){stuID=10001,stuName="小杨"},
                new Student(){stuID=10002,stuName="小朱"},
                new Student(){stuID=10003,stuName="小王"},
                new Student(){stuID=10004,stuName="小李"},
                new Student(){stuID=10005,stuName="小刘"},
                new Student(){stuID=10006,stuName="小张"},
                new Student(){stuID=10007,stuName="小梅"}
            };
            //List<T>集合中定义了一个FindAll方法：public T FindAll(Predicate<T> match)
            List<Student> list = ListAll.FindAll(s => s.stuID > 10003);
            foreach (var item in list)
            {
                Console.WriteLine(item.stuName + ":" + item.stuID);
            }
            Console.ReadLine();
        }

10.FindAll方法与Linq语句与Linq方法查询比较

        static void Main(string[] args)
        {
            List<Student> ListAll = new List<Student>()
            {
                new Student(){stuID=10001,stuName="小杨"},
                new Student(){stuID=10002,stuName="小朱"},
                new Student(){stuID=10003,stuName="小王"},
                new Student(){stuID=10004,stuName="小李"},
                new Student(){stuID=10005,stuName="小刘"},
                new Student(){stuID=10006,stuName="小张"},
                new Student(){stuID=10007,stuName="小梅"}
            };
            //List<T>集合中定义了一个FindAll方法：public T FindAll(Predicate<T> match)
            List<Student> list0 = ListAll.FindAll(s => s.stuID > 10003);
            Console.WriteLine("----------使用Predicate委托----------");
            foreach (var item in list0)
            {
                Console.WriteLine(item.stuName + ":" + item.stuID);
            }
            Console.WriteLine("----------使用Linq语句查询----------");
            var list1 = from stu in ListAll
                        where stu.stuID > 10003
                        select stu;
            foreach (var item in list1)
            {
                Console.WriteLine(item.stuName + ":" + item.stuID);
            }
            Console.WriteLine("----------使用Linq方法查询----------");
            var list2 = ListAll.Where(s => s.stuID > 10003)
                .Select(s => s);
            foreach (var item in list2)
            {
                Console.WriteLine(item.stuName + ":" + item.stuID);
            }
            Console.ReadLine();
        }

 11.泛型再结

　　委托三大意义：【1】委托解耦【2】异步多线程【3】

　　泛型好处：类型安全、方便编码、无需拆装箱操作

　　常见泛型：泛型类和泛型方法

　　后续深入：泛型委托（自定义泛型委托、Func、Action、Predicate）

　　提取不变的，封装变化的

12.泛型类的规范   public class 类名<T>{类的成员...}

　　T：仅仅表示一个占位符，只要符合C#的命名规范即可使用，但一般都是用T

　　T：表示一个通用的数据类型，在使用的时候用实际类型代替

　　T：泛型类可以在定义中包含多个任意类型的参数，参数之间用多个逗号分隔开

　　　　例如  class MyGenericClass<T1,T2,T3>{...}

　　　　各种类型参数可以用作成员变量的类型、属性或方法等成员的返回类型已经方法的参数类型等。

13.泛型应用于出入栈

    /// <summary>
    /// 编写一个入栈和出栈操作的通用类
    /// </summary>
    /// <typeparam name="T">可以是任意类型</typeparam>
    public class MyStack<T>
    {
        private T[] stack;
        private int size;//栈数据容量
        private int stackPoint;//当前位置指针

        public MyStack(int size)
        {
            this.size = size;
            stack = new T[size];
            stackPoint = -1;
        }

        /// <summary>
        /// 入栈方法
        /// </summary>
        /// <param name="item"></param>
        public void Push(T item)
        {
            if (stackPoint >= size)
            {
                Console.WriteLine("栈已满");
            }
            else
            {
                stackPoint++;
                stack[stackPoint] = item;
            }
        }
        /// <summary>
        /// 出栈方法
        /// </summary>
        /// <returns></returns>
        public T Pop()
        {
            T data = this.stack[stackPoint];
            stackPoint--;
            return data;
        }
    }

        //栈：先进后出
        static void Main(string[] args)
        {
            MyStack<int> objStack = new MyStack<int>(5);
            objStack.Push(1);
            objStack.Push(2);
            objStack.Push(3);
            objStack.Push(4);
            objStack.Push(5);
            Console.WriteLine(objStack.Pop());
            Console.WriteLine(objStack.Pop());
            Console.WriteLine(objStack.Pop());
            Console.WriteLine(objStack.Pop());
            Console.WriteLine(objStack.Pop());
            Console.ReadLine();
        }

 14.default关键字在泛型类中的使用

    class MyGenericClass1<T1, T2>
    {
        private T1 obj1;

        private MyGenericClass1()
        {
            //obj1 = null; //不能这么用
            //obj1 = new T1();//不能随便假设某种类型，这种类型也许没有构造方法，也许是私有的。

            //解决方法：default关键字
            obj1 = default(T1);//如果T1是引用类型，就赋值null，如果是值类型就给默认值，对于数值类型就是0，结构类型的话要依据具体的成员类型确定为0或者null
        }
    }

15.添加带约束的泛型类

　　约束泛型类：泛型类的参数类型受约束，例如泛型类有三个泛型参数，第一个要求必须是值类型、第二个要求必须是引用类型，诸如此类的约束。

     class MyGenericCalss2<T1, T2, T3>
        where T1 : struct //说明：类型必须是值类型
        where T2 : class //说明：类型必须是引用类型
        where T3 : new() //说明：类型必须有一个无参数的构造方法，且必须放到最后
    //其他类型：基类类型、接口类型
    {
        public List<T2> ProductList { get; set; }          //产品列表
        public T3 Publisher { get; set; }             //发行者
        public MyGenericCalss2()
        {
            ProductList = new List<T2>();
            Publisher = new T3();
        }
        /// <summary>
        /// 购买第几个产品
        /// </summary>
        /// <param name="num">产品索引</param>
        /// <returns>购买的产品</returns>
        public T2 Buy(T1 num)
        {
            // return ProductList[num];//直接写是错误的。因为数组通过下标访问的时候必须是int类型，而int和T1又是冲突的
            dynamic a = num; //动态类型，在编译时解析
            return ProductList[a];
        }
    }

    /// <summary>
    /// 课程（产品类）
    /// </summary>
    class Course
    {
        /// <summary>
        /// 课程名称
        /// </summary>
        public string CourseName { get; set; }
        /// <summary>
        /// 学习周期
        /// </summary>
        public int Period { get; set; }
    }
    /// <summary>
    /// 课程老师（发行人）
    /// </summary>
    class Teacher
    {
        public string Name { get; set; }//姓名
        public int Count { get; set; }//授课数量
    }

        static void Main(string[] args)
        {
            //【1】实例化泛型类型对象
            MyGenericCalss2<int, Course, Teacher> myClass2 = new MyGenericCalss2<int, Course, Teacher>();
            //【2】给对象属性赋值
            myClass2.Publisher = new Teacher() { Name = "常老师", Count = 20 }; //课程的发行人
            myClass2.ProductList = new List<Course>()       //课程（产品）列表
            {
                new Course(){CourseName =".NET-CS+BS高级工程师VIP班",Period=6},
                new Course(){CourseName =".NET-CS高级工程师VIP班",Period=3},
                new Course(){CourseName =".NET-BS高级工程师VIP班",Period=3},
            };
            //【3】调用对象方法
            Course myCourse = myClass2.Buy(0);
            //数据处理
            string info = string.Format("我购买的课程是：{0}  学期:{1}个月  课程主讲：{2}",
                myCourse.CourseName,
                myCourse.Period,
                myClass2.Publisher.Name);
            Console.WriteLine(info);
            Console.ReadLine();
        }

    /// <summary>
    /// 自己写的泛型约束类，模拟一个商品列表，购买以及商品发行人的实例
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            MyGenericClass<int, Course, Teacher> objGeneric = new MyGenericClass<int, Course, Teacher>();
            objGeneric.Publisher = new Teacher() { TeaName = "杨老师" };
            objGeneric.Products = new List<Course>()
            {
                new Course(){CourseName="C#教程",Period=12},
                new Course(){CourseName="VB教程",Period=10},
                new Course(){CourseName="SQLServer教程",Period=6}
            };
            Course objCourseBuy = objGeneric.Buy(1);
            string info = string.Format("购买的课程是{0}，课程授课时长是{1}，课程主讲老师是{2}", 
                objCourseBuy.CourseName, objCourseBuy.Period, objGeneric.Publisher.TeaName);
            Console.WriteLine(info);
            Console.ReadLine();
        }
    }

    /// <summary>
    /// 商品交互委托泛型类
    /// </summary>
    /// <typeparam name="T1">商品索引</typeparam>
    /// <typeparam name="T2">商品列表</typeparam>
    /// <typeparam name="T3">商品发行人</typeparam>
    public class MyGenericClass<T1, T2, T3>
        where T1 : struct //T1必须是值类型(值类型包括整型、浮点型、decimal、bool、enum)
        where T2 : class  //T2必须是引用类型（引用类型包括数组、class、interface、delegate、object、string）
        where T3 : new()  //T3必须有一个空的构造函数
    {
        public T3 Publisher;  //发行人
        public List<T2> Products = new List<T2>();  //商品
        public T2 Buy(T1 index)
        {
            dynamic t1 = index;
            return Products[t1];
        }
    }

    /// <summary>
    /// 课程（商品）类
    /// </summary>
    public class Course
    {
        /// <summary>
        /// 课程名称
        /// </summary>
        public string CourseName { get; set; } 
        /// <summary>
        /// 课程周期
        /// </summary>
        public int Period { get; set; }
    }

    /// <summary>
    /// 老师（发行人）类
    /// </summary>
    public class Teacher
    {
        /// <summary>
        /// 老师姓名
        /// </summary>
        public string TeaName { get; set; }
    }

16.泛型方法

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Add1("大家好", "我是帅气的杨三少"));
            Console.WriteLine("10+20={0}", Add1(10, 20));
            Console.WriteLine("10.2+20.3={0}", Add1(10.2, 20.3));
            Console.WriteLine("10+20.6={0}", Add1(10, 20.6));
            Console.ReadLine();
        }

        static T Add1<T>(T a, T b)
        {
            dynamic a1 = a;
            dynamic b1 = b;
            return a1 + b1;
        }

        static T Add2<T>(T a, T b) where T : struct
        {
            dynamic a1 = a;
            dynamic b1 = b;
            return a1 + b1;
        }
    }

 17.使用委托从窗体向子窗体发送消息

    //1.在主窗体定义委托
    public delegate void CountDele(string str);
    public partial class FrmMain : Form
    {
        public FrmMain()
        {
            InitializeComponent();

            FrmOther objOther = new FrmOther();
            //4.将委托变量与方法关联
            objOther.objCountDele = ShowCount;
            objOther.Show();
        }

        //2.在主窗体定义委托方法
        private void ShowCount(string str)
        {
            lbl_Count.Text = str;
        }
    }

        //3.定义委托变量
        public CountDele objCountDele;
        private int count = 0;
        public FrmOther()
        {
            InitializeComponent();
        }

        private void btn_1_Click(object sender, EventArgs e)
        {
            count++;
            //5.委托代替方法执行
            objCountDele(count.ToString());
        }

18.使用委托主窗体向多个从窗体传递消息

    //1.定义委托
    public delegate void DeleCount(string str);
    public partial class FrmMain : Form
    {
        //3.定义委托变量
        private DeleCount objDeleCount;
        private int count = 0;
        public FrmMain()
        {
            InitializeComponent();

            FrmOther01 frm01 = new FrmOther01();
            FrmOther02 frm02 = new FrmOther02();
            FrmOther03 frm03 = new FrmOther03();
            //4.委托变量关联委托方法
            objDeleCount += frm01.ShowCount;
            objDeleCount += frm02.ShowCount;
            objDeleCount += frm03.ShowCount;
            frm01.Show();
            frm02.Show();
            frm03.Show();
        }

        private void btn_Add_Click(object sender, EventArgs e)
        {
            //5.调用委托变量传递消息
            count++;
            objDeleCount(count.ToString());
        }

        private void btn_Clear_Click(object sender, EventArgs e)
        {
            //5.调用委托变量传递消息
            count = 0;
            objDeleCount(count.ToString());
        }
    }

        //2.定义委托方法
        public void ShowCount(string str)
        {
            lbl_Count.Text = str;
        }

19.事件event

　　事件：事件是对象在外界“刺激”下发生事情，而对外提供的一种消息机制。

　　事件就是委托类型。

　　事件的两个参与者：

　　　　发送者(Sender)：即对象本身，当本身状态发生变化时触发事件，并通知事件的接收者。

　　　　接收者(Receiver)：用来处理事件的(事件的关注者)，在事件发送者触发一个事件后，会自动执行的内容。

　　事件一般的使用规则：委托声明在主窗体类内。委托对象也叫委托实例或委托变量或事件event定义在事件的发送者所在类中，委托调用的方法定义在事件的接收者所在类中，事件关联在主窗体内，事件代替方法实现调用在发送者所在类内。

20.主窗体统一向多个从窗体发送消息（类似广播），与委托类似

    //1.声明委托
    public delegate void DeleSendMsg(string msg);
    public partial class FrmMain : Form
    {
        //3.定义事件
        public event DeleSendMsg EventSendMsg;
        public FrmMain()
        {
            InitializeComponent();
            FrmClient01 frm1 = new FrmClient01();
            FrmClient02 frm2 = new FrmClient02();
            //4.将主窗体的事件与客户端窗体的接收方法关联起来
            EventSendMsg += frm1.Receive;
            EventSendMsg += frm2.Receive;
            frm1.Show();
            frm2.Show();
        }

        private void btn_SendMsg_Click(object sender, EventArgs e)
        {
            //5.使用事件发送消息
            EventSendMsg(tb_Msg.Text.Trim());
        }
    }

        //2.定义客户端窗体的接收方法
        public void Receive(string msg)
        {
            tb_Msg.Text = msg;
        }

21.从窗体向主窗体发送消息，要求在主窗体中显示是来自谁的消息

    //1.定义委托
    public delegate void DeleSendMsg(string msg);
    public partial class FrmMain : Form
    {
        public FrmMain()
        {
            InitializeComponent();
            FrmClient1 frm1 = new FrmClient1();
            FrmClient2 frm2 = new FrmClient2();
            //5.事件关联方法
            frm1.EventSendMsg += Receice;
            frm2.EventSendMsg += Receice;
            frm1.Show();
            frm2.Show();
        }

        //2.定义主窗体接收消息的方法
        private void Receice(string msg)
        {
            tb_Msg.Text += msg + "
";
        }

        private void btn_ClearMsg_Click(object sender, EventArgs e)
        {
            tb_Msg.Text = "";
        }
    }

        //3.定义事件
        public event DeleSendMsg EventSendMsg;
        public FrmClient1()
        {
            InitializeComponent();
        }

        private void btn_SendMsg_Click(object sender, EventArgs e)
        {
            //4.事件发送消息
            EventSendMsg("客户端1的消息：" + tb_Msg.Text.Trim());
        }

        //3.定义事件
        public event DeleSendMsg EventSendMsg;
        public FrmClient2()
        {
            InitializeComponent();
        }

        private void btn_SendMsg_Click(object sender, EventArgs e)
        {
            //4.事件发送消息
            EventSendMsg("客户端2的消息：" + tb_Msg.Text.Trim());
        }

22.委托与事件的比较

　　事件在内部使用可以用“=”，如果是外部使用事件对象必须放在“+=”或“-=”的左边。

　　相同点：事件对象本质就是一个私有的委托对象，以及公有的两个方法，add和remove。

　　不同点：+=方式，实际上是调用add方法对委托对象进行添加。

　　　　　　事件对象私有化后，无法直接从外部赋值（内部赋值除外）。例如：事件=null;会出现编译错误，而委托允许这样做。

　　　　　　好处：避免用户直接将对象清除。比如微软给开发者所定义的各种事件，只允许开发者通过+=方式使用，而不允许开发者把定义好的事件清除掉。Click=null;这是不允许的。只能通过-=方式断开事件，这样能起到保护作用，而委托“太开放”

 23.异步编程　　

　　异步编程：核心是基于委托实现的。

　　委托类型的BeginInvoke(<输入和输出变量>,AsyncCallBack callBack,object ayncState)方法是异步调用的核心
　　第一个参数10，表示委托对应的方法实参
　　第二个参数CallBack，回调函数，表示异步调用结束后，自动调用的方法
　　第三个参数AsyncState，用于向回调函数提供相应的参数信息
　　返回值：IAsyncResult异步操作状态接口，封装了异步执行的参数

　　委托类型的EndInvoke(IAsyncResult)方法
　　参数是BeginInvoke方法的返回值
　　返回值：异步执行的结果，返回值类型和委托类型、委托方法的返回值类型一致

    //异步编程的核心是基于委托
    public partial class FrmMain : Form
    {
        //异步执行【1】.声明委托
        public delegate int DeleExecute(int a);
        public FrmMain()
        {
            InitializeComponent();
        }

        //同步执行
        private void btnTest1_Click(object sender, EventArgs e)
        {
            lblInfo1.Text = ExecuteTask1(30).ToString();
            lblInfo2.Text = ExecuteTask2(40).ToString();
        }

        //异步执行【3】.异步调用
        private void btnTest2_Click(object sender, EventArgs e)
        {
            //定义委托变量，引用相应方法
            DeleExecute objDeleExecute = new DeleExecute(ExecuteTask1);

            //通过委托异步调用方法ExecuteTask1
            //委托类型的BeginInvoke(<输入和输出变量>,AsyncCallBack callBack,object ayncState)方法是异步调用的核心
            //第一个参数10，表示委托对应的方法实参
            //第二个参数CallBack，回调函数，表示异步调用结束后，自动调用的方法
            //第三个参数AsyncState，用于向回调函数提供相应的参数信息
            //返回值：IAsyncResult异步操作状态接口，封装了异步执行的参数

            //【1】.异步调用任务
            IAsyncResult result = objDeleExecute.BeginInvoke(50, null, null);
            lblInfo1.Text = "异步执行开始计算...";
            //【2】.可以并行执行其他任务
            lblInfo2.Text = ExecuteTask2(60).ToString();
            //【3】.获取异步执行的结果
            //委托类型的EndInvoke(IAsyncResult)方法
            //参数是BeginInvoke方法的返回值
            //返回值：异步执行的结果，返回值类型和委托类型、委托方法的返回值类型一致
            int r = objDeleExecute.EndInvoke(result);
            lblInfo1.Text = r.ToString();
        }

        //异步编程【2】.定义委托方法
        private int ExecuteTask1(int a)
        {
            System.Threading.Thread.Sleep(5000);
            return a * a;
        }

        private int ExecuteTask2(int a)
        {
            return a * a;
        }
    }

//同时执行10个任务，第i个任务演示i秒，计算返回i的平方
namespace _016异步编程执行多个任务
{
    //【1】.声明委托
    public delegate int DeleExecuteTasks(int a,int ms);
    public partial class FrmMain : Form
    {
        //【3】.创建委托变量，因为异步函数和回调函数都要用，所以定义为成员变量
        private DeleExecuteTasks objDeleExecuteTasks;
        public FrmMain()
        {
            InitializeComponent();
            //【3】.初始化委托变量
            objDeleExecuteTasks = new DeleExecuteTasks(ExecuteTask);
        }

        //【2】.定义委托方法
        private int ExecuteTask(int a, int ms)
        {
            System.Threading.Thread.Sleep(ms);
            return a * a;
        }
        //【4】.异步同时执行多个任务
        private void btn_AsyncTasks_Click(object sender, EventArgs e)
        {
            //使用循环发布多个任务
            for (int i = 1; i < 11; i++)
            {
                //开始异步执行
                //前两个参数与异步方法内的参数一致
                //AsyncCallBack:回调函数
                //object @object:最后一个参数是给回调函数的字段AsyncState(IAsyncResult.AsyncState)赋值，如果参数很多可以定义成类或结构
                objDeleExecuteTasks.BeginInvoke(10 * i, 1000 * i, MyAsyncCallBack, i);
            }
        }

        //【5】.回调函数：作用是当任务完成后的反馈机制，回调函数可以有自己的自定义参数
        private void MyAsyncCallBack(IAsyncResult result)
        {
            int r = objDeleExecuteTasks.EndInvoke(result);
            //IAsyncResult.AsyncState用来封装回调函数自定义参数，是object类型
            Console.WriteLine("第{0}个任务的执行结果为：{1}", result.AsyncState, r);
        }
    }
}

24.异步编程总结

　　异步编程是建立在委托基础上一种编程的方法

　　异步调用的每个方法都是在独立的线程中执行，本质上异步编程就是一种多线程程序，是简化的多线程

　　比较适合在后台运行较为耗时的简单任务，并且任务之间要求相互独立，任务中不应该有直接访问可视化控件的代码

　　如果后台任务要求必须按照特定顺序执行，或者访问共享资源，则异步编程不太合适，应该选择多线程开发技术

 25.线程Thread

　　进程：一个正在运行的程序就是一个进程，操作系统根据进程分配各种资源（比入内存...）

　　线程：操作系统为了提高效率会将一个进程分成多个线程，并按照线程来分配CPU执行时间

　　线程特点：在具有多个CPU的计算机中，可以并行执行

　　Thread类：表示托管线程，每个Thread对象都代表一个托管线程，每个托管线程都会对应一个函数

　　ThreadStart 委托定义：public delegate void ThreadStart()    无返回值且无参数

        private void btn_TaskThread1_Click(object sender, EventArgs e)
        {
            //ThreadStart 委托类型 返回值void且无参数
            int a = 0;
            Thread objThread1=new Thread(delegate()
                {
                    for (int i = 1; i <= 10; i++)
                    {
                        a += i;
                        Console.WriteLine("-----1线程------{0}---", a);
                        Thread.Sleep(500);
                    }
                });
            objThread1.IsBackground = true;
            objThread1.Start();
        }

        private void btn_TaskThread2_Click(object sender, EventArgs e)
        {
            Thread objThread2 = new Thread(() =>
            {
                for (int i = 1; i < 100; i++)
                {
                    Console.WriteLine("-----2线程------{0}---", i);
                    Thread.Sleep(20);
                }
            });
            objThread2.IsBackground = true;
            objThread2.Start();
        }

26.跨线程访问控件

        private void btnExecute1_Click(object sender, EventArgs e)
        {
            Thread objThread1 = new Thread(() =>
            {
                for (int i = 1; i < 11; i++)
                {
                    if (lblResult1.InvokeRequired)
                    {
                        lblResult1.Invoke(new Action<string>(s => lblResult1.Text = s), (i * i).ToString());
                        Thread.Sleep(100);
                    }
                }
            });
            objThread1.IsBackground = true;
            objThread1.Start();
        }

        private void btnExecute2_Click(object sender, EventArgs e)
        {
            Thread objThread2 = new Thread(() =>
            {
                for (int i = 11; i < 21; i++)
                {
                    if (lblResult2.InvokeRequired)
                    {
                        lblResult2.Invoke(new Action<string>(s => { lblResult2.Text = s; }), (i * i).ToString());
                        Thread.Sleep(200);
                    }
                }
            });
            objThread2.IsBackground = true;
            objThread2.Start();
        }

27.制作二次开发的控件

　　1.新建项目——>选择类库——>删除自生成的class1——>添加组件——>进入代码视图——>将ComPonent直接替换成TextBox——>引用添加System.Windows.Forms——>using命名空间——>添加一个ErrorProvider——>编写public的验证是否为空的方法

        /// <summary>
        /// 判断文本框输入是否为空
        /// </summary>
        /// <returns>返回值【0为空】【1不为空】</returns>
        public int BeginCheckEmpty()
        {
            if (this.Text.Trim() == "")
            {
                errorProvider.SetError(this, "必填项不能为空！");
                return 0;
            }
            else
            {
                errorProvider.SetError(this,string.Empty);
                return 1;
            }
        }

        /// <summary>
        /// 判断文本框输入是否为正整数
        /// </summary>
        /// <param name="regularExpression">正则表达式</param>
        /// <param name="errorMsg">匹配失败后返回的消息</param>
        /// <returns>返回值【0匹配失败】【1匹配成功】</returns>
        public int BeginCheckRegularExpression(string regularExpression, string errorMsg)
        {
            if (BeginCheckEmpty() == 0)
            {
                return 0;
            }
            Regex objRegex = new Regex(regularExpression, RegexOptions.IgnoreCase);
            if (objRegex.IsMatch(this.Text.Trim()))
            {
                errorProvider.SetError(this, string.Empty);
                return 1;
            }
            else
            {
                errorProvider.SetError(this, errorMsg);
                return 0;
            }
        }

        private void btn_Save_Click(object sender, EventArgs e)
        {
            int a = STB_Name.BeginCheckEmpty();
            int b = STB_Age.BeginCheckRegularExpression(@"^[1-9]d*$", "年龄必须为正整数！");
            int result = a * b;
            if (result!=0)
            {
                MessageBox.Show("保存成功");
            }
        }