Effective C# Item 22: Define Outgoing Interface With Events

Effective C# Item 22: Define Outgoing Interface With Events

      事件为我们的类型定义了对外的接口。事件是通过委托来提供类型安全的函数签名。由于大部分情况下我们使用委托的例子都是事件,这使得我们容易将二者混为一谈。在Item 21中,我们举了不定义事件的委托的例子。当我们的类型在系统中必须与多个客户程序进行信息交互时,我们应考虑当使用事件。

      我们来考虑一个简单的例子。我们创建一个日志类来调度应用程序中的所有消息。它会接受应用程序资源的所有消息并将其调度给感兴趣的监听者。这个监听者可能是控制台,数据库,系统日志或者其它的什么机制。我们可以像下面这样定义这个类,创建一个事件来处理消息。

     public   class  LoggerEventArgs : EventArgs
    
{
        
public readonly string Message;
        
public readonly int Priority;

        
public LoggerEventArgs(int p, string m)
        
{
            Priority 
= p;
            Message 
= m;
            Console.WriteLine(
"loggereventArgs ");
        }

    }


    
public   delegate   void  AddMessageEventHandler( object  sender, LoggerEventArgs msg);

    
public   class  Logger
    
{
        
private static Logger _theOnly = null;
        
static Logger()
        
{
            _theOnly 
= new Logger();
        }


        
public Logger Singleton
        
{
            
get
            
{
                
return _theOnly;
            }

        }


        
public event AddMessageEventHandler Log;

        
public void AddMsg(int priority, string msg)
        
{
            AddMessageEventHandler l 
= Log;
            
if (l != null)
            
{
                l(
nullnew LoggerEventArgs(priority, msg));
            }

        }

    }

      我定义了LoggerEventArgs来保存事件的优先级和消息。委托为特定事件的句柄定义了签名。在Logger类内部声明的事件字段定义了事件的句柄。编译器可以识别这些public的事件定义并自动为我们生成add和remove操作符。生成的代码和我们下面所示的代码是相同的:

     public   class  Logger
    
{
        
private event AddMessageEventHandler _Log;
        
public event AddMessageEventHandler Log
        
{
            add
            
{
                _Log 
+= _Log + value;
            }

            remove
            
{
                _Log 
-= _Log - value;
            }

        }



        
public void AddMsg(int priority, string msg)
        
{
            AddMessageEventHandler l 
= _Log;
            
if (l != null)
            
{
                l(
nullnew LoggerEventArgs(priority, msg));
            }

        }

    }

      C#编译器会自动为我们的public事件添加add和remove。这种声明方法更加简洁,易于理解和掌握,而且更为准确。当我们在类中创建事件时,应当将事件声明为public让编译器为我们生成add和remove属性。当然如果我们需要为其添加一些额外的条件约束的话,也可以手工来完成这些操作。

      事件不关心任何潜在的监听者。下面这个类示例将所有消息发送至输出标准错误信息的控制台:

class  ConsoleLogger
    
{
        
private static Logger logger = new Logger();
        
static ConsoleLogger()
        
{
            logger.Log 
+= new AddMessageEventHandler(Logger_Log);
        }


        
private static void Logger_Log(object sender, LoggerEventArgs msg)
        
{
            Console.Error.Write(
"{0}:\t{1}", msg.Priority.ToString(), msg.Message);
        }

    }

      而下例中的类将消息输出到系统事件日志:

     class  EventLogger
    
{
        
private static Logger logger = new Logger();

        
private static string eventSource;
        
private static EventLog logDest;
        
static EventLogger()
        
{
            logger.Log 
+= new AddMessageEventHandler(Event_Log);
        }


        
public static string EventSource
        
{
            
get
            
{
                
return eventSource;
            }

            
set
            
{
                eventSource 
= value;
                
if (!EventLog.SourceExists(eventSource))
                
{
                    EventLog.CreateEventSource(eventSource, 
"ApplicationEventLogger");
                }

                
if (logDest != null)
                
{
                    logDest.Dispose();
                }

                logDest 
= new EventLog();
                logDest.Source 
= eventSource;
            }

        }


        
static void Event_Log(object sender, LoggerEventArgs msg)
        
{
            
if (logDest != null)
            
{
                logDest.WriteEntry(msg.Message, EventLogEntryType.Information, msg.Priority);
            }

        }

    }

      一旦某些特定的情况发生,事件处理会通知所有感兴趣的客户端。Logger类不需要提前了解任何对此事件感兴趣的对象信息。

      Logger类只包含唯一的一个事件。但是有些类包含了大量的事件(例如大部分的窗体控件)。在这种情况下,为每个事件单独创建一个事件字段的做法就有些欠妥,通常在应用程序中每次只有一少部分事件会被确实的使用。当我们遇到这种情况时,我们可以修改创建事件的方法,使其在运行阶段动态生成这些事件对象。

      这个Logger类的扩展版本包含了一个System.ComponentModel.EventHandlerList容器来储存所有可能被唤起的事件对象。新版本的AddMsg()方法通过一个string型的参数来辨别子系统需要处理的消息。一旦子系统有任何的监听者,那么这个对应的事件将被唤起。

     public   class  Logger
    
{
        
private static EventHandlerList handlers = new EventHandlerList();

        
public static void AddLogger(string system, AddMessageEventHandler ev)
        
{
            handlers[system] 
= ev;
        }


        
public static void RemoveLogger(string system)
        
{
            handlers[system] 
= null;
        }


        
public static void AddMsg(string system, int priority, string msg)
        
{
            
if (!string.IsNullOrEmpty(system))
            
{
                AddMessageEventHandler l 
= handlers[system] as AddMessageEventHandler;
                LoggerEventArgs args 
= new LoggerEventArgs(priority, msg);
                
if (l != null)
                
{
                    l(
null, args);
                }

                l 
= handlers[""as AddMessageEventHandler;
                
if (l != null)
                
{
                    l(
null, args);
                }

            }

        }

    }

      这个新的例子将所有的事件句柄存储在EventHandlerList集合中。当一个新的事件对象被创建后,对于来自于同一个子系统的后续请求将返回同一个事件对象。如果我们开发一个包含大量事件的类,你应当考虑使用事件句柄集合来处理。在.Net Framework中,System.Windows.Forms.Control类使用一种更加复杂的实现方法来对应复杂的事件字段。每个事件字段内部包含一个对象集合来添加和移除特定的句柄。

      当我们在接口中为类定义事件时,我们应当明白任何客户端程序都可以将句柄关联到上面来。那些客户端程序并不需要了解编译时的状态。使用C#中的事件可以消除发送者和可能接收者之间的耦合关系。发送者可以被开发成与接收者无关的模式。事件是消息传递的一种标准的模式。

      译自   Effective C#:50 Specific Ways to Improve Your C#                      Bill Wagner著

      回到目录

你可能感兴趣的:(interface)