委托与事件入门经典

委托的声明

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 Delegate_Example
{

    class Program
    {
        //声明一个委托
        delegate int ComputeDelegate(int a,int b );
        static void Main(string[] args)
        {
           // 从一个委托compute1创建一个委托实例
           ComputeDelegate compute1 = new ComputeDelegate(C.Add);
           int x = compute1(10, 20);
           Console.WriteLine("compute1的运行结果:{0}",x);     //Add

           // 从一个委托compute2创建一个委托实例
           ComputeDelegate compute2 = new ComputeDelegate(C.Substence);
           int y = compute2(8, 4);
           Console.WriteLine("compute2的运行结果:{0}", y);    //Substence


           // 从一个委托compute3创建一个委托实例
           ComputeDelegate compute3 = new ComputeDelegate(C.Mutiplacation);
           int j = compute3(8, 4);
           Console.WriteLine("compute3的运行结果:{0}", j);    //Mutiplacation


           // 从一个委托compute4创建一个委托实例
           ComputeDelegate compute4= new ComputeDelegate(C.Division);
           int k = compute4(8, 4);
           Console.WriteLine("compute4的运行结果:{0}", k);    //Division

           // 组合两个委托
           ComputeDelegate compute5 = compute1 + compute2;   //Add,Substence,Division
            compute5+=compute4;
           int z=compute5(10, 20);
           Console.WriteLine("compute5的运行结果:{0}", z);

            //使用已有的委托
           ComputeDelegate compute6 = new ComputeDelegate(compute5);
           int n = compute6(10, 20);                         //Add,Substence,Division
           Console.WriteLine("compute6的运行结果:{0}", n);


           //从组合委托里删除
           ComputeDelegate compute7 = compute5 - compute2;   //Add,Division
           compute7 -= compute2;                             //虽然d6调用列表中已经没有d3了，但这样只是不可能的移除没有错误发生
           int l = compute7(10,25);
           Console.WriteLine("compute7的运行结果:{0}", l);

           Console.ReadKey();

        }

        

    }

    class C
    {
        //加法运算
        public static int Add(int a, int b)
        {

            return a + b;
        }

        //减法运算
        public static int Substence(int a, int b)
        {
            return a - b;
        }

        //乘法运算
        public static int Mutiplacation(int a, int b)
        {
            return a * b;
        }

        //除法运算
        public static int Division(int a, int b)
        {
            return a / b;
        }
    }

}

 

事件委托

事件概述

事件就是当对象或类状态发生改变时，对象或类发出的信息或通知。发出信息的对象或类称为"事件源",对事件进行处理的方法称为"接收者",通常事件源在发出状态改变信息时,它

并不知道由哪个事件接收者来处理.这就需要一种管理机制来协调事件源和接收者,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());
            }
        }
    }
}   

 

转自http://www.cnblogs.com/ktgu/archive/2006/11/28/575279.html