delegate

 

网上说delegate的一大堆，从我当时学C#开始就已经多得要命，可是我看了N久，也不明白什么意思。有种清者自清，浊者自浊的味道，不懂的人看了还是不懂。吸取我自己的教训，从简单到复杂，从具体到抽象。
举个例子，相信大家都考试过，别人有没有作弊过，我不想知道，但是我有！如果没有作弊经验的朋友可以想象成开卷考。我们把能做的都做了，剩下不能做的，只好抄别人了（如果不抄，那只能等挂科了）。

class 我
    {
        void 做题目1()
        { 
        }
        void 做题目2()
        { 
        }
        void 抄别人的(int 题目编号)
        {
        }
        void 考试()
        {
            this.做题目1();
            this.做题目2();
            //第三道我不会做,只好抄别人
            this.抄别人的(3);
        }
    }

可是问题来了，我不知道我的旁边是谁？所以不能这样贸然行事.

 void 抄别人的(int 题目编号)
        {
            张三.做题目3();
        }

我只知道我可以抄旁边的，谁坐到我的旁边我就抄谁，有个前提就是这个人会做第三道题目，这个是一个约束，也是人们常说的函数签名.

delegate void 做题目3();
    class 我
    {
        做题目3 别人做的;//目前还不知道这个人是谁
        void 做题目1()
        { 
        }
        void 做题目2()
        { 
        }
        void 抄别人的(int 题目编号)
        {
            this.别人做的();
        }
        void 考试()
        {
            this.做题目1();
            this.做题目2();
            //第三道我不会做,只好抄别人
            this.抄别人的(3);
        }
    }

到了考场，开始考试：

static void Main(string[] args)
        {
            我 me = new 我();
            //到了考场我知道是谁了，就指定他
            me.别人做的 = new 做题目3(张三.做题目3);
            //me.别人做的 = new 做题目3(李四.做题目3);
            me.考试();
        }

这个就是委托，我把做第三道题委托给张三帮我做。
现在我们来看一个排序的例子，因为我不知道是升序还是降序，所以我只好委托给使用者了。

public delegate int Compare(int a,int b);
    public class Sort
    {
        public int[] SortInt32(Compare compare, params int[] array)
        {
            int length = array.Length;
            //冒泡排序
            for (int i = 0; i < length; i++)
            {
                for (int j = i + 1; j < length; j++)
                {
                    if (compare(array[i], array[j]) > 0)
                    {
                        int temp = array[i];
                        array[i] = array[j];
                        array[j] = temp;
                    }
                }
            }
            return array;
        }
    }

使用

static class Program
    {
        [STAThread]
        static void Main()
        {

            Sort sort = new Sort();
            int[] result = sort.SortInt32(Compare, 1, 3, 4, 6);

            for (int i = 0; i < result.Length; i++)
                System.Console.WriteLine(result[i]);

            System.Console.ReadLine();
        }
        static int Compare(int a, int b)
        {
            if (a > b)
                return 1;
            if (a < b)
                return -1;
            return 0;
        }
    }

答案是 1,3,4,6

static void Main()
        {

            Sort sort = new Sort();
            int[] result = sort.SortInt32(CompareDesc, 1, 3, 4, 6);

            for (int i = 0; i < result.Length; i++)
                System.Console.WriteLine(result[i]);

            System.Console.ReadLine();
        }
        static int CompareDesc(int a, int b)
        {
            if (a > b)
                return -1;
            if (a < b)
                return 1;
            return 0;
        }

修改后运行代码，答案就是6，4，3，1
使用委托可以使程序变得非常的灵活。学好委托是学好事件的必要条件。
这个是C#的先进之处，如果是java则要复杂一些。java需要使用接口，这里直接用C# 代码，两者相似。

public interface ICompare
    {
        int Compare(int a, int b);
    }
    public class Sort
    {
        public int[] SortInt32(ICompare myCompare,params int[] array)
        {
            int length = array.Length;
            //冒泡排序
            for (int i = 0; i < length; i++)
            {
                for (int j = i + 1; j < length; j++)
                {
                    if (myCompare.Compare(array[i], array[j]) > 0)
                    {
                        int temp = array[i];
                        array[i] = array[j];
                        array[j] = temp;
                    }
                }
            }
            return array;
        }
    }

调用时：

static class Program
    {
        /**//// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main()
        {
            Sort sort = new Sort();
            ICompare compare = new Test();
            int[] result = sort.SortInt32(compare, 1, 2, 9, 8, 6);
            for (int i = 0; i < result.Length; i++)
                System.Console.WriteLine(result[i]);
            
            System.Console.ReadLine();
        }
    }
    public class Test:ICompare
    {
        public int Compare(int a, int b)
        {
            if (a > b)
                return 1;
            if (a < b)
                return -1;
            return 0;
        }
    }

显然，这种实现方式没有delegate灵活。delegate相当于C++中的指针函数，可以进行回调。使用接口实现回调的代码：

public interface ICompare
    {
        int Compare(int a, int b);
    }
    public class Sort
    {
        public ICompare myCompare;
        public int[] SortInt32(params int[] array)
        {
            int length = array.Length;
            //冒泡排序
            for (int i = 0; i < length; i++)
            {
                for (int j = i + 1; j < length; j++)
                {
                    if (myCompare.Compare(array[i], array[j]) > 0)
                    {
                        int temp = array[i];
                        array[i] = array[j];
                        array[j] = temp;
                    }
                }
            }
            return array;
        }
    }
    static class Program
    {
        [STAThread]
        static void Main()
        {
            new Test().Sort();
        }
    }
    public class Test:ICompare
    {
        public void Sort()
        {
            Sort sort = new Sort();
            sort.myCompare = this;
            int[] result = sort.SortInt32( 1, 2, 9, 8, 6);
            for (int i = 0; i < result.Length; i++)
                System.Console.WriteLine(result[i]);

            System.Console.ReadLine();
        }
        public int Compare(int a, int b)
        {
            if (a > b)
                return -1;
            if (a < b)
                return 1;
            return 0;
        }
    }