C#委托 事件 小计

　　委托 、事件， 一直是个门槛，实际应用中基本上没有使用，但是当自己写一套方法时候，了解就有必要了！

　　委托：委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If-Else(Switch)语句，同时使得程序具有更好的可扩展性。

通用例子：

public void GreetPeople(string name,int type )
{
    if(type==1)
        EnglishGreeting(name);
    else 
         ChineseGreeting(name);
}
public void EnglishGreeting(string name)
{
    Console.WriteLine("Morning, " + name);
}
public void ChineseGreeting(string name)
{
    Console.WriteLine("早上好, " + name);
}

namespace Delegate {
//定义委托，它定义了可以代表的方法的类型
public delegate void GreetingDelegate(string name);
//新建的GreetingManager类
public class GreetingManager{
public GreetingDelegate delegate1;

public void GreetPeople(string name, GreetingDelegate MakeGreeting) {
//MakeGreeting(name);

if(delegate1!=null){ //如果有方法注册委托变量
delegate1(name); //通过委托调用方法
}

}
}
class Program {
private static void EnglishGreeting(string name) {
Console.WriteLine("Morning, " + name);
}
private static void ChineseGreeting(string name) {
Console.WriteLine("早上好, " + name);
}
static void Main(string[] args) {
   GreetingManager gm = new GreetingManager();
    gm.delegate1 = EnglishGreeting;
    gm.delegate1 += ChineseGreeting;
    gm.GreetPeople("Jimmy Zhang"); 
}
}
}

这个例子中可以看出 可以对委托进行方法的绑定、解除 （+= 、 -=）

这样会有一个问题的，那就是我们可以再类外面随意的干扰，破坏这个委托，如：

gm.delegate1=null;

这样就有了事件，对一个属性 保护使用封装

对委托进行保护则使用事件

在类的内部，不管你声明它是public还是protected，它总是private的。

在类的外部，注册方法 “+=”和注销方法“-=”的访问限定符（）与你在声明事件时使用的访问符相同

说明我们没法对事件用赋值[=] 号来进行注册，这就避免了破坏直接委托链的指针指向了

代码：

public event GreetingDelegate MakeGreet;
public void GreetPeople(string name) {
MakeGreet(name);
}
}

static void Main(string[] args) {
GreetingManager gm = new GreetingManager();
gm.MakeGreet = EnglishGreeting; 
// 编译错误1 只能使用+=  -= 之前绑定的多个方法不受影响
gm.MakeGreet += ChineseGreeting;
gm.GreetPeople("Jimmy Zhang");
}

 http://www.cnblogs.com/leslies2/archive/2012/03/22/2389318.html这个要搞搞

委托的协变

public class Worker
     {.......}
     public class Manager:Worker
     {.......}
 
      class Program
     {
         public delegate Worker GetWorkerHandler(int id);
         //在 Framework2.0 以上，委托 GetWorkerHandler 可绑定 GetWorker 与 GetManager 两个方法10  
         public static Worker GetWorker(int id)
         {
             Worker worker = new Worker();
             return worker;
         }
 
         public static Manager GetManager(int id)
         {
             Manager manager = new Manager();
             return manager;
         }
 
        static void Main(string[] args)
        {
            GetWorkerHandler workerHandler = new GetWorkerHandler(GetWorker);
            Worker worker=workerHandler(1);
            GetWorkerHandler managerHandler = new GetWorkerHandler(GetManager);
            Manager manager = managerHandler(2) as Manager;
            Console.ReadKey();
        }
     }

委托GetWorkerHandler 使用GetWorker  将返回一个Worker   但是使用委托传递GetManager也将返回一个可以转为Manager的Worker
委托的逆变

class Program
    {
        public delegate void Handler(object obj);

        public static void GetMessage(object message)
        {
            if (message is string)
                Console.WriteLine("His name is : " + message.ToString());
            if (message is int)
                Console.WriteLine("His age is : " + message.ToString());
        }

        static void Main(string[] args)
        {
            Handler handler = new Handler(GetMessage);
            handler(29);
            Console.ReadKey();
        }
   }

委托逆变是从方法的参数上面做手脚，可以接受未知类型的参数

泛型委托

委托逆变虽然实用，但如果都以 object 作为参数，则需要每次都对参数进行类型的判断，这不禁令人感到厌烦。

为此，泛型委托应运而生，泛型委托有着委托逆变的优点，同时利用泛型的特性，可以使一个委托绑定多个不同类型参数的方法，而且在方法中不需要使用 is 进行类型判断，从而简化了代码。

class Program
    {
        public delegate void Handler<T>(T obj);

        public static void GetWorkerWages(Worker worker)
        {
            Console.WriteLine("Worker's total wages is " + worker.Wages);
        }

        public static void GetManagerWages(Manager manager)
        {
            Console.WriteLine("Manager's total wages is "+manager.Wages);
        }

        static void Main(string[] args)
        {
            Handler<Worker> workerHander = new Handler<Worker>(GetWorkerWages);
            Worker worker = new Worker();
            worker.Wages = 3000;
            workerHander(worker);

            Handler<Manager> managerHandler = new Handler<Manager>(GetManagerWages);
            Manager manager = new Manager();
            manager.Wages = 4500;
            managerHandler(manager);

            Console.ReadKey();
        }
    }