委托, 泛型委托,Func<T>和Action<T>，funcaction

委托, 泛型委托,Func<T>和Action<T>，funcaction

使用委托來做一些事情，大致思路是：

1、定義聲明一個委托，規定輸入參數和輸出類型。
2、寫幾個符合委托定義的方法。
3、把方法列表賦值給委托
4、執行委托

    internal delegate int MyDelegate();
    class Program
    {
        static void Main(string[] args)
        {
            MyDelegate d = ReturnOne;
            d += ReturnTwo;
            foreach (int i in GetAllReturnVals(d))
            {
                Console.WriteLine(i);
            }
            Console.ReadKey();
        }
        static IEnumerable<int> GetAllReturnVals(MyDelegate myDelegate)
        {
            foreach (MyDelegate del in myDelegate.GetInvocationList())
            {
                yield return del();
            }
        }
        static int ReturnOne()
        {
            return 1;
        }
        static int ReturnTwo()
        {
            return 2;
        }
    }

以上，委托的返回類型是int,如果讓返回類型是泛型呢？只要讓以上的GetAllReturnVals方法針對泛型就可以了。

   internal delegate T MyDelegate<T>();
    class Program
    {
        static void Main(string[] args)
        {
            MyDelegate<int> d = ReturnOne;
            d += ReturnTwo;
            foreach (int i in GetAllReturnVals(d))
            {
                Console.WriteLine(i);
            }
            MyDelegate<string> d1 = ReturnA;
            d1 += ReturnB;
            foreach (string s in GetAllReturnVals(d1))
            {
                Console.WriteLine(s);
            }
            Console.ReadKey();
        }
        //返回所有委托方法的執行結果
        static IEnumerable<T> GetAllReturnVals<T>(MyDelegate<T> myDelegate)
        {
            foreach (MyDelegate<T> del in myDelegate.GetInvocationList())
            {
                yield return del();
            }
        }
        static int ReturnOne()
        {
            return 1;
        }
        static int ReturnTwo()
        {
            return 2;
        }
        static string ReturnA()
        {
            return "A";
        }
        static string ReturnB()
        {
            return "B";
        }
    }

不過，.NET還為我們准備了一個更"懶 "的方法，那就是針對泛型的委托Func<T>，這下，連委托都不要事先聲明了。Func<T>的<>中的泛型列表的最後一個是返回類型，其它的都是輸入類型，Func<T>多達十幾個重載。

   class Program
    {
        static void Main(string[] args)
        {
            Func<int> d = ReturnOne;
            d += ReturnTwo;
            foreach (int i in GetAllReturnVals(d))
            {
                Console.WriteLine(i);
            }
            Func<string> d1 = ReturnA;
            d1 += ReturnB;
            foreach (string s in GetAllReturnVals(d1))
            {
                Console.WriteLine(s);
            }
            Console.ReadKey();
        }
        //返回所有委托方法的執行結果
        static IEnumerable<T> GetAllReturnVals<T>(Func<T> myDelegate)
        {
            foreach (Func<T> del in myDelegate.GetInvocationList())
            {
                yield return del();
            }
        }
        static int ReturnOne()
        {
            return 1;
        }
        static int ReturnTwo()
        {
            return 2;
        }
        static string ReturnA()
        {
            return "A";
        }
        static string ReturnB()
        {
            return "B";
        }
    }

以上泛型委托Func<T>同時有輸入參數和返回類型，如果返回類型為void，那就可以使用Action<T>了，當然Action<T>也有多達十幾個重載。

   class Program
    {
        static void Main(string[] args)
        {
            Action<int> a1 = ReturnInt;
            a1(1);
            Action<string> a2 = ReturnStr;
            a2("hello");
   
            Console.ReadKey();
        }
        static void ReturnStr(string s)
        {
            Console.WriteLine(s);
        }
        static void ReturnInt(int a) 
        {
            Console.WriteLine(a);
        }
    }

總結：Func<T>和Action<T>是泛型委托的"語法糖",如果返回類型為void，那就使用Action<T>，否則使用Func<T>。