InversionOfControl/Castle.MicroKernel/KernelEventSupport.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.MicroKernel
  16 {
  17         using System;
  18         using System.ComponentModel;
  19         using System.Runtime.Serialization;
  20
  21         using Castle.Core;
  22
  23         /// <summary>
  24         /// Summary description for KernelEventSupport.
  25         /// </summary>
  26         [Serializable]
  27         public abstract class KernelEventSupport : MarshalByRefObject, IKernelEvents, ISerializable
  28         {
  29                 private static readonly object HandlerRegisteredEvent = new object();
  30                 private static readonly object ComponentRegisteredEvent = new object();
  31                 private static readonly object ComponentUnregisteredEvent = new object();
  32                 private static readonly object ComponentCreatedEvent = new object();
  33                 private static readonly object ComponentDestroyedEvent = new object();
  34                 private static readonly object AddedAsChildKernelEvent = new object();
  35                 private static readonly object ComponentModelCreatedEvent = new object();
  36                 private static readonly object DependencyResolvingEvent = new object();
  37                 private static readonly object RemovedAsChildKernelEvent = new object();
  38
  39                 [NonSerialized]
  40                 private EventHandlerList events;
  41
  42                 public KernelEventSupport()
  43                 {
  44                         events = new EventHandlerList();
  45                 }
  46
  47                 public KernelEventSupport(SerializationInfo info, StreamingContext context)
  48                 {
  49                         events = new EventHandlerList();
  50
  51                         events[HandlerRegisteredEvent] = (Delegate)
  52                                  info.GetValue("HandlerRegisteredEvent", typeof(Delegate));
  53                 }
  54
  55                 public override object InitializeLifetimeService()
  56                 {
  57                         return null;
  58                 }
  59
  60                 /// <summary>
  61                 /// Pending
  62                 /// </summary>
  63                 public event HandlerDelegate HandlerRegistered
  64                 {
  65                         add { events.AddHandler(HandlerRegisteredEvent, value); }
  66                         remove { events.RemoveHandler(HandlerRegisteredEvent, value); }
  67                 }
  68
  69                 /// <summary>
  70                 /// Pending
  71                 /// </summary>
  72                 /// <value></value>
  73                 public event ComponentDataDelegate ComponentRegistered
  74                 {
  75                         add { events.AddHandler(ComponentRegisteredEvent, value); }
  76                         remove { events.RemoveHandler(ComponentRegisteredEvent, value); }
  77                 }
  78
  79                 /// <summary>
  80                 /// Pending
  81                 /// </summary>
  82                 /// <value></value>
  83                 public event ComponentDataDelegate ComponentUnregistered
  84                 {
  85                         add { events.AddHandler(ComponentUnregisteredEvent, value); }
  86                         remove { events.RemoveHandler(ComponentUnregisteredEvent, value); }
  87                 }
  88
  89                 /// <summary>
  90                 /// Pending
  91                 /// </summary>
  92                 /// <value></value>
  93                 public event ComponentInstanceDelegate ComponentCreated
  94                 {
  95                         add { events.AddHandler(ComponentCreatedEvent, value); }
  96                         remove { events.RemoveHandler(ComponentCreatedEvent, value); }
  97                 }
  98
  99                 /// <summary>
 100                 /// Pending
 101                 /// </summary>
 102                 /// <value></value>
 103                 public event ComponentInstanceDelegate ComponentDestroyed
 104                 {
 105                         add { events.AddHandler(ComponentDestroyedEvent, value); }
 106                         remove { events.RemoveHandler(ComponentDestroyedEvent, value); }
 107                 }
 108
 109                 /// <summary>
 110                 /// Pending
 111                 /// </summary>
 112                 /// <value></value>
 113                 public event EventHandler AddedAsChildKernel
 114                 {
 115                         add { events.AddHandler(AddedAsChildKernelEvent, value); }
 116                         remove { events.RemoveHandler(AddedAsChildKernelEvent, value); }
 117                 }
 118
 119                 /// <summary>
 120                 /// Pending
 121                 /// </summary>
 122                 public event EventHandler RemovedAsChildKernel
 123                 {
 124                         add { events.AddHandler(RemovedAsChildKernelEvent, value); }
 125                         remove { events.RemoveHandler(RemovedAsChildKernelEvent, value); }
 126                 }
 127
 128                 /// <summary>
 129                 /// Pending
 130                 /// </summary>
 131                 /// <value></value>
 132                 public event ComponentModelDelegate ComponentModelCreated
 133                 {
 134                         add { events.AddHandler(ComponentModelCreatedEvent, value); }
 135                         remove { events.RemoveHandler(ComponentModelCreatedEvent, value); }
 136                 }
 137
 138                 public event DependencyDelegate DependencyResolving
 139                 {
 140                         add { events.AddHandler(DependencyResolvingEvent, value); }
 141                         remove { events.RemoveHandler(DependencyResolvingEvent, value); }
 142                 }
 143
 144                 protected virtual void RaiseComponentRegistered(String key, IHandler handler)
 145                 {
 146                         ComponentDataDelegate eventDelegate = (ComponentDataDelegate) events[ComponentRegisteredEvent];
 147                         if (eventDelegate != null) eventDelegate(key, handler);
 148                 }
 149
 150
 151                 protected virtual void RaiseComponentUnregistered(String key, IHandler handler)
 152                 {
 153                         ComponentDataDelegate eventDelegate = (ComponentDataDelegate) events[ComponentUnregisteredEvent];
 154                         if (eventDelegate != null) eventDelegate(key, handler);
 155                 }
 156
 157                 public virtual void RaiseComponentCreated(ComponentModel model, object instance)
 158                 {
 159                         ComponentInstanceDelegate eventDelegate = (ComponentInstanceDelegate) events[ComponentCreatedEvent];
 160                         if (eventDelegate != null) eventDelegate(model, instance);
 161                 }
 162
 163                 public virtual void RaiseComponentDestroyed(ComponentModel model, object instance)
 164                 {
 165                         ComponentInstanceDelegate eventDelegate = (ComponentInstanceDelegate) events[ComponentDestroyedEvent];
 166                         if (eventDelegate != null) eventDelegate(model, instance);
 167                 }
 168
 169                 protected virtual void RaiseAddedAsChildKernel()
 170                 {
 171                         EventHandler eventDelegate = (EventHandler) events[AddedAsChildKernelEvent];
 172                         if (eventDelegate != null) eventDelegate(this, EventArgs.Empty);
 173                 }
 174
 175                 protected virtual void RaiseRemovedAsChildKernel()
 176                 {
 177                         EventHandler eventDelegate = (EventHandler) events[RemovedAsChildKernelEvent];
 178                         if (eventDelegate != null) eventDelegate(this, EventArgs.Empty);
 179                 }
 180
 181                 protected virtual void RaiseComponentModelCreated(ComponentModel model)
 182                 {
 183                         ComponentModelDelegate eventDelegate = (ComponentModelDelegate) events[ComponentModelCreatedEvent];
 184                         if (eventDelegate != null) eventDelegate(model);
 185                 }
 186
 187                 public virtual void RaiseHandlerRegistered(IHandler handler)
 188                 {
 189                         bool stateChanged = true;
 190
 191                         while(stateChanged)
 192                         {
 193                                 stateChanged = false;
 194                                 HandlerDelegate eventDelegate = (HandlerDelegate) events[HandlerRegisteredEvent];
 195                                 if (eventDelegate != null) eventDelegate(handler, ref stateChanged);
 196                         }
 197                 }
 198                 protected virtual void RaiseDependencyResolving(ComponentModel client, DependencyModel model, Object dependency)
 199                 {
 200                         DependencyDelegate eventDelegate = (DependencyDelegate) events[DependencyResolvingEvent];
 201                         if (eventDelegate != null) eventDelegate(client, model, dependency);
 202                 }
 203
 204                 #region IDeserializationCallback Members
 205
 206                 public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
 207                 {
 208                         info.AddValue("HandlerRegisteredEvent", events[HandlerRegisteredEvent]);
 209                 }
 210
 211                 #endregion
 212         }
 213 }