欧美jizzhd精品欧美巨大免费,国产精品久久影院,久久久91精品国产

c# 事�g认识

Thu, 30 Sep 2010 06:17:00 GMT

CLR事�g机制建立在委托机制上

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.定义一个类型，保存所有传递参数�?br>.net框架规定所有的信息�c�d���l�承于EventArgs,�c�d��名称以EventArgs�l�束,EventArgs原型如下:
[Serializable]
public class EventArgs
{
    public static readonly EventArgs Empty = new EventArgs();
    public EventArgs(){};
}
只有一个静态的Empty成员,因�ؓ事�g中有些不需要额外的参数信息�Q�所以只要提供EventArgs.Empty,不需要在构造新的对�?br>2.定义一个委托类�?指定事�g触发时调用的函数原型
public delegate void MailEventHandler(Object sender, MailEventArgs e);
如果事�g中�ƈ没有额外的传递信�?则可以��用System.EventHandler,原型�?br>public delegate void EventHandler(Object sender,EventArgs e);
3.定义一个事件成�?br>public event MailEventHandler MailMsg;
4.定义受保护的虚方法，通知事�g登记对象
protected virtual void OnMailMsg(MailEventArgs e);
5.定义驱动事�g�Ҏ��
public virtual void SimulateArrivingMsg(String from, String to, String subject, String body);

深入理解事�g
当编译器遇到public event MailEventHandler MailMsg;
会���?个构�?一个私有委托类型，及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字段可以���添加的注册对象保存

侦听事�g
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;
        }
    }

注意,当一个对象仍然登记有另外一个对象的事�g�Q�该对象��׃��可能对垃圑֛��Ӟ��如果我们�c�d����C��IDisposable接口�Q�那我们应该�?br>Dispose理注销所有登��C���?br>
昄���控制事�g注册
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);
            }
        }

来代�?/span>public event MailEventHandler MailMsg;定义

当一个类型中含有多个事�g�Ӟ���׃��每个事�g事例声明都将产生委托字段�Q�所以推�?/span> 不要提供公共的事件成员变量，使用事�g讉K��器替换这些变�?br>
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,如果设计该种事�g�c�d��,其中�l�出了EventHandlerSet的实玎ͼ�
.net框架中也有类似的事�g EventHandlerList,但是讉K��效率和线�E�同步有�~�陷�Q�所以有需要我们自己提�?br>EventHandlerSet实现.详情请参考microsoft .net 框架设计

��果�?/a> 2010-09-30 14:17 发表评论

c# 委托认识

Wed, 29 Sep 2010 09:24:00 GMT

.net框架�?c#为回调函数提供了委托的类型安全机�?下面是声明，创徏和��?/span>

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();
        }
    }
}

上例昄��了��用委托如何静态回调和非静态回调方�?当声�?br>

public delegate void FeedBack(Object value, Int32 item, Int32 numberItems);
微��Y�~�译器�ؓ其��生如下定义：
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�c?可以在�Q何类定义的地方声明委托，委托本质是一个类�Q�因为委托��?/span>System.MulticastDelegate�Q?br>所以会�l�承其相应字�D�：
_target,_methodPtr,_prev.

public FeedBack(Object target,Int32 methodPtr);构造函数包含两个参�?target和methodPtr,一个对象引用和一个指向回调函数的整数�Q?br>但是我们构造的时候只是给�?span style="color: #000000;">Program.FeedBackToConsole�q�样的��|��其实是编译器为我们做了工作，它知道我们在构造委托，它会分析源代码知道我�?br>引用的是哪个对象和哪个方�?br>
当委托调用的时�?/span>feedback(items[i], i + 1, items.Length);实质�?/span>feedback.Invoke(items[i], i + 1, items.Length);不过c#不允�?br>昄��调用该方�?当invoke调用的时�?它��用_target,_methodPtr来指定对象调用的�Ҏ��Q�invoke�Ҏ��的签名和声明的委托签名一�?br>
System.MulticastDelegate System.Delegate,前者��承与后者，微��Y�~�译器��生的委托都是�l�承�?/span>System.MulticastDelegate,但是我们有些时�?br>会遇�?/span>System.Delegate,System.Delegate提供了两个静态方法，Combine和Remove�Q�其参数都是Delegate�c�d��Q�所以我们可以传�?/span>MulticastDelegate
�l�它

关于委托的判�{?br>Delegate重写了Object的Equals�Ҏ��Q�如果_target和_methodPtr是否指向同样的对象和�Ҏ��Q�返回true
MulticastDelegate重写了Delegate�?/span>Equals�Ҏ��,在delegate之上�Q�还要比较_prev

委托�?br>MulticastDelegate的_prev保存了下一个委托的应用,使得多个委托对象可以�l�成一个链�?/span>
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);
    }
}

可以看出�Q�当委托链调用的时候，如果回调函数有返回��|��只保留最后一个委托调用的�q�回��|��而且链表��N��?br>委托先调用，递归调用

c#中重载了-=,+=,可以方便实现委托铄��操作�Q�其实质是调用了以上三个静态函数实�?同时��Z��增加对委托的控制�Q?br>MulticastDelegate提供�?br>public virtual Delegate[] GetInvocationList();
�q�回委托铄��数组�Q�可以操控里面的每个委托对象�?br>
(具体请参考Microsoft.Net 框架设计)

��果�?/a> 2010-09-29 17:24 发表评论