C#委托與事件學習筆記-有解無憂

本筆記摘抄自：https://www.cnblogs.com/leslies2/archive/2012/03/22/2389318.html，記錄一下學習程序以備后續查用，

一、委托型別的來由

在使用C語言的年代，整個專案中都充滿著針指的身影，那時候流行使用函式指標來創建回呼函式，使用回呼可以把函式回呼給程式中的另一個函式，但函式指標

只是簡單地把地址指向另一個函式，并不能傳遞其他額外資訊，

在.NET中，大部分時間里都沒有指標的身影，因為指標被封閉在內部函式當中，可是回呼函式卻依然存在，它是以委托的方式來完成的，委托可以被視為一個更

高級的指標，它不僅僅能把地址指向另一個函式，而且還能傳遞引數、回傳值等多個資訊，系統還為委托物件自動生成了同步、異步的呼叫方式，開發人員使用

BeginInvoke、EndInvoke方法就可以拋開Thread而直接使用多執行緒呼叫，

二、建立委托類

使用delegate可以直接創建委托型別，當進行系統編譯時，系統就會自動生成此型別，可以使用delegate void MyDelegate()方式創建一個委托類，

    class Program
    {
        delegate void MyDelegate();
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World.");
            Console.Read();
        }
    }

View Code

使用ILDASM.exe觀察委托成員，可以看到它繼承了System.MulticastDelegate類，并自動生成BeginInvoke、EndInvoke、Invoke 等三個常用方法，

Invoke 方法是用于同步呼叫委托物件的對應方法，而BeginInvoke、EndInvoke是用于以異步方式呼叫對應方法，

    public class MyDelegate:MulticastDelegate
     {
         //同步呼叫委托方法
         public virtual void Invoke();
         //異步呼叫委托方法
         public virtual IAsyncResult BeginInvoke(AsyncCallback callback,object state);
         public virtual void EndInvoke(IAsyncResult result);
     }

View Code

MulticastDelegate是System.Delegate的子類，它是一個特殊類，編譯器和其他工具可以從此類派生，但是自定義類不能顯式地從此類進行派生，它支持多路

廣播委托，并擁有一個帶有鏈接的委托串列，在呼叫多路廣播委托時，系統將按照呼叫串列中的委托出現順序來同步呼叫這些委托，

MulticastDelegate具有兩個常用屬性：Method、Target，其中Method用于獲取委托所表示的方法，Target用于獲取當前呼叫的類實體，

MulticastDelegate有以下幾個常用方法：

方法名稱	說明
Clone	創建委托的淺表副本，
GetInvocationList	按照呼叫順序回傳此多路廣播委托的呼叫串列，
GetMethodImpl	回傳由當前的 MulticastDelegate 表示的靜態方法，
GetObjectData	用序列化該實體所需的所有資料填充 SerializationInfo 物件，
MemberwiseClone	創建當前 Object 的淺表副本，
RemoveImpl	呼叫串列中移除與指定委托相等的元素

MulticastDelegate與Delegate給委托物件建立了強大的支持，

三、委托使用方式

3.1 簡單的委托

當建立委托物件時，委托的引數型別必須與委托方法相對應，只要向建立委托物件的建構式中輸入方法名稱example.Method，委托就會直接系結此方法，

使用myDelegate.Invoke(string message)，就能顯式呼叫委托方法，

但在實際的操作中，我們無須用到Invoke方法，而只要直接使用myDelegate(string message)，就能呼叫委托方法，

下面代碼演示簡單的委托：

    class Program
    {
        delegate void MyDelegateVoid(string message);

        public class Example
        {
            public void ShowMessage(string message)
            {
                Console.WriteLine(message);
            }
        }

        static void Main(string[] args)
        {
            #region 簡單的委托
            Example example = new Example();
            MyDelegateVoid myDelegateVoid = new MyDelegateVoid(example.ShowMessage);
            myDelegateVoid("Hello World");
            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

3.2 帶回傳值的委托

當建立委托物件時，委托的回傳值必須與委托方法相對應，

下面代碼演示帶回傳值的委托：

    class Program
    {
        delegate string MyDelegateString(string message);

        public class Example
        {
            public string SayHi(string name)
            {
                return "Hello " + name;
            }
        }

        static void Main(string[] args)
        {
            #region 帶回傳值的委托
            Example example = new Example();
            MyDelegateString myDelegateString = new MyDelegateString(example.SayHi);
            string message = myDelegateString("Atomy");
            Console.WriteLine(message);
            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

3.3 多路廣播委托

在第二節前曾經提過，委托類繼承于MulticastDelegate，這使委托物件支持多路廣播，即委托物件可以系結多個方法，

下面代碼演示多路廣播委托：

    class Program
    {
        delegate double MyDelegateDouble(double message);

        public class Example
        {
            public double Ordinary(double price)
            {
                double price1 = 0.95 * price;
                Console.WriteLine($"Ordinary price={price1}");
                return price1;
            }

            public double Favourable(double price)
            {
                double price1 = 0.85 * price;
                Console.WriteLine($"Favourable price={price1}");
                return price1;
            }
        }

        static void Main(string[] args)
        {
            #region 多路廣播委托
            Example example = new Example();
            MyDelegateDouble myDelegateDouble = new MyDelegateDouble(example.Ordinary);
            myDelegateDouble += new MyDelegateDouble(example.Favourable);
            Console.WriteLine($"Current Price={myDelegateDouble(100)}");
            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

3.4 淺談Observer模式（觀察者模式）

簡單回顧一下Observer模式，它使用一對多的方式，可以讓多個觀察者同時關注同一個事物，并作出不同的回應，

如下例，Manager的底薪為基本工資的1.5倍，Assistant的底薪為基本工資的1.2倍，WageManager類的RegisterWorker方法與RemoveWorker方法可以

用于注冊和注銷觀察者，最后執行Execute方法可以對多個已注冊的觀察者同時輸入引數，

下面代碼演示使用非委托方式實作觀察者模式：

    class Program
    {
        #region 非委托觀察者模式
        /// <summary>
        /// 作業者類
        /// </summary>
        public abstract class Worker
        {
            public abstract double GetWages(double basicWages);
        }

        /// <summary>
        /// 管理級類
        /// </summary>
        public class Manager : Worker
        {
            public override double GetWages(double basicWages)
            {
                double totalWages = 1.5 * basicWages;
                Console.WriteLine($"Manager's wages is:{totalWages}");
                return totalWages;
            }
        }

        /// <summary>
        /// 助理級類
        /// </summary>
        public class Assistant : Worker
        {
            public override double GetWages(double basicWages)
            {
                double totalWages = 1.2 * basicWages;
                Console.WriteLine($"Assistant's wages is:{totalWages}");
                return totalWages;
            }
        }

        /// <summary>
        /// 工資管理類
        /// </summary>
        public class WageManager
        {
            IList<Worker> workerList = new List<Worker>();

            public void RegisterWorker(Worker worker)
            {
                workerList.Add(worker);
            }

            public void RemoveWorker(Worker worker)
            {
                workerList.Remove(worker);
            }

            public void Excute(double basicWages)
            {
                if (workerList.Count != 0)
                {
                    foreach (var worker in workerList)
                    {
                        worker.GetWages(basicWages);
                    }
                }
            }
        }
        #endregion

        static void Main(string[] args)
        {
            #region 非委托觀察者模式
            WageManager wageManager = new WageManager();
            //注冊觀察者
            wageManager.RegisterWorker(new Manager());
            wageManager.RegisterWorker(new Assistant());
            //同時輸入底薪3000元，分別進行計算，
            wageManager.Excute(3000);
            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

開發Observer模式時若借助委托，可以進一步簡化開發程序，由于委托物件支持多路廣播，所以可以把Worker類省略，在WageManager類中建立了一個

委托物件wageHandler，通過Attach與Detach方法可以分別加入及取消委托，如果觀察者想對事物進行監測，只需要加入一個委托物件即可，在第二節提過，

委托的GetInvodationList方法能獲取多路廣播委托串列，在Execute方法中，就是通過多路廣播委托串列去判斷所系結的委托數量是否為0，

下面代碼演示使用委托方式實作觀察者模式：

    class Program
    {
        #region 委托觀察者模式
        public delegate double Handler(double basicWages);

        public class Manager
        {
            public double GetWages(double basicWages)
            {
                double totalWages = 1.5 * basicWages;
                Console.WriteLine($"Manager's wages is:{totalWages}");
                return totalWages;
            }
        }

        public class Assistant
        {
            public double GetWages(double basicWages)
            {
                double totalWages = 1.2 * basicWages;
                Console.WriteLine($"Assistant's wages is:{totalWages}");
                return totalWages;
            }
        }

        public class WageManager
        {
            private Handler wageHandler;

            //加入觀察者
            public void Attach(Handler wageHandler1)
            {
                wageHandler += wageHandler1;
            }

            //洗掉觀察者
            public void Detach(Handler wageHandler1)
            {
                wageHandler -= wageHandler1;
            }

            //通過GetInvodationList方法獲取多路廣播委托串列，如果觀察者數量大于0即執行方法，
            public void Execute(double basicWages)
            {
                if (wageHandler != null)
                {
                    if (wageHandler.GetInvocationList().Count() != 0)
                    {
                        wageHandler(basicWages);
                    }
                }
            }
        }
        #endregion

        static void Main(string[] args)
        {
            #region 委托觀察者模式
            WageManager wageManager = new WageManager();
            //加入Manager觀察者
            Manager manager = new Manager();
            Handler managerHandler = new Handler(manager.GetWages);
            wageManager.Attach(managerHandler);

            //加入Assistant觀察者
            Assistant assistant = new Assistant();
            Handler assistantHandler = new Handler(assistant.GetWages);
            wageManager.Attach(assistantHandler);

            //同時加入底薪3000元，分別進行計算
            wageManager.Execute(3000);
            Console.ReadKey();
            #endregion
        }
    }

View Code

運行結果如下：

3.5 委托的協變與逆變

在Framework 2.0出現之前，委托協變這個概念還沒有出現，此時因為委托是安全型別，它們不遵守繼承的基礎規則，即會這下面的情況：Manager雖然

是Worker的子類，但GetWorkerHander委托不能直接系結GetManager方法，因為在委托當中它們的回傳值Manager與Worker被視為完全無關的兩個型別，

自Framework 2.0面世以后，委托協變的概念就應運而生，此時委托可以按照傳統的繼承規則進行轉換，即GetWorkerHandler委托可以直接系結

GetManager方法，

下面代碼演示委托的協變：

    class Program
    {
        #region 委托的協變
        /// <summary>
        /// 在Framework 2.0以上可系結GetWorker與GetManager兩個方法
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public delegate Worker GetWorkerHandler(int id);

        public class Worker
        {
            public Worker() { }

            public Worker(int id)
            {
                Id = id;
            }

            public int Id { get; set; }

            public void ShowId()
            {
                Console.WriteLine($"Id={Id}");
            }
        }

        public class Manager : Worker
        {
            public Manager() { }
            public Manager(int id)
            {
                Id = id;
            }
        }

        public static Worker GetWorker(int id)
        {
            Worker worker = new Worker(id);
            return worker;
        }

        public static Manager GetManager(int id)
        {
            Manager manager = new Manager(id);
            return manager;
        }
        #endregion

        static void Main(string[] args)
        {
            #region 委托的協變
            GetWorkerHandler workerHandler = new GetWorkerHandler(GetWorker);
            Worker worker = workerHandler(1);
            worker.ShowId();
            GetWorkerHandler managerHandler = new GetWorkerHandler(GetManager);
            Manager manager = managerHandler(2) as Manager;
            manager.ShowId();
            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

委托逆變，是指委托方法的引數同樣可以接收 “繼承” 這個傳統規則，像下面的例子，以object為引數的委托，可以接受任何object子類的物件作為引數，

最后可以在處理方法中使用is對輸入資料的型別進行判斷，分別處理對不同的型別的物件，

下面代碼演示委托的逆變：

    class Program
    {
        #region 委托的逆變
        public delegate void Handler(object obj);

        public static void GetMessage(object message)
        {
            if (message is string)
                Console.WriteLine("His name is:" + message.ToString());
            if (message is int)
                Console.WriteLine("His age is:" + message.ToString());
        }
        #endregion

        static void Main(string[] args)
        {
            #region 委托的逆變
            Handler handler = new Handler(GetMessage);
            handler(29);
            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

注：委托與其系結方法的引數必須一至，即當 Handler 所輸入的引數為 A 型別，其系結方法 GetMessage 的引數也必須為 A 類或者 A 的父類，相反，

當系結方法的引數為 A 的子類，系統也無法辨認，

3.6 泛型委托

委托逆變雖然實用，但如果都以object作為引數，則需要每次都對引數進行型別的判斷，這不禁令人感到厭煩，

為此，泛型委托應運而生，泛型委托有著委托逆變的優點，同時利用泛型的特性，可以使一個委托系結多個不同型別引數的方法，而且在方法中不需要

使用is進行型別判斷，從而簡化了代碼，

下面代碼演示泛型委托：

    class Program
    {
        #region 泛型委托
        public delegate void Handler<T>(T obj);

        /// <summary>
        /// 作業者類
        /// </summary>
        public class Worker
        {
            public double Wages { get; set; }
        }

        /// <summary>
        /// 管理級類
        /// </summary>
        public class Manager : Worker
        {
        }

        public static void GetWorkerWages(Worker worker)
        {
            Console.WriteLine("Worker's total wages is:" + worker.Wages);
        }

        public static void GetManagerWages(Manager manager)
        {
            Console.WriteLine("Manager's total wages is:" + manager.Wages);
        }
        #endregion

        static void Main(string[] args)
        {
            #region 泛型委托
            Handler<Worker> workerHander = new Handler<Worker>(GetWorkerWages);
            Worker worker = new Worker
            {
                Wages = 3000
            };
            workerHander(worker);

            Handler<Manager> managerHandler = new Handler<Manager>(GetManagerWages);
            Manager manager = new Manager
            {
                Wages = 4500
            };
            managerHandler(manager);

            Console.ReadKey();
            #endregion
        }
    }

View Code

運行結果如下：

四、深入決議事件

4.1 事件的由來

在介紹事件之前大家可以先看看下面的例子，PriceManager負責對商品價格進行處理，當委托物件GetPriceHandler的回傳值大于100元，按8.8折計算，

低于100元按原價計算，

    class Program
    {
        #region 事件的由來
        public delegate double PriceHandler();
        public class PriceManager
        {
            public PriceHandler GetPriceHandler;

            //委托處理，當價格高于100元按8.8折計算，其他按原價計算，
            public double GetPrice()
            {
                if (GetPriceHandler.GetInvocationList().Count() > 0)
                {
                    if (GetPriceHandler() > 100)
                        return GetPriceHandler() * 0.88;
                    else
                        return GetPriceHandler();
                }
                return -1;
            }
        }
        //書本價格為98元
        public static double BookPrice()
        {
            return 98.0;
        }
        //計算機價格為8800元
        public static double ComputerPrice()
        {
            return 8800.0;
        }
        #endregion

        static void Main(string[] args)
        {
            #region 事件的由來
            PriceManager priceManager = new PriceManager
            {
                //呼叫priceManager的GetPrice方法獲取價格
                //直接呼叫委托的Invoke獲取價格，兩者進行比較，
                GetPriceHandler = new PriceHandler(ComputerPrice)
            };
            Console.WriteLine(string.Format("GetPrice\n Computer's price is {0}",priceManager.GetPrice()));
            Console.WriteLine(string.Format("Invoke\n Computer's price is {0}",priceManager.GetPriceHandler.Invoke()));
            Console.WriteLine();
            priceManager.GetPriceHandler = new PriceHandler(BookPrice);
            Console.WriteLine(string.Format("GetPrice\n Book's price is {0}",priceManager.GetPrice()));
            Console.WriteLine(string.Format("Invoke\n Book's price is {0}",priceManager.GetPriceHandler.Invoke()));
            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

觀察運行的結果，如果把委托物件GetPriceHandler設定為public，外界可以直接呼叫GetPriceHandler.Invoke獲取運行結果而移除了GetPrice方法的處理，

這正是開發人員最不想看到的，

為了保證系統的封裝性，開發往往需要把委托物件GetPriceHandler設定為private，再分別加入AddHandler、RemoveHandler方法對GetPriceHandler委托

物件進行封裝，為了保存封裝性，很多操作都需要加入AddHandler、RemoveHandler這些相似的方法代碼，這未免令人感到厭煩，

為了進一步簡化操作，事件這個概念應運而生，

4.2 事件的定義

事件（event）可被視作為一種特別的委托，它為委托物件隱式地建立起add_XXX、remove_XXX兩個方法，用作注冊與注銷事件的處理方法，而且事件對

應的變數成員將會被視為private變數，外界無法超越事件所在物件直接訪問它們，這使事件具備良好的封裝性，而且免除了add_XXX、remove_XXX等繁瑣

的代碼，

#region 事件的定義
public class EventTest
{
    public delegate void MyDelegate();
    public event MyDelegate MyEvent;
}
#endregion

使用ILDASM.exe觀察事件成員，系統為MyEvent事件自動建立add_MyEvent、remove_MyEvent 方法，

4.3 事件的使用方式

事件能通過+=和-=兩個方式注冊及注銷對其處理的方法，使用+=與-=運算子的時候，系統會自動呼叫對應的add_XXX、remove_XXX進行處理，

值得留意，在PersonManager類的Execute方法中，如果MyEvent系結的處理方法不為空，即可使用MyEvent(string)引發事件，但如果在外界的Main方法中

直接使用personManager.MyEvent(string)來引發事件，系統將引發錯誤報告，這正是因為事件具備了良好的封裝性，使外界不能超越事件所在的物件訪問其變

量成員，

注：在事件所處的物件之外，事件只能出現在+=、-=的左方，

下面代碼演示事件的使用：

    class Program
    {
        #region 事件的使用
        public delegate void MyDelegate(string name);

        public class PersonManager
        {
            public event MyDelegate MyEvent;

            //執行事件
            public void Execute(string name)
            {
                if (MyEvent != null)
                {
                    MyEvent(name);
                }
            }
        }

        public static void GetName(string name)
        {
            Console.WriteLine("My name is " + name);
        }
        #endregion

        static void Main(string[] args)
        {
            #region 事件的使用
            PersonManager personManager = new PersonManager();
            //系結事件處理方法
            personManager.MyEvent += new MyDelegate(GetName);
            personManager.Execute("Atomy");
            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

4.4 事件處理方法的系結

在系結事件處理方法的時候，事件出現在+=、-= 運算子的左邊，對應的委托物件出現在+=、-= 運算子的右邊，對應以上例子，事件提供了更簡單的系結方式，

只需要在+=、-= 運算子的右方寫上方法名稱，系統就能自動辯認，

下面代碼演示事件處理方法的系結：

    class Program
    {
        #region 事件的使用及方法系結
        public delegate void MyDelegate(string name);

        public class PersonManager
        {
            public event MyDelegate MyEvent;

            //執行事件
            public void Execute(string name)
            {
                if (MyEvent != null)
                {
                    MyEvent(name);
                }
            }
        }

        public static void GetName(string name)
        {
            Console.WriteLine("My name is " + name);
        }
        #endregion

        static void Main(string[] args)
        {
            #region 事件的使用及方法系結
            PersonManager personManager = new PersonManager();
            //系結事件處理方法方式一
            personManager.MyEvent += new MyDelegate(GetName);
            //系結事件處理方法方式二
            personManager.MyEvent += GetName;
            personManager.Execute("Atomy");
            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

如果覺得撰寫GetName方法過于麻煩，還可以使用匿名方法系結事件的處理，

下面代碼演示事件處理方法的匿名方法系結：

    class Program
    {
        #region 事件的使用
        public delegate void MyDelegate(string name);

        public class PersonManager
        {
            public event MyDelegate MyEvent;

            //執行事件
            public void Execute(string name)
            {
                if (MyEvent != null)
                {
                    MyEvent(name);
                }
            }
        }

        public static void GetName(string name)
        {
            Console.WriteLine("My name is " + name);
        }
        #endregion

        static void Main(string[] args)
        {
            #region 事件的使用及方法系結
            PersonManager personManager = new PersonManager();
            //系結事件處理方法方式一
            personManager.MyEvent += new MyDelegate(GetName);
            //系結事件處理方法方式二
            personManager.MyEvent += GetName;
            //系結事件處理方法方式三(匿名方法)
            personManager.MyEvent += delegate (string name) { Console.WriteLine("My name is " + name); };
            personManager.Execute("Atomy");
            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

4.5 C#控制元件中的事件

在C#控制元件中存在很多的事件，比如Click、TextChanged、SelectIndexChanged等等，很多都是通過EventHandler委托系結事件的處理方式，EventHandler

可說是C#控制元件中最常見的委托，

public delegate void EventHandler (Object sender, EventArgs e)

EventHandler委托并無回傳值，sender代表引發事件的控制元件物件，e代表由該事件生成的資料，

下面代碼演示C#控制元件中的事件系結：

    public partial class EventTest : Form
    {
        public EventTest()
        {
            InitializeComponent();
        }

        private void EventTest_Load(object sender, EventArgs e)
        {
            btnEvent.Click += new EventHandler(btnEvent_onclick);
        }

        public void btnEvent_onclick(object sender,EventArgs e)
        {
            Button button = (Button)sender;
            MessageBox.Show(button.Text);
        }
    }

View Code

運行結果如下：

EventHandler只是EventHandler<TEventArgs>泛型委托的一個簡單例子，事實上，大家可以利用 EventHandler<TEventArgs> 構造出所需要的委托，

public delegate void EventHandler<TEventArgs> (Object sender, TEventArgs e)

在EventHandler<TEventArgs>中，sender代表事件源，e代表派生自EventArgs類的事件引數，開發人員可以建立派生自EventArgs的類，從中加入需要使用

到的事件引數，然后建立EventHandler<TEventArgs>委托，

下面的例子中，先建立一個派生自EventArgs的類MyEventArgs作為事件引數，然后在EventManager中建立事件myEvent , 通過Execute方法可以激發事件，

最后在測驗中系結myEvent的處理方法ShowMessage，在ShowMessage顯示myEventArgs的事件引數Message，

    class Program
    {
        #region EventArgs派生
        public class MyEventArgs : EventArgs
        {
            private string args;

            public MyEventArgs(string message)
            {
                args = message;
            }

            public string Message
            {
                get { return args; }
                set { args = value; }
            }
        }

        public class EventManager
        {
            public event EventHandler<MyEventArgs> myEvent;

            public void Execute(string message)
            {
                myEvent?.Invoke(this, new MyEventArgs(message));
            }
        }

        public static void ShowMessage(object obj, MyEventArgs e)
        {
            Console.WriteLine(e.Message);
        }
        #endregion

        static void Main(string[] args)
        {
            #region EventArgs派生
            EventManager eventManager = new EventManager();
            eventManager.myEvent += new EventHandler<MyEventArgs>(ShowMessage);
            eventManager.Execute("How are you?");
            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

4.6 為用戶控制元件建立事件

開發程序中，往往會出現很多類似的控制元件與代碼，開發人員可以通過用戶控制元件來避免重復的代碼，但往往同一個用戶控制元件，在不同的頁面中需要有不同的回應，

此時為用戶控制元件建立事件，便可輕松地解決此問題，

新建一個Person類：

    class Person
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
    }

View Code

新建一個用戶控制元件，拖入一個DataGridView，命名為：DataGridViewControl，

    public partial class DataGridViewControl : UserControl
    {
        public DataGridViewControl()
        {
            InitializeComponent();
        }

        private void DataGridViewEvent_Load(object sender, EventArgs e)
        {
            dataGridView1.DataSource = GetPersonList();
        }

        //資料源
        private IList<Person> GetPersonList()
        {
            IList<Person> list = new List<Person>();
            Person person = new Person
            {
                Id = 1,
                Name = "Hello",
                Age = 1
            };
            list.Add(person);
            person = new Person
            {
                Id = 2,
                Name = "World",
                Age = 2
            };
            list.Add(person);
            return list;
        }

        //單元格事件
        public event DataGridViewCellEventHandler CellEventHandler;

        private void dataGridView1_RowEnter(object sender, DataGridViewCellEventArgs e)
        {
            CellEventHandler?.Invoke(sender, e);
        }
    }

View Code

新建一個WinForm表單，命名為Main，并拖入DataGridViewControl用戶控制元件，

    public partial class Main : Form
    {
        public Main()
        {
            InitializeComponent();
        }

        private void Main_Load(object sender, EventArgs e)
        {
            dataGridViewControl1.CellEventHandler += DataGridViewControl1_CellEventHandler;
        }

        private void DataGridViewControl1_CellEventHandler(object sender, DataGridViewCellEventArgs e)
        {
            DataGridView dataGridView1 = (DataGridView)sender;
            int rowIndex = int.Parse(e.RowIndex.ToString());
            int columnIndex = int.Parse(e.ColumnIndex.ToString());
            MessageBox.Show(dataGridView1.Rows[rowIndex].Cells[columnIndex].Value.ToString());
        }
    }

View Code

運行結果如下：

使用控制元件已有的事件固然簡單，但它限制了傳送的引數型別，使開發人員無法傳送額外的自定義引數，在結構比較復雜的用戶控制元件中，使用已有的控制元件事件，

顯然不夠方便，此時，您可以考慮為用戶控制元件建立自定義事件，

新建一個MyEventArgs類：

    public class MyEventArgs : EventArgs
    {
        public string Name { get; set; }                    //買家姓名
        public string Address { get; set; }                 //買家地址
        public string Tel { get; set; }                     //買家電話
        public string OrderCode { get; set; }               //訂單號碼
        public IList<OrderItem> OrderItemList { get; set; } //訂單明細
        public MyEventArgs(string name, string address, string tel, string orderCode, IList<OrderItem> orderItemList)
        {
            Name = name;
            Address = address;
            Tel = tel;
            OrderCode = orderCode;
            OrderItemList = orderItemList;
        }
    }

View Code

新建一個OrderItem類：

    public class OrderItem
    {
        public string OrderItemID { get; set; } //明細單ID
        public string Goods { get; set; }       //商品名稱
        public double Price { get; set; }       //商品單價
        public int Count { get; set; }          //商品數量

        public OrderItem(string id, string goods, double price, int count)
        {
            OrderItemID = id;
            Goods = goods;
            Price = price;
            Count = count;
        }
    }

View Code

新建一個用戶控制元件，拖入一個DataGridView及一個Button，命名為：OrderControl，

    public partial class OrderControl : UserControl
    {
        //自定義委托及事件  
        public delegate void MyDelegate(object sender, MyEventArgs myEventArgs);
        public event MyDelegate MyEvent;

        public OrderControl()
        {
            InitializeComponent();
        }

        private void OrderControl_Load(object sender, EventArgs e)
        {
            dataGridView1.DataSource = GetList();
        }

        //資料源
        private IList<OrderItem> GetList()
        {
            IList<OrderItem> list = new List<OrderItem>();
            OrderItem orderItem = new OrderItem("1", "滑鼠", 160, 2);
            list.Add(orderItem);
            orderItem = new OrderItem("2", "鍵盤", 80, 2);
            list.Add(orderItem);
            return list;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            if (MyEvent != null)
            {
                if (dataGridView1.CurrentCell != null)
                {
                    int rowIndex = int.Parse(dataGridView1.CurrentCell.RowIndex.ToString());
                    MyEventArgs myEventArgs = new MyEventArgs
                    (
                        "張三",
                        "廣東",
                        "111111111111",
                        "2019122300001",
                        GetList()
                    );
                    MyEvent(this, myEventArgs);
                }
            }
        }
    }

View Code

新建一個WinForm表單，命名為OrderForm，并拖入OrderControl用戶控制元件，

    public partial class OrderForm : Form
    {
        public OrderForm()
        {
            InitializeComponent();
        }

        private void OrderForm_Load(object sender, EventArgs e)
        {
            orderControl1.MyEvent += OrderControl1_MyEvent;
        }

        private void OrderControl1_MyEvent(object sender, MyEventArgs myEventArgs)
        {
            MessageBox.Show($"Name={myEventArgs.Name},Address={myEventArgs.Address},Tel={myEventArgs.Tel}","資訊",MessageBoxButtons.OK,MessageBoxIcon.Information); 
        }
    }

View Code

運行結果如下：

轉載請註明出處，本文鏈接：https://www.uj5u.com/net/87782.html

標籤：C#

上一篇：2、IOC--手寫Unity容器--第一層依賴注入

下一篇：值型別與參考型別的區別