委托和事件

一、委托的使用

  1：首先来看看委托的使用

    1）传统的委托使用的分为三步。

        /// <summary>
        /// 定义委托
        /// </summary>
        /// <param name="x">变量 x</param>
        /// <param name="y">变量 y</param>
        /// <returns>返回一个 Int 值</returns>
        public delegate int IntDelegate(int x, int y);
        
        /// <summary>
        /// Add 静态方法
        /// </summary>
        /// <param name="x">参数 x</param>
        /// <param name="y">参数 y</param>
        /// <returns>返回 Int 值</returns>
        public static int Add(int x, int y)
        {
            return x + y;
        }

        /// <summary>
        /// 入口函数
        /// </summary>
        /// <param name="args"></param>
        public static void Main(string[] args)
        {
            IntDelegate delegt = new IntDelegate(Add);
            Console.WriteLine(delegt.Invoke(3, 9));
        }

    2）以下的三种方式展示两步解决委托的使用

        /// <summary>
        /// 实例化委托类
        /// </summary>
        public static void Test2()
        {
            IntDelegate delegt = delegate(int x, int y) { return x + y; };
            Console.WriteLine(delegt(4, 10));
        }

        /// <summary>
        /// 在上面的方法的基础上去掉 delegate
        /// </summary>
        public static void Test3()
        {
            IntDelegate delegt = (int x, int y) => { return x + y; };
            Console.WriteLine(delegt.Invoke(4, 50));
        }

        /// <summary>
        /// 在上面的方法的基础上去掉 delegate 和 return 
        /// </summary>
        public static void Test4()
        {
            IntDelegate delegt = (x, y) => (x + y);
            Console.WriteLine(delegt.Invoke(4, 50));
        }

      

  2：再来看看 .NET 自己封装的委托— Action 、 Func 

    1）其区别： Action 是无返回值的；Func 是有返回值的，且返回值的类型是其最后一个参数类型（学艺不精，大牛请指教）

    2）下面是 Func 的使用，下面的例子只支持2个参数，但是同样支持4个参数

        /// <summary>
        /// Add 静态方法
        /// </summary>
        /// <param name="x">参数 x</param>
        /// <param name="y">参数 y</param>
        /// <returns>返回 Int 值</returns>
        public static int Add(int x, int y)
        {
            return x + y;
        }

        /// <summary>
        /// Func 的使用,第三个Int 是返回值类型
        /// </summary>
        public static void Test5()
        {
            Func<int, int, int> func = (x, y) => Add(x, y);
            Console.WriteLine(func.Invoke(102, 204));
        }

    3）下面是 Action 的使用

        /// <summary>
        /// Sub 静态方法
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        public static void Sub(int x, int y)
        {
            Console.WriteLine(x - y);
        }

        /// <summary>
        /// Action 的使用
        /// </summary>
        public static void Test6()
        {
            Action<int, int> action = Sub;
            action.Invoke(101, 94);
        }

二、事件的使用

    /// <summary>
    /// 委托
    /// </summary>
    /// <param name="str">委托参数</param>
    public delegate void Show(string str);
    public class Program
    {
        /// <summary>
        /// 事件
        /// </summary>
        public static event Show ShowEvent;

        /// <summary>
        /// 方法 ShowImg
        /// </summary>
        /// <param name="strImg"></param>
        public static void ShowImg(string strImg)
        {
            Console.WriteLine("strImg: " + strImg);
        }

        /// <summary>
        /// 方法 ShowMusic
        /// </summary>
        /// <param name="strMusic"></param>
        public static void ShowMusic(string strMusic)
        {
            Console.WriteLine("strMusic: " + strMusic);
        }
        static void Main(string[] args)
        {
            ShowEvent += ShowImg;
            Console.WriteLine(ShowEvent.GetInvocationList().Count());
            ShowEvent += ShowMusic;
            Console.WriteLine(ShowEvent.GetInvocationList().Count());
            ShowEvent("图片");
            ShowEvent("音乐");
        }
    }

细心的童鞋可能发现：

在调用的时候，我有时用委托构造方法，有时调用委托的虚方法 invoke 方法

其实是一样的，但是我还不知道为什么。。。  >..<...|| (大神指教)