EventsHelper委托触发类

• 在我们使用事件的时候常常会这样写：
          public   event  EventHandler ChangedEvent;
          private   void  OnChangedEvent()
          {
              if  (ChangedEvent  !=   null )
              {
                  ChangedEvent( this , EventArgs.Empty);
              }
          }
          private   void  OnChangeEventAsync()
          {
              if  (ChangedEvent  !=   null )
              {
                  ChangedEvent.BeginInvoke( this , EventArgs.Empty,  null ,  null );
              }
          }
• 判断事件是否有订阅，触发事件等，是经常重复写的部分，其实我们可以把他们封装起来。

1. 创建一个EventsHelper静态类，首先完成同步操作：创建以下方法：
           // 私有检查参数函数
           private   static   bool  CheckArguments(Delegate del,  params   object [] args)
           {
               if  (del  ==   null ) {  return   false ; }
               if  (args.Length  >   7 )
               {
                   throw   new  ArgumentOutOfRangeException( " 参数过多 " );
               }
               return   true ;
           }
           // 委托触发函数
           private   static   void  Fire(Delegate del,  params   object [] args)
           {
               foreach  (var item  in  del.GetInvocationList())
               {
                   try
                   {
                       item.DynamicInvoke(args);
                   }
                   catch  { }
               }
           }
           //非类型安全委托触发函数
           public   static   void  UnsafeFire(Delegate del,  params   object [] args)
           {
               if  (CheckArguments(del, args))
               {
                   Fire(del, args);
               }
           }
2. 由于UnsafeFire（）方法并没有检查参数类型，所以并不能保证类型安全，于是我们创建一些通用的委托，使用这些泛型委托我们可以创建一些通用的事件。因为十分长的参数并不常用，所以我只创建到参数最长7位的泛型委托。
           public   delegate   void  GenericEventHandler();
           public   delegate   void  GenericEventHandler < T > (T t);
           public   delegate   void  GenericEventHandler < T, U > (T t, U u);
           public   delegate   void  GenericEventHandler < T, U, V > (T t, U u, V v);
           public   delegate   void  GenericEventHandler < T, U, V, W > (T t, U u, V v, W w);
           public   delegate   void  GenericEventHandler < T, U, V, W, X > (T t, U u, V v, W w, X x);
           public   delegate   void  GenericEventHandler < T, U, V, W, X, Y > (T t, U u, V v, W w, X x, Y y);
           public   delegate   void  GenericEventHandler < T, U, V, W, X, Y, Z > (T t, U u, V v, W w, X x, Y y, Z z);
3. 创建安全的委托触发函数。
            public   static   void  Fire(EventHandler del,  object  sender, EventArgs e)
           {
               UnsafeFire(del, sender, e);
           }
            public   static   void  Fire < T > (EventHandler < T >  del,  object  sender, T t)  where  T : EventArgs
           {
               UnsafeFire(del, sender, t);
           }
            public   static   void  Fire(GenericEventHandler del)
           {
               UnsafeFire(del,  null );
           }
            public   static   void  Fire < T > (GenericEventHandler < T >  del, T t)
           {
               UnsafeFire(del, t);
           }
            public   static   void  Fire < T, U > (GenericEventHandler < T, U >  del, T t, U u)
           {
               UnsafeFire(del, t, u);
           }
            public   static   void  Fire < T, U, V > (GenericEventHandler < T, U, V >  del, T t, U u, V v)
           {
               UnsafeFire(del, t, u, v);
           }
            public   static   void  Fire < T, U, V, W > (GenericEventHandler < T, U, V, W >  del, T t, U u, V v, W w)
           {
               UnsafeFire(del, t, u, v, w);
           }
            public   static   void  Fire < T, U, V, W, X > (GenericEventHandler < T, U, V, W, X >  del, T t, U u, V v, W w, X x)
           {
               UnsafeFire(del, t, u, v, w, x);
           }
            public   static   void  Fire < T, U, V, W, X, Y > (GenericEventHandler < T, U, V, W, X, Y >  del, T t, U u, V v, W w, X x, Y y)
           {
               UnsafeFire(del, t, v, w, x, y);
           }
            public   static   void  Fire < T, U, V, W, X, Y, Z > (GenericEventHandler < T, U, V, W, X, Y, Z >  del, T t, U u, V v, W w, X x, Y y, Z z)
           {
               UnsafeFire(del, t, u, v, w, x, y, z);
           }
4. 完成异步操作：创建类型不安全委托函数异步触发方法。
            private   static   void  FireAsync(Delegate del,  params   object [] args)
           {
               AsyncFire asyncFire  =  Fire;
                foreach  (var item  in  del.GetInvocationList())
               {
                    try
                   {
                       asyncFire.BeginInvoke(del, args,  null ,  null );
                   }
                    catch  { }
               }
           }
            delegate   void  AsyncFire(Delegate del,  params   object [] args);
            public   static   void  UnsafeFireAsync(Delegate del,  params   object [] args)
           {
                if  (CheckArguments(del, args))
               {
                   FireAsync(del, args);
               }
           }
5. 同3,创建类型安全的委托异步触发。
            public   static   void  FireAsync(EventHandler del,  object  sender, EventArgs e)
           {
               UnsafeFireAsync(del, sender, e);
           }
            public   static   void  FireAsync < T > (EventHandler < T >  del,  object  sender, T t)  where  T : EventArgs
           {
               UnsafeFireAsync(del, sender, t);
           }
            public   static   void  FireAsync(GenericEventHandler del)
           {
               UnsafeFireAsync(del,  null );
           }
            public   static   void  FireAsync < T > (GenericEventHandler < T >  del, T t)
           {
               UnsafeFireAsync(del, t);
           }
            public   static   void  FireAsync < T, U > (GenericEventHandler < T, U >  del, T t, U u)
           {
               UnsafeFireAsync(del, t, u);
           }
            public   static   void  FireAsync < T, U, V > (GenericEventHandler < T, U, V >  del, T t, U u, V v)
           {
               UnsafeFireAsync(del, t, u, v);
           }
            public   static   void  FireAsync < T, U, V, W > (GenericEventHandler < T, U, V, W >  del, T t, U u, V v, W w)
           {
               UnsafeFireAsync(del, t, u, v, w);
           }
            public   static   void  FireAsync < T, U, V, W, X > (GenericEventHandler < T, U, V, W, X >  del, T t, U u, V v, W w, X x)
           {
               UnsafeFireAsync(del, t, u, v, w, x);
           }
            public   static   void  FireAsync < T, U, V, W, X, Y > (GenericEventHandler < T, U, V, W, X, Y >  del, T t, U u, V v, W w, X x, Y y)
           {
               UnsafeFireAsync(del, t, v, w, x, y);
           }
            public   static   void  FireAsync < T, U, V, W, X, Y, Z > (GenericEventHandler < T, U, V, W, X, Y, Z >  del, T t, U u, V v, W w, X x, Y y, Z z)
           {
               UnsafeFireAsync(del, t, u, v, w, x, y, z);
           }
6. 使用EventsHelper
        class  Program
       {
            public   event  EventHandler ChangedEvent;
            private   string  m_name;
            public   string  Name
           {
                get  {  return  m_name; }
                set
               {
                    if  (value  !=  m_name)
                   {
                       m_name  = value;
                      // 编译器会自动推断委托类型
                         EventsHelper.Fire(ChangedEvent, null, null);
                   }
               }
           }
            static   void  Main( string [] args)
           {
               Program pro  =   new  Program();
               pro.ChangedEvent  +=   new  EventHandler(pro_ChangedEvent);
               pro.Name  =   " FlashPast " ;
               Console.ReadLine();
           }
            public   static   void  pro_ChangedEvent( object  sender, EventArgs e)
           {
               Console.WriteLine( " Name 改变 " );
           }
       }