C#委託、事件剖析(上)

時間  2019-12-10
標籤 c# 委託 事件 剖析 欄目 C# 简体版
原文   原文鏈接

本節對委託、事件作以總結。

1、委託：

一、概念：先來講明變量和函數的概念，變量，以某個地址爲起點的一段內存中所存儲的值，函數，以某個地址爲起點的一段內存中存儲的機器語言指令。有了這2個概念之後，咱們來看c++中的函數指針，函數指針就是指向這個函數的地址，函數指針所指向的類型就是函數在內存中的大小，有了這個起點和大小，函數指針就能夠代替函數完成對函數的調用。在C#中，委託delegate就是對c++中函數指針作了一個升級，一樣它沒有直接調用方法採用的是間接調用，是一種類，因此也是一種數據類型。下面舉一個簡單的例子，說明它是類。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            Action action = new Action(Method);
            Console.WriteLine(action.GetType().IsClass);
        }
        static void Method()
        { }
    }
}

這裏咱們用了C#類庫中自帶的Action委託，先不須要管它是什麼樣的委託，後面會介紹，而後調用Type類的IsClass屬性,返回true，則他就是一個類，因此它也是一種數據類型。能夠看出，委託造成了一種動態調用代碼（方法）的結構，功能十分強大。

二、委託的通常使用：在聲明一個委託時，這個委託的參數就是一個方法名，這樣就能夠把這個具體的委託當作參數傳入另外一個方法，也就至關於把

這個委託中的方法當作參數傳入另外一個方法，這個被傳入的方法分爲2種：

(1)回調方法：無返回值，沒有返回值就說明他只是作了一些處理，至於被不被調用徹底要看主調方法是否選擇調用它，這就和找工做一個道理，你發一份簡歷

出去，至於公司給不給你offer取決於公司。

(2)模(mu)板方法：有返回值，說明你所返回的東西會對調用者起必定的影響做用，有返回值通常也有參數，根據參數的不一樣返回不一樣的返回值，因此

它的做用對於調用者是一個模板。

Example1:c++

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            Action action = new Action(Method);
            action.Invoke();
            action();
            
        }
        static void Method()
        {
            Console.WriteLine("Hello Delegate");
        }
    }
}

 

這裏用的是C#類庫中最經常使用的返回值爲空而且無參的Action委託，Method方法無參無返回值，2種調用方式，第一種調用委託的invoke()方法，

第二種採用的是函數指針式的調用，均可以使用。

Example2：算法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            Action<string, int> action = new Action<string, int>(Method);
            action.Invoke("張三",18);
            action("李四",19);
        }
        static void Method(string name, int age)
        {
            Console.WriteLine($"我叫{name}今年{age}歲");
        }
    }
}

 這裏用到了C#自帶的常見泛型委託Action<T>無返回值有參數，泛型這裏就當作一個類型就好，會在別的章節作詳細說明

 Example3:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<double, double, double> func = new Func<double, double, double>(Add);
            double result1 = func.Invoke(1.5,3.5);
            Console.WriteLine(result1);
            double result2 = func(2.5,4.5);
            Console.WriteLine(result2);
        }
        static double Add(double x, double y)
        {
            double result = x + y;
            return result;
        }
        
    }
}

這裏用了C#類庫中經常使用的Func<T>委託，也是一個泛型委託，<>中最後一個是返回值結果，能夠在vs的提示重載中看到。

Example4：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string> func = new Func<string>(FindName);
            SayHello(func);
        }
        static void SayHello(Func<string> FindDelegate)
        {
            Console.WriteLine($"Hello {FindDelegate()}");
        }
        static string FindName()
        {
            return "小明";
        }
        
        
    }
}

這裏用了Func<T>只有返回值的狀況，並將這個委託當作參數傳進了另外一個方法，也就間接的把FindName這個方法當作參數傳入了SayHello這個方法。

三、下面舉兩個比較貼近生活、委託和別的結合使用的典型事例。

Example1:

   using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp3
{
    public delegate Product ProductDelegate();
    public delegate void LogDelegate(Product product);
    class Program
    {
        static void Main(string[] args)
        {
            
            WrapProduct product = new WrapProduct();
            Logger logger = new Logger();
            WrapFactory wrapFactory = new WrapFactory();
            ProductDelegate productDelegate1 = new ProductDelegate(product.GetToy);
            ProductDelegate productDelegate2 = new ProductDelegate(product.GetStationery);
            LogDelegate logDelegate = new LogDelegate(logger.Log);
            Box box1 = wrapFactory.GetBox(productDelegate1,logDelegate);
            Box box2 = wrapFactory.GetBox(productDelegate2,logDelegate);
            Console.WriteLine($"Product1 {box1.Product.Name} the price is {box1.Product.Price}");
            Console.WriteLine($"Product2 {box2.Product.Name} the price is {box2.Product.Price}");

        }

    }

    public class Product
    {
        public string Name { get; set; }
        public int Price { get; set; }
    }
    public class Box
    {
        public Product Product { get; set; }
    }
    public class WrapFactory
    {
        public Box GetBox(ProductDelegate productDelegate,LogDelegate logDelegate)
        {
            Box box = new Box();
            Product product = productDelegate.Invoke();
            if (product.Price>50)
            {
                logDelegate.Invoke(product);
            }
            box.Product = product;
            return box;
        }
    }
    public class WrapProduct
    {
        public Product GetToy()
        {
            Product product = new Product();
            product.Name = "Toy";
            product.Price = 100;
            return product;
        }
        public Product GetStationery()
        {
            Product product = new Product();
            product.Name = "Stationery";
            product.Price = 30;
            return product;
        }
    }
    public class Logger
    {
        public void Log(Product product)
        {
            Console.WriteLine($"Product {product.Name} created at {DateTime.Now.ToString()}");
        }
    }
}

delegate既然是類，那麼應該和類平級，放於類的外部。這裏用了自定義的委託，有返回值的委託ProductDelegate封裝的方法是WrapProduct製造產品類裏的製造玩具和製造文具方法，無返回值的委託LogDelegate封裝的是Logger記錄日誌類裏的Log日誌方法。首先作2個實體類,Product產品類，Box盒子類，盒子中放的就是產品，而後作一個包裝類，返回一個盒子，寫一個將產品包裝在盒子中的方法，這個方法的2個參數，是2個委託，一個用於創做產品一個當產品價格大於50的時候，就調用log方法記錄日誌，最後在main方法裏開始實例化類並調用，自定義委託和C#類庫自帶的委託均可以使用，看我的喜愛，C#自帶的就不用聲明委託了。

Example2:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp4
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int, int, int> func1 = new Func<int, int, int>((int a, int b) => { return a + b; });
            var func2 = new Func<int,int,int>((a, b) => { return a * b; });
            Calculate(func1,2,3);
            Calculate(func2,3,4);
            Calculate((x,y)=> { return x - y; },7,1);
        }
        static void Calculate<T>(Func<T,T,T> func,T x,T y)
        {
            T z = func.Invoke(x,y);
            Console.WriteLine(z);
        }
    }
}

這裏用到了蠻多的小知識點，首先泛型函數和泛型委託，而後用到了lambda表達式，精簡的說一下lambda表達式:(T t)=>{expression; }小括號裏是參數，大括號中是要寫的算法，也就是方法體，固然不會寫太多，否則還不如寫一個方法就用不到lambda表達式了。已經知道，委託聲明是封裝一個方法，那麼就能夠用lambda表達式代替方法，這就是把一個lambda表達式賦值給一個委託，C#中不少委託都會用到，因此第三次調用Calculate方法時，直接將lambda表達式當成參數傳進去，是不會報錯的。最後還有一個重要的點，就是泛型委託的類型參數推斷，在第二個委託func2中，C#根據傳入的參數推斷出泛型的具體類型是int，從而將代碼簡寫。

四、委託的抗變和協變

一、概念： .net 4.0中抗變和協變已經成熟了，主要分爲2類，委託的和泛型的，此處只講委託的，泛型的後面會說明。委託所封裝的方法和聲明委託是所定義的類型不必定相同，這就產生了抗變和協變。

namespace ConsoleApp5
{
    class Father { }
    class Son : Father { }
    class Program
    {
        static void Main(string[] args)
        {
            Func<Father> func = new Func<Father>(Method);
        }
        static Son Method()
        {
            Son son = new Son();
            return son;
        }
    }
}

上面的是抗變：2個實體類Father父類，Son子類，繼承Father，委託聲明時，返回值爲父類，調用的時候卻調用的是返回值爲Son的方法，

也就是說抗變指的是委託所封裝的方法的返回值是聲明委託的返回值類型的子類。

namespace ConsoleApp5
{
    class Father { }
    class Son : Father { }
    class Program
    {
        static void Main(string[] args)
        {
            Action<Son> action = new Action<Son>(Method);
        }
        static void Method(Father father) { }
    }
}

如今這個天然是協變，仍然一個父類一個子類，很明顯，協變指的是委託所封裝的方法的參數是聲明委託時參數的父類。

五、委託的高級使用：

主要講2個方面：多播委託以及委託的隱式異步調用。

（1）多播委託：

一般的委託，一個委託封裝一個方法，多播委託中能夠一個委託封裝多個方法，這些方法一般都是void的，可是不爲空也能夠，不會報錯，實例以下：

namespace ConsoleApp6
{
    class Program
    {
        static void Main(string[] args)
        {
            var func = new Func<int, int, int>(M1);
            func += M2;
            func += M3;
            func(3,3);
            Console.WriteLine(func(3,3));
        }
        static int M1(int x, int y)
        {
            Console.WriteLine(x+y);
            return x + y;
        }
        static int M2(int x, int y)
        {
            Console.WriteLine(x - y);
            return x - y;
        }
        static int M3(int x, int y)
        {
            Console.WriteLine(x*y);
            return x * y;
        }
    }
}

能夠看到確實沒有報錯，可是它最後的返回值是9，也就是說調用多播委託之後他最後的返回值是最後一個方法的返回值，因此有返回值的方法通常不用於多播委託，來看一個正常的例子。

namespace ConsoleApp7
{
    class Program
    {
        static void Main(string[] args)
        {
            var action = new Action(M1);
            action += M2;
            action += M3;
            action.Invoke();
            action -= M2;
            action.Invoke();
        }
        static void M1()
        {
            Console.WriteLine("M1 is invoked");
        }
        static void M2()
        {
            Console.WriteLine("M2 is invoked");
        }
        static void M3()
        {
            Console.WriteLine("M3 is invoked");
        }
    }
}

 

這裏用+=和-=將方法逐一封裝在同一個委託裏，實現了只須要調用一次委託就調用了全部方法的功能。

那這裏的底層實現是什麼呢，先舉實例：

namespace ConsoleApp8
{
    class Program
    {
        static void Main(string[] args)
        {
            var action1 = new Action(M1);
            var action2 = new Action(M2);
            var action3 = new Action(M3);
            Action action = null;
            action = (Action)Delegate.Combine(action,action1);
            action = (Action)Delegate.Combine(action,action2);
            action = (Action)Delegate.Combine(action,action3);
            action();
            Console.WriteLine();
            action = (Action)Delegate.Remove(action,action2);
            action();
        }
        static void M1()
        {
            Console.WriteLine("M1 is invoked");
        }
        static void M2()
        {
            Console.WriteLine("M2 is invoked");
        }
        static void M3()
        {
            Console.WriteLine("M3 is invoked");
        }
    }
}

 

從上面的例子中能夠看出，+=和-=的具體實現使用Delegate的Combine和Remove方法，來增長或刪除委託中的方法。

(2)先來看一下顯示異步調用：

namespace ConsoleApp9
{
    class Program
    {
        static void Main(string[] args)
        {
            Thread thread1 = new Thread(new ThreadStart(M1));
            Thread thread2 = new Thread(new ThreadStart(M2));
            thread1.Start();
            thread2.Start();
        }
        static void M1() {}
        static void M2() {}
    }
}

這裏能夠用到了線程，能夠看到ThreadStart是一個委託。

namespace ConsoleApp10
{
    class Program
    {
        static void Main(string[] args)
        {
            Task task = new Task(new Action(M1));
            task.Start();
        }
        static void M1() { }
    }
}

這裏用Task也能夠，也是線程中的東西關於task會在之後詳細說明，能夠看到參數也是一個委託。

下面是隱式異步調用的例子：

namespace ConsoleApp11
{
    class Program
    {
        static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            Func<int, int, int> func = new Func<int, int, int>(calculator.Add);
            IAsyncResult asyncResult = func.BeginInvoke(2,3,null,null);
            Console.WriteLine($"結果是{func.EndInvoke(asyncResult)}");
            Console.WriteLine("計算完成");
        }
    }

    public class Calculator
    {
        public int Add(int a, int b)
        {
            return a + b;
        }
    }
}

隱式異步調用的底層機制就是多線程，而委託中的BeginInvoke方法剛好會生成分支線程，所產生的信息能夠經過IAsyncResult接受，產生的返回值調用EndInvoke方法便可，注：BeginInvoke方法的參數是一個AsyncCallBack委託，主要用來做爲回調函數也就是你調完方法之後還須要作什麼，若是不須要傳入null就能夠了。

 

 

 

到此委託部分結束，事件會在下一節總結。　　　　　　　　　　　　　　　　　　　　　　　　2018-08-17   10:31:56

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程