从Prism中学习设计模式之Event Aggregator 模式

Event Aggregator 模式定义：渠道事件从多个对象通过一个单一的对象来简化clients的注册。

结构图：

Prism的Event Aggregator 模式：Event Aggregator允许多对象定位和发布、订阅事件。

我们从Prism源代码中的EventAggregator和CompositePresentationEvent可以学习它是如何管理和传递事件消息的。

  1     public interface IEventAggregator
  2     {
  3         TEventType GetEvent<TEventType>() where TEventType : EventBase, new();
  4     }
  5 
  6     public class EventAggregator : IEventAggregator
  7     {
  8         private readonly Dictionary<Type, EventBase> events = new Dictionary<Type, EventBase>();
  9 
 10         public TEventType GetEvent<TEventType>() where TEventType : EventBase, new()
 11         {
 12             EventBase existingEvent = null;
 13 
 14             if (!this.events.TryGetValue(typeof(TEventType), out existingEvent))
 15             {
 16                 TEventType newEvent = new TEventType();
 17                 this.events[typeof(TEventType)] = newEvent;
 18 
 19                 return newEvent;
 20             }
 21             else
 22             {
 23                 return (TEventType)existingEvent;
 24             }
 25         }
 26     }
 27 
 28   public class CompositePresentationEvent<TPayload> : EventBase
 29     {
 30         private IDispatcherFacade uiDispatcher;
 31 
 32         private IDispatcherFacade UIDispatcher
 33         {
 34             get
 35             {
 36                 if (uiDispatcher == null)
 37                 {
 38                     this.uiDispatcher = new DefaultDispatcher();
 39                 }
 40 
 41                 return uiDispatcher;
 42             }
 43         }
 44 
 45         public SubscriptionToken Subscribe(Action<TPayload> action)
 46         {
 47             return Subscribe(action, ThreadOption.PublisherThread);
 48         }
 49 
 50         public SubscriptionToken Subscribe(Action<TPayload> action, ThreadOption threadOption)
 51         {
 52             return Subscribe(action, threadOption, false);
 53         }
 54 
 55         public SubscriptionToken Subscribe(Action<TPayload> action, bool keepSubscriberReferenceAlive)
 56         {
 57             return Subscribe(action, ThreadOption.PublisherThread, keepSubscriberReferenceAlive);
 58         }
 59 
 60         public SubscriptionToken Subscribe(Action<TPayload> action, ThreadOption threadOption, bool keepSubscriberReferenceAlive)
 61         {
 62             return Subscribe(action, threadOption, keepSubscriberReferenceAlive, null);
 63         }
 64 
 65         public virtual SubscriptionToken Subscribe(Action<TPayload> action, ThreadOption threadOption, bool keepSubscriberReferenceAlive, Predicate<TPayload> filter)
 66         {
 67             IDelegateReference actionReference = new DelegateReference(action, keepSubscriberReferenceAlive);
 68             IDelegateReference filterReference;
 69             if (filter != null)
 70             {
 71                 filterReference = new DelegateReference(filter, keepSubscriberReferenceAlive);
 72             }
 73             else
 74             {
 75                 filterReference = new DelegateReference(new Predicate<TPayload>(delegate { return true; }), true);
 76             }
 77             EventSubscription<TPayload> subscription;
 78             switch (threadOption)
 79             {
 80                 case ThreadOption.PublisherThread:
 81                     subscription = new EventSubscription<TPayload>(actionReference, filterReference);
 82                     break;
 83                 case ThreadOption.BackgroundThread:
 84                     subscription = new BackgroundEventSubscription<TPayload>(actionReference, filterReference);
 85                     break;
 86                 case ThreadOption.UIThread:
 87                     subscription = new DispatcherEventSubscription<TPayload>(actionReference, filterReference, UIDispatcher);
 88                     break;
 89                 default:
 90                     subscription = new EventSubscription<TPayload>(actionReference, filterReference);
 91                     break;
 92             }
 93 
 94 
 95             return base.InternalSubscribe(subscription);
 96         }
 97 
 98         public virtual void Publish(TPayload payload)
 99         {
100             base.InternalPublish(payload);
101         }
102 
103         public virtual void Unsubscribe(Action<TPayload> subscriber)
104         {
105             lock (Subscriptions)
106             {
107                 IEventSubscription eventSubscription = Subscriptions.Cast<EventSubscription<TPayload>>().FirstOrDefault(evt => evt.Action == subscriber);
108                 if (eventSubscription != null)
109                 {
110                     Subscriptions.Remove(eventSubscription);
111                 }
112             }
113         }
114 
115         public virtual bool Contains(Action<TPayload> subscriber)
116         {
117             IEventSubscription eventSubscription;
118             lock (Subscriptions)
119             {
120                 eventSubscription = Subscriptions.Cast<EventSubscription<TPayload>>().FirstOrDefault(evt => evt.Action == subscriber);
121             }
122             return eventSubscription != null;
123         }
124 
125     }

订阅
取消订阅
发布
比较定位

简单用法：

 1 public class Model{
 2     private readonly IEventAggregator eventAggregator;
 3 
 4     this.eventAggregator = eventAggregator;
 5     this.eventAggregator.GetEvent<UpdatedEvent>().Subscribe(this.Updated, ThreadOption.UIThread);
 6 
 7         private void Updated()
 8         {
 9             //Todo Something
10         }
11 
12 }
13 
14     public class UpdatedEvent: CompositePresentationEvent<IDictionary<string, decimal>>
15     {
16     }

参考资料：

http://www.martinfowler.com/eaaDev/EventAggregator.html