異步編程之委託

前言：

項目中因爲大量的數據讀取操做，致使每次加載界面都須要長時間等待，所以決定使用異步來獲取數據，實現更好的用戶體驗。

趁此機會，也好好的補充一下本身在異步編程方面的知識！

先從委託開始提及！

委託的定義：

委託是一個類，它定義了方法的類型，使得能夠將方法看成另外一個方法的參數來進行傳遞。

委託的特色：

委託相似於 C++ 函數指針，但它們是類型安全的。
委託容許將方法做爲參數進行傳遞。
委託可用於定義回調方法。
方法沒必要與委託簽名徹底匹配。

委託的聲明：

(1). delegate

        delegate咱們經常使用到的一種聲明

　　  Delegate至少0個參數，至多32個參數，能夠無返回值，也能夠指定返回值類型。

　　  例：public delegate int MethodtDelegate(int x, int y);表示有兩個參數，並返回int型。

(2). Action

       Action是無返回值的泛型委託。

　　 Action 表示無參，無返回值的委託

　　 Action<int,string> 表示有傳入參數int,string無返回值的委託

 　　Action<int,string,bool> 表示有傳入參數int,string,bool無返回值的委託

       Action<int,int,int,int> 表示有傳入4個int型參數，無返回值的委託

　　 Action至少0個參數，至多16個參數，無返回值。

　　 例：

public void Test<T>(Action<T> action,T p)
        {
            action(p);
        }

 (3). Func

　　 Func是有返回值的泛型委託

　　 Func<int> 表示無參，返回值爲int的委託

　　 Func<object,string,int> 表示傳入參數爲object, string 返回值爲int的委託

　　 Func<object,string,int> 表示傳入參數爲object, string 返回值爲int的委託

　　 Func<T1,T2,,T3,int> 表示傳入參數爲T1,T2,,T3(泛型)返回值爲int的委託

　　 Func至少0個參數，至多16個參數，根據返回值泛型返回。必須有返回值，不可void

      例：　

public int Test<T1,T2>(Func<T1,T2,int>func,T1 a,T2 b)
        {
            return func(a, b);
        }

(4) .predicate

　　 predicate 是返回bool型的泛型委託

　　 predicate<int> 表示傳入參數爲int 返回bool的委託

　　 Predicate有且只有一個參數，返回值固定爲bool

　　 例：public delegate bool Predicate<T> (T obj)

委託的使用：

　(1).Delegate的使用

public delegate int MethodDelegate(int x, int y);
        private static MethodDelegate method;
        static void Main(string[] args)
        {
            method = new MethodDelegate(Add);
            Console.WriteLine(method(10,20));
            Console.ReadKey();
        }

        private static int Add(int x, int y)
        {
            return x + y;
        }

結果：

我的想法：委託就像一個統一的類，能夠把全部參數和返回值相同的方法統一塊兒來進行調用。

(2).Action的使用

 static void Main(string[] args)
        {
            Test<string>(Action,"Hello World!");
            Test<int>(Action, 1000);
            Test<string>(p => { Console.WriteLine("{0}", p); }, "Hello World");//使用Lambda表達式定義委託
            Console.ReadKey();
        }
        public static void Test<T>(Action<T> action, T p)
        {
            action(p);
        }
        private static void Action(string s)
        {
            Console.WriteLine(s);
        }
        private static void Action(int s)
        {
            Console.WriteLine(s);
        }

結果：

(3).Func的使用

static void Main(string[] args)
        {
            Console.WriteLine(Test<int,int>(Fun,100,200));
            Console.ReadKey();
        }
        public static int Test<T1, T2>(Func<T1, T2, int> func, T1 a, T2 b)
        {
            return func(a, b);
        }
        private static int Fun(int a, int b)
        {
            return a + b;
        }

結果：

(4). predicate的使用

static void Main(string[] args)
        {
            Point point1 = new Point() { X = 100, Y = 200 };
            Point point2 = new Point() { X = 1000, Y = 200 };
            Console.WriteLine(Test<Point>(ProductGT10,point1));
            Console.WriteLine(Test<Point>(ProductGT10, point2));
            Console.ReadKey();
        }
        public static bool Test<T>(Predicate<T> predicate, T p)
        {
            return predicate(p);
        }
        private static bool ProductGT10(Point p)
        {
            if (p.X * p.Y > 100000)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

結果：

 參考連接：

https://www.cnblogs.com/akwwl/p/3232679.html