简单谈一下对委托的认识，算是对这篇博客（ 这里）的理解和概括吧！

委托（Delegate）首先可以看做一个特殊的类，而一些函数是他的变量取值范围。

如声明一个委托：public delegate void GreetingDelegate(string name);那么我们在别的函数中把函数名当做变量传进来，这样子就可以调用相应的函数了。委托应该先声明才能用，注意作用范围。在任意函数里就可以用这个委托了。public void GreetingPeople(string name, GreetingDelegate MakeGreeting); 第二个参数就可以赋值为不同的函数名。可以这样子 调用这个函数，GreetingPeople("Bruce", ChineseGreering); 或者 GreetingPeople(string name, EnglishGreeting); 注意这里的两个函数 ChineseGreeting 和 EnglishGreeting 得和GreetingDelegate的类型一样（返回值，参数）。

我们可以声明一个委托类型，并把函数赋值（或者说改叫绑定了）过来，如 GreetingDelegate delegate1; delegate1 = EnglishGreeting; delegate1 += ChineseGreeting; 这样子可以同时调用两个函数了，当然，这里的参数是一样的。

这里的 delegate1 既然是一个特殊的函数，那么就可以像函数那样直接调用：delegate1("Bruce"); 效果是一样的。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication2
{
    public delegate void GreetingDelegate(string name);
    class Program
    {
        private static void EnglishGreeting(string name)
        {
            Console.WriteLine("Good morning!  " + name);
        }

        private static void ChineseGreeing(string name)
        {
            Console.WriteLine("您好!  " + name);
        }

        private static void Greeting(string name, GreetingDelegate MakeGreeting)
        {
            MakeGreeting(name);
        }

        static void Main(string[] args)
        {
            GreetingDelegate delegate1, delegate2;
            delegate1 = ChineseGreeing;
            delegate1 += EnglishGreeting;
            delegate2 = EnglishGreeting;
            Greeting("张小彬", delegate1);
            Greeting("Bruce", delegate2);
            Console.ReadKey();
            
        }
    }
}

事件（Event）是一个特殊的委托变量，只是封装了委托类型的变量。

event 和 delegate1 只是访问权相不一样，对委托的变量，类型定义为public（太暴露）和private（失去作用）都不合适，于是event出现了。事件变量（或者说委托变量）在类的内部相当于是私有的，在外部只能有+=和-=操作。

Observer设计模式

Observer设计模式有两类身份，一个叫做Subject，即目标，监视的对象；另一个叫做Observer，即监视者。Subject一旦有某些特定的行为（如学生，作弊的行为），那么注册过的Observer会相应该行为（如老师，立刻过去没收考卷）。Observer设计模式是一种松耦合的设计模式。我们一般在Subject中定义事件（Event）和触发规则。下面是一个加热器的例子，显然不符合微软的规范，但是对理解概念很有帮助

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication3
{
    public class Heater
    {
        private int temperature;
        public delegate void NowHandler(string param);
        public event NowHandler MyEvent;

        public void heat()
        {
            for (int i = 0; i <= 100; ++i)
            {
                temperature = i;
                if (temperature > 95)
                {
                    MyEvent(i + "");
                }
            }
        }
    }

    public class Alarm
    {
        public void AlarmNow(string param)
        {
            Console.WriteLine("Alarm: Fire! Fire!" + param);
        }
    }

    public class Display
    {
        public void DisplayNow(string param)
        {
            Console.WriteLine("Display: Fire! Fire!" + param);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Heater heater = new Heater();
            Alarm alarm = new Alarm();
            Display display = new Display();
            heater.MyEvent += alarm.AlarmNow;
            heater.MyEvent += display.DisplayNow;
            heater.heat();
            Console.ReadKey();
        }
    }
}