InversionOfControl/Castle.MicroKernel/Resolvers/DefaultDependencyResolver.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.Resolvers
  16 {
  17         using System;
  18         using System.Collections;
  19         using Castle.Core;
  20         using Castle.MicroKernel.SubSystems.Conversion;
  21         using Castle.MicroKernel.Util;
  22
  23         /// <summary>
  24         /// Default implementation for <see cref="IDependencyResolver"/>.
  25         /// This implementation is quite simple, but still should be useful
  26         /// for 99% of situations.
  27         /// </summary>
  28         [Serializable]
  29         public class DefaultDependencyResolver : IDependencyResolver
  30         {
  31                 private readonly IKernel kernel;
  32                 private readonly ITypeConverter converter;
  33                 private DependencyDelegate dependencyResolvingDelegate;
  34                 private IList subResolvers = new ArrayList();
  35
  36                 /// <summary>
  37                 /// Initializes a new instance of the <see cref="DefaultDependencyResolver"/> class.
  38                 /// </summary>
  39                 /// <param name="kernel">The kernel.</param>
  40                 public DefaultDependencyResolver(IKernel kernel)
  41                 {
  42                         this.kernel = kernel;
  43
  44                         converter = (ITypeConverter)kernel.GetSubSystem(SubSystemConstants.ConversionManagerKey);
  45                 }
  46
  47                 /// <summary>
  48                 /// Initializes this instance with the specified dependency delegate.
  49                 /// </summary>
  50                 /// <param name="dependencyDelegate">The dependency delegate.</param>
  51                 public void Initialize(DependencyDelegate dependencyDelegate)
  52                 {
  53                         dependencyResolvingDelegate = dependencyDelegate;
  54                 }
  55
  56                 /// <summary>
  57                 /// Registers a sub resolver instance
  58                 /// </summary>
  59                 /// <param name="subResolver">The subresolver instance</param>
  60                 public void AddSubResolver(ISubDependencyResolver subResolver)
  61                 {
  62                         if (subResolver == null) throw new ArgumentNullException("subResolver");
  63
  64                         subResolvers.Add(subResolver);
  65                 }
  66
  67                 /// <summary>
  68                 /// Unregisters a sub resolver instance previously registered
  69                 /// </summary>
  70                 /// <param name="subResolver">The subresolver instance</param>
  71                 public void RemoveSubResolver(ISubDependencyResolver subResolver)
  72                 {
  73                         if (subResolver == null) throw new ArgumentNullException("subResolver");
  74
  75                         subResolvers.Remove(subResolver);
  76                 }
  77
  78                 /// <summary>
  79                 /// Returns true if the resolver is able to satisfy the specified dependency.
  80                 /// </summary>
  81                 /// <param name="context">Creation context, which is a resolver itself</param>
  82                 /// <param name="parentResolver">Parent resolver</param>
  83                 /// <param name="model">Model of the component that is requesting the dependency</param>
  84                 /// <param name="dependency">The dependency model</param>
  85                 /// <returns><c>true</c> if the dependency can be satisfied</returns>
  86                 public bool CanResolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model,
  87                                                            DependencyModel dependency)
  88                 {
  89                         // 1 - check for the dependency on CreationContext, if present
  90
  91                         if (context != null)
  92                         {
  93                                 if (context.CanResolve(context, parentResolver, model, dependency))
  94                                 {
  95                                         return true;
  96                                 }
  97                         }
  98
  99                         // 2 - check with the model's handler, if not the same as the parent resolver
 100
 101                         IHandler handler = kernel.GetHandler(model.Name);
 102
 103                         if (handler != null && handler != parentResolver)
 104                         {
 105                                 if (handler.CanResolve(context, parentResolver, model, dependency))
 106                                 {
 107                                         return true;
 108                                 }
 109                         }
 110
 111                         // 3 - check within parent resolver, if present
 112
 113                         if (parentResolver != null)
 114                         {
 115                                 if (parentResolver.CanResolve(context, parentResolver, model, dependency))
 116                                 {
 117                                         return true;
 118                                 }
 119                         }
 120
 121                         // 4 - check within subresolvers
 122
 123                         foreach (ISubDependencyResolver subResolver in subResolvers)
 124                         {
 125                                 if (subResolver.CanResolve(context, parentResolver, model, dependency))
 126                                 {
 127                                         return true;
 128                                 }
 129                         }
 130
 131                         // 5 - normal flow, checking against the kernel
 132
 133                         if (dependency.DependencyType == DependencyType.Service ||
 134                                 dependency.DependencyType == DependencyType.ServiceOverride)
 135                         {
 136                                 return CanResolveServiceDependency(context, model, dependency);
 137                         }
 138                         else
 139                         {
 140                                 return CanResolveParameterDependency(model, dependency);
 141                         }
 142                 }
 143
 144                 /// <summary>
 145                 /// Try to resolve the dependency by checking the parameters in
 146                 /// the model or checking the Kernel for the requested service.
 147                 /// </summary>
 148                 /// <remarks>
 149                 /// The dependency resolver has the following precedence order:
 150                 /// <list type="bullet">
 151                 /// <item><description>
 152                 /// The dependency is checked within the <see cref="CreationContext"/>
 153                 /// </description></item>
 154                 /// <item><description>
 155                 /// The dependency is checked within the <see cref="IHandler"/> instance for the component
 156                 /// </description></item>
 157                 /// <item><description>
 158                 /// The dependency is checked within the registered <see cref="ISubDependencyResolver"/>s
 159                 /// </description></item>
 160                 /// <item><description>
 161                 /// Finally the resolver tries the normal flow
 162                 /// which is using the configuration
 163                 /// or other component to satisfy the dependency
 164                 /// </description></item>
 165                 /// </list>
 166                 /// </remarks>
 167                 /// <param name="context">Creation context, which is a resolver itself</param>
 168                 /// <param name="parentResolver">Parent resolver</param>
 169                 /// <param name="model">Model of the component that is requesting the dependency</param>
 170                 /// <param name="dependency">The dependency model</param>
 171                 /// <returns>The dependency resolved value or null</returns>
 172                 public object Resolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model,
 173                                                           DependencyModel dependency)
 174                 {
 175                         object value = null;
 176
 177                         bool resolved = false;
 178
 179                         // 1 - check for the dependency on CreationContext, if present
 180
 181                         if (context != null)
 182                         {
 183                                 if (context.CanResolve(context, parentResolver, model, dependency))
 184                                 {
 185                                         value = context.Resolve(context, parentResolver, model, dependency);
 186                                         resolved = true;
 187                                 }
 188                         }
 189
 190                         // 2 - check with the model's handler, if not the same as the parent resolver
 191
 192                         IHandler handler = kernel.GetHandler(model.Name);
 193
 194                         if (!resolved && handler != parentResolver)
 195                         {
 196                                 if (handler.CanResolve(context, parentResolver, model, dependency))
 197                                 {
 198                                         value = handler.Resolve(context, parentResolver, model, dependency);
 199                                         resolved = true;
 200                                 }
 201                         }
 202
 203                         // 3 - check within parent resolver, if present
 204
 205                         if (!resolved && parentResolver != null)
 206                         {
 207                                 if (parentResolver.CanResolve(context, parentResolver, model, dependency))
 208                                 {
 209                                         value = parentResolver.Resolve(context, parentResolver, model, dependency);
 210                                         resolved = true;
 211                                 }
 212                         }
 213
 214                         // 4 - check within subresolvers
 215
 216                         if (!resolved)
 217                         {
 218                                 foreach (ISubDependencyResolver subResolver in subResolvers)
 219                                 {
 220                                         if (subResolver.CanResolve(context, parentResolver, model, dependency))
 221                                         {
 222                                                 value = subResolver.Resolve(context, parentResolver, model, dependency);
 223                                                 resolved = true;
 224                                                 break;
 225                                         }
 226                                 }
 227                         }
 228
 229                         // 5 - normal flow, checking against the kernel
 230
 231                         if (!resolved)
 232                         {
 233                                 if (dependency.DependencyType == DependencyType.Service ||
 234                                         dependency.DependencyType == DependencyType.ServiceOverride)
 235                                 {
 236                                         value = ResolveServiceDependency(context, model, dependency);
 237                                 }
 238                                 else
 239                                 {
 240                                         value = ResolveParameterDependency(context, model, dependency);
 241                                 }
 242                         }
 243
 244                         if (value == null && !dependency.IsOptional)
 245                         {
 246                                 String implementation = String.Empty;
 247
 248                                 if (model.Implementation != null)
 249                                 {
 250                                         implementation = model.Implementation.FullName;
 251                                 }
 252
 253                                 String message = String.Format(
 254                                         "Could not resolve non-optional dependency for '{0}' ({1}). Parameter '{2}' type '{3}'",
 255                                         model.Name, implementation, dependency.DependencyKey, dependency.TargetType.FullName);
 256
 257                                 throw new DependencyResolverException(message);
 258                         }
 259
 260                         RaiseDependencyResolving(model, dependency, value);
 261
 262                         return value;
 263                 }
 264
 265                 protected virtual bool CanResolveServiceDependency(CreationContext context, ComponentModel model, DependencyModel dependency)
 266                 {
 267                         if (dependency.DependencyType == DependencyType.ServiceOverride)
 268                         {
 269                                 return HasComponentInValidState(dependency.DependencyKey);
 270                         }
 271
 272                         ParameterModel parameter = ObtainParameterModelMatchingDependency(dependency, model);
 273
 274                         if (parameter != null)
 275                         {
 276                                 // User wants to override
 277
 278                                 String value = ExtractComponentKey(parameter.Value, parameter.Name);
 279
 280                                 return HasComponentInValidState(value);
 281                         }
 282                         else if (dependency.TargetType == typeof(IKernel))
 283                         {
 284                                 return true;
 285                         }
 286                         else
 287                         {
 288                                 // Default behaviour
 289
 290                                 if (dependency.TargetType != null)
 291                                 {
 292                                         return HasComponentInValidState(context, dependency.TargetType);
 293                                 }
 294                                 else
 295                                 {
 296                                         return HasComponentInValidState(dependency.DependencyKey);
 297                                 }
 298                         }
 299                 }
 300
 301                 protected virtual bool CanResolveParameterDependency(ComponentModel model, DependencyModel dependency)
 302                 {
 303                         ParameterModel parameter = ObtainParameterModelMatchingDependency(dependency, model);
 304
 305                         return parameter != null;
 306                 }
 307
 308                 protected virtual object ResolveServiceDependency(CreationContext context, ComponentModel model,
 309                                                                                                                   DependencyModel dependency)
 310                 {
 311                         IHandler handler = null;
 312
 313                         if (dependency.DependencyType == DependencyType.Service)
 314                         {
 315                                 ParameterModel parameter = ObtainParameterModelMatchingDependency(dependency, model);
 316
 317                                 if (parameter != null)
 318                                 {
 319                                         // User wants to override, we then
 320                                         // change the type to ServiceOverride
 321
 322                                         dependency.DependencyKey = ExtractComponentKey(parameter.Value, parameter.Name);
 323                                         dependency.DependencyType = DependencyType.ServiceOverride;
 324                                 }
 325                         }
 326
 327                         if (dependency.TargetType == typeof(IKernel))
 328                         {
 329                                 return kernel;
 330                         }
 331                         else
 332                         {
 333                                 if (dependency.DependencyType == DependencyType.ServiceOverride)
 334                                 {
 335                                         handler = kernel.GetHandler(dependency.DependencyKey);
 336                                 }
 337                                 else
 338                                 {
 339                                         handler = TryGetHandlerFromKernel(dependency, context);
 340
 341                                         if (handler == null)
 342                                         {
 343                                                 throw new DependencyResolverException(
 344                                                         "Cycle detected in configuration.\r\n" +
 345                                                         "Component " + model.Name + " has a dependency on " +
 346                                                         dependency.TargetType + ", but it doesn't provide an override.\r\n" +
 347                                                         "You must provide an override if a component " +
 348                                                         "has a dependency on a service that it - itself - provides");
 349                                         }
 350                                 }
 351                         }
 352
 353                         if (handler == null) return null;
 354
 355                         context = RebuildContextForParameter(context, dependency.TargetType);
 356
 357                         return handler.Resolve(context);
 358                 }
 359
 360                 private IHandler TryGetHandlerFromKernel(DependencyModel dependency, CreationContext context)
 361                 {
 362                         // we are doing it in two stages because it is likely to be faster to a lookup
 363                         // by key than a linear search
 364                         IHandler handler = kernel.GetHandler(dependency.TargetType);
 365                         if (context.HandlerIsCurrentlyBeingResolved(handler) == false)
 366                                 return handler;
 367
 368                         // make a best effort to find another one that fit
 369
 370                         IHandler[] handlers = kernel.GetHandlers(dependency.TargetType);
 371
 372                         foreach (IHandler maybeCorrectHandler in handlers)
 373                         {
 374                                 if (context.HandlerIsCurrentlyBeingResolved(maybeCorrectHandler) == false)
 375                                 {
 376                                         handler = maybeCorrectHandler;
 377                                         break;
 378                                 }
 379                         }
 380                         return handler;
 381                 }
 382
 383                 protected virtual object ResolveParameterDependency(CreationContext context, ComponentModel model,
 384                                                                                                                         DependencyModel dependency)
 385                 {
 386                         ParameterModel parameter = ObtainParameterModelMatchingDependency(dependency, model);
 387
 388                         if (parameter != null)
 389                         {
 390                                 converter.Context.PushModel(model);
 391
 392                                 try
 393                                 {
 394                                         if (parameter.Value != null || parameter.ConfigValue == null)
 395                                         {
 396                                                 return converter.PerformConversion(parameter.Value, dependency.TargetType);
 397                                         }
 398                                         else
 399                                         {
 400                                                 return converter.PerformConversion(parameter.ConfigValue, dependency.TargetType);
 401                                         }
 402                                 }
 403                                 finally
 404                                 {
 405                                         converter.Context.PopModel();
 406                                 }
 407                         }
 408
 409                         return null;
 410                 }
 411
 412                 protected virtual ParameterModel ObtainParameterModelMatchingDependency(DependencyModel dependency,
 413                                                                                                                                                                 ComponentModel model)
 414                 {
 415                         String key = dependency.DependencyKey;
 416
 417                         if (key == null) return null;
 418
 419                         return model.Parameters[key];
 420                 }
 421
 422                 /// <summary>
 423                 /// Extracts the component name from the a ref strings which is
 424                 /// ${something}
 425                 /// </summary>
 426                 /// <param name="name"></param>
 427                 /// <param name="keyValue"></param>
 428                 /// <returns></returns>
 429                 protected virtual String ExtractComponentKey(String keyValue, String name)
 430                 {
 431                         if (!ReferenceExpressionUtil.IsReference(keyValue))
 432                         {
 433                                 throw new DependencyResolverException(
 434                                         String.Format("Key invalid for parameter {0}. " +
 435                                                                   "Thus the kernel was unable to override the service dependency", name));
 436                         }
 437
 438                         return ReferenceExpressionUtil.ExtractComponentKey(keyValue);
 439                 }
 440
 441                 private void RaiseDependencyResolving(ComponentModel model, DependencyModel dependency, object value)
 442                 {
 443                         dependencyResolvingDelegate(model, dependency, value);
 444                 }
 445
 446                 private bool HasComponentInValidState(string key)
 447                 {
 448                         IHandler handler = kernel.GetHandler(key);
 449
 450                         return IsHandlerInValidState(handler);
 451                 }
 452
 453                 private bool HasComponentInValidState(CreationContext context, Type service)
 454                 {
 455                         IHandler[] handlers = kernel.GetHandlers(service);
 456
 457                         foreach (IHandler handler in handlers)
 458                         {
 459                                 if (context == null || context.HandlerIsCurrentlyBeingResolved(handler) == false)
 460                                         return IsHandlerInValidState(handler);
 461                         }
 462
 463                         return false;
 464                 }
 465
 466                 private static bool IsHandlerInValidState(IHandler handler)
 467                 {
 468                         if (handler != null)
 469                         {
 470                                 return handler.CurrentState == HandlerState.Valid;
 471                         }
 472
 473                         return false;
 474                 }
 475
 476                 /// <summary>
 477                 /// This method rebuild the context for the parameter type.
 478                 /// Naive implementation.
 479                 /// </summary>
 480                 private CreationContext RebuildContextForParameter(CreationContext current, Type parameterType)
 481                 {
 482                         if (parameterType.ContainsGenericParameters)
 483                         {
 484                                 return current;
 485                         }
 486                         else
 487                         {
 488                                 return new CreationContext(current.Handler, parameterType, current);
 489                         }
 490                 }
 491         }
 492 }