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(10 , 20));
            Tools.OutputParams(dg.Invoke(20, 10));
            //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 *****
");

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

            // 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 = 0; i < 6; i++)
                c1.Accelerate(20);

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

            Console.WriteLine("
***** Speeding up *****");
            for (int i = 0; i < 6; i++)
                c1.Accelerate(20);

            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 = 100;
        }

        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 (10 == 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 = 0;

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

            // 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("
***** Speeding up *****");
            for (int i = 0; i < 6; i++)
                c1.SpeedUp(20);

            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 = 100;
        }

        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 (10 == 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 *****
");
      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[] { 20, 1, 4, 8, 9, 44 });

      // 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}	", evenNumber);
      }
      Console.WriteLine();
    }
    // Target for the Predicate<> delegate.
    static bool IsEvenNumber(int i)
    {
      // Is it an even number?
      return (i % 2) == 0;
    }
    #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[] { 20, 1, 4, 8, 9, 44 });

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

      Console.WriteLine("Here are your even numbers:");
      foreach (int evenNumber in evenNumbers)
      {
        Console.Write("{0}	", 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[] { 20, 1, 4, 8, 9, 44 });

      // 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 % 2) == 0);
        return isEven;
      });

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

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

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