分分搞懂c#中的委托

分分搞懂c#中的委托；

不说废话，不来虚的概念，不管代码是否有意义，看我的优化之路，你会理解委托了；

源代码1

public class test
    {
        //我们不管代码是否有意义，我们直接看代码重构和一步步优化的过程
        int flage = 1;
        public void show(int a)
        {
            if (flage == 1)
            {
                do1(a);
            }
            else if (flage == 2)
            {
                do2(a);
            }
            else if (flage == 3)
            {
                do3(a);
            }
            else if (flage == 4)
            {
                do4(a);
            }
            else
            {

            }

        }

        public void do1(int val)
        {
        }
        public void do2(int val)
        {

        }
        public void do3(int val)
        {

        }
        public void do4(int val)
        {

        }


    }

优化一：

public enum flag
    {
        a = 1,
        b = 2,
        c = 3,
        d = 4
    }

    public class test2
    {
public void show(int a, flag f)
        {
            switch (f)
            {
                case flag.a:
                    do1(a);
                    break;
                case flag.b:
                    do2(a);
                    break;
                case flag.c:
                    do3(a);
                    break;
                case flag.d:
                    do4(a);
                    break;
            }
        }

        public void do1(int val)
        {
        }
        public void do2(int val)
        {

        }
        public void do3(int val)
        {

        }
        public void do4(int val)
        {

        }


    }

优化二（委托“现身了”）

public delegate void mydelegate(int val);
    public class test3
    {
        public void show(int a,mydelegate de )
        {
            de(a);
        }

        public void do1(int val)
        {
        }
        public void do2(int val)
        {

        }
        public void do3(int val)
        {

        }
        public void do4(int val)
        {

        }


    }

    class Program
    {
        static void Main(string[] args)
        {
            test3 t = new test3();
            t.show(12,t.do2);
        }
    }
}

哈哈哈，这下明白了撒！(我们将方法名，当成了一个参数来传递滴呀~)

现在我们才来总结概念！

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

我们也可以将方法绑定到委托上滴呀；

还是直接上代码：

namespace Delegate003
{
    public delegate void myDelegate(string val);
    class Program
    {
        public static void show(string val,myDelegate de)
        {
            de(val);
        }
        public static void do1(string val )
        {
            Console.WriteLine("do1.."+val);
        }

        public static void do2(string val)
        {
            Console.WriteLine("do2..."+val);
        }

        public static void do3(string val)
        {
            Console.WriteLine("do3...'"+val);
        }

        static void Main(string[] args)
        {
            //使用方式一
            myDelegate de1,de2;
            string val="sth";
            de1 = do1;
            de2 = do2;
            show(val, de1);
            show(val, de2);
            Console.ReadLine();
            //使用方式二
            //可以将多个方法赋给同一个委托，或者叫将多个方法绑定到同一个委托，当调用这个委托的时候，将依次调用其所绑定的方法
            myDelegate de;
            string val2="something";
            de = do1;
            de += do2;  //使用-=就是取消绑定
            de += do3;
            show(val2, de);
            Console.ReadLine();

            //使用方式三，绕过我们的show方法，直接调用；
            myDelegate directMy;
            string directVal = "direct";
            directMy = do1;
            directMy(directVal);  //直接通过调用委托来使用滴呀； 

            //使用方式四;
            myDelegate delegate1 = new myDelegate(do1);
            string val4 = "val4";
            delegate1(val4);

            //使用方法五


        }
    }
}

现在再来看看总结我们的概念滴呀；

使用委托可以将多个方法绑定到同一个委托变量，当调用此变量时(这里用“调用”这个词，是因为此变量代表一个方法)，可以依次调用所有绑定的方法。