InversionOfControl/Castle.MicroKernel/Context/CreationContext.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.Collections;
  19         using System.Reflection;
  20         using System.Text;
  21
  22         using Castle.MicroKernel.Exceptions;
  23         using Castle.Core;
  24
  25         /// <summary>
  26         /// Used during a component request, passed along to the whole process.
  27         /// This allow some data to be passed along the process, which is used
  28         /// to detected cycled dependency graphs and now it's also being used
  29         /// to provide arguments to components.
  30         /// </summary>
  31         [Serializable]
  32         public sealed class CreationContext : MarshalByRefObject, ISubDependencyResolver
  33         {
  34                 /// <summary>Creates a new, empty <see cref="CreationContext" /> instance.</summary>
  35                 /// <remarks>A new CreationContext should be created every time, as the contexts keeps some state related to dependency resolution.</remarks>
  36                 public static CreationContext Empty
  37                 {
  38                         get { return new CreationContext(new DependencyModel[0]); }
  39                 }
  40
  41                 /// <summary>
  42                 ///
  43                 /// </summary>
  44                 private readonly IHandler handler;
  45
  46                 /// <summary>
  47                 /// The list of handlers that are used to resolve
  48                 /// the component.
  49                 /// We track that in order to try to avoid attempts to resolve a service
  50                 /// with itself.
  51                 /// </summary>
  52         private readonly ArrayList handlersChain = new ArrayList();
  53
  54                 private readonly IDictionary additionalArguments;
  55
  56                 /// <summary>
  57                 /// Holds the scoped dependencies being resolved.
  58                 /// If a dependency appears twice on the same scope, we'd have a cycle.
  59                 /// </summary>
  60                 private readonly DependencyModelCollection dependencies;
  61
  62                 private readonly Type[] genericArguments;
  63
  64                 public CreationContext(IHandler handler, IDictionary additionalArguments)
  65                 {
  66                         this.handler = handler;
  67                         this.additionalArguments = additionalArguments;
  68                         dependencies = new DependencyModelCollection();
  69                 }
  70
  71                 public CreationContext(DependencyModel[] dependencies)
  72                 {
  73                         handler = null;
  74                         this.dependencies = new DependencyModelCollection(dependencies);
  75                 }
  76
  77                 public CreationContext(IHandler handler, DependencyModelCollection dependencies, IList handlersChain)
  78                         : this(handler, (IDictionary)null)
  79                 {
  80                         this.dependencies = new DependencyModelCollection(dependencies);
  81             this.handlersChain.AddRange(handlersChain);
  82                 }
  83
  84                 public CreationContext(IHandler handler, Type typeToExtractGenericArguments, IDictionary additionalArguments)
  85                         : this(handler, additionalArguments)
  86                 {
  87                         genericArguments = ExtractGenericArguments(typeToExtractGenericArguments);
  88                 }
  89
  90                 public CreationContext(IHandler handler, Type typeToExtractGenericArguments,
  91                                                            CreationContext parentContext)
  92                         : this(handler, parentContext.Dependencies, parentContext.handlersChain)
  93                 {
  94                         additionalArguments = parentContext.additionalArguments;
  95                         genericArguments = ExtractGenericArguments(typeToExtractGenericArguments);
  96                 }
  97
  98                 #region ISubDependencyResolver
  99
 100                 public object Resolve(CreationContext context, ISubDependencyResolver parentResolver,
 101                                                           ComponentModel model, DependencyModel dependency)
 102                 {
 103                         if (additionalArguments != null)
 104                         {
 105                                 return additionalArguments[dependency.DependencyKey];
 106                         }
 107
 108                         return null;
 109                 }
 110
 111                 public bool CanResolve(CreationContext context, ISubDependencyResolver parentResolver,
 112                                                            ComponentModel model, DependencyModel dependency)
 113                 {
 114                         if (dependency.DependencyKey == null) return false;
 115
 116                         if (additionalArguments != null)
 117                         {
 118                                 return additionalArguments.Contains(dependency.DependencyKey);
 119                         }
 120
 121                         return false;
 122                 }
 123
 124                 #endregion
 125
 126                 public IDictionary AdditionalParameters
 127                 {
 128                         get { return additionalArguments; }
 129                 }
 130
 131                 public bool HasAdditionalParameters
 132                 {
 133                         get { return additionalArguments != null && additionalArguments.Count != 0; }
 134                 }
 135
 136                 /// <summary>
 137                 /// Pendent
 138                 /// </summary>
 139                 public IHandler Handler
 140                 {
 141                         get { return handler; }
 142                 }
 143
 144                 #region Cycle detection related members
 145
 146                 public DependencyModelCollection Dependencies
 147                 {
 148                         get { return dependencies; }
 149                 }
 150
 151                 #endregion
 152
 153                 public Type[] GenericArguments
 154                 {
 155                         get { return genericArguments; }
 156                 }
 157
 158                 private static Type[] ExtractGenericArguments(Type typeToExtractGenericArguments)
 159                 {
 160                         return typeToExtractGenericArguments.GetGenericArguments();
 161                 }
 162
 163                 /// <summary>
 164                 /// Check if we are now in the middle of resolving this handler,
 165                 /// and as such, we shouldn't try to resolve that.
 166                 /// </summary>
 167                 public bool HandlerIsCurrentlyBeingResolved(IHandler handlerToTest)
 168                 {
 169                         return handlersChain.Contains(handlerToTest);
 170                 }
 171
 172                 public IDisposable ResolvingHandler(IHandler handlerBeingResolved)
 173                 {
 174                         handlersChain.Add(handlerBeingResolved);
 175                         return new RemoveHandlerFromCurrentlyResolving(this, handlerBeingResolved);
 176                 }
 177
 178                 private class RemoveHandlerFromCurrentlyResolving : IDisposable
 179                 {
 180                         private readonly CreationContext parent;
 181                         private readonly IHandler handler;
 182
 183                         public RemoveHandlerFromCurrentlyResolving(CreationContext parent, IHandler handler)
 184                         {
 185                                 this.parent = parent;
 186                                 this.handler = handler;
 187                         }
 188
 189                         public void Dispose()
 190                         {
 191                                 parent.handlersChain.Remove(handler);
 192                         }
 193                 }
 194         }
 195 }