C#委托与事件

现在还不会的孩子，请面壁思过！！！！！

委托的声明

public delegate void MyDelegate(string str);
注
1.委托的定义和方法的定义类似，只是在前面加了一个delegate,但委托不是方法，它是一种类型。是一种特殊的类型,看成是一种新的对象类型比较好理解。用于对与该委托有相同签名的方法调用。
2.委托相当于C++中的函数指针，但它是类型安全的。
3.委托是从System.Delegate派生，但不能象定义常规类型一样直接从System.Delegate派生，对委托的声明只能通过上面的声明格式进行定义。关键字delegate通知编译器这是一个委托类型，从而在编译的时候对该类进行封装,对这一过程C#定义了专门的语法来处理这一过程。
4.不能从一个委托类型进行派生，因为它也是默认sealed的
5.委托即可以对静态方法进行调用也可以对实例方法进行调用。
6.每个委托类型包含一个自己的调用列表，当组合一个委托或从一个委托中删除一个委托时都将产生个新的调用列表。
7.两个不同类型的委托即使它们有相同的签名和返回值，但还是两个不同类型的委托。但其实在使用中可看作是相同的。

委托的比较

C#中对委托定义了两个操作符 == 和 !=
在以下情况下两个委托是相等的：
1.当两个委托都同时为null的时候
2.当两个委托都不为null时,下列情况下是相等的。
a.当两个委托的各自的调用列表只含有一个入口点的时候
   在下列情况下是相等的
   (1) 调用同一对象的同一静态方法
   (2) 调用同一对象的同一实例方法
b.当两个委托具有多个入口点时
   在下列情况下是相等的
   (1)只有当它们调用列表中的调用的方法按顺序都一一对应相同的对象及对象的同一方法的时候如上所述的两个不同类型的委托但是它们具有相同的签名和返回值时，只要满足上述条件的，即使它们类型不同，但比较的结果也是相同的。

委托的异常处理

当调用该委托的方法中发生了异常时，首先在调用该委托的方法中搜寻catch语句块。如果没有，则去该委托调用的方法中去寻找有没有catch语句块，这和调用方法发生异常的处理是一样的。当调用一个为null的委托即委托中列表中不存在调用方法时，将发生NullRefrenceException

委托的注意点:
当一个委托有多个入口点的时候,调用委托将依该委托的调用列表中的方法的顺序依次调用.这些方法共享一个参数集合,所以当委托有返回值的时候调用完这个委托后的返回值是最后一个方法的返回值或是有out参数.如果该委托的参数为ref(引用类型),那么在招待第一个方法的时候如果对这个参数的值有所改变,那么这个改变将会影响到后面的方法调用.

委托的一个例子

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // 创建一个委托实例，封装C类的静态方法M1
            MyDelegate d1 = new MyDelegate(C.M1);
            d1("D1"); // M1

            // 创建一个委托实例，封装C类的静态方法M2
            MyDelegate d2 = new MyDelegate(C.M2);
            d2("D2"); // M2

            // 创建一个委托实例，封装C类的实例方法M3
            MyDelegate d3 = new MyDelegate(new C().M3);
            d3("D3"); // M3

            // 从一个委托d3创建一个委托实例
            MyDelegate d4 = new MyDelegate(d3);
            d4("D4"); // M3

            // 组合两个委托
            MyDelegate d5 = d1 + d2;
            d5 += d3;
            d5("D5"); // M1,M2,M3

            // 从组合委托中删除d3
            MyDelegate d6 = d5 - d3;
            d6("D6"); // M1,M2
            d6 -= d3; // 虽然d6调用列表中已经没有d3了，但这样只是不可能的移除没有错误发生
            d6("D6"); // M1,M2
            d6 -= d6;
            //d6("D6"); 此时d6的调用列表为空，d6为null,所以引发System.NullReferenceException

            MyDelegate d7 = new MyDelegate(C1.P1);
            d7("D7"); // C1.P1

            MyDelegate d8 = new MyDelegate(new C2().P1);
            d8("D8"); // C2.P1

        }
    }

    // 声明一个委托MyDelegate
    public delegate void MyDelegate(string str);

    public class C
    {
        public static void M1(string str)
        {
            Console.WriteLine("From:C.M1:   {0}", str);
        }

        public static void M2(string str)
        {
            Console.WriteLine("From:C.M2:   {0}", str);
        }

        public void M3(string str)
        {
            Console.WriteLine("From:C.M3:   {0}", str);
        }
    }

    public class C1
    {
        public static void P1(string str)
        {
            Console.WriteLine("From:C1.P1:   {0}", str);
        }
    }

    public class C2
    {
        public void P1(string str)
        {
            Console.WriteLine("From:C2.P1:   {0}", str);
        }
    }    
}

事件委托

事件概述

事件就是当对象或类状态发生改变时，对象或类发出的信息或通知。发出信息的对象或类称为"事件源",对事件进行处理的方法称为"接收者",通常事件源在发出状态改变信息时,它并不知道由哪个事件接收者来处理.这就需要一种管理机制来协调事件源和接收者,C++中通过函数指针来完成的.在C#中事件使用委托来为触发时将调用的方法提供类型安全的封装

 

事件的声明

1.声明一个委托
public delegate void EventHandler(object sender, System.EventArgs e);

2.声明一个事件
public event EventHandler Changed;

3.引发一个事件
public OnChanged(EnventArgs e)
{
 if ( Changed != null)
 {
  Changed(this,e);
 }
}

4.定义事件处理程序
public MyText_OnChanged(Object sender,EventArgs e)
{
 ...
}

5.订阅事件(将事件处理程序添加到事件的调用列表中)

myText.Changed += EventHandler(MyText_OnChanged);

下面的一个小例子说明了怎样定义一个完整的事件机制:

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {        
        static void Main(string[] args)
        {              
            MyText myText = new MyText();

            // 将事件处理程序添加到事件的调用列表中(即事件布线)
            myText.Changed += new MyText.ChangedEventHandler(myText_Changed);         
            
            string str = "";
            while (str != "quit")
            {
                Console.WriteLine("please enter a string:");
                str = Console.ReadLine();
                myText.Text = str;
            }
        }

        // 对Change事件处理的程序
        private static void myText_Changed(object sender, EventArgs e)
        {
            Console.WriteLine("text has been changed  :{0}\n" ,((MyText)sender).Text);
        }        
    }  

    public class MyText
    {
        private string _text = "";

        // 定义事件的委托
        public delegate void ChangedEventHandler(object sender, EventArgs e);

        // 定义一个事件
        public event ChangedEventHandler Changed;

        // 用以触发Change事件
        protected virtual void OnChanged(EventArgs e)
        {
            if (this.Changed != null)
                this.Changed(this, e);
        }

        // Text属性
        public string Text
        {
            get { return this._text; }
            set
            {
                this._text = value;
                // 文本改变时触发Change事件
                this.OnChanged(new EventArgs());
            }
        }
    }
}   

作者：yiki

一、在控制台下使用C#委托和事件

    我们都知道，C#中有“接口”这个概念，所谓的“接口”就是定义一套标准，然后由实现类来具体实现其中的方法，所以说“接口，是一组类的抽象”。同样道理，我们可以将“委托”理解为“方法的抽象”，也就是说定义一个方法的模板，至于这个方法具体是怎么样的，就由方法自己去实现。

    我们知道接口的最大好处就是可以实现多态，同理，“委托”是可以实现方法的多态，当我们想调用某个具体方法的时候，我们不直接调用这个方法，而是去调用这个委托。当然，我们必须在具体方法和委托之间建立某种关联。

    下面我们来看例子。

    首先，我们定义一个委托：

  
  
public delegate void SaySomething(string name); 

    这跟抽象方法的语法格式很相似，只是多了一个关键字delegate。既然是对方法的一种抽象，那么我们最关注的当然就是方法的返回值以及方法的参数了。所以上面红色的部分就是我们定义出来的一个规矩，如果某个方法想委托我去做事，那么请你遵循我的规矩，就是返回值为void，参数为一个字符串。我们这个委托的含义是，当某个人来了，就向他说点东西。

    好，既然我们已经定义了这个规矩，下面我们就定义具体的方法了。

  
  
public void SayHello(string name)  
{  
    Console.WriteLine("Hello," + name + "!");  
}  
 
 
public void SayNiceToMeetYou(string name)  
{  
    Console.WriteLine("Nice to meet you," + name + "!");  
} 

    我们这里一共定义了两个方法，一个是向某人说Hello，另一个是向某人说Nice to meet you。我们看到，这里定义的两个方法的返回值和参数跟我们前面定义的“委托”是一致的。

    接下来，我们来看事件。

  
  
public event SaySomething come; 

    我们定义了一个事件，这个事件是“有人来了”，注意定义的时候我们使用event关键字，除此之外，我们还加上了前面定义的“委托”的名字。这个意思是说，我这个事件只会跟“SaySomething”打交道，并且，当我这个事件发生的时候，我会通知关注我的这些“委托”（再由这些“委托”去调用具体的方法）。

    我们来定义一个测试方法：

  
  
public void test() {   
    SaySomething sayhello = new SaySomething(SayHello);  
    SaySomething saynice = new SaySomething(SayNiceToMeetYou);  
    come += sayhello;  
    come += saynice;  
    come("张三");  
}  

    方法体中的前面两行是用来实例化委托，注意我们用到了new关键字，就好像实例化一个类一样，然后传入一个参数，但这个参数不是string类型、也不是int类型，而是一个方法名。

    再下面两行就是将委托加到事件上，意思是说，如果你这个事件发生了，就告诉我一声。可以通过“+=”来将n个委托实例加到某个事件上，一旦这个事件发生，所有的这些委托实例都会得到通知。

    最后一行是触发一个事件，注意我们是直接用一个事件名，然后跟一个参数，这又跟“委托”中定义的那个规矩一致（即，要有一个string类型的参数）。

    最后运行一下

  
  
static void Main(string[] args)  
{  
    Program program = new Program();  
    program.test();  
    Console.Read();  
}  

 

    我们回过头来再看一下“事件”的定义：

  
  
public event SaySomething come; 

    这里已经指出了“委托”的名字，所以，我们可以直接将方法加到事件上，而省略“委托”的实例化过程，因此上面的test()方法可以简单写为：

  
  
public void test() {   
    come += SayHello;  
    come += SayNiceToMeetYou;  
    come("张三");  
}  

二、在窗体中使用C#委托和事件

    上面的例子并不能体现委托和事件的优点，其实，委托和事件在C#中使用非常广泛，例如，当我们点击某个“按钮”的时候，就会有一个“Click”事件触发，而这个事件会通知“委托”，在C#窗体应用程序中，“委托”的名字比较规范，统一使用“EventHandler”，它的具体格式是“void EventHandler(object sender, EventArgs e);”。相信大家都写过下面这样子的HelloWorld程序：

 

    当点击按钮的时候弹出一个对话框。我们怎样实现的呢？你肯定会说，我们在设计窗口双击按钮，就会自动为我们生成类似如下的方法：

  
  
private void button1_Click(object sender, EventArgs e)  
{  
    MessageBox.Show("我被点击了！！！");  
} 

    其实，这里用到的就是事件和委托，这里的button1_Click就是符合EventHandler委托规矩的一个具体的方法，即返回值为void，参数分别是一个object和EventArgs。

    我们可以在Form1.Designer.cs中看到如下代码：

  
  
this.button1.Click += new System.EventHandler(this.button1_Click); 

    可以看到，这里有一个Click事件，然后将一个委托实例附加到这个事件上，跟我们前面讲的控制台应用程序中的用法是完全一样的。那这个Click事件是怎么触发的呢？对于这些系统类的事件，并不用我们管。

    当然，我们也可以定义自己的事件和委托，例如我定义一个事件，这个事件就是输出对象的名字。

 

    我们这里定义了一个ShowName委托和一个btnclick事件。并且，在button1_Click()方法中触发这个btnclick事件。最后的结果是，当我们点击按钮的时候，首先弹出一个“我被点击了！！！”的对话框，然后确定之后再弹出另一个显示按钮名称的对话框：

 

    C#委托与事件的相关内容介绍到这里，希望对大家会有帮助。

作者：ruizhinet