委托的高级使用

线程之间互不相干但是

多播(multicast)委托

举个例子：不同学生用不同颜色的笔做作业。
学生类（这个类在以下的各个例子中是不变的）

    class Student
    {
        public int ID { get; set; }
        public ConsoleColor PenColor { get; set; }
        public void DoHomework()
        {
            for (int i = 0; i < 5; ++i)
            {
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student{0} doing homework {1} hour(s).", this.ID, i);
                Thread.Sleep(1000);//线程睡一秒
            }
        }
    }

把委托1，2，3都合并到委托1里，只调用委托1。这样用一个委托封装多个委托方法的过程就叫多播委托。

 class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Red};
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Yellow };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Blue };

            Action action1 = new Action(stu1.DoHomework);
            Action action2 = new Action(stu2.DoHomework);
            Action action3 = new Action(stu3.DoHomework);

            action1 = action1 + action2;
            action1 = action1 + action3;
            action1.Invoke();
        }
    }

多播委托调用的执行顺序按照是封装方法的顺序执行的

            action1.Invoke();
            action2.Invoke();
            action3.Invoke();

结果：

同步调用：
直接同步调用：通过方法名调用
间接同步调用：通过委托调用

直接同步调用（通过方法名调用）
这个直接和间接是以是否用委托来区分的，不用委托直接方法名调用就是直接调用，用委托就是间接调用。

    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Red};
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Yellow };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Blue };
            stu1.DoHomework();
            stu2.DoHomework();
            stu3.DoHomework();
            for (int i = 0; i < 5; ++i)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;//青色
                Console.WriteLine("Main thread{0}", i);//这里thread代表主线程
                Thread.Sleep(1000);
            }
        }
    }

三个直接调用的颜色结束后，主线程还要进行一段（打印青色字体）

即这种情形，红色的是主线程，然后分别调用了三个方法，方法结束再回到主线程。

间接同步调用（通过委托调用）

            stu1.DoHomework();
            stu2.DoHomework();
            stu3.DoHomework();

替换为

            action1.Invoke();
            action2.Invoke();
            action3.Invoke();

结果是一样的，没什么好多说的。
上面的多播委托，也是同步调用的（间接调用），同步异步与直接间接是没有相关性的，这两个概念可以任意组合。

异步调用：
隐式异步调用：BeginInvoke方法
显式异步调用：Thread
显式异步调用：Task

隐式异步调用（使用委托，自然都是间接调用）
委托除了Invoke方法，还有个方法叫

这里的BeginInvoke方法会给我们自动生成一个分支线程，然后在分支线程里去调用它封装的方法。
BeginInvoke会要两个参数，
第一个是异步调用的回调（你不是要我在一个分支线程里去调用这个方法么，调用完了之后你打算让我后续做什么呢？也就是回调方法）
第二个参数，不知道是啥一般给null。
执行一下程序

    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Red};
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Yellow };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Blue };

            Action action1 = new Action(stu1.DoHomework);
            Action action2 = new Action(stu2.DoHomework);
            Action action3 = new Action(stu3.DoHomework);

            action1.BeginInvoke(null, null);
            action2.BeginInvoke(null, null);
            action3.BeginInvoke(null, null);
            for (int i = 0; i < 5; ++i)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("Main thread{0}", i);
                Thread.Sleep(1000);
            }
        }
    }

结果（在.Net Core是会报错的，因此是在.Net Freamwork下运行的）

可以看到颜色和执行顺序是乱的

而且每次运行的结果都不同。
为什么呢？
是因为三个线程都在访问控制台的前景色(ForegroundColor)这个属性，
多个线程在访问同一个资源的时候，就可能在争抢资源时发生冲突，
我们看到的就是发生冲突的场景。为了避免冲突，我们会为线程加锁。

那么是如何争抢资源的呢？

我们通过监视可以发现：
控制台的ForegroundColor属性是个静态属性，属于主线程。

action1.BeginInvoke(null, null);
action2.BeginInvoke(null, null);
action3.BeginInvoke(null, null);
这三个子线程并发进行，每一时刻都不确定谁在执行，谁前谁后。
这三个子线程都有可能调用(修改)主线程的ForegroundColor静态属性
举个具体例子：
一：
如果是action1.BeginInvoke(null, null);先启动的，
把ForegroundColor属性赋予了 Red，
二：
action1还未打印就被action3.BeginInvoke(null, null);
把ForegroundColor属性改为了Blue
三：
action3还未打印就被action2.BeginInvoke(null, null);
把ForegroundColor属性改为了Yellow
四：
结果打印的时候action3.BeginInvoke(null, null);抢先打印的，这样
Student3 doing homework 0 hour(s).这句话是第一个被打印出来的，
而且它的颜色会是Yellow，
五：
随后
Student2 doing homework 0 hour(s).
Student1 doing homework 0 hour(s).
这两句话也紧跟着打印出来了，它们也是Yellow

具体情况随机性极强，千变万化。本质原因就是赋颜色和打印这两步里，
第一步都是三个线程对一个主线程的静态属性进行多次操作（争抢），
导致最后留下的是谁的颜色不清楚，随后在打印的时候三个线程的先后也有随机性，
这样重叠起来就会导致三个线程和一个主线程的各种颜色，输出顺序混乱。

显式异步调用（我们自己动手声明多线程）
方式一：比较古老的Thread

    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Red };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Yellow };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Blue };
            //创建三个线程
            Thread thread1 = new Thread(new ThreadStart(stu1.DoHomework));
            Thread thread2 = new Thread(new ThreadStart(stu2.DoHomework));
            Thread thread3 = new Thread(new ThreadStart(stu3.DoHomework));
            //启动三个线程
            thread1.Start();
            thread2.Start();
            thread3.Start();

            for (int i = 0; i < 5; ++i)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("Main thread{0}", i);
                Thread.Sleep(1000);
            }
        }
    }

结果：

主线程和支线程谁也不等谁，彼此独立运行，还有资源争抢。

除了使用Thread 进行显示的异步调用，C#类库给我们准备了一种更高级的方式——Task

方式二：
输入Task然后Ctrl+.会提示你输入名称空间

using System.Threading.Tasks;

    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Red };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Yellow };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Blue };

            Task task1 = new Task(new Action(stu1.DoHomework));
            Task task2 = new Task(new Action(stu2.DoHomework));
            Task task3 = new Task(new Action(stu3.DoHomework));

            task1.Start();
            task2.Start();
            task3.Start();

            for (int i = 0; i < 5; ++i)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("Main thread{0}", i);
                Thread.Sleep(1000);
            }
        }
    }

结果：

同样是主线程和支线程谁也不等谁，彼此独立运行，还有资源争抢。

应该适时地使用接口(interface)取代一些对委托的使用
Java中没有委托这个功能，Java用接口实现委托
这个例子源于：

用接口代替委托的方式：
产品类和包装盒类

    class Product
    {
        public string Name { get; set; }
    }
    class Box
    {
        public Product Product { get; set; }
    }

加工工厂类

    class WarpFactory
    {
        public Box WarpProduct(IProductFactory productFactory)
        {
            Box box = new Box();
            Product product = productFactory.Make();//Product类的product变量去接Make()方法返回的Product类型对象。
            box.Product = product;//传给box.product
            return box;
        }
    }

生产工厂接口

    interface IProductFactory
    {
        Product Make();
    }

产品工厂类被拆分成了披萨工厂和玩具车工厂，都继承生产工厂这个接口
披萨工厂类：生产工厂

    class PizzaFactory : IProductFactory
    {
        public Product Make()
        {
            Product product = new Product();
            product.Name = "Pizza";
            return product;
        }
    }

披萨工厂：生产工厂

    class ToyCarFactory : IProductFactory
    {
        public Product Make()
        {
            Product product = new Product();
            product.Name = "ToyCar";
            return product;
        }
    }
}

主函数类

    class Program
    {
        static void Main(string[] args)
        {
            IProductFactory pizzafactory = new PizzaFactory();
            IProductFactory toycarfactory = new ToyCarFactory();
            WarpFactory warpfactory = new WarpFactory();

            Box pizzabox = warpfactory.WarpProduct(pizzafactory);
            Box toycarbox = warpfactory.WarpProduct(toycarfactory);

            Console.WriteLine(pizzabox.Product.Name);
            Console.WriteLine(toycarbox.Product.Name);
        }
    }

结果是一样的：

但是我们的程序中已经没有委托了，没有了方法级别的耦合。