using System;

namespace DelegateDemo
{
    class Program
    {
        /// <summary>
        /// 泛型委托
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="S"></typeparam>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public delegate int ProcessDelegate<T, S, V>(T a, S b, V v);
        /// <summary>
        /// 委托
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public delegate int ProcessDelegate(int a, int b);
        static void Main(string[] args)
        {
            //静态调用
            ProcessDelegate process = new ProcessDelegate(Add);
            ProcessDelegate<int, int, int> processDelegate = new ProcessDelegate<int, int, int>(Add);
            var a = processDelegate(5, 5, 5);
            Console.WriteLine(process(2, 4));
            Console.WriteLine(Calculate(4, 3, Add ));
            Console.WriteLine(Calculate(4, 3,5, Add));
           
            Console.WriteLine(a);
            //实例调用
            Test test = new Test();
            ProcessDelegate  processA = new ProcessDelegate(test.Add);
            Console.WriteLine(processA(5, 8));
            ProcessDelegate processB = (ProcessDelegate)Delegate.Combine(process , processA);
            //调用了Delegate.Combine()方法，通过名称可以指定它用于将多个委托组合起来，调用test3时，会按照它的参数顺序执行所有方法。这种方式有时候非常有用，因为我们很可能在某个事件发生时，要执行多个操作。
            Console.WriteLine(Calculate(50, 10, processB));
            //Func调用从无参到16个参数共有17个重载，用于分装有输入值而且有返回值的方法。如：delegate TResule Func<T>(T obj);
            Func<int, int, int> func = new Func<int, int, int>(Add);
            //Action 从无参到16个参数共有17个重载，用于分装有输入值而没有返回值的方法。如：delegate void Action<T>(T obj);
            Action<int, int> action = new Action<int, int>(test.Say);
            Console.WriteLine(func(5, 9));
        }

        //执行委托
        public static int Calculate(int a, int b, ProcessDelegate process) {
           return process(a, b);
        }
        public static int Calculate(int a, int b, int c , ProcessDelegate<int , int ,int > process)
        {
            return process(a, b , c);
        }
        public static int Add(int a, int b)
        {
            return a + b;
        }
        public static int DS(int a, int b)
        {
            return a + b;
        }
        public static int Add(int a, int b, int c)
        {
            return a + b + c;
        }
    }
    public class Test {

        public int Add(int a, int b) {
            return a + b;
        }
        public void Say(int a, int b)
        {
            Console.WriteLine(a + b);
        }
    }
    
}