InversionOfControl/Castle.MicroKernel/ComponentActivator/DefaultComponentActivator.cs

   1 // Copyright 2004-2007 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.ComponentActivator
  16 {
  17         using System;
  18         using System.Reflection;
  19         using System.Runtime.Remoting;
  20         using Castle.Core;
  21         using Castle.Core.Interceptor;
  22         using Castle.MicroKernel.LifecycleConcerns;
  23
  24         /// <summary>
  25         /// Standard implementation of <see cref="IComponentActivator"/>.
  26         /// Handles the selection of the best constructor, fills the
  27         /// writable properties the component exposes, run the commission
  28         /// and decommission lifecycles, etc.
  29         /// </summary>
  30         /// <remarks>
  31         /// Custom implementors can just override the <c>CreateInstance</c> method.
  32         /// Please note however that the activator is responsible for the proxy creation
  33         /// when needed.
  34         /// </remarks>
  35         [Serializable]
  36         public class DefaultComponentActivator : AbstractComponentActivator
  37         {
  38                 /// <summary>
  39                 /// Initializes a new instance of the <see cref="DefaultComponentActivator"/> class.
  40                 /// </summary>
  41                 /// <param name="model"></param>
  42                 /// <param name="kernel"></param>
  43                 /// <param name="onCreation"></param>
  44                 /// <param name="onDestruction"></param>
  45                 public DefaultComponentActivator(ComponentModel model, IKernel kernel,
  46                                                                                  ComponentInstanceDelegate onCreation,
  47                                                                                  ComponentInstanceDelegate onDestruction)
  48                         : base(model, kernel, onCreation, onDestruction)
  49                 {
  50                 }
  51
  52                 #region AbstractComponentActivator Members
  53
  54                 protected override object InternalCreate(CreationContext context)
  55                 {
  56                         object instance = Instantiate(context);
  57
  58                         SetUpProperties(instance, context);
  59
  60                         ApplyCommissionConcerns(instance);
  61
  62                         return instance;
  63                 }
  64
  65                 protected override void InternalDestroy(object instance)
  66                 {
  67                         ApplyDecommissionConcerns(instance);
  68                 }
  69
  70                 #endregion
  71
  72                 protected virtual object Instantiate(CreationContext context)
  73                 {
  74                         ConstructorCandidate candidate = SelectEligibleConstructor(context);
  75
  76                         Type[] signature;
  77                         object[] arguments = CreateConstructorArguments(candidate, context, out signature);
  78
  79                         return CreateInstance(context, arguments, signature);
  80                 }
  81
  82                 protected virtual object CreateInstance(CreationContext context, object[] arguments, Type[] signature)
  83                 {
  84                         object instance = null;
  85
  86                         Type implType = Model.Implementation;
  87
  88                         bool createProxy = Model.Interceptors.HasInterceptors;
  89                         bool createInstance = true;
  90
  91                         if (createProxy)
  92                         {
  93                                 createInstance = Kernel.ProxyFactory.RequiresTargetInstance(Kernel, Model);
  94                         }
  95
  96                         if (createInstance)
  97                         {
  98                                 try
  99                                 {
 100                                         ConstructorInfo cinfo = implType.GetConstructor(
 101                                                 BindingFlags.Public | BindingFlags.Instance, null, signature, null);
 102
 103                                         instance = System.Runtime.Serialization.FormatterServices.GetUninitializedObject(implType);
 104
 105                                         cinfo.Invoke(instance, arguments);
 106                                 }
 107                                 catch (Exception ex)
 108                                 {
 109                                         throw new ComponentActivatorException(
 110                                                 "ComponentActivator: could not instantiate " + Model.Implementation.FullName, ex);
 111                                 }
 112                         }
 113
 114                         if (createProxy)
 115                         {
 116                                 try
 117                                 {
 118                                         instance = Kernel.ProxyFactory.Create(Kernel, instance, Model, arguments);
 119                                 }
 120                                 catch (Exception ex)
 121                                 {
 122                                         throw new ComponentActivatorException("ComponentActivator: could not proxy " + Model.Implementation.FullName, ex);
 123                                 }
 124                         }
 125
 126                         return instance;
 127                 }
 128
 129                 protected virtual void ApplyCommissionConcerns(object instance)
 130                 {
 131                         instance = GetUnproxiedInstance(instance);
 132                         object[] steps = Model.LifecycleSteps.GetCommissionSteps();
 133                         ApplyConcerns(steps, instance);
 134                 }
 135
 136                 protected virtual void ApplyDecommissionConcerns(object instance)
 137                 {
 138                         instance = GetUnproxiedInstance(instance);
 139                         object[] steps = Model.LifecycleSteps.GetDecommissionSteps();
 140                         ApplyConcerns(steps, instance);
 141                 }
 142
 143                 protected virtual void ApplyConcerns(object[] steps, object instance)
 144                 {
 145                         foreach(ILifecycleConcern concern in steps)
 146                         {
 147                                 concern.Apply(Model, instance);
 148                         }
 149                 }
 150
 151                 protected virtual ConstructorCandidate SelectEligibleConstructor(CreationContext context)
 152                 {
 153                         if (Model.Constructors.Count == 0)
 154                         {
 155                                 // This is required by some facilities
 156                                 return null;
 157                         }
 158
 159                         if (Model.Constructors.Count == 1)
 160                         {
 161                                 return Model.Constructors.FewerArgumentsCandidate;
 162                         }
 163
 164                         ConstructorCandidate winnerCandidate = null;
 165
 166                         int winnerPoints = 0;
 167
 168                         foreach(ConstructorCandidate candidate in Model.Constructors)
 169                         {
 170                                 int candidatePoints = 0;
 171
 172                                 foreach(DependencyModel dep in candidate.Dependencies)
 173                                 {
 174                                         if (CanSatisfyDependency(context, dep))
 175                                         {
 176                                                 candidatePoints += 2;
 177                                         }
 178                                         else
 179                                         {
 180                                                 candidatePoints -= 2;
 181                                         }
 182                                 }
 183
 184                                 if (winnerCandidate == null || winnerPoints < candidatePoints)
 185                                 {
 186                                         winnerCandidate = candidate;
 187                                         winnerPoints = candidatePoints;
 188                                 }
 189                         }
 190
 191                         if (winnerCandidate == null)
 192                         {
 193                                 throw new ComponentActivatorException("Could not find eligible constructor for " + Model.Implementation.FullName);
 194                         }
 195
 196                         return winnerCandidate;
 197                 }
 198
 199                 protected virtual bool CanSatisfyDependency(CreationContext context, DependencyModel dep)
 200                 {
 201                         return Kernel.Resolver.CanResolve(context, context.Handler, Model, dep);
 202                 }
 203
 204                 protected virtual object[] CreateConstructorArguments(
 205                         ConstructorCandidate constructor, CreationContext context, out Type[] signature)
 206                 {
 207                         signature = null;
 208
 209                         if (constructor == null) return new object[0];
 210
 211                         object[] arguments = new object[constructor.Constructor.GetParameters().Length];
 212                         signature = new Type[arguments.Length];
 213
 214                         int index = 0;
 215
 216                         foreach (DependencyModel dependency in constructor.Dependencies)
 217                         {
 218                                 object value;
 219                                 using (new DependencyTrackingScope(context, Model, constructor.Constructor, dependency))
 220                                 {
 221                                         value = Kernel.Resolver.Resolve(context, context.Handler, Model, dependency);
 222                                 }
 223                                 arguments[index] = value;
 224                                 signature[index++] = dependency.TargetType;
 225                         }
 226
 227                         return arguments;
 228                 }
 229
 230                 protected virtual void SetUpProperties(object instance, CreationContext context)
 231                 {
 232                         instance = GetUnproxiedInstance(instance);
 233
 234                         foreach (PropertySet property in Model.Properties)
 235                         {
 236                                 object value = null;
 237
 238                                 using (new DependencyTrackingScope(context, Model, property.Property, property.Dependency))
 239                                 {
 240                                         if (Kernel.Resolver.CanResolve(context, context.Handler, Model, property.Dependency))
 241                                         {
 242                                                 value = Kernel.Resolver.Resolve(context, context.Handler, Model, property.Dependency);
 243                                         }
 244                                 }
 245
 246                                 if (value == null) continue;
 247
 248                                 MethodInfo setMethod = property.Property.GetSetMethod();
 249
 250                                 try
 251                                 {
 252                                         setMethod.Invoke(instance, new object[] { value });
 253                                 }
 254                                 catch (Exception ex)
 255                                 {
 256                                         String message =
 257                                                 String.Format(
 258                                                         "Error setting property {0} on type {1}, Component id is {2}. See inner exception for more information.",
 259                                                         setMethod.Name, instance.GetType().FullName, Model.Name);
 260                                         throw new ComponentActivatorException(message, ex);
 261                                 }
 262                         }
 263                 }
 264
 265                 private static object GetUnproxiedInstance(object instance)
 266                 {
 267                         if (!RemotingServices.IsTransparentProxy(instance))
 268                         {
 269                                 IProxyTargetAccessor accessor = instance as IProxyTargetAccessor;
 270
 271                                 if (accessor != null)
 272                                 {
 273                                         instance = accessor.DynProxyGetTarget();
 274                                 }
 275                         }
 276
 277                         return instance;
 278                 }
 279         }
 280 }