C++博客-xiaoguozi's Blog-随笔分类-.Net

c# 事件认识

小果子 — Thu, 30 Sep 2010 06:17:00 GMT

CLR事件机制建立在委托机制上

class MailManager
    {
        public class MailEventArgs : EventArgs
        {
            public MailEventArgs(
                String from,
                String to,
                String subject,
                String body)
            {
                this.from = from;
                this.to = to;
                this.subject = subject;
                this.body = body;
            }
            public readonly String from, to, subject, body;
        }
        public delegate void MailEventHandler(Object sender, MailEventArgs e);
        public event MailEventHandler MailMsg;
        protected virtual void OnMailMsg(MailEventArgs e)
        {
            if (MailMsg != null)
            {
                MailMsg(this, e);
            }
        }
        public virtual void SimulateArrivingMsg(String from, String to, String subject, String body)
        {
            MailEventArgs e = new MailEventArgs(from, to, subject, body);
            OnMailMsg(e);
        }
    }
以上是一个事件类型定义，简单步骤:
1.定义一个类型，保存所有传递参数。
.net框架规定所有的信息类型继承于EventArgs,类型名称以EventArgs结束,EventArgs原型如下:
[Serializable]
public class EventArgs
{
    public static readonly EventArgs Empty = new EventArgs();
    public EventArgs(){};
}
只有一个静态的Empty成员,因为事件中有些不需要额外的参数信息，所以只要提供EventArgs.Empty,不需要在构造新的对象
2.定义一个委托类型,指定事件触发时调用的函数原型
public delegate void MailEventHandler(Object sender, MailEventArgs e);
如果事件中并没有额外的传递信息,则可以使用System.EventHandler,原型为
public delegate void EventHandler(Object sender,EventArgs e);
3.定义一个事件成员
public event MailEventHandler MailMsg;
4.定义受保护的虚方法，通知事件登记对象
protected virtual void OnMailMsg(MailEventArgs e);
5.定义驱动事件方法
public virtual void SimulateArrivingMsg(String from, String to, String subject, String body);

深入理解事件
当编译器遇到public event MailEventHandler MailMsg;
会产生3个构造,一个私有委托类型，及add和remove方法
private MailEventHandler MailMsg;
[MethodImplAttribute(MethodImplOptions.Synchronized)]
public virtual void add_MailMsg(MailEventHandler handler)
{
     MailMsg = (MailEventHandler)Delegate.Combine(MailMsg, handler);
}
[MethodImplAttribute(MethodImplOptions.Synchronized)]
public virtual void remove_MailMsg(MailEventHandler handler)
{
     MailMsg = (MailEventHandler)Delegate.Remove(MailMsg, handler);
}
通过MailMsg内_prev字段可以将添加的注册对象保存

侦听事件
class Fax
    {
        public Fax(MailManager mm)
        {
            mm.MailMsg += new MailManager.MailEventHandler(FaxMsg);
        }
        private void FaxMsg(Object sender, MailManager.MailEventArgs e)
        {

        }
        public void UnRegister(MailManager mm)
        {
            MailManager.MailEventHandler callback = new MailManager.MailEventHandler(FaxMsg);
            mm.MailMsg -= callback;
        }
    }

注意,当一个对象仍然登记有另外一个对象的事件，该对象就不可能对垃圾回收，如果我们类实现了IDisposable接口，那我们应该在
Dispose理注销所有登记事件

显示控制事件注册
private MailEventHandler mailMsgEventHandlerDelegate;
        public event MailEventHandler MailMsg
        {
            add
            {
                mailMsgEventHandlerDelegate =(MailEventHandler)Delegate.Combine(mailMsgEventHandlerDelegate, value);
            }
            remove
            {
                mailMsgEventHandlerDelegate = (MailEventHandler)Delegate.Remove(mailMsgEventHandlerDelegate, value);
            }
        }
        protected virtual void OnMailMsg(MailEventArgs e)
        {
            if (MailMsg != null)
            {
                mailMsgEventHandlerDelegate(this, e);
            }
        }

来代替public event MailEventHandler MailMsg;定义

当一个类型中含有多个事件时，由于每个事件事例声明都将产生委托字段，所以推荐 不要提供公共的事件成员变量，使用事件访问器替换这些变量

class EventHandlerSet:IDisposable
    {
        private Hashtable events = new Hashtable();
        public virtual Delegate this[Object eventKey]
        {
            get
            {
                return (Delegate)events[eventKey];
            }
            set
            {
                events[eventKey] = value;
            }
        }
        public virtual void AddHandler(Object eventKey,Delegate handler)
        {
            events[eventKey] = Delegate.Combine((Delegate)events[eventKey], handler);
        }
        public virtual void RevHandler(Object eventKey, Delegate handler)
        {
            events[eventKey] = Delegate.Remove((Delegate)events[eventKey], handler);
        }
        public virtual void Fire(Object eventKey, Object sender, EventArgs e)
        {
            Delegate d = (Delegate)events[eventKey];
            if (d != null)
                d.DynamicInvoke(new Object[]{sender,e});
        }
        public void Dispose()
        {
            events = null;
        }
        public static EventHandlerSet Synchronized(EventHandlerSet eventHandlerSet)
        {
            if (eventHandlerSet == null)
                throw new ArgumentNullException("eventHandlerSet");
            return new SynchronizedEventHandlerSet(eventHandlerSet);
        }
        public class SynchronizedEventHandlerSet : EventHandlerSet
        {
            private EventHandlerSet eventHandlerSet;
            public SynchronizedEventHandlerSet(EventHandlerSet eventHandlerSet)
            {
                this.eventHandlerSet = eventHandlerSet;
                Dispose();
            }
            public override Delegate this[object eventKey]
            {
                [MethodImpl(MethodImplOptions.Synchronized)]
                get
                {
                    return eventHandlerSet[eventKey];
                }
                set
                {
                    eventHandlerSet[eventKey] = value;
                }
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            public override void AddHandler(object eventKey, Delegate handler)
            {
                eventHandlerSet.AddHandler(eventKey, handler);
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            public override void RevHandler(object eventKey, Delegate handler)
            {
                eventHandlerSet.RevHandler(eventKey, handler);
            }
            [MethodImpl(MethodImplOptions.Synchronized)]
            public override void Fire(object eventKey, object sender, EventArgs e)
            {
                eventHandlerSet.Fire(eventKey, sender, e);
            }
        }
    }
    class TypeWithLotsEvents
    {
        protected EventHandlerSet eventSet = EventHandlerSet.Synchronized(new EventHandlerSet());
        protected static readonly Object fooEventKey = new Object();
        public class FooEventArgs : EventArgs { };
        public delegate void FooEventHandler(Object sender, FooEventArgs e);
        public event FooEventHandler Foo
        {
            add
            {
                eventSet.AddHandler(fooEventKey, value);
            }
            remove
            {
                eventSet.AddHandler(fooEventKey, value);
            }
        }
        protected virtual void OnFoo(FooEventArgs e)
        {
            eventSet.Fire(fooEventKey, this, e);
        }
        public void SimulateFoo()
        {
            OnFoo(new FooEventArgs());
        }

    }
以上是microsoft .net 框架设计一个example,如果设计该种事件类型,其中给出了EventHandlerSet的实现，
.net框架中也有类似的事件 EventHandlerList,但是访问效率和线程同步有缺陷，所以有需要我们自己提供
EventHandlerSet实现.详情请参考microsoft .net 框架设计

小果子 2010-09-30 14:17 发表评论

c# 委托认识

小果子 — Wed, 29 Sep 2010 09:24:00 GMT

.net框架中,c#为回调函数提供了委托的类型安全机制,下面是声明，创建和使用

namespace CSharpDotNet
{
    class Set
    {
        public Set(Int32 numberItems)
        {
            items = new Object[numberItems];
            for (Int32 i = 0; i < numberItems; i++)
                items[i] = i;
        }
        private Object[] items;
        public delegate void FeedBack(Object value, Int32 item, Int32 numberItems);
        /*public FeedBack:System.MulticastDelegate{
            public FeedBack(Object target,Int32 methodPtr);
            public virtual void Invoke(Object value, Int32 item, Int32 numberItems);
            public virtual IAsyncResult BeginInvoke(Object value, Int32 item, Int32 numberItems,
                    AsyncCallback callback,Object object);
            public virtual IAsyncResult EndInvoke(IAsyncResult result);
        }*/

        public void ProcessItems(FeedBack feedback)
        {
            for (Int32 i = 0; i < items.Length; i++)
            {
                if (feedback != null)
                {
                    feedback(items[i], i + 1, items.Length);
                }
            }
        }

    }
    class Program
    {
        static void StaticCallbacks()
        {
            Set setOfItems = new Set(5);
            setOfItems.ProcessItems(new Set.FeedBack(Program.FeedBackToConsole));
        }
        static void FeedBackToConsole(Object value, Int32 item, Int32 numberItems)
        {
            Console.WriteLine("{0},{1},{2}", value, item, numberItems);
        }
        static void InstanceCallbacks()
        {
            Set setOfItems = new Set(5);
            Program p = new Program();
            setOfItems.ProcessItems(new Set.FeedBack(p.FeedBackToMsg));
        }
        private void FeedBackToMsg(Object value, Int32 item, Int32 numberItems)
        {
            Console.WriteLine("msg");
        }
        static void Main(string[] args)
        {
            StaticCallbacks();
            InstanceCallbacks();
        }
    }
}

上例显示了使用委托如何静态回调和非静态回调方法,当声明

public delegate void FeedBack(Object value, Int32 item, Int32 numberItems);
微软编译器为其产生如下定义：
public FeedBack:System.MulticastDelegate{
       public FeedBack(Object target,Int32 methodPtr);
       public virtual void Invoke(Object value, Int32 item, Int32 numberItems);
       public virtual IAsyncResult BeginInvoke(Object value, Int32 item, Int32 numberItems,
                    AsyncCallback callback,Object object);
       public virtual IAsyncResult EndInvoke(IAsyncResult result);
}

因为委托声明为public,所以会产生public类,可以在任何类定义的地方声明委托，委托本质是一个类，因为委托继承System.MulticastDelegate，
所以会继承其相应字段：
_target,_methodPtr,_prev.

public FeedBack(Object target,Int32 methodPtr);构造函数包含两个参数,target和methodPtr,一个对象引用和一个指向回调函数的整数，
但是我们构造的时候只是给了Program.FeedBackToConsole这样的值，其实是编译器为我们做了工作，它知道我们在构造委托，它会分析源代码知道我们
引用的是哪个对象和哪个方法

当委托调用的时候feedback(items[i], i + 1, items.Length);实质是feedback.Invoke(items[i], i + 1, items.Length);不过c#不允许
显示调用该方法,当invoke调用的时候,它使用_target,_methodPtr来指定对象调用的方法，invoke方法的签名和声明的委托签名一致

System.MulticastDelegate System.Delegate,前者继承与后者，微软编译器产生的委托都是继承与System.MulticastDelegate,但是我们有些时候
会遇到System.Delegate,System.Delegate提供了两个静态方法，Combine和Remove，其参数都是Delegate类型，所以我们可以传递MulticastDelegate
给它

关于委托的判等
Delegate重写了Object的Equals方法，如果_target和_methodPtr是否指向同样的对象和方法，返回true
MulticastDelegate重写了Delegate的Equals方法,在delegate之上，还要比较_prev

委托链
MulticastDelegate的_prev保存了下一个委托的应用,使得多个委托对象可以组成一个链表
Delegate定义了三个静态方法:
public static Delegate Combine(Delegate tail,Delegate head);
public static Delegate Combine(Delegate[] delegateArray);
public static Delegate Remove(Delegate source,Delegate value);

class FeedBack:MulticastDelegate{
     public void virtual Invoke(Object value, Int32 item, Int32 numberItems){
          if(_prev!=null)_prev.Invoke(value,item,numberItems);
          _target.methodPtr(value,item,numberItems);
    }
}

可以看出，当委托链调用的时候，如果回调函数有返回值，将只保留最后一个委托调用的返回值，而且链表尾部的
委托先调用，递归调用

c#中重载了-=,+=,可以方便实现委托链的操作，其实质是调用了以上三个静态函数实现,同时为了增加对委托的控制，
MulticastDelegate提供了
public virtual Delegate[] GetInvocationList();
返回委托链的数组，可以操控里面的每个委托对象。

(具体请参考Microsoft.Net 框架设计)

小果子 2010-09-29 17:24 发表评论