c＃中的委托和事件的简单实例_c#应用

在C#中使用一个类时，分两个阶段。首先需要定义这个类，即告诉编译器这个类由什么字段和方法组成。然后(除非只使用静态方法)实例化类的一个对 象。使用委托时，也需要经过这两个步骤。首先定义要使用的委托，对于委托，定义它就是告诉编译器这种类型的委托代表了哪种类型的方法，然后创建该委托的一 个或多个实例。编译器在后台将创建表示该委托的一个类。

定义委托的语法如下：
delegate void IntMethodInvoker(int x);

在这个示例中，定义了一个委托IntMethodInvoker，并指定该委托的每个实例都包含一个方法的细节，该方法带有一个int参数，并返回void。理解委托的一个要点是它们的类型安全性非常高。在定义委托时，必须给出它所代表的方法签名和返回类型的全部细节。

提示：
理解委托的一种好方式是把委托当作给方法签名和返回类型指定名称。

假定要定义一个委托TwoLongsOp，该委托代表的方法有两个long型参数，返回类型为double。可以编写如下代码：
delegate double TwoLongsOp(long first, long second);

或者定义一个委托，它代表的方法不带参数，返回一个string型的值，则可以编写如下代码：
delegate string GetAString();

其语法类似于方法的定义，但没有方法体，定义的前面要加上关键字delegate。因为定义委托基本上是定义一个新类，所以可以在定义类的任何地方 定义委托，既可以在另一个类的内部定义，也可以在任何类的外部定义，还可以在命名空间中把委托定义为顶层对象。根据定义的可见性，可以在委托定义上添加一 般的访问修饰符：public、 private和 protected等：
public delegate string GetAString();

注意：
实际上，“定义一个委托”是指“定义一个新 类”。委托实现为派生于基类System. Multicast Delegate的类，System.MulticastDelegate又派生于基类System.Delegate。C#编译器知道这个类，会使用其 委托语法，因此我们不需要了解这个类的具体执行情况，这是C#与基类共同合作，使编程更易完成的另一个示例。

定义好委托后，就可以创建它的一个实例，以存储特定方法的细节。

注意：
此处，在术语方面有一个问题。类有两个不同的术语:“类”表示较广义的定义，“对象”表示类的实例。但委托只有一个术语。在创建委托的实例时，所创建的委托的实例仍称为委托。必须从上下文中确定委托的确切含义。

在C#中使用委托

下面的代码段说明了如何使用委托。这是在int上调用ToString()方法的一种相当冗长的方式：

private delegate string GetAString();
static void Main
{
int x = 40;
GetAString firstStringMethod = new GetAString(x.ToString);
Console.WriteLine("String is" + firstStringMethod());
// With firstStringMethod initialized to x.ToString(), 
// the above statement is equivalent to saying 
// Console.WriteLine("String is" + x.ToString());  }    

在 这段代码中，实例化了类型为GetAString的一个委托，并对它进行初始化，使它引用整型变量x的ToString()方法。在C#中，委托在语法上 总是带有一个参数的构造函数，这个参数就是委托引用的方法。这个方法必须匹配最初定义委托时的签名。所以在这个示例中，如果用不带参数、返回一个字符串的 方法来初始化firstStringMethod变量，就会产生一个编译错误。注意，int.ToString()是一个实例方法(不是静态方法)，所以 需要指定实例(x)和方法名来正确初始化委托。

下一行代码使用这个委托来显示字符串。在任何代码中，都应提供委托实例的名称，后面的括号中应包含调用该委托中的方法时使用的参数。所以在上面的代码中，Console.WriteLine()语句完全等价于注释语句中的代码行。

实际上，给委托实例提供括号与调用委托类的Invoke()方法完全相同。firstStringMethod是委托类型的一个变量，所以C#编译器会用firstStringMethod. Invoke()代替firstStringMethod()。

firstStringMethod();
firstStringMethod. Invoke();    

委托的一个特征是它们的类型是安全的，可以确保被调用的方法签名是正确的。但有趣的是，它们不关心在什么类型的对象上调用该方法，甚至不考虑该方法是静态方法，还是实例方法。

提示：
给定委托的实例可以表示任何类型的任何对象上的实例方法或静态方法—— 只要方法的签名匹配于委托的签名即可。

为了说明这一点，我们扩展上面的代码，让它使用firstStringMethod委托在另一个对象上调用其他两个方法，其中一个是实例方法，另一个是静态方法。为此，再次使用本章前面定义的Currency结构。

 struct Currency
{
public uint Dollars;
public ushort Cents;
public Currency(uint dollars, ushort cents)
{
this.Dollars = dollars;
this.Cents = cents;
}
public override string ToString()
{
return string.Format("${0}.{1,–2:00}", Dollars,Cents);
}
public static explicit operator Currency (float value)
{
checked
{
uint dollars =(uint)value;
ushort cents =(ushort)((value-dollars)*100);
return new Currency(dollars,cents);
}
}
public static implicit operator float (Currency value)
{
return value.Dollars + (value.Cents/100.0f);
}
public static implicit operator Currency (uint value)
{
return new Currency(value, 0);
}
public static implicit operator uint (Currency value)
{
return value.Dollars;
}
}   

Currency结构已经有了自己的ToString()重载方法。为了说明如何使用带有静态方法的委托，再增加一个静态方法，其签名与Currency的签名相同：

struct Currency
{
public static string GetCurrencyUnit()
{
return "Dollar";
}
下面就可以使用GetAString 实例，代码如下所示：
private delegate string GetAString();
static void Main
{
int x = 40;
GetAString firstStringMethod = new GetAString(x.ToString);
Console.WriteLine("String is " + firstStringMethod());
Currency balance = new Currency(34, 50);
// firstStringMethod references an instance method
firstStringMethod = new GetAString(balance.ToString);
Console.WriteLine("String is " + firstStringMethod());
// firstStringMethod references a static method
firstStringMethod = new GetAString(Currency.GetCurrencyUnit);
Console.WriteLine("String is " + firstStringMethod());
}   

这段代码说明了如何通过委托来调用方法，然后重新给委托指定在类的不同实例上执行的不同方法，甚至可以指定静态方法，或者在类的不同类型的实例上执行的方法，只要每个方法的签名匹配于委托定义即可。
运行应用程序，会得到委托引用的不同方法的结果：

String is 40
String is $34.50
String is Dollar   

但是，我们还没有说明把一个委托传递给另一个方法的具体过程，也没有给出任何有用的结果。调用int和Currency对象的ToString() 的方法要比使用委托直观得多！在真正领会到委托的用处前，需要用一个相当复杂的示例来说明委托的本质。下面就是两个委托的示例。第一个示例仅使用委托来调 用两个不同的操作，说明了如何把委托传递给方法，如何使用委托数组，但这仍没有很好地说明：没有委托，就不能完成很多工作。第二个示例就复杂得多了，它有 一个类BubbleSorter，执行一个方法，按照升序排列一个对象数组，这个类没有委托是很难编写出来的。

事件 （event）是一个非常重要的概念，我们的程序时刻都在触发和接收着各种事件：鼠标点击事件，键盘事件，以及处理操作系统的各种事件。所谓事件就是由某 个对象发出的消息。比如用户按下了某个按钮，某个文件发生了改变，socket上有数据到达。触发事件的对象称作发送者（sender），捕获事件并且做 出响应的对象称作接收者（receiver），一个事件可以存在多个接受者。

在异步机制中， 事件是线程之间进行通信的一个非常常用的方式。比如：用户在界面上按下一个按钮，执行某项耗时的任务。程序此时启动一个线程来处理这个任务，用户界面上显 示一个进度条指示用户任务执行的状态。这个功能就可以使用事件来进行处理。可以将处理任务的类作为消息的发送者，任务开始时，发出“TaskStart” 事件，任务进行中的不同时刻发出“TaskDoing”事件，并且携带参数说明任务进行的比例，任务结束的时候发出“TaskDone”事件，在画面中接 收并且处理这些事件。这样实现了功能，并且界面和后台执行任务的模块耦合程度也是最低的。

具体说C#语言，事件的实现依赖于“代理”（delegate）的概念，先了解一下代理。

代理（delegate）

delegate是C#中的一种类型，它实际上是一个能够持有对某个方法的引用的类。与其它的类不同，delegate类能够拥有一个签名（signature），并且它只能持有与它的签名相匹配的方法的引用。它所实现的功能与C/C++中的函数指针十分相似。它允许你传递一个类A的方法m给另一个类B的对象，使得类B的对象能够调用这个方法m。但与函数指针相比，delegate有许多函数指针不具备的优点。首先，函数指针只能指向静态函数，而delegate既可以引用静态函数，又可以引用非静态成员函数。在引用非静态成员函数时，delegate不但保存了对此函数入口指针的引用，而且还保存了调用此函数的类实例的引用。其次，与函数指针相比，delegate是面向对象、类型安全、可靠的受控（managed）对象。也就是说，runtime能够保证delegate指向一个有效的方法，你无须担心delegate会指向无效地址或者越界地址。

实现一个delegate是很简单的，通过以下3个步骤即可实现一个delegate：

1．  声明一个delegate对象，它应当与你想要传递的方法具有相同的参数和返回值类型。

2．  创建delegate对象，并将你想要传递的函数作为参数传入。

3．  在要实现异步调用的地方，通过上一步创建的对象来调用方法。

下面是一个简单的例子：

public class MyDelegateTest

{

    // 步骤1，声明delegate对象

    public delegate void MyDelegate(string name);

    // 这是我们欲传递的方法，它与MyDelegate具有相同的参数和返回值类型

    public static void MyDelegateFunc(string name)

    {

        Console.WriteLine("Hello, {0}", name);

    }

    public static void Main ()

    {

        // 步骤2，创建delegate对象

        MyDelegate md = new MyDelegate(MyDelegateTest.MyDelegateFunc);

        // 步骤3，调用delegate

        md("sam1111");

    }

}

输出结果是：Hello, sam1111

下面我们来看看事件是如何处理的：

事件（event）

C#中的事件处理实际上是一种具有特殊签名的delegate，象下面这个样子：

public delegate void MyEventHandler(object sender, MyEventArgs e);

其中的两个参数，sender代表事件发送者，e是事件参数类。MyEventArgs类用来包含与事件相关的数据，所有的事件参数类都必须从System.EventArgs类派生。当然，如果你的事件不含特别的参数，那么可以直接用System.EventArgs类作为参数。

结合delegate的实现，我们可以将自定义事件的实现归结为以下几步：

1：定义delegate对象类型，它有两个参数，第一个参数是事件发送者对象，第二个参数是事件参数类对象。

2：定义事件参数类，此类应当从System.EventArgs类派生。如果事件不带参数，这一步可以省略。

3：定义事件处理方法，它应当与delegate对象具有相同的参数和返回值类型。

4：用event关键字定义事件对象，它同时也是一个delegate对象。

5：用+=操作符添加事件到事件队列中（-=操作符能够将事件从队列中删除）。

6：在需要触发事件的地方用调用delegate的方式写事件触发方法。一般来说，此方法应为protected访问限制，既不能以public方式调用，但可以被子类继承。名字是可以是OnEventName。

7：在适当的地方调用事件触发方法触发事件。

下面是一个例子，例子模仿容器和控件的模式，由控件触发一个事件，在容器中捕捉并且进行处理。

事件的触发者：

/// <summary>

/// 事件的触发者

/// </summary>

public class Control

{

    public delegate void SomeHandler(object sender, System.EventArgs e);

　

    /**

     * 可以采用系统提供的System.EventHandler, 这里为了说明情况使用了自己定义的delegate

     * 如果需要在事件的参数中使用自己定义的类型，也要自己定义delegate

     */

    //public event System.EventHandler SomeEvent;

    public event SomeHandler SomeEvent;

　

    public Control()

    {

        //这里使用的delegate必须与事件中声名的一致

        //this.SomeEvent += new System.EventHandler(this.Control_SomeEvent);

        this.SomeEvent += new SomeHandler(this.ProcessSomeEvent);

    }

　

    public void RaiseSomeEvent()

    {

        EventArgs e = new EventArgs();

        Console.Write("Please input 'a':");

        string s = Console.ReadLine();

　

        //在用户输入一个小a的情况下触发事件，否则不触发

        if (s == "a")

        {

            SomeEvent(this, e);

        }

    }

　

    //事件的触发者自己对事件进行处理，这个方法的参数必须和代理中声名的一致

    private void ProcessSomeEvent(object sender, EventArgs e)

    {

        Console.WriteLine("hello");

    }

}

事件的接收者：

/// <summary>

/// 事件的接收和处理者

/// </summary>

class Container

{

    private Control ctrl = new Control();

　

    public Container()

    {

        //这里使用的delegate必须与事件中声名的一致

        //ctrl.SomeEvent += new EventHandler(this.OnSomeEvent);

        ctrl.SomeEvent += new Control.SomeHandler(this.ResponseSomeEvent);

        ctrl.RaiseSomeEvent();

    }

　

    public static void Main()

    {

        Container pane = new Container();

　

        //这个readline是暂停程序用的，否则画面会一闪而过什么也看不见

        Console.ReadLine();

    }

　

    //这是事件的接受者对事件的响应

    private void ResponseSomeEvent(object sender, EventArgs e)

    {

        Console.WriteLine("Some event occur!");

    }

}

程序运行的结果如下：

please input 'a':a

hello

Some event occur!

　

事件的应用

例如有下面的需求需要实现：程序主画面中弹出一个子窗口。此时主画面仍然可以接收用户的操作（子窗口是非模态的）。子窗口上进行某些操作，根据操作的结果要在主画面上显示不同的数据。我发现一些程序员这样实现这个功能：

主画面弹出子窗 口后，将自己的指针交给子画面，然后在子画面中使用这个指针，调用主画面提供的方法，改变主画面上的数据显示。这样虽然可以达到目的，但是各个模块之间产 生了很强的耦合。一般说来模块之间的调用应该是单方向的：模块A调用了模块B，模块B就不应该反向调用A，否则就破坏了程序的层次，加强了耦合程度，也使 得功能的改变和追加变得很困难。

这时正确的做法应该是在子窗口的操作过程中发出各种事件，而由主窗口捕捉这些事件进行处理，各个模块专心的做自己的事情，不需要过问其他模块的事情。