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