设计类型（三）

设计类型

事件

基础概念

1. 设计要公开事件的类型

   • 第一步： 定义类型来容纳所有需要发送给时间通知接收者的附加信息

     // 按实际需求定义类型
     internal class XxEventArgs : EventArgs{
         public object Yy{get;set;}
     }
     

   • 第二步：定义事件成员

     public event EventHandler xxEventHandler;
     

   • 第三步：定义负责引发事件的方法来通知事件的登记对象

     // 支持线程安全
     EventHandler temp = Volatile.Read(ref xxEventHandler);
     if(temp != null){
         temp(this,xx);
     }
     

   • 第四步：定义方法将输入转化为期望的事件

     this.eventHandler += (o, e) => {
        Console.WriteLine("Hehhahah:"+e.HelloWorld);
     };
     

2. 编译器如何实现事件

   • TODO：待分析IL和底层实现代码

3. 显示实现事件

       /// 
   
       ///  显示实现事件，优化
       /// 
       public  class B
       {
           private readonly EventSet _eventSet = new EventSet();
   
           protected EventSet EventSet { get { return _eventSet; } }
   
           protected static readonly EventKey _fooEventKey = new EventKey();
   
           public event EventHandler Foo {
               add { _eventSet.Add(_fooEventKey, value);
               }
               remove { _eventSet.Remove(_fooEventKey, value); }
           }
   
           protected virtual void OnFoo(XxEventArgs e)
           {
               _eventSet.Raise(_fooEventKey, this, e);
           }
   
           public void SimulateFoo()
           {
               OnFoo(new XxEventArgs { });
           }
       }
   
       public class XxEventArgs : EventArgs {
           public override string ToString()
           {
               return "Hello,World";
           }
       }
   
       public sealed class EventKey { }
   
       public sealed class EventSet
       {
           // 私有字典维护EventKey -> 到Delegate的映射
           private readonly ConcurrentDictionary _events = new ConcurrentDictionary();
   
           public void Add(EventKey eventKey,Delegate handler)
           {
               // TODO 理解使用线性安全的字段是否还需要加同步操作
               // Monitor.Enter(_events);
               Delegate d;
               _events.TryGetValue(eventKey, out d);
               _events[eventKey] = Delegate.Combine(d, handler);
               // Monitor.Exit(_events);
           }
   
           public void Remove(EventKey eventKey,Delegate handler)
           {
               // Monitor.Enter(_events);
               Delegate d;
               if(_events.TryGetValue(eventKey,out d))
               {
                   d = Delegate.Remove(d, handler);
                   if (d != null)
                   {
                       _events[eventKey] = d;
                   }
                   else
                   {
                       _events.TryRemove(eventKey,out d);
                   }
               }
               // Monitor.Exit(_events);
           }
   
           public  void Raise(EventKey eventKey,Object sender,EventArgs e)
           {
               Delegate d;
               // Monitor.Enter(_events);
               _events.TryGetValue(eventKey, out d);
               //  Monitor.Exit(_events);
               if (d != null)
               {
                   d.DynamicInvoke(new object[] { sender,e});
               }
           }
       }
   
       public sealed class BDemo
       {
           public void Run()
           {
               B b = new B();
               b.Foo += B_Foo;
               b.SimulateFoo();
           }
   
           private void B_Foo(object sender, XxEventArgs e)
           {
               Console.WriteLine(e.ToString());
           }
       }
   

泛型

基础概念

1. 开放类型和封闭类型
   • 具有泛型类型参数的类型称为开放类型，CLR禁止构造开放类型的任何实例
   • 为所有类型参数都传递了实际的数据类型，类型就成为封闭类型。
2. 代码爆炸

逆变和协变

​ In C#, covariance and contravariance enable implicit reference conversion（隐式引用转换 ） for array types, delegate types, and generic type arguments. Covariance preserves assignment compatibility and contravariance reverses it.

1. 泛型类型参数
   • 不变量（invariant）：意味着泛型类型参数不能更改。
   • 逆变量（contravariant）：意味着泛型类型参数可以从一个类更改为他的某个派生类。
   • 协变量（covariant）：意味着泛型类型参数可以从一个类更改为她的某个基类。
2. 简而言之，协变性（covariance）指定返回的类型的兼容性，逆变（contravariance）指定参数的兼容性。

案例

1. 方法逆变和协变

   static object GetObject() { return null; }  
   static void SetObject(object obj) { }  
     
   static string GetString() { return ""; }  
   static void SetString(string str) { }  
     
   static void Test()  
   {  
       // 协变
       // Covariance. A delegate specifies a return type as object,  
       // but you can assign a method that returns a string.  
       Func