6. 第二章：C#委托和事件之.net framework3.5委托扩展

第二章：C#委托和事件

 

第三节：Action<T>和Func<T,TResult>

这些都是在.net framework 3.5新增的委托类型，在.net framework 2.0里面，我们用的委托是Delegate

过多的理论叙述不是我们的目的，这里我们用示例的方式展示给大家看一看这些新增的委托的用法：(涉及到函数的重载和泛型的知识点，C#基础不在此处赘述。)

1. Action / Action<T> / Action<T,S> / Action<T,S,M> / ....(无参和多个泛型传参均可)，[Action无返回值函数！]

    public class MyClass2<T>
    {
        //无传参
        private Action _action1;
        //一个传参
        private Action<T> _action2;

        public MyClass2(Action action1, Action<T> action2)
        {
            this._action1 = action1;
            this._action2 = action2;
        }

        public Action Action1
        {
            get
            {
                return this._action1;
            }
        }

        public Action<T> Action2
        {
            get
            {
                return this._action2;
            }
        }
    }

    public class MyClass2<T, S> : MyClass2<T>
    {
        //两个传参
        private Action<T, S> _action3;

        public MyClass2(Action action1, Action<T> action2, Action<T, S> action3)
            : base(action1, action2)
        {
            this._action3 = action3;
        }

        public Action<T, S> Action3
        {
            get
            {
                return this._action3;
            }
        }
    }

调用：

        static void Main(string[] args)
        {
            //两个参数，泛型为string类型
            MyClass2<string> myClass2_001 = new MyClass2<string>(MyMethod, MyMethod);//第一个MyMethod是函数1，第二个MyMethod是函数2
            myClass2_001.Action1.Invoke();
            myClass2_001.Action2.Invoke("Microsoft Visual Studio 2013");
            Console.WriteLine();

            //两个参数，泛型为int类型
            MyClass2<int> myClass2_002 = new MyClass2<int>(MyMethod, MyMethod);//第一个MyMethod是函数1，第二个MyMethod是函数3(若没有函数3，则会调用函数4； 若有函数3，则会选择函数3确定的类型而不选择函数4)
            myClass2_002.Action1.Invoke();
            myClass2_002.Action2.Invoke(100);
            Console.WriteLine();

            //两个参数，泛型为实例化才定义类型
            MyClass2<double> myClass2_003 = new MyClass2<double>(MyMethod, MyMethod);//第一个MyMethod是函数1，第二个MyMethod是函数4
            myClass2_003.Action1.Invoke();
            myClass2_003.Action2.Invoke(3.1415926);
            Console.WriteLine();

            //三个参数，泛型为实例化才定义类型
            MyClass2<double, string> myClass2_004 = new MyClass2<double, string>(MyMethod, MyMethod, MyMethod);//第一个MyMethod是函数1，第二个MyMethod是函数4,第三个MyMethod是函数5
            myClass2_004.Action1.Invoke();
            myClass2_004.Action2.Invoke(3.1415926);
            myClass2_004.Action3.Invoke(3.1415926, "Microsoft Visual Studio 2013");
            Console.WriteLine();

            //Lambda语法的匿名函数，注意对比这种写法和前面的写法有何不同！
            MyClass2<DateTime> myClass2_005 = new MyClass2<DateTime>(() =>
            {
                Console.WriteLine("Written by lambda: Hello, world!");
            }, (param) =>
            {
                Console.WriteLine(string.Format("Written by lambda: {0}", param));
            });
            myClass2_005.Action1.Invoke();
            myClass2_005.Action2.Invoke(System.DateTime.Now);

            Console.ReadLine();
        }

        //函数1
        private static void MyMethod()
        {
            Console.WriteLine("Hello, world!");
        }

        //函数2
        private static void MyMethod(string param)
        {
            Console.WriteLine(param);
        }

        //函数3
        private static void MyMethod(int param)
        {
            Console.WriteLine(param);
        }

        //函数4
        private static void MyMethod<T>(T param)
        {
            Console.WriteLine(param);
        }

        //函数5
        private static void MyMethod<T, S>(T param1, S param2)
        {
            Console.WriteLine(param1);
            Console.WriteLine(param2);
        }

运行结果：

Hello, world!

Microsoft Visual Studio 2013

Hello, world!

100

Hello, world!

3.1415926

Hello, world!

3.1415926

3.1415926

Microsoft Visual Studio 2013

Written by lambda: Hello, world!

Written by lambda: 2016/1/3 2:21:51（这里的时间不一定是这个，根据你自己的运行时间为准！）

2. Func<T,TResult> / Func<T，S,TResult> /...(支持多个泛型参数传入，但一定至少要有一个传入参数，而且返回TResult只能有一个！)

示例1里面已经用了函数的重载和泛型的方式去展现，那在此处的示例就不再用这些方式去展示了，原理类似。（如果想要扩展请自己动手，若写不出就说明阁下基本功掌握的还未熟练，多加练习吧~）

    public class MyClass3
    {
        private Func<string, string> _func;

        public MyClass3(Func<string, string> func)
        {
            this._func = func;
        }

        public Func<string, string> Func
        {
            get
            {
                return this._func;
            }
        }
    }

调用：

        static void Main(string[] args)
        {
            MyClass3 myClass3_001 = new MyClass3(MyMethod);
            Console.WriteLine(myClass3_001.Func.Invoke("Jacky"));
            Console.WriteLine(myClass3_001.Func.Invoke("Tom"));

            Console.ReadLine();
        }

        private static string MyMethod(string param)
        {
            return string.Format("Good morning, {0}!", param);
        }

运行结果：
Good morning, Jacky!
Good morning, Tom!