C# 委托的使用

委托类与委托变量

系统自带委托

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

namespace Lesson12_delegate
{
    class Program
    {
        #region 知识一 委托是什么
        // 委托对象 是函数（或方法）的容器
        // 用来存储、传递函数(或方法)
        // 委托类 本质是一个类，用来定义函数（方法）的类型（返回值和参数的类型）
        // 委托类 创建的 委托对象 只能放入 格式一样的 函数或方法

        #endregion

        #region 知识二 基本语法 定义委托类
        // 关键字 delegate 函数
        //  语法： 访问修饰符 delegate 返回值 委托名 (参数列表)
        // 函数声明前面 加一个 delegate

        #endregion

        #region 知识三 定义自定义委托类
        // 一般定义在 类外面(命名空间中 ) 默认为 public
        // 定义时 不能重名 不能重载

        // 声明了一个 无参无返回 委托类 （只是定义了规则）
        delegate void MyAction();

        // 声明了一个 无参有返回 委托类 
        public delegate int MyFunc(int a);

        #endregion

        #region 知识六  通常用法
        // 定义在类中
        class Test
        {
            public MyAction action = null;
            public MyFunc func = null ;

            public void TestFun(MyAction act, MyFunc fc)
            {
                // 可以先处理一些 事情，然后处理传入的函数
                //act();
                //fc(5);

                this.action = act;
                this.func = fc;
            }

            // 增加
            // 对外部提供  委托变量 增加装载的函数的 功能
            public void AddFun(MyAction act, MyFunc fc)
            {
                this.action += act;
                this.func += fc;
            }
            // 减少 装载函数
            public void RemoveFun(MyAction act, MyFunc fc)
            {
                this.action -= act;
                this.func -= fc;
            }
        }
        #endregion



        static void Main(string[] args)
        {
            Console.WriteLine("委托的使用");

            #region 知识四 使用自定义委托类（定义委托变量）
            // 委托变量 是函数的容器
            // 创建委托变量 将一个 无参无返回的函数==>委托变量
            MyAction action = new MyAction(TargetFun);    // 装载函数(委托类一致)的容器

            Console.WriteLine("处理事情 1 2 3 4 5  ");

            Console.WriteLine("调用 委托变量中装载的 函数（Fun） ");
            // 调用 委托变量中装载的 函数 
            action.Invoke();  // 调用变量中 装载的函数

            // 第二种创建与调用方式
            MyAction action2 = TargetFun;  // 创建委托变量 装载函数
            Console.WriteLine("处理事情 10 20 30 40 50  ");
            action2(); // 调用变量中 装载的函数

            #endregion

            #region 知识五 有参有返回的
            // 必须装载 有参有返回的 函数
            MyFunc func1 = new MyFunc(TargetFun2);
            int ret = func1.Invoke(888);
            Console.WriteLine("函数返回值" + ret);

            #endregion

            // 知识六 增加与删除函数
            Console.WriteLine("------------------类中 委托变量 【增加】装载函数");
            Test t = new Test();  
            t.TestFun(TargetFun, TargetFun2);
            t.AddFun(TargetFun, TargetFun3);
            Console.WriteLine("+>委托变量 Invoke  无参无返回");
            t.action.Invoke();
            Console.WriteLine("+>委托变量 Invoke  有参有返回");
            t.func.Invoke(50);

            Console.WriteLine("------------------类中 委托变量 【减少】 装载函数");
            t.RemoveFun(TargetFun, TargetFun2);
            Console.WriteLine("+>委托变量 Invoke  无参无返回");
            t.action.Invoke();
            Console.WriteLine("+>委托变量 Invoke  有参有返回");
            t.func.Invoke(100);

            #region 知识七 委托变量可以存储多个函数

            // 增加 
            Console.WriteLine("------------------委托变量  装载多个函数");
            Console.WriteLine("+>委托变量  装载TargetFun2 ");
            Console.WriteLine("+>  委托变量  装载TargetFun3 ");
            MyFunc func3 = TargetFun2;   // func3 委托变量 装载 TargetFun2函数
            func3 += TargetFun3;              // func3 委托变量 再次装载 TargetFun3函数
            Console.WriteLine("--委托变量 Invoke");
            func3.Invoke(55);

            // 删除
            func3 -= TargetFun3;
            // 多移除函数 不报错
            func3 -= TargetFun3;
            func3.Invoke(60);

            // 清空
            func3 = null;

            if (func3 != null)
            {
                // 报错
                func3.Invoke(65);
            }

            #endregion

            #region 知识八  系统定义好的委托
            Console.WriteLine("----------------------------系统提供 委托类型 ");
            // 使用系统自带委托 无参无返回
            // 无参无返回
            Action sysAction = TargetFun;
            sysAction.Invoke();
            // 有参无返回
            Action<string> sysAction2 = new Action<string>(TargetFun1);
            sysAction2.Invoke("sysAction2");

            // 有参有返回 委托类 (前面类型为输入类型，最后一个泛型类为输出类型)
            // string 输入参数 , int 为返回值
            Func<string, int> sysFunc = new Func<string, int>(TargetFun4);
            Console.WriteLine("sysFunc 的输出：" + sysFunc.Invoke("sysFunc"));
            #endregion

            Console.ReadLine();
        }



        // 无参无返回 函数
        static void TargetFun()
        {
            Console.WriteLine("----TargetFun调用无参无返回函数。");
        }

        // 无参无返回 函数
        static void TargetFun1(string strInput)
        {
            Console.WriteLine("----TargetFun1 调用有参无返回函数 输入:" + strInput);
        }

        // 有参有返回 函数
        static int TargetFun2(int value)
        {
            Console.WriteLine("----TargetFun2调用 有参有返回函数。" + value.ToString());

            return 200;
        }

        // 有参有返回 函数
        static int TargetFun3(int value)
        {
            Console.WriteLine("----TargetFun3调用 有参有返回函数。" + value.ToString());

            return 300;
        }
		// 有参有返回 函数
        static int TargetFun4(string value)
        {
            Console.WriteLine("----TargetFun4调用 有参有返回函数, 输入：" + value);

            return 400;
        }
    }
}