C#委托初探

委托是一种定义方法签名的类型，可以与具有兼容签名的任何方法关联。您可以通过委托调用其中已添加的方法列表。委托用于将方法作为参数传递给其他方法。事件处理程序就是通过委托调用的方法。您可以创建一个自定义方法，当发生特定事件时某个类（例如 Windows 控件）就可以调用您的方法。button的单击事件发生后，通过委托这个管道找到用户添加的处理方法，从而执行方法；不必像之前win32程序那样循环等待某个事件消息。

先直接添端代码进来，

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

 namespace Test_Delegate
 {
     //定义一个委托，对应方法签名为 int Fun(int , int )
     //编译器会自动生成一个委托类 dgOP,在此相当于声明一个类对象，稍后使用时new实例化
     //继承链如：Delegate:MulticastDelegate:Delegate:ICloneable,ISerializable
     public delegate int dgOP(int x, int y);
     //生成的类形如
     //sealed class dgOP : System.MulticastDelegate
     //{
     //    //构造函数，原理不清楚  ！！
     //    public dgOP(object target,unit functionAddr);
     //    //成员函数，可在外调用
     //    public virtual int Invoke(int x, int y);
     //    public virtual IAsyncResult BeginInvoke(int x, int y
     //        , AsyncCallback callback, object @object);
     //    public virtual int EndInvoke(IAsyncResult result);
     //}

     public class SimpleMath
     {
         /***********静态方法*******************/
         public static int Add(int x, int y)
         {
             Console.WriteLine("add");
             return x + y;
         }
         public static int Square(int x)
         {
             return x * x;
         }
         /***********动态方法*******************/

         public int Sub(int x, int y)
         {
             Console.WriteLine("sub");
             return x - y;
         }
     }

     class Program
     {
         static dgOP dg;
         static void Main(string[] args)
         {
             //静态方法
             //实例化上文中定义的（编译器自动生成的）委托类，并指定方法
             //+=内部隐式调用dgOP.Combine
             //Del(new dgOP(SimpleMath.Add));
             dg = dgOP.Combine(new dgOP(SimpleMath.Add),new dgOP(new SimpleMath().Sub)) as dgOP;
             //执行调用列表的函数,但最终只返回最后一个函数调用返回值。
             //dg(10 , 20)内部隐式调用 dg.Invoke(20 , 10)
             Tools.OutputParams(dg( , ));
             Tools.OutputParams(dg.Invoke(, ));
             //DisplayDelegate(dg);
             Tools.NewLine();

             ////动态方法
             //SimpleMath m=new SimpleMath();
             //dgOP dg2 = new dgOP(m.Sub);
             //Tools.OutputParams(dg2(10,20),dg2.Invoke(20,10));
             //DisplayDelegate(dg2);
             ////委托已经声明为方法签名为：void Fun(int x,int y)，对应2个参数
             ////SimpleMath.Square只含一个参数
             ////dgOP dg3 = new dgOP(SimpleMath.Square);

             Tools.Pause();
         }

         private static void Del(dgOP dgOP)
         {
             dg += dgOP;
         }

         private static dgOP Del()
         {
             dgOP dg = new dgOP(SimpleMath.Add);
             dg += new dgOP(new SimpleMath().Sub);
             return dg;
         }

         private static void DisplayDelegate(dgOP dg)
         {
             //输出委托列表内部的方法签名，类对象
             foreach (Delegate item in dg.GetInvocationList())
             {
                 Tools.OutputParams(item.Method, item.Target);
             }
         }

     }
 }

Tools类只是个工具，用来输出值至控制台，或者另起一行，停止控制台。

委托是最底层，事件是较上层，用来简化处理委托声明，封装维护调用列表。

 #region Using directives

 using System;
 using System.Collections.Generic;
 using System.Text;

 #endregion

 namespace CarEvents
 {
     class Program
     {
         static void Main(string[] args)
         {
             Console.WriteLine("***** Fun with Events *****\n");

             // Make a car as usual.
             Car c1 = new Car("SlugBug", , );

             // Register event handlers.
             c1.AboutToBlow += new Car.CarEventHandler(c1_AboutToBlow);
             c1.AboutToBlow += new Car.CarEventHandler(CarIsAlmostDoomed);
             c1.AboutToBlow += new Car.CarEventHandler(CarAboutToBlow);

             Car.CarEventHandler d = new Car.CarEventHandler(CarExploded);
             c1.Exploded += d;

             // Speed up (this will generate the events.)
             Console.WriteLine("***** Speeding up *****");
             for (int i = ; i < ; i++)
                 c1.Accelerate();

             // Remove CarExploded method
             // from invocation list.
             c1.Exploded -= d;

             Console.WriteLine("\n***** Speeding up *****");
             for (int i = ; i < ; i++)
                 c1.Accelerate();

             Console.ReadLine();
         }

         static void c1_AboutToBlow(string msg)
         {
             Console.WriteLine("xxxx");
         }

         public static void CarAboutToBlow(string msg)
         { Console.WriteLine(msg); }

         public static void CarIsAlmostDoomed(string msg)
         { Console.WriteLine("Critical Message from Car: {0}", msg); }

         public static void CarExploded(string msg)
         { Console.WriteLine(msg); }

     }
 }

 #region Using directives

 using System;
 using System.Collections.Generic;
 using System.Text;

 #endregion

 namespace CarEvents
 {
     public class Car
     {
         //// This delegate works in conjunction with the
         //// Car’s events.
         //public delegate void CarEventHandler(string msg);

         //// This car can send these events.
         //public event CarEventHandler Exploded;
         //public event CarEventHandler AboutToBlow;

         public delegate void CarEventHandler(string msg);

         public event CarEventHandler Exploded;
         public event CarEventHandler AboutToBlow;
         #region Basic Car members...

         #region Nested radio
         // Radio as nested type
         public class Radio
         {
             public void TurnOn(bool on)
             {
                 if (on)
                     Console.WriteLine("Jamming...");
                 else
                     Console.WriteLine("Quiet time...");
             }
         }
         #endregion

         // Internal state data.
         private int currSpeed;
         private int maxSpeed;
         private string petName;

         // Is the car alive or dead?
         bool carIsDead;

         // A car has-a radio.
         private Radio theMusicBox = new Radio();

         public Car()
         {
             maxSpeed = ;
         }

         public Car(string name, int max, int curr)
         {
             currSpeed = curr;
             maxSpeed = max;
             petName = name;
         }

         public void CrankTunes(bool state)
         {
             theMusicBox.TurnOn(state);
         }
         #endregion

         #region Accelerate method
         public void Accelerate(int delta)
         {
             // If the car is dead, fire Exploded event.
             if (carIsDead)
             {
                 if (Exploded != null)
                     Exploded("Sorry, this car is dead...");
             }
             else
             {
                 currSpeed += delta;

                 // Almost dead?
                 if ( == maxSpeed - currSpeed
                   && AboutToBlow != null)
                 {
                     AboutToBlow("Careful buddy!  Gonna blow!");
                 }

                 // Still OK!
                 if (currSpeed >= maxSpeed)
                     carIsDead = true;
                 else
                     Console.WriteLine("->CurrSpeed = {0}", currSpeed);
             }
         }
         #endregion

     }
 }

匿名方法是简化了委托及方法定义，不必再手动定义方法，直接间写在委托中。

 #region Using directives

 using System;
 using System.Collections.Generic;
 using System.Text;

 #endregion

 namespace AnonymousMethods
 {
     class Program
     {
         static void Main(string[] args)
         {
             Console.WriteLine("***** Anonymous Methods *****");

             int aboutToBlowCounter = ;

             // Make a car as usual.
             Car c1 = new Car("SlugBug", , );

             // Register event handlers as anonymous methods.
             c1.AboutToBlow += delegate
             {
                 aboutToBlowCounter++;
                 Console.WriteLine("Eek!  Going too fast!");
             };

             c1.AboutToBlow += delegate(object sender, CarEventArgs e)
             {
                 aboutToBlowCounter++;
                 Console.WriteLine("Message from Car: {0}", e.msg);
             };

             c1.Exploded += delegate(object sender, CarEventArgs e)
             { Console.WriteLine("Message from Car: {0}", e.msg); };

             // Speed up (this will generate the events.)
             Console.WriteLine("\n***** Speeding up *****");
             for (int i = ; i < ; i++)
                 c1.SpeedUp();

             Console.WriteLine("AboutToBlow event was fired {0} times",
               aboutToBlowCounter);

             Console.ReadLine();
         }
     }
 }
 #region Using directives

 using System;
 using System.Collections.Generic;
 using System.Text;

 #endregion

 namespace AnonymousMethods
 {
    //与上面的事件代码类似
     public class CarEventArgs : EventArgs
     {
         public readonly string msg;
         public CarEventArgs(string message)
         {
             msg = message;
         }
     }

     public class Car
     {
         // This delegate works in conjunction with the
         // Car’s events.
         public delegate void CarEventHandler(object sender, CarEventArgs e);

         // This car can send these events.
         public event CarEventHandler Exploded;
         public event CarEventHandler AboutToBlow;

         #region Basic Car members...
         #region Nested radio
         // Radio as nested type
         public class Radio
         {
             public void TurnOn(bool on)
             {
                 if (on)
                     Console.WriteLine("Jamming...");
                 else
                     Console.WriteLine("Quiet time...");
             }
         }
         #endregion

         // Internal state data.
         private int currSpeed;
         private int maxSpeed;
         private string petName;

         // Is the car alive or dead?
         bool carIsDead;

         // A car has-a radio.
         private Radio theMusicBox = new Radio();

         public Car()
         {
             maxSpeed = ;
         }

         public Car(string name, int max, int curr)
         {
             currSpeed = curr;
             maxSpeed = max;
             petName = name;
         }

         public void CrankTunes(bool state)
         {
             theMusicBox.TurnOn(state);
         }
 #endregion 

         public void SpeedUp(int delta)
         {
             // If the car is dead, fire Exploded event.
             if (carIsDead && Exploded != null)
             {
                 Exploded(this, new CarEventArgs("Sorry, this car is dead..."));
             }
             else
             {
                 currSpeed += delta;

                 // Almost dead?
                 if ( == maxSpeed - currSpeed
                     && AboutToBlow != null)
                 {
                     AboutToBlow(this, new CarEventArgs("Careful buddy!  Gonna blow!"));
                 }

                 // Still OK!
                 if (currSpeed >= maxSpeed)
                     carIsDead = true;
                 else
                     Console.WriteLine("->CurrSpeed = {0}", currSpeed);
             }
         }
     }
 }

而lambdar表达式则是对匿名方法的再次简化，由此可以引申出linq,ef的语法。

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

 namespace SimpleLambdaExpressions
 {
   class Program
   {
     static void Main(string[] args)
     {
       Console.WriteLine("***** Fun with Lambdas *****\n");
       TraditionalDelegateSyntax();
       AnonymousMethodSyntax();

       Console.WriteLine();
       LambdaExpressionSyntax();

       Console.ReadLine();
     }

     #region Traditional delegate syntax
     static void TraditionalDelegateSyntax()
     {
       // Make a list of integers.
       List<int> list = new List<int>();
       list.AddRange(new int[] { , , , , ,  });

       // Call FindAll() using traditional delegate syntax.
       Predicate<int> callback = new Predicate<int>(IsEvenNumber);
       List<int> evenNumbers = list.FindAll(callback);

       Console.WriteLine("Here are your even numbers:");
       foreach (int evenNumber in evenNumbers)
       {
         Console.Write("{0}\t", evenNumber);
       }
       Console.WriteLine();
     }
     // Target for the Predicate<> delegate.
     static bool IsEvenNumber(int i)
     {
       // Is it an even number?
       return (i % ) == ;
     }
     #endregion 

     #region Anonymous method syntax
     static void AnonymousMethodSyntax()
     {
       // Make a list of integers using C# 3.0
       // collection initialization syntax.
       List<int> list = new List<int>();
       list.AddRange(new int[] { , , , , ,  });

       List<int> evenNumbers = list.FindAll(
         delegate(int i)
         {
           return (i % ) == ;
         }
       );

       Console.WriteLine("Here are your even numbers:");
       foreach (int evenNumber in evenNumbers)
       {
         Console.Write("{0}\t", evenNumber);
       }
       Console.WriteLine();
     }
     #endregion

     #region Lambda expression syntax
     static void LambdaExpressionSyntax()
     {
       // Make a list of integers.
       List<int> list = new List<int>();
       list.AddRange(new int[] { , , , , ,  });

       // Now process each argument within a group of
       // code statements.
       List<int> evenNumbers = list.FindAll((i) =>
       {
         Console.WriteLine("value of i is currently: {0}", i);
         bool isEven = ((i % ) == );
         return isEven;
       });

       Console.WriteLine("Here are your even numbers:");
       foreach (int evenNumber in evenNumbers)
       {
         Console.Write("{0}\t", evenNumber);
       }
       Console.WriteLine();
     }
     #endregion
   }
 }

总结性的比较少，代码比较多。因为我还没有完全领悟，只是初步了解了下。

具体大家可以发挥google的优势。