委托-c#版

      1. 委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If-Else(Switch)语句，同时使得程序具有更好的可扩展性。
       2.方法并不能直接被当作参数被传递和调用
       3. 委托也是一种类型，所以委托和类是同级的，可以通过委托来掉用方法，不要误以为委托和方法同级的
      4.委托的定义： public delegate int 委托名(int a, int b);它的定义有这几个特点，（1）可以用访问修饰符修饰。（2）delegate关键字。（3）有返回值和参数。
        5.委托是一种类型，与之对应的方法必须和它具有相同的签名，即相同的参数个数，相同的参数类型和相同的返回值类型

       6.无返回值的委托，你给它注册多少个方法，它就执 行多少个方法，而有返回值的委托，同样注册多少个方法就执行多少个方法，但返回的是最后一个方法的返回值。

       7.使用-=最终是将委托置为null，为null另一个意思就是空引用，这样就可以等待垃圾回收器进行回收了。

例1：

    class Program
    {
        private delegate void  Expression();
        static void Main(string[] args)
        {
            //Expression ex = new Expression(Add);也可以，但没有下面这种常用
            Expression ex = Add;
            Add();
            Console.ReadKey();
        }
        public static int a = 2;
        public static void Add()
        {
            Console.WriteLine(a + a); 
        }
    }

例2：

    class Program
    {
        public delegate void P();
        static void Main(string[] args)
        {

            P p = Person.Name ;
            p += Person.Age;
            p();
            Console.ReadKey();
        }
        
        public class Person
        {
            public static void Name()
            {
                Console.WriteLine("我是Zhangsan");
            }
            public static void Age()
            {
                Console.WriteLine(",今年20岁");
            }
        }
    }

 

例3：

 

    class Program
    {
        private delegate int Expression(int a, int b);
        static void Main(string[] args)
        {
            Calculate(Add, 1, 2);

            Console.ReadKey();
        }
        static int Add(int a, int b)
        {
            return a + b;
        }
        static int Divide(int a, int b)
        {
            return a - b;
        }
        static void Calculate(Expression ex, int a, int b)
        {
            Console.WriteLine(ex(a, b));
        }
    }

例四：

    class Program
    {
        private delegate int Expression(int a, int b);
        static void Main(string[] args)
        {
            Expression add = new Expression(Add);
            Expression divide = Divide;
            
            Console.WriteLine(add(1, 2));
            Console.WriteLine(divide(6, 2));

            Console.ReadKey();
        }
        static int Add(int a, int b)
        {
            return a + b;
        }
        static int Divide(int a, int b)
        {
            return a - b;
        }
    }

例五：（Action委托）

          Action是系统内置（预定义）的一个委托类型，它指向了一个没有返回值的方法。

 class Program
    {
        static void Main(string[] args)
        {
            Action a = PrintInt;
            Action<string> b = PrintString;
            Action<int, int> c = PrintTwoInt;

            a();
            b("你好");
            c(2,3);

            Console.ReadKey();
        }
        static void PrintInt()
        {
            Console.WriteLine("hello world");
        }
        static void PrintString(string str)
        {
            Console.WriteLine(str);
        }
        static void PrintTwoInt(int a,int b)
        {
            Console.WriteLine(a .ToString ()+ b.ToString ());
        }
    }

例六：（Func委托）

             Func是系统内置（预定义）的一个委托类型，它指向了带有一个返回值的方法。它可以传递0-16个参数类型，和一个返回值类型。

    class Program
    {
        static void Main(string[] args)
        {
            Func<int> a = Test1;//Func中的泛型类型指的是方法的返回值类型
            Func<string, int> b = Test2;//func后面可以跟很多类型，最后一个类型是返回值类型，前面的类型是参数类型，参数类型必须跟指定的方法的参数类型按照顺序对应
            Func<int, int, int> c = Test3;//func后面必须指定一个返回值类型，参数类型可以有0-16个，先写参数类型，最后一个是返回值类型

            a();
            b("你好");
            c(2,5);

            Console.ReadKey();
        }
        static int Test1()
        {
            return 1;
        }
        static int Test2(string str)
        {
            Console.WriteLine(str);
            return 100;
        }
        static int Test3(int i,int j)
        {
            return i + j;
        }
    }

实例：（猫捉老鼠，观察者模式，func）

猫类：

    class Cat
    {
        string name;
        public Cat (string name)
        {
            this.name = name;
        }
        public void CatComing()
        {
            Console.WriteLine(name + "来了");
            if(catcome !=null)
            {
                catcome();
            }
        }
        public Action catcome;
    }

老鼠类：

    class Mouse
    {
        string name;
        public Mouse (string name ,Cat cat)
        {
            this.name = name;
            cat.catcome += MouseRun;
        }
        public void MouseRun()
        {
            Console.WriteLine(name + "开始跑了");
        }
    }

客户端：

    class Program
    {
        static void Main(string[] args)
        {
            Cat cat1 = new Cat("汤姆猫");

            Mouse mouse1 = new Mouse("大老鼠",cat1 );
            Mouse mouse2 = new Mouse("小老鼠",cat1 );

            cat1.CatComing();
            Console.ReadKey();
        }
    }