Me.ZhuoYue.Me

1. Alexander Chemeris’ ISO C9x compliant inttypes.h for Microsoft Visual Studio (http://code.google.com/p/msinttypes/)
2. Android dirname_r (https://android.googlesource.com/platform/bionic/+/android-4.0.3_r1.1/libc/bionic/dirname_r.c)
3. Anti-Grain Geometry version 2.4 (http://antigrain.com/license/index.html#toc0002)
4. ANTLR (http://www.antlr.org/)
Includes:ANTLR version 3.3.1.7705 (http://www.antlr.org/)
Includes:ANTLR version 3.4.1.9004 (http://www.antlr.org/)
5. ASP.NET (http://www.asp.net/)
Includes:SignalR version 1.1.2 (https://github.com/SignalR/SignalR)
Includes:SignalR version 1.1.3 (https://github.com/SignalR/SignalR)
Includes:SignalR version 2.0 (https://github.com/SignalR/SignalR)
Includes:Web Stack Components (MVC) version 4 (http://aspnetwebstack.codeplex.com/)
Includes:Web Stack Components (MVC) version 5 (http://aspnetwebstack.codeplex.com/)
Includes:Web Stack Components (WebAPI) version 2 (http://aspnetwebstack.codeplex.com/)
Includes:Web Stack Components (WebAPI) version 4 (http://aspnetwebstack.codeplex.com/)
Includes:Web Stack Components (WebAPI) version 5 (http://aspnetwebstack.codeplex.com/)
Includes:Web Stack Components (Web Pages) version 2 (http://aspnetwebstack.codeplex.com/)
Includes:Web Stack Components (Web Pages) version 3 (http://aspnetwebstack.codeplex.com/)
6. Attractive Chaos’ h.h (https://github.com/attractivechaos/klib/blob/master/khash.h)
7. BERKELEY YACC (http://dickey.his.com/byacc/byacc.html)
8. Bootstrap (http://nuget.org/packages/Twitter.Bootstrap)
Includes:Bootstrap version 2.3.1 (http://nuget.org/packages/Twitter.Bootstrap)
Includes:Bootstrap version 3.0 (http://nuget.org/packages/Twitter.Bootstrap)
9. BSD fnmatch (http://opensource.apple.com/source/gcc/gcc-5666.3/libiberty/bsearch.c)
10. BSD glibc bsearch (http://www.gnu.org/software/libc/download.html)
11. ch-siphash (https://github.com/tanglebones/ch-siphash)
12. Chris Swenson’s sorting routine implementations (https://github.com/swenson/sort)
13. clar (https://github.com/vmg/clar)
14. CommonServiceLocator 1.0 (http://commonservicelocator.codeplex.com/)
15. D3.js version 3.0.6 (http://d3js.org/)
16. DataJS (http://datajs.codeplex.com/)
Includes:DataJS version 1.1.0 (http://datajs.codeplex.com/)
Includes:DataJS version 1.1.1 (http://datajs.codeplex.com/)
17. DotNetOpenAuth (http://www.dotnetopenauth.net/)
Includes:DotNetOpenAuth version 4 (http://www.dotnetopenauth.net/)
Includes:DotNetOpenAuth version 4.1.3 (http://www.dotnetopenauth.net/)
Includes:DotNetOpenAuth version 4.1.4 (http://www.dotnetopenauth.net/)
Includes:DotNetOpenAuth version 4.1.4.12333 (http://www.dotnetopenauth.net/)
18. EnterpriseLibrary (http://entlib.codeplex.com/)
Includes:EnterpriseLibrary.Common version 5.0.505.0 (http://entlib.codeplex.com/)
Includes:EnterpriseLibrary.Logging version 5.0.505.1 (http://entlib.codeplex.com/)
19. Entity Framework (http://entityframework.codeplex.com/)
Includes:Entity Framework version 5 (http://entityframework.codeplex.com/)
Includes:Entity Framework version 6 (http://entityframework.codeplex.com/)
20. Esprima.js (http://esprima.org/)
21. FaceBook C# SDK (http://facebooksdk.net/)
Includes:FaceBook C# SDK version 6.1.4 (http://facebooksdk.net/)
Includes:FaceBook C# SDK version 6.4.2 (http://facebooksdk.net/)
Includes:Simple-Json (https://github.com/facebook-csharp-sdk/simple-json)
Includes:Json.cs (http://techblog.procurios.nl/k/618/news/view/14605/14863/How-do-I-write-my-own-parser-for-JSON.html)
22. FDLIBM version 5.3 (http://www.netlib.org/fdlibm/)
23. Freetype 2 Font Engine (http://www.freetype.org/)
24. Git Logo by Jason Long (http://git-scm.com/downloads/logos and http://twitter.com/jasonlong)
25. HighCharts.js (http://www.highcharts.com/)
Includes:HighCharts.js version 2.2.4 (http://www.highcharts.com/)
Includes:HighCharts.js version 3.0.0 (http://www.highcharts.com/)
Includes:php.js (http://phpjs.org)
26. Independent JPEG Group’s JPEG Library (http://www.ijg.org/)
27. JasPer Project version 2.0 (http://www.ece.uvic.ca/~frodo/jasper)
28. Javascript Cookie Library with jQuery bindings and JSON support version 2.2.0 (http://code.google.com/p/cookies/)
29. JGit test (https://github.com/spearce/JGit/commit/e4bf8f6957bbb29362575d641d1e77a02d906739)
30. JGit xhistogram (http://www.eclipse.org/org/documents/edl-v10.php)
31. jqGrid version 4.4.4 (http://www.trirand.net.)
32. jQuery (http://jquery.com/)
Includes:jQuery version 1.7.1 (http://jquery.com/)
Includes:jQuery version 1.8.2 (http://jquery.com/)
Includes:jQuery version 1.9.1 (http://jquery.com/)
Includes:jQuery version 1.10.2 (http://jquery.com/)
Includes:jQuery Core version 1.6.2 (http://jquery.com/)
Includes:jQuery Core version 1.6.4 (http://jquery.com/)
Includes:jQuery Core version 1.7.2 (http://jquery.com/)
Includes:jQuery Core version 1.7.3 (http://jquery.com/)
Includes:jQuery Core version 1.8.2 (http://jquery.com/)
Includes:Sizzle.js (http://sizzlejs.com)
33. jQuery.LazyLoad version 1.8.5 (http://www.appelsiini.net/projects/lazyload)
34. jQuery Mobile (http://jquerymobile.com/)
Includes:jQuery Mobile version 1.1.0 (http://jquerymobile.com/)
Includes:jQuery Mobile version 1.2.0 (http://jquerymobile.com/)
Includes:JQuery Mobile version 1.3.0 (http://jquerymobile.com/)
Includes:JQuery Mobile version 1.3.1 (http://jquerymobile.com/)
35. jQuery postMessage version 0.5 (http://benalman.com/projects/jquery-postmessage-plugin/)
36. jQuery UI (http://jqueryui.com/)
Includes:jQuery UI version 1.8.11 (http://jqueryui.com/)
Includes:jQuery UI version 1.8.20 (http://jqueryui.com/)
Includes:jQuery UI version 1.8.24 (http://jqueryui.com/)
Includes:jQuery UI version 1.9.2 (http://jqueryui.com/)
Includes:jQueryUI version 1.10.0 (http://jqueryui.com/)
Includes:jQueryUI version 1.10.3 (http://jqueryui.com/)
37. jQuery Validation (http://bassistance.de/jquery-plugins/jquery-plugin-validation/)
Includes:jQuery Validation version 1.8.1 (http://bassistance.de/jquery-plugins/jquery-plugin-validation/)
Includes:jQuery Validation version 1.9 (http://bassistance.de/jquery-plugins/jquery-plugin-validation/)
Includes:jQuery Validation version 1.9.1 (http://bassistance.de/jquery-plugins/jquery-plugin-validation/)
Includes:jQuery Validation version 1.10 (http://bassistance.de/jquery-plugins/jquery-plugin-validation/)
Includes:jQuery Validation version 1.11.1 (http://bassistance.de/jquery-plugins/jquery-plugin-validation/)
38. jquery-base64 version 1.0 (https://github.com/yckart/jquery.base64.js)
39. Json2.js (https://github.com/douglascrockford/JSON-js)
Includes:Json2.js version 1.0 (https://github.com/douglascrockford/JSON-js)
Includes:Json2.js version 1.0.2 (https://github.com/douglascrockford/JSON-js)
40. Json.NET version 4.5.6 (http://json.codeplex.com/)
Includes:Json.NET version 4.5.11 (http://json.codeplex.com/)
Includes:Json.NET version 5.0 (http://json.codeplex.com/)
Includes:Json.NET version 5.0.6 (http://json.codeplex.com/)
41. Katana version 2.0 (http://katanaproject.codeplex.com/)
42. Knockout.js (http://knockoutjs.com/)
Includes:Knockout.js version 2.1.0 (http://knockoutjs.com/)
Includes:Knockout.js version 2.2.0 (http://knockoutjs.com/)
Includes:Knockout.js version 2.2.1 (http://knockoutjs.com/)
Includes:Knockout.js version 2.3.0 (http://knockoutjs.com/)
43. Knockout Validation version 1.0.1 (https://github.com/ericmbarnard/Knockout-Validation)
44. LibGit2Sharp (https://github.com/libgit2/libgit2sharp/)
45. LIBXML2 (http://www.xmlsoft.org/)
46. Little CMS Color Management (http://www.littlecms.com/)
47. Log4Net version 2.0.0 (http://logging.apache.org/log4net/)
48. Modernizr (http://www.modernizr.com)
Includes:Modernizr version 2.5.3 (http://www.modernizr.com)
Includes:Modernizr version 2.6.2 (http://www.modernizr.com)
49. Nlog version 2.0.0.2000 (http://nlog-project.org/)
50. NuGet (http://nuget.codeplex.com/)
Includes:NuGet version 2.0 (http://nuget.codeplex.com/)
Includes:NuGet version 2.7 (http://nuget.codeplex.com/)
Includes:NuGet.Core version 1.6.2 (http://nuget.codeplex.com/)
51. OWIN (http://owin.org/)
Includes:OWIN version 1.0 (http://owin.org/)
Includes:OWIN version 2.0 (http://owin.org/)
52. Respond.js version 1.2 (https://github.com/scottjehl/Respond)
53. StructureMap (https://github.com/structuremap/structuremap)
Includes:StructureMap version 2.6.4.1 (https://github.com/structuremap/structuremap)
Includes:StructuremapMap.MVC version 2.6.4.1 (https://github.com/structuremap/structuremap)
54. WebActivator version 1.5.3 (http://nuget.org/packages/WebActivator)
55. WebGrease (http://webgrease.codeplex.com/)
Includes:WebGrease version 1.0 (http://webgrease.codeplex.com/)
Includes:WebGrease version 1.3 (http://webgrease.codeplex.com/)
Includes:WebGrease version 1.5.2 (http://webgrease.codeplex.com/)
56. Volkan Yazc libpqueue (https://github.com/vy/libpqueue)
57. Zlib Decompressor (http://zlib.net/zlib_license.html)

事件和委托

事件是对象发送的消息，以发信号通知操作的发生。操作可能是由用户交互（例如鼠标单击）引起的，也可能是由某些其他的程序逻辑触发的。引发事件的对象称为事件发送方。捕获事件并对其作出响应的对象叫做事件接收方。

在事件通信中，事件发送方类不知道哪个对象或方法将接收到（处理）它引发的事件。所需要的是在源和接收方之间存在一个媒介（或类似指针的机制）。.NET Framework 定义了一个特殊的类型 (Delegate)，该类型提供函数指针的功能。

委托是可保存对方法的引用的类。与其他的类不同，委托类具有一个签名，并且它只能对与其签名匹配的方法进行引用。这样，委托就等效于一个类型安全函数指针或一个回调。虽然委托具有许多其他的用途，但这里只讨论委托的事件处理功能。一个委托声明足以定义一个委托类。声明提供委托的签名，公共语言运行库提供实现。下面的示例显示了事件委托声明。

public class WakeMeUp 
{
    // AlarmRang has the same signature as AlarmEventHandler.
    public void AlarmRang(object sender, AlarmEventArgs e)
    {...};
    ...
}

只有当事件生成事件数据时才需要自定义事件委托。许多事件，包括一些用户界面事件（例如鼠标单击）在内，都不生成事件数据。在这种情况下，类库中为无数据事件提供的事件委托 System.EventHandler 便足够了。其声明如下。

delegate void EventHandler(object sender, EventArgs e);

事件委托是多路广播的，这意味着它们可以对多个事件处理方法进行引用。有关详细信息，请参见 Delegate。委托考虑了事件处理中的灵活性和精确控制。通过维护事件的已注册事件处理程序列表，委托为引发事件的类担当事件发送器的角色。

如何：将事件处理程序方法连接到事件

为事件添加事件处理程序方法

void EventHandler(object sender, EventNameEventArgs e) {}

如果事件没有任何关联数据，则引发事件的类使用 System.EventHandler 作为委托，并将 System.EventArgs 作为事件数据。具有关联数据的事件使用从事件数据类型的 EventArgs 派生的类以及相应的事件委托类型。例如，如果您要处理 Windows 窗体应用程序中的 MouseUp 事件，则事件数据类是 MouseEventArgs，而事件委托是 MouseEventHandler。请注意，某些鼠标事件使用事件数据的公共类和公共事件委托，因此命名方案与上面所述的约定不完全匹配。对于鼠标事件，事件处理程序必须具有以下签名：

void Mouse_Moved(object sender, MouseEventArgs e){}

发送方和事件变量参数向事件处理程序提供有关鼠标事件的详细信息。发送方对象指示引发事件的对象。MouseEventArgs 参数提供有关引发事件的鼠标移动的详细信息。许多事件源提供有关事件的其他数据，且许多事件处理程序在处理事件时使用事件特定的数据。有关阐释如何引发和处理具有事件特定数据的事件的示例，请参见如何：引发和使用事件。

静态事件和动态事件

.NET Framework 允许订户为获得事件通知而进行静态或动态注册。静态事件处理程序在其所处理的事件所属类的整个生存期内有效。这是处理事件的最常用方法。动态事件处理程序在程序执行期间显式激活和停用，通常是为了响应某些条件程序逻辑。例如，如果只在特定条件下才需要事件通知，或者如果应用程序提供了多个事件处理程序，并由运行时条件来确定要使用哪个事件处理程序，则可以使用动态事件处理程序。

EventInfo.AddEventHandler 方法添加动态事件处理程序，而 EventInfo.RemoveEventHandler 方法停用这些事件处理程序。各种语言还提供各自的用于动态处理事件的功能。下面的示例定义一个TemperatureMonitor 类，每当温度达到预定义的阈值时该类将引发 TemperatureTheshold 事件。随后，在程序执行期间将激活和停用订阅此事件的事件处理程序。

using System;

public class TemperatureEventArgs : EventArgs
{
   private decimal oldTemp;
   private decimal newTemp;

   public decimal OldTemperature
   {
      get { return this.oldTemp; }
   }

   public decimal NewTemperature
   {
      get { return this.newTemp; }
   }

   public TemperatureEventArgs(decimal oldTemp, decimal newTemp)
   {
      this.oldTemp = oldTemp;
      this.newTemp = newTemp;   
   }
}

public delegate void TemperatureEventHandler(object sender, TemperatureEventArgs ev);

public class TemperatureMonitor
{
   private decimal currentTemperature;
   private decimal threshholdTemperature;

   public event TemperatureEventHandler TemperatureThreshold; 

   public TemperatureMonitor(decimal threshhold)
   {
      this.threshholdTemperature = threshhold;
   }

   public void SetTemperature(decimal newTemperature)
   {
      if ( (this.currentTemperature > this.threshholdTemperature && 
           newTemperature <= this.threshholdTemperature) ||
           (this.currentTemperature < this.threshholdTemperature &&
           newTemperature >= this.threshholdTemperature) )
         OnRaiseTemperatureEvent(newTemperature);
      this.currentTemperature = newTemperature;
   }

   public decimal GetTemperature()
   {
      return this.currentTemperature;
   }

   protected virtual void OnRaiseTemperatureEvent(decimal newTemperature)
   {
      // Raise the event if it has subscribers.
      if (TemperatureThreshold != null)
         TemperatureThreshold(this, new TemperatureEventArgs(this.currentTemperature, 
                               newTemperature));
   }
}

public class Example
{
   public static void Main()
   {
      Example ex = new Example();
      ex.MonitorTemperatures();
   }

   public void MonitorTemperatures()
   {
      TemperatureMonitor tempMon = new TemperatureMonitor(32);
      tempMon.SetTemperature(33);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", 
                        tempMon.GetTemperature());
      tempMon.SetTemperature(32);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.",
                        tempMon.GetTemperature());

      // Add event handler dynamically using C# syntax.
      tempMon.TemperatureThreshold += this.TempMonitor;

      tempMon.SetTemperature(33);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", 
                        tempMon.GetTemperature());
      tempMon.SetTemperature(34);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", 
                        tempMon.GetTemperature());
      tempMon.SetTemperature(32);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.",
                        tempMon.GetTemperature());

      // Remove event handler dynamically using C# syntax.
      tempMon.TemperatureThreshold -= this.TempMonitor;

      tempMon.SetTemperature(31);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", 
                        tempMon.GetTemperature());
      tempMon.SetTemperature(35);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", 
                        tempMon.GetTemperature());
   }

   private void TempMonitor(object sender, TemperatureEventArgs e)
   {
      Console.WriteLine("   ***Warning: Temperature is changing from {0} to {1}.", 
                        e.OldTemperature, e.NewTemperature);
   } 
}
// The example displays the following output:
//       Current temperature is 33 degrees Fahrenheit.
//       Current temperature is 32 degrees Fahrenheit.
//       Current temperature is 33 degrees Fahrenheit.
//       Current temperature is 34 degrees Fahrenheit.
//          ***Warning: Temperature is changing from 34 to 32.
//       Current temperature is 32 degrees Fahrenheit.
//       Current temperature is 31 degrees Fahrenheit.
//       Current temperature is 35 degrees Fahrenheit.

引发事件

private EventNameHandler eh = null;

编译器还会创建两个公共方法，即 add_EventName 和 remove_EventName。这些方法是事件挂钩，它们允许委托与事件委托 eh 合并或从该事件委托中移除。这些详细信息对程序员是隐藏的。

定义事件实现后，您必须确定引发事件的时间。通过在定义事件的类或派生类中调用受保护的 OnEventName 方法来引发事件。OnEventName 方法通过调用委托，传入所有事件特定的数据来引发事件。事件的委托方法可以执行事件操作或处理事件特定的数据。

受保护的 OnEventName 方法也允许派生类重写事件，而不必向其附加委托。派生类必须始终调用基类的 OnEventName 方法以确保注册的委托接收到事件。

如果希望处理另一个类中引发的事件，请向事件中添加委托方法。如果您不熟悉 .NET Framework 中事件的委托模型，请参见事件和委托。

如何：在类中实现事件

实现不具有事件特定的数据的事件

1. 在类中定义公共事件成员。将事件成员的类型设置为 System.EventHandler 委托。

   public class Countdown 
   {
       ...
       public event EventHandler CountdownCompleted;   
   }

2. 在引发事件的类中提供一个受保护的方法。对 OnEventName 方法进行命名。在该方法中引发该事件。

   public class Countdown 
   {
       ...
       public event EventHandler CountdownCompleted;   
       protected virtual void OnCountdownCompleted(EventArgs e)    {        if (CountdownCompleted != null)            CountdownCompleted(this, e);    }
   }

3. 在类中确定引发该事件的时间。调用 OnEventName 以引发该事件。

   public class Countdown 
   {
       ...
       public void Decrement
       {
           internalCounter = internalCounter - 1;
           if (internalCounter == 0)
               OnCountdownCompleted(new EventArgs());
       }
   }

实现具有事件特定的数据的事件

// EventSample.cs.
//
namespace EventSample
{  
   using System;
   using System.ComponentModel;

   // Class that contains the data for 
   // the alarm event. Derives from System.EventArgs.
   //
   public class AlarmEventArgs : EventArgs 
   {  
      private readonly bool snoozePressed ;
      private readonly int nrings;

      //Constructor.
      //
      public AlarmEventArgs(bool snoozePressed, int nrings) 
      {
         this.snoozePressed = snoozePressed;
         this.nrings = nrings;
      }

      // The NumRings property returns the number of rings
      // that the alarm clock has sounded when the alarm event 
      // is generated.
      //
      public int NumRings
      {     
         get { return nrings;}      
      }

      // The SnoozePressed property indicates whether the snooze
      // button is pressed on the alarm when the alarm event is generated.
      //
      public bool SnoozePressed 
      {
         get {return snoozePressed;}
      }

      // The AlarmText property that contains the wake-up message.
      //
      public string AlarmText 
      {
         get 
         {
            if (snoozePressed)
            {
               return ("Wake Up!!! Snooze time is over.");
            }
            else 
            {
               return ("Wake Up!");
            }
         }
      }  
   }

   // Delegate declaration.
   //
   public delegate void AlarmEventHandler(object sender, AlarmEventArgs e);

   // The Alarm class that raises the alarm event.
   //
   public class AlarmClock 
   {  
      private bool snoozePressed = false;
      private int nrings = 0;
      private bool stop = false;

      // The Stop property indicates whether the 
      // alarm should be turned off.
      //
      public bool Stop 
      {
         get {return stop;}
         set {stop = value;}
      }

      // The SnoozePressed property indicates whether the snooze
      // button is pressed on the alarm when the alarm event is generated.
      //
      public bool SnoozePressed
      {
         get {return snoozePressed;}
         set {snoozePressed = value;}
      }
      // The event member that is of type AlarmEventHandler.
      //
      public event AlarmEventHandler Alarm;

      // The protected OnAlarm method raises the event by invoking 
      // the delegates. The sender is always this, the current instance 
      // of the class.
      //
      protected virtual void OnAlarm(AlarmEventArgs e)
      {
        AlarmEventHandler handler = Alarm; 
        if (handler != null) 
        { 
           // Invokes the delegates. 
           handler(this, e); 
        }
      }

      // This alarm clock does not have
      // a user interface. 
      // To simulate the alarm mechanism it has a loop
      // that raises the alarm event at every iteration
      // with a time delay of 300 milliseconds,
      // if snooze is not pressed. If snooze is pressed,
      // the time delay is 1000 milliseconds.
      //
      public void Start()
      {
         for (;;)    
         {
            nrings++;      
            if (stop)
            {
               break;
            }

            else if (snoozePressed)
            {
               System.Threading.Thread.Sleep(1000);
               {
                  AlarmEventArgs e = new AlarmEventArgs(snoozePressed, 
                     nrings);
                  OnAlarm(e);
               }
            }
            else
            {
               System.Threading.Thread.Sleep(300);
               AlarmEventArgs e = new AlarmEventArgs(snoozePressed, 
                  nrings);
               OnAlarm(e);
            }           
         }
      }
   }

   // The WakeMeUp class has a method AlarmRang that handles the
   // alarm event.
   //
   public class WakeMeUp
   {

      public void AlarmRang(object sender, AlarmEventArgs e)
      {

         Console.WriteLine(e.AlarmText +"\n");

         if (!(e.SnoozePressed))
         {
            if (e.NumRings % 10 == 0)
            {
               Console.WriteLine(" Let alarm ring? Enter Y");
               Console.WriteLine(" Press Snooze? Enter N"); 
               Console.WriteLine(" Stop Alarm? Enter Q");
               String input = Console.ReadLine();

               if (input.Equals("Y") ||input.Equals("y")) return;

               else if (input.Equals("N") || input.Equals("n"))
               {
                  ((AlarmClock)sender).SnoozePressed = true;
                  return;
               }
               else
               {
                  ((AlarmClock)sender).Stop = true;
                  return;
               }
            }
         }
         else
         {
            Console.WriteLine(" Let alarm ring? Enter Y"); 
            Console.WriteLine(" Stop Alarm? Enter Q");
            String input = Console.ReadLine();
            if (input.Equals("Y") || input.Equals("y")) return;
            else 
            {
               ((AlarmClock)sender).Stop = true;
               return;
            }
         }
      }
   }

   // The driver class that hooks up the event handling method of
   // WakeMeUp to the alarm event of an Alarm object using a delegate.
   // In a forms-based application, the driver class is the
   // form.
   //
   public class AlarmDriver
   {  
      public static void Main (string[] args)
      {  
         // Instantiates the event receiver.
         WakeMeUp w= new WakeMeUp();

         // Instantiates the event source.
         AlarmClock clock = new AlarmClock();

         // Wires the AlarmRang method to the Alarm event.
         clock.Alarm += new AlarmEventHandler(w.AlarmRang);

         clock.Start();
      }
   }   
}

引发多个事件

如果您的类引发多个事件，并且您按引发事件中的说明对这些事件进行编程，编译器将为每个事件委托实例生成一个字段。如果事件的数目很大，则一个委托一个字段的存储成本可能无法接受。对于这些情况，.NET Framework 提供一个称为事件属性的构造（Visual Basic 2005 中的自定义事件），此构造可以和（您选择的）另一数据结构一起用于存储事件委托。

事件属性由带事件访问器的事件声明组成。事件访问器是您定义的方法，用以允许事件委托实例添加到存储数据结构或从存储数据结构移除。请注意，事件属性要比事件字段慢，这是因为必须先检索每个事件委托，然后才能调用它。这是内存和速度之间的折中方案。如果您的类定义了许多不常引发的事件，那么您可能要实现事件属性。Windows 窗体控件和 ASP.NET 服务器控件使用事件属性而不是事件字段。

如何：使用事件属性处理多个事件

使用事件属性处理多个事件

// The class SampleControl defines two event properties, MouseUp and MouseDown.
class SampleControl: Component {
   // :
   // Define other control methods and properties.
   // :

   // Define the delegate collection.
   protected EventHandlerList listEventDelegates = new EventHandlerList();

   // Define a unique key for each event.
   static readonly object mouseDownEventKey = new object();
   static readonly object mouseUpEventKey = new object();

   // Define the MouseDown event property.
   public event MouseEventHandler MouseDown {  
      // Add the input delegate to the collection.
      add { listEventDelegates.AddHandler(mouseDownEventKey, value); }
      // Remove the input delegate from the collection.
      remove { listEventDelegates.RemoveHandler(mouseDownEventKey, value); }
   }

   // Define the MouseUp event property.
   public event MouseEventHandler MouseUp {
      // Add the input delegate to the collection.
      add { listEventDelegates.AddHandler(mouseUpEventKey, value); }
      // Remove the input delegate from the collection.
      remove { listEventDelegates.RemoveHandler(mouseUpEventKey, value); }
   }
}

14.1、委托

当要把方法作为实参传送给其他方法的形参时，形参需要使用委托。委托是一个类型，是一个函数指针类型，这个类型将该委托的实例化对象所能指向的函数的细节封装起来了，即规定了所能指向的函数的签名，也就是限制了所能指向的函数的参数和返回值。当实例化委托的时候，委托对象会指向某一个匹配的函数，实质就是将函数的地址赋值给了该委托的对象，然后就可以通过该委托对象来调用所指向的函数了。利用委托，程序员可以在委托对象中封装一个方法的引用，然后委托对象作为形参将被传给调用了被引用方法的代码，而不需要知道在编译时刻具体是哪个方法被调用。

一般的调用函数，我们都不会去使用委托，因为如果只是单纯的调用函数，使用委托更麻烦一些；但是如果想将函数作为实参，传递给某个函数的形参，那么形参就一定要使用委托来接收实参，一般使用方法是：在函数外面定义委托对象，并指向某个函数，再将这个对象赋值给函数的形参，形参也是该委托类型的对象变量，函数里面再通过形参来调用所指向的函数。

14.1.1、定义委托

语法如下：

delegate result-type Identifier ([parameters]);

说明:

result-type:返回值的类型，和方法的返回值类型一致

Identifier:委托的名称

parameters:参数，要引用的方法带的参数

小结：

当定义了委托之后，该委托的对象一定可以而且也只能指向该委托所限制的函数。即参数的个数、类型、顺序都要匹配，返回值的类型也要匹配。

因为定义委托相当于是定义一个新类，所以可以在定义类的任何地方定义委托，既可以在一个类的内部定义，那么此时就要通过该类的类名来调用这个委托（委托必须是public、internal），也可以在任何类的外部定义，那么此时在命名空间中与类的级别是一样的。根据定义的可见性，可以在委托定义上添加一般的访问修饰符：当委托定义在类的外面，那么可以加上public、internal修饰符；如果委托定义到类的内部，那么可以加上public、 private、 protected、internal。一般委托都是定义在类的外面的。

14.1.2、实例化委托

Identifier objectName = new Identifier( functionName )

实例化委托的实质就是将某个函数的地址赋值给委托对象。在这里：

Identifier ：这个是委托名字。

objectName ：委托的实例化对象。

functionName：是该委托对象所指向的函数的名字。对于这个函数名要特别注意：定义这个委托对象肯定是在类中定义的，那么如果所指向的函数也在该类中，不管该函数是静态还是非静态的，那么就直接写函数名字就可以了；如果函数是在别的类里面定义的public、internal，但是如果是静态，那么就直接用类名.函数名，如果是非静态的，那么就类的对象名.函数名，这个函数名与该对象是有关系的，比如如果函数中出现了this，表示的就是对当前对象的调用。

14.1.3、委托推断

C# 2.0用委托推断扩展了委托的语法。当我们需要定义委托对象并实例化委托的时候，就可以只传送函数的名称，即函数的地址：

Identifier objectName = functionName;

这里面的functionName与14.1.2节中实例化委托的functionName是一样的，没什么区别，满足上面的规则。

C#编译器创建的代码是一样的。编译器会用objectName检测需要的委托类型，因此会创建Identifier委托类型的一个实例，用functionName即方法的地址传送给Identifier的构造函数。

注意：

不能在functionName后面加括号和实参，然后把它传送给委托变量。调用方法一般会返回一个不能赋予委托变量的普通对象，除非这个方法返回的是一个匹配的委托对象。总之：只能把相匹配的方法的地址赋予委托变量。

委托推断可以在需要委托实例化的任何地方使用，就跟定义普通的委托对象是一样的。委托推断也可以用于事件，因为事件基于委托（参见本章后面的内容）。

14.1.4、匿名方法

到目前为止，要想使委托工作，方法必须已经存在。但实例化委托还有另外一种方式：即通过匿名方法。

用匿名方法定义委托的语法与前面的定义并没有区别。但在实例化委托时，就有区别了。下面是一个非常简单的控制台应用程序，说明了如何使用匿名方法：

using System;

namespace Wrox.ProCSharp.Delegates
{

    class Program
    {

        delegate string DelegateTest(string val);

        static void Main()
        {

            string mid = ", middle part,";

            //在方法中定义了方法

            DelegateTest anonDel = delegate(string param)
            {

                param += mid;

                param += " and this was added to the string.";

                return param;

            };

            Console.WriteLine(anonDel("Start of string"));

        }

    }

}

using System;

namespace Wrox.ProCSharp.Delegates
{

    class Program
    {

        delegate string DelegateTest(string val);

        static void Main()
        {

            string mid = ", middle part,";

            //Lamada表示法

            DelegateTest anonDel = ( param)=>
            {

                param += mid;

                param += " and this was added to the string.";

                return param;

            };

            Console.WriteLine(anonDel("Start of string"));

        }

    }

}

委托DelegateTest在类Program中定义，它带一个字符串参数。有区别的是Main方法。在定义anonDel时，不是传送已知的方法名，而是使用一个简单的代码块：它前面是关键字delegate，后面是一个参数：

            DelegateTest anonDel = delegate(string param)
            {

                param += mid;

                param += " and this was added to the string.";

                return param;

            };

匿名方法的优点是减少了要编写的代码。方法仅在有委托使用时才定义。在为事件定义委托时，这是非常显然的。(本章后面探讨事件。)这有助于降低代码的复杂性，尤其是定义了好几个事件时，代码会显得比较简单。使用匿名方法时，代码执行得不太快。编译器仍定义了一个方法，该方法只有一个自动指定的名称，我们不需要知道这个名称。

在使用匿名方法时，必须遵循两个规则：

1、在匿名方法中不能使用跳转语句跳到该匿名方法的外部，反之亦然：匿名方法外部的跳转语句不能跳到该匿名方法的内部。

2、在匿名方法内部不能访问不安全的代码。另外，也不能访问在匿名方法外部使用的ref和out参数。但可以使用在匿名方法外部定义的其他变量。方法内部的变量、方法的参数可以任意的使用。

如果需要用匿名方法多次编写同一个功能，就不要使用匿名方法。而编写一个指定的方法比较好，因为该方法只需编写一次，以后可通过名称引用它。

14.1.5、多播委托

前面使用的每个委托都只包含一个方法调用，调用委托的次数与调用方法的次数相同，如果要调用多个方法，就需要多次给委托赋值，然后调用这个委托。

委托也可以包含多个方法，这时候要向委托对象中添加多个方法，这种委托称为多播委托，多播委托有一个方法列表，如果调用多播委托，就可以连续调用多个方法，即先执行某一个方法，等该方法执行完成之后再执行另外一个方法，这些方法的参数都是一样的，这些方法的执行是在一个线程中执行的，而不是每个方法都是一个线程，最终将执行完成所有的方法。

如果使用多播委托，就应注意对同一个委托调用方法链的顺序并未正式定义，调用顺序是不确定的，不一定是按照添加方法的顺序来调用方法，因此应避免编写依赖于以特定顺序调用方法的代码。如果要想确定顺序，那么只能是单播委托，调用委托的次数与调用方法的次数相同。

多播委托的各个方法签名最好是返回void；否则，就只能得到委托最后调用的一个方法的结果，而最后调用哪个方法是无法确定的。

多播委托的每一个方法都要与委托所限定的方法的返回值、参数匹配，否则就会有错误。

我自己写代码测试，测试的结果目前都是调用顺序和加入委托的顺序相同的，但是不排除有不同的时候。

delegate result-type Identifier ([parameters]);

14.1.5.1、委托运算符 =

Identifier objectName = new Identifier( functionName);

或者

Identifier objectName = functionName;

这里的“=”号表示清空 objectName 的方法列表，然后将 functionName 加入到 objectName 的方法列表中。

14.1.5.2、委托运算符 +=

objectName += new Identifier( functionName1);

或者

objectName += functionName1;

这里的“+=”号表示在原有的方法列表不变的情况下，将 functionName1 加入到 objectName 的方法列表中。可以在方法列表中加上多个相同的方法，执行的时候也会执行完所有的函数，哪怕有相同的，就会多次执行同一个方法。

注意：objectName 必须是已经赋值了的，否则在定义的时候直接使用该符号：

Identifier objectName += new Identifier( functionName1);或者

Identifier objectName += functionName1;就会报错。

14.1.5.3、委托运算符 -=

objectName -= new Identifier(functionName1);

或者

objectName -= functionName1;

这里的“-=”号表示在 objectName 的方法列表中减去一个functionName1。可以在方法列表中多次减去相同的方法，减一次只会减一个方法，如果列表中无此方法，那么减就没有意义，对原有列表无影响，也不会报错。

注意：objectName 必须是已经赋值了的，否则在定义的时候直接使用该符号：

Identifier objectName -= new Identifier( functionName1);或者

Identifier objectName -= functionName1;就会报错。

14.1.5.4、委托运算符 +、-

Identifier objectName = objectName + functionName1 - functionName1;

或者

Identifier objectName = new Identifier(functionName1) + functionName1 - functionName1;

对于这种+、-表达式，在第一个符号+或者-的前面必须是委托而不能是方法，后面的+、-左右都随便。这个不是绝对规律，还有待进一步的研究。

14.1.5.5、多播委托的异常处理

通过一个委托调用多个方法还有一个大问题。多播委托包含一个逐个调用的委托集合。如果通过委托调用的一个方法抛出了异常，整个迭代就会停止。下面是MulticastIteration示例。其中定义了一个简单的委托DemoDelegate，它没有参数，返回void。这个委托调用方法One()和Two()，这两个方法满足委托的参数和返回类型要求。注意方法One()抛出了一个异常：

using System;

namespace Wrox.ProCSharp.Delegates
{

    public delegate void DemoDelegate();

    internal class Program
    {
        private static void One()
        {

            Console.WriteLine("One");

            throw new Exception("Error in one");

        }

        private static void Two()
        {

            Console.WriteLine("Two");

        }

        static void Main()
        {

            DemoDelegate d1 = One;

            d1 += Two;

            try
            {

                d1();

            }

            catch (Exception)
            {

                Console.WriteLine("Exception caught");

            }
            Console.ReadKey();
        }

    }

}

在Main()方法中，创建了委托d1，它引用方法One()，接着把Two()方法的地址添加到同一个委托中。调用d1委托，就可以调用这两个方法。异常在try/catch块中捕获。

委托只调用了第一个方法。第一个方法抛出了异常，所以委托的迭代会停止，不再调用Two()方法。当调用方法的顺序没有指定时，结果会有所不同。

One

Exception Caught

注意：

多播委托包含一个逐个调用的委托集合。如果通过委托调用的一个方法抛出了异常，整个迭代就会停止。即如果任一方法引发了异常，而在该方法内未捕获该异常，则该异常将传递给委托的调用方，并且不再对调用列表中后面的方法进行调用。

在这种情况下，为了避免这个问题，应手动迭代方法列表。Delegate类定义了方法GetInvocationList()，它返回一个Delegate对象数组。现在可以使用这个委托调用与委托直接相关的方法，捕获异常，并继续下一次迭代。

using System;

namespace Wrox.ProCSharp.Delegates
{

    public delegate void DemoDelegate();

    internal class Program
    {
        private static void One()
        {

            Console.WriteLine("One");

            throw new Exception("Error in one");

        }

        private static void Two()
        {

            Console.WriteLine("Two");

        }

        static void Main()
        {

            DemoDelegate d1 = One;

            d1 += Two;

            Delegate[] delegates = d1.GetInvocationList();

            foreach (DemoDelegate d in delegates)
            {

                try
                {

                    d();

                }

                catch (Exception)
                {

                    Console.WriteLine("Exception caught");

                }

            }
            Console.ReadKey();
        }
    }

}

修改了代码后运行应用程序，会看到在捕获了异常后，将继续迭代下一个方法。

One

Exception caught

Two

注意：其实如果在多播委托的每个具体的方法中捕获异常，并在内部处理，而不抛出异常，一样能实现多播委托的所有方法执行完毕。这种方式与上面方式的区别在于这种方式的宜昌市在函数内部处理的，上面那种方式的异常是在函数外面捕获并处理的。

14.1.6、通过委托对象来调用它所指向的函数

1、委托实例的名称，后面的括号中应包含调用该委托中的方法时使用的参数。

2、调用委托对象的Invoke()方法，Invoke后面的括号中应包含调用该委托中的方法时使用的参数。

注意：实际上，给委托实例提供括号与调用委托类的Invoke()方法完全相同。因为Invoke()方法是委托的同步调用方法。

注意：不管是多播委托还是单播委托，在没有特殊处理的情况下，在一个线程的执行过程中去调用委托（委托对象所指向的函数），调用委托的执行是不会新起线程的，这个执行还是在原线程中的，这个对于事件也是一样的。当然，如果是在委托所指向的函数里面去启动一个新的线程那就是另外一回事了。

14.2、事件

14.2.1、自定义事件

14.2.1.1、声明一个委托：

Delegate result-type delegateName ([parameters]);

这个委托可以在类A内定义也可以在类A外定义。

14.2.1.2、声明一个基于某个委托的事件

Event delegateName eventName;

eventName不是一个类型，而是一个具体的对象，这个具体的对象只能在类A内定义而不能在类A外定义。

14.2.1.3、在类A中定义一个触发该事件的方法

ReturnType FunctionName([parameters])

{

……

If(eventName != null)

{

eventName([parameters]);

或者eventName.Invoke([parameters]);

}

……

}

触发事件之后，事件所指向的函数将会被执行。这种执行是通过事件名称来调用的，就像委托对象名一样的。

触发事件的方法只能在A类中定义，事件的实例化，以及实例化之后的实现体都只能在A类外定义。

14.2.1.4、初始化A类的事件

在类B中定义一个类A的对象，并且让类A对象的那个事件指向类B中定义的方法，这个方法要与事件关联的委托所限定的方法吻合。

14.2.1.5、触发A类的事件

在B类中去调用A类中的触发事件的方法：用A类的对象去调用A类的触发事件的方法。

14.2.1.6、程序实例

using System;

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

using System.Threading;

namespace DelegateStudy
{

    public delegate void DelegateClick(int a);

    public class Butt
    {

        public event DelegateClick Click;

        public void OnClick(int a)
        {

            if (Click != null)
                Click.Invoke(a);

            //Click(a);//这种方式也是可以的

            Console.WriteLine("Click()");

        }

    }

    class Program
    {
        public static void Btn_Click(int a)
        {

            for (long i = 0; i < a; i++)

                Console.WriteLine(i.ToString(CultureInfo.InvariantCulture));

        }
        static void Main(string[] args)
        {

            var b = new Butt();

            //在委托中，委托对象如果是null的，直接使用+=符号，会报错，但是在事件中，初始化的时候，只能用+=

            b.Click += Btn_Click; //事件是基于委托的，所以委托推断一样适用，下面的语句一样有效：b.Click += Fm_Click;

            //b.Click(10);错误:事件“DelegateStudy.Butt.Click”只能出现在 += 或 -= 的左边(从类型“DelegateStudy.Butt”中使用时除外)

            b.OnClick(10000);

            Console.ReadLine();

        }
    }
}

14.2.2、控件事件

基于Windows的应用程序也是基于消息的。这说明，应用程序是通过Windows来与用户通信的，Windows又是使用预定义的消息与应用程序通信的。这些消息是包含各种信息的结构，应用程序和Windows使用这些信息决定下一步的操作。

比如：当用户用鼠标去点击一个windows应用程序的按钮的时候，windows操作系统就会捕获到这个点击按钮的动作，这个时候它会根据捕获到的动作发送一个与之对应的预定义的消息给windows应用程序的这个按钮，windows应用程序的按钮消息处理程序会处理接收到的消息，这个程序处理过程就是根据收到的消息去触发相应的事件，事件被按钮触发后，会通知所有的该事件的订阅者来接收这个事件，从而执行相应的的函数。

在MFC等库或VB等开发环境推出之前，开发人员必须处理Windows发送给应用程序的消息。VB和今天的.NET把这些传送来的消息封装在事件中。如果需要响应某个消息，就应处理对应的事件。

14.2.2.1、控件事件委托EventHandler

在控件事件中，有很多的委托，在这里介绍一个最常用的委托EventHandler，.NET Framework中控件的事件很多都基于该委托，EventHandler委托已在.NET Framework中定义了。它位于System命名空间：

Public delegate void EventHandler(object sender,EventArgs e);

14.2.2.2、委托EventHandler参数和返回值

事件最终会指向一个或者多个函数，函数要与事件所基于的委托匹配。事件所指向的函数（事件处理程序）的命名规则：按照约定，事件处理程序应遵循“object_event”的命名约定。object就是引发事件的对象，而event就是被引发的事件。从可读性来看，应遵循这个命名约定。

首先，事件处理程序总是返回void，事件处理程序不能有返回值。其次是参数，只要是基于EventHandler委托的事件，事件处理程序的参数就应是object和EventArgs类型：

第一个参数接收引发事件的对象，比如当点击某个按钮的时候，这个按钮要触发单击事件最终执行这个函数，那么就会把当前按钮传给sender，当有多个按钮的单击事件都指向这个函数的时候，sender的值就取决于当前被单击的那个按钮，所以可以为几个按钮定义一个按钮单击处理程序，接着根据sender参数确定单击了哪个按钮:

if(((Button)sender).Name ==”buttonOne”)

第二个参数e是包含有关事件的其他有用信息的对象。

14.2.2.3、控件事件的其他委托

控件事件还有其他的委托，比如在窗体上有与鼠标事件关联的委托：

Public delegate void MouseEventHandler(object sender,MouseEventArgs e);

public event MouseEventHandler MouseDown;

this.MouseDown += new System.Windows.Forms.MouseEventHandler(this.Form1_MouseDown);

private void Form1_MouseDown(object sender, MouseEventArgs e){};

MouseDown事件使用MouseDownEventArgs，它包含鼠标的指针在窗体上的的X和Y坐标，以及与事件相关的其他信息。

控件事件中，一般第一个参数都是object sender，第二个参数可以是任意类型，不同的委托可以有不同的参数，只要它派生于EventArgs即可。

14.2.2.4、程序实例

using System;

using System.Collections.Generic;

using System.Text;

using System.Threading;

namespace SecondChangeEvent1
{

    // 该类用来存储关于事件的有效信息外，

    // 还用来存储额外的需要传给订阅者的Clock状态信息

    public class TimeInfoEventArgs : EventArgs
    {

        public TimeInfoEventArgs(int hour, int minute, int second)
        {

            this.hour = hour;

            this.minute = minute;

            this.second = second;

        }

        public readonly int hour;

        public readonly int minute;

        public readonly int second;

    }

    // 定义名为SecondChangeHandler的委托，封装不返回值的方法，

    // 该方法带参数，一个clock类型对象参数，一个TimeInfoEventArgs类型对象

    public delegate void SecondChangeHandler(

    object clock,

    TimeInfoEventArgs timeInformation

    );

    // 被其他类观察的钟（Clock）类，该类发布一个事件：SecondChange。观察该类的类订阅了该事件。

    public class Clock
    {

        // 代表小时，分钟，秒的私有变量

        int _hour;

        public int Hour
        {

            get { return _hour; }

            set { _hour = value; }

        }

        private int _minute;

        public int Minute
        {

            get { return _minute; }

            set { _minute = value; }

        }

        private int _second;

        public int Second
        {

            get { return _second; }

            set { _second = value; }

        }

        // 要发布的事件

        public event SecondChangeHandler SecondChange;

        // 触发事件的方法

        protected void OnSecondChange(

        object clock,

        TimeInfoEventArgs timeInformation

        )
        {

            // Check if there are any Subscribers

            if (SecondChange != null)
            {

                // Call the Event

                SecondChange(clock, timeInformation);

            }

        }

        // 让钟（Clock）跑起来，每隔一秒钟触发一次事件

        public void Run()
        {

            for (; ; )
            {

                // 让线程Sleep一秒钟

                Thread.Sleep(1000);

                // 获取当前时间

                System.DateTime dt = System.DateTime.Now;

                // 如果秒钟变化了通知订阅者

                if (dt.Second != _second)
                {

                    // 创造TimeInfoEventArgs类型对象，传给订阅者

                    TimeInfoEventArgs timeInformation =

                    new TimeInfoEventArgs(

                    dt.Hour, dt.Minute, dt.Second);

                    // 通知订阅者

                    OnSecondChange(this, timeInformation);

                }

                // 更新状态信息

                _second = dt.Second;

                _minute = dt.Minute;

                _hour = dt.Hour;

            }

        }

    }

    /* ======================= Event Subscribers =============================== */

    // 一个订阅者。DisplayClock订阅了clock类的事件。它的工作是显示当前时间。

    public class DisplayClock
    {

        // 传入一个clock对象，订阅其SecondChangeHandler事件

        public void Subscribe(Clock theClock)
        {

            theClock.SecondChange +=

            new SecondChangeHandler(TimeHasChanged);

        }

        // 实现了委托匹配类型的方法

        public void TimeHasChanged(

        object theClock, TimeInfoEventArgs ti)
        {

            Console.WriteLine("Current Time: {0}:{1}:{2}",

            ti.hour.ToString(),

            ti.minute.ToString(),

            ti.second.ToString());

        }

    }

    // 第二个订阅者，他的工作是把当前时间写入一个文件

    public class LogClock
    {

        public void Subscribe(Clock theClock)
        {

            theClock.SecondChange +=

            new SecondChangeHandler(WriteLogEntry);

        }

        // 这个方法本来应该是把信息写入一个文件中

        // 这里我们用把信息输出控制台代替

        public void WriteLogEntry(

        object theClock, TimeInfoEventArgs ti)
        {

            Clock a = (Clock)theClock;

            Console.WriteLine("Logging to file: {0}:{1}:{2}",

            a.Hour.ToString(),

            a.Minute.ToString(),

            a.Second.ToString());

        }

    }

    /* ======================= Test Application =============================== */

    // 测试拥有程序

    public class Test
    {

        public static void Main()
        {

            // 创建clock实例

            Clock theClock = new Clock();

            // 创建一个DisplayClock实例，让其订阅上面创建的clock的事件

            DisplayClock dc = new DisplayClock();

            dc.Subscribe(theClock);

            // 创建一个LogClock实例，让其订阅上面创建的clock的事件

            LogClock lc = new LogClock();

            lc.Subscribe(theClock);

            // 让钟跑起来

            theClock.Run();

        }

    }

}

14. 3、小结

（1）、在定义事件的那个类A里面，可以任意的使用事件名，可以触发；在别的类里面，事件名只能出现在 += 或 -= 的左边来指向函数，即只能实例化，不能直接用事件名触发。但是可以通过A类的对象来调用A类中的触发事件的函数。这是唯一触发事件的方式。

（2）、不管是多播委托还是单播委托，在没有特殊处理的情况下，在一个线程的执行过程中去调用委托（委托对象所指向的函数），调用委托的执行是不会新起线程的，这个执行还是在原线程中的，这个对于事件也是一样的。当然，如果是在委托所指向的函数里面去启动一个新的线程那就是另外一回事了。

（3）、事件是针对某一个具体的对象的，一般在该对象的所属类A中写好事件，并且写好触发事件的方法，那么这个类A就是事件的发布者，然后在别的类B里面定义A的对象，并去初始化该对象的事件，让事件指向B类中的某一个具体的方法，B类就是A类事件的订阅者。当通过A类的对象来触发A类的事件的时候（只能A类的对象来触发A类的事件，别的类的对象不能触发A类的事件，只能订阅A类的事件，即实例化A类的事件），作为订阅者的B类会接收A类触发的事件，从而使得订阅函数被执行。一个发布者可以有多个订阅者，当发布者发送事件的时候，所有的订阅者都将接收到事件，从而执行订阅函数，但是即使是有多个订阅者也是单线程。