委托

最简单的委托示例：

// 该委托可以指向任何传入两个整数并返回一个整数的方法
    public delegate int BinaryOp( int x, int y );
    public class SimpleMath
    {
        public int Add( int x, int y )
        { return x + y; }
        public int Subtract( int x, int y )
        { return x - y; }
        public static int SquareNumber( int a )
        { return a * a; }
    } 
    class Program
    {
        static void Main( string[] args )
        {
            Console.WriteLine("***** Simple Delegate Example *****\n");

            SimpleMath m = new SimpleMath();

            BinaryOp b = new BinaryOp(m.Add);
            DisplayDelegateInfo(b);
      
            Console.WriteLine("10 + 10 is {0}", b(10, 10));

            Console.ReadLine();
        }    
        static void DisplayDelegateInfo( Delegate delObj )
        {           
            foreach (Delegate d in delObj.GetInvocationList())
            {
                Console.WriteLine("Method Name: {0}", d.Method);
                Console.WriteLine("Type Name: {0}", d.Target);
            }
        }      
    }

 

支持多路广播的委托示例：

/*
 * 2015.5
 * Car.cs
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CarDelegate
{
    public class Car
    {
        // 内部状态数据
        public int CurrentSpeed { get; set; }
        public int MaxSpeed { get; set; }
        public string PetName { get; set; }
        private bool carIsDead = false;

        // 构造函数
        public Car() { MaxSpeed = 180; }
        public Car( string name, int maxSp, int currSp )
        {
            CurrentSpeed = currSp;
            MaxSpeed = maxSp;
            PetName = name;
        }
     
        // 定义委托类型
        public delegate void CarEngineHandler( string msgForCaller );

        // 定义每个委托类型的成员变量
        private CarEngineHandler listOfHandlers;

        // 添加注册函数
        public void RegisterWithCarEngine( CarEngineHandler methodToCall )
        {   // 给每个委托对象添加多个方法
            // 支持多路广播，可以使用 +=操作符，或直接调用Delegate.Combine()

            // listOfHandlers += methodToCall; 

            if (listOfHandlers == null)
                listOfHandlers = methodToCall;
            else
                Delegate.Combine(listOfHandlers, methodToCall);
        }

        public void UnRegisterWithCarEngine( CarEngineHandler methodToCall )
        {   // 从委托的调用列表移除成员, 也可调用 Delegate.Remove()

            listOfHandlers -= methodToCall;
        }
   
        public void Accelerate( int delta )
        {        
            if (carIsDead)
            {
                if (listOfHandlers != null)
                    listOfHandlers("Sorry, this car is dead...");
            }
            else
            {
                CurrentSpeed += delta;
                if (10 == (MaxSpeed - CurrentSpeed)
                    && listOfHandlers != null)
                {
                    listOfHandlers("Careful buddy!");
                }
                if (CurrentSpeed >= MaxSpeed)
                    carIsDead = true;
                else
                    Console.WriteLine("CurrentSpeed = {0}", CurrentSpeed);
            }
        }
    }
}

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

namespace CarDelegate
{
    class Program
    {
        static void Main( string[] args )
        {
            Console.WriteLine("***** Delegates as event enablers *****\n");

            Car c1 = new Car("BMW", 100, 10);
                      
            // 先绑定委托对象，稍后再注销
            Car.CarEngineHandler handler2 = new Car.CarEngineHandler(OnCarEngineEvent2);
            c1.RegisterWithCarEngine(handler2);

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

            c1.UnRegisterWithCarEngine(handler2);

            // 注销上一种方法，注册另一种方法
            // 观察到两种方法的输出不一样
            c1.RegisterWithCarEngine(new Car.CarEngineHandler(OnCarEngineEvent));
            Console.WriteLine("***** Speeding up 2*****");
            for (int i = 0; i < 6; i++)
                c1.Accelerate(20);

            Console.ReadLine();
        }
     
        public static void OnCarEngineEvent( string msg )
        {
            Console.WriteLine("\n***** Message From Car Object *****");
            Console.WriteLine("=> {0}", msg);
            Console.WriteLine("***********************************\n");
        }

        public static void OnCarEngineEvent2( string msg )
        {
            Console.WriteLine("=> {0}", msg.ToUpper());
        }
    }
}

 

泛型Action<>和Func<>委托示例：

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

namespace ActionAndFuncDelegates
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("***** Fun with Action and Func *****\n");

            // 使用泛型 Action<> 委托来指向DisplayMessage， Action<>可以指向多至16个参数
            Action<string, ConsoleColor, int> actionTarget = 
                new Action<string, ConsoleColor, int>(DisplayMessage);

            actionTarget("Action Message!", ConsoleColor.Green, 5);

            // 使用泛型 Func<> 委托
            Func<int, int, int> funcTarget = new Func<int, int, int>(Add);
            int result = funcTarget.Invoke(40, 40);
            Console.WriteLine("40 + 40 = {0}", result);

            Func<int, int, string> funcTarget2 = new Func<int, int, string>(SumToString);
            string sum = funcTarget2(90, 300);
            Console.WriteLine(sum);

            Console.ReadLine();
        }

        static void DisplayMessage(string msg, ConsoleColor txtColor, int printCount)
        {
            // 设置命令行文本颜色 
            ConsoleColor previous = Console.ForegroundColor;
            Console.ForegroundColor = txtColor;

            for (int i = 0; i < printCount; i++)
            {
                Console.WriteLine(msg);
            }
            // 重置颜色 
            Console.ForegroundColor = previous;
        }
      
        static int Add(int x, int y)
        {
            return x + y;
        }

        static string SumToString(int x, int y)
        {
            return (x + y).ToString();
        }
    }
}

 

在事件注册时直接将一个委托与一段代码相关联称为匿名方法。使用 +=语法处理事件时被内联定义。

如：　　

Car c1 = new Car("BMW", 100, 10);

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

};

 

C#的Lambda 表达式都使用 Lambda 运算符 =>，该运算符读为“goes to”。语法如下：

形参列表=>函数体

函数体多于一条语句的可用大括号括起。

Lambda 表达式可以用于任何匿名方法或者强类型委托可以应用的场合，而且比匿名方法更节省编码时间。其实编译器只是把表达式编译为使用委托Predicate<T>的标准匿名方法而已。

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

namespace LambdaExpressionsMultipleParams
{
    public class SimpleMath
    {
        // 多个参数
        public delegate void MathMessage( string msg, int result );
        private MathMessage mmDelegate;

        public void SetMathHandler( MathMessage target )
        { mmDelegate = target; }

        public void Add( int x, int y )
        {
            if (mmDelegate != null)
                mmDelegate.Invoke("Adding has completed!", x + y);
        }
    }

    class Program
    {
        static void Main( string[] args )
        {
            // 使用Lambda表达式注册委托
            SimpleMath m = new SimpleMath();
            m.SetMathHandler(( msg, result ) =>
            { Console.WriteLine("Message: {0}, Result: {1}", msg, result); });

            // 执行Lambda表达式
            m.Add(10, 10);
            Console.ReadLine();
        }
    }
}