黑马程序员_委托、多播委托、委托与指针的区别

一、委托

1.将方法当做变量来使用的一种机制（作为回调方法、实现事件）|将函数以参数形式传到别的方法里|在一个类里执行另外一个类的私有方法。

2.委托是一种类型

3.语法：[访问修饰符]delegate 类型名 委托名(参数列表)

4.使用：准备方法->准备委托类型->定义委托变量->使用

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

namespace 比较算法
{
    class Program
    {
        #region 准备委托类型
        public delegate bool DeleCompare(string str1, string str2); 
        #endregion

        static void Main(string[] args)
        {
            while (true)
            {
                string str1 = "20";
                string str2 = "100";
                Console.WriteLine("请问你要用什么方式进行比较：（0、数字；1、字符串)");
                string res = Console.ReadLine();
                #region 定义委托变量
                DeleCompare dc; 
                #endregion
                #region 定义委托变量
                if (res == "0")
                {
                    //装配方法
                    dc = Compare1;
                }
                else if (res == "1")
                {
                    //装配方法
                    dc = Compare2;
                }
                else
                {
                    dc = null;
                    Console.WriteLine("输入有误，请重新输入。");
                    Console.ReadKey(true);
                    Console.Clear();
                    continue;
                } 
                #endregion
                string str = "";

                //开始比较
                #region 使用
                str = dc(str1, str2) ? ">" : "<"; 
                #endregion
                Console.WriteLine("{0}{1}{2}", str1, str, str2);
                Console.ReadKey(true);
                Console.Clear();
            }
        }
        #region 准备方法
        //比较数字的大小
        static bool Compare1(string str1, string str2)
        {
            int num1 = int.Parse(str1);
            int num2 = int.Parse(str2);
            return num1 > num2;
        }
        //比较字符串的大小
        static bool Compare2(string str1, string str2)
        {
            if (string.Compare(str1, str2) > 0)
            {
                return true;
            }
            return false;
        }
        #endregion
    }
}

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

namespace 委托学习
{
    public delegate void DeleShow();
    class Program
    {
        static void Main(string[] args)
        {
            //DeleShow ds = Show2.ShowIn;
            //Show1.ShowOut(ds);
            DeleShow ds;
            Console.WriteLine("你想做什么？
1.打印字符
2.打开记事本");
            string str=Console.ReadLine();
            switch (str)
            {
                //这里就好像是多态，但是这里是同一个方法(Show1.ShowOut())展现出不同方法体的特征，
                //就像是多态的方法表现形式一样。
                case "1": ds = Show2.ShowIn; break;
                case "2": ds = Open.OpenNotepad; break;
                default: ds = null; break;
            }
            Show1.ShowOut(ds);
            Console.ReadKey(true);
        }
    }
    class Show1
    {
        public static void ShowOut(DeleShow show)
        {
            //在ShowOut这个方法体里面调用在其它类下的其它方法。委托的一种实现。
            Console.WriteLine("==================");

            //当show没有赋值的时候，或者赋值表达式不由你进行控制的时候，你是不知道show会执行什么的，那么这样就灵活多了。
            //如果在这里直接写ShowIn方法，就写死了，灵活度就降低了。
            show();
            Console.WriteLine("==================");
        }
    }
    class Show2
    {
        public static void ShowIn()
        {
            Console.WriteLine("欢迎来到黑马训练营");
        }
    }
    class Open
    {
        public static void OpenNotepad()
        {
            System.Diagnostics.Process.Start("notepad.exe");
        }
    }
}

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

namespace 自定义排序
{
    public delegate bool DelegateSortStr(string str1, string str2);
    class Program
    {
        static void Main(string[] args)
        {
            DelegateSortStr DgS = SortStr;
            string[] str = { "5464", "786783", "4234", "12", "7576", "564", "976", "63", "5" };
            for (int i = 0; i < str.Length - 1; i++)
            {
                for (int j = 0; j < str.Length - 1 - i; j++)
                {
                    if (DgS(str[j], str[j + 1]))
                    {
                        string temp = str[j];
                        str[j] = str[j + 1];
                        str[j + 1] = temp;
                    }
                }
            }
            foreach (string temp in str)
            {
                Console.WriteLine(temp);
            }
            Console.ReadKey(true);
        }
        //static bool SortNum(string str1, string str2)
        //{
        //    return int.Parse(str1) > int.Parse(str2);
        //}
        static bool SortStr(string str1, string str2)
        {
            return string.Compare(str1, str2) > 0 ? true : false;
        }
    }
}

二、多播委托（委托链）

1.每次加上一个委托就会创建一委托对象

2.委托链其中一个出现异常，那么后面的将不再执行

3.委托有返回值时，只返回最后一个

4.对于访问委托链中的每一个的返回结果，使用GetInvocationList()得到一个Delegate数组（委托基类），使用的时候必须强转为定义的委托类型。

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

namespace 多播委托
{
    public delegate int DelegateDemo();
    class Program
    {
        static void Main(string[] args)
        {
            DelegateDemo DgDemo = Func1;
            DgDemo += Func2;
            DgDemo += Func3;
            DgDemo += Func4;
            DgDemo += Func5;
            //多播委托，依次执行所有方法
            //多播委托只返回最后一个方法的值
            Console.WriteLine(DgDemo());
            //想要返回所有方法，则必须用到委托的GetInVoCationList()方法将每个结果返回            
            Delegate[] DS = DgDemo.GetInvocationList();
            foreach (Delegate temp in DS)
            {
                //输出的时候必须强转回定义的委托类型
                Console.WriteLine(((DelegateDemo)temp)());
            }
            Console.ReadKey(true);
        }
        static int Func1()
        {
            Console.WriteLine("Func1");
            return 1;
        }
        static int Func2()
        {
            Console.WriteLine("Func2");
            return 2;
        }
        static int Func3()
        {
            Console.WriteLine("Func3");
            return 3;
        }
        static int Func4()
        {
            Console.WriteLine("Func4");
            return 4;
        }
        static int Func5()
        {
            Console.WriteLine("Func5");
            return 5;
        }
        //输出结果：
        //Func1
        //Func2
        //Func3
        //Func4
        //Func5
        //5
        //Func1
        //1
        //Func2
        //2
        //Func3
        //3
        //Func4
        //4
        //Func5
        //5
    }
}

三、委托与指针的区别

1.委托是面向对象的，是一个对象。委托比较安全，在定义时规定了类型，不是所有方法都可以（指向），委托是安全的类型。

2.指针是函数的首地址，是指向一个地址。通过指针可以访问函数的地址，指针有空类型，可以指向任何一段地址。