Core/Castle.Core/Model/ComponentModel.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.Core
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Specialized;
  20         using System.Diagnostics;
  21         using Castle.Core.Configuration;
  22
  23         #region Enums
  24
  25         /// <summary>
  26         /// Enumeration used to mark the component's lifestyle.
  27         /// </summary>
  28         public enum LifestyleType
  29         {
  30                 /// <summary>
  31                 /// No lifestyle specified.
  32                 /// </summary>
  33                 Undefined,
  34                 /// <summary>
  35                 /// Singleton components are instantiated once, and shared
  36                 /// between all clients.
  37                 /// </summary>
  38                 Singleton,
  39                 /// <summary>
  40                 /// Thread components have a unique instance per thread.
  41                 /// </summary>
  42                 Thread,
  43                 /// <summary>
  44                 /// Transient components are created on demand.
  45                 /// </summary>
  46                 Transient,
  47                 /// <summary>
  48                 /// Optimization of transient components that keeps
  49                 /// instance in a pool instead of always creating them.
  50                 /// </summary>
  51                 Pooled,
  52                 /// <summary>
  53                 /// Any other logic to create/release components.
  54                 /// </summary>
  55                 Custom,
  56                 /// <summary>
  57                 /// PerWebRequest components are created once per Http Request
  58                 /// </summary>
  59                 PerWebRequest
  60         }
  61
  62         /// <summary>
  63         ///
  64         /// </summary>
  65         public enum PropertiesInspectionBehavior
  66         {
  67                 Undefined,
  68                 None,
  69                 All,
  70                 DeclaredOnly
  71         }
  72
  73         #endregion
  74
  75         /// <summary>
  76         /// Represents the collection of information and
  77         /// meta information collected about a component.
  78         /// </summary>
  79         [DebuggerDisplay("{Implementation} / {Service}")]
  80         [Serializable]
  81         public sealed class ComponentModel : GraphNode
  82         {
  83                 public const string SkipRegistration = "skip.registration";
  84
  85                 #region Fields
  86                 // Note the use of volatile for fields used in the double checked lock pattern.
  87                 // This is necessary to ensure the pattern works correctly.
  88
  89                 /// <summary>Name (key) of the component</summary>
  90                 private String name;
  91
  92                 /// <summary>Service exposed</summary>
  93                 private Type service;
  94
  95                 /// <summary>Implementation for the service</summary>
  96                 private Type implementation;
  97
  98                 /// <summary>Extended properties</summary>
  99                 [NonSerialized] private volatile IDictionary extended;
 100
 101                 /// <summary>Lifestyle for the component</summary>
 102                 private LifestyleType lifestyleType;
 103
 104                 private PropertiesInspectionBehavior inspectionBehavior;
 105
 106                 /// <summary>Custom lifestyle, if any</summary>
 107                 private Type customLifestyle;
 108
 109                 /// <summary>Custom activator, if any</summary>
 110                 private Type customComponentActivator;
 111
 112                 /// <summary>Dependencies the kernel must resolve</summary>
 113                 private volatile DependencyModelCollection dependencies;
 114
 115                 /// <summary>All available constructors</summary>
 116                 private volatile ConstructorCandidateCollection constructors;
 117
 118                 /// <summary>All potential properties that can be setted by the kernel</summary>
 119                 private volatile PropertySetCollection properties;
 120
 121                 //private MethodMetaModelCollection methodMetaModels;
 122
 123                 /// <summary>Steps of lifecycle</summary>
 124                 private volatile LifecycleStepCollection lifecycleSteps;
 125
 126                 /// <summary>External parameters</summary>
 127                 private volatile ParameterModelCollection parameters;
 128
 129                 /// <summary>Configuration node associated</summary>
 130                 private IConfiguration configuration;
 131
 132                 /// <summary>Interceptors associated</summary>
 133                 private volatile InterceptorReferenceCollection interceptors;
 134
 135                 /// <summary>/// Custom dependencies/// </summary>
 136                 [NonSerialized] private IDictionary customDependencies;
 137
 138                 private bool requiresGenericArguments;
 139
 140                 #endregion
 141
 142                 /// <summary>
 143                 /// Constructs a ComponentModel
 144                 /// </summary>
 145                 public ComponentModel(String name, Type service, Type implementation)
 146                 {
 147                         this.name = name;
 148                         this.service = service;
 149                         this.implementation = implementation;
 150                         lifestyleType = LifestyleType.Undefined;
 151                         inspectionBehavior = PropertiesInspectionBehavior.Undefined;
 152                 }
 153
 154                 /// <summary>
 155                 /// Sets or returns the component key
 156                 /// </summary>
 157                 public String Name
 158                 {
 159                         get { return name; }
 160                         set { name = value; }
 161                 }
 162
 163                 /// <summary>
 164                 /// Gets or sets the service exposed.
 165                 /// </summary>
 166                 /// <value>The service.</value>
 167                 public Type Service
 168                 {
 169                         get { return service; }
 170                         set { service = value; }
 171                 }
 172
 173                 /// <summary>
 174                 /// Gets or sets the component implementation.
 175                 /// </summary>
 176                 /// <value>The implementation.</value>
 177                 public Type Implementation
 178                 {
 179                         get { return implementation; }
 180                         set { implementation = value; }
 181                 }
 182
 183                 /// <summary>
 184                 /// Gets or sets a value indicating whether the component requires generic arguments.
 185                 /// </summary>
 186                 /// <value>
 187                 /// <c>true</c> if generic arguments are required; otherwise, <c>false</c>.
 188                 /// </value>
 189                 public bool RequiresGenericArguments
 190                 {
 191                         get { return requiresGenericArguments; }
 192                         set { requiresGenericArguments = value; }
 193                 }
 194
 195                 /// <summary>
 196                 /// Gets or sets the extended properties.
 197                 /// </summary>
 198                 /// <value>The extended properties.</value>
 199                 public IDictionary ExtendedProperties
 200                 {
 201                         get
 202                         {
 203                                 if (extended == null)
 204                                 {
 205                                         lock (this)
 206                                         {
 207                                                 if (extended == null) extended = new HybridDictionary();
 208                                         }
 209                                 }
 210                                 return extended;
 211                         }
 212                         set { extended = value; }
 213                 }
 214
 215                 /// <summary>
 216                 /// Gets the constructors candidates.
 217                 /// </summary>
 218                 /// <value>The constructors.</value>
 219                 public ConstructorCandidateCollection Constructors
 220                 {
 221                         get
 222                         {
 223                                 if (constructors == null)
 224                                 {
 225                                         lock (this)
 226                                         {
 227                                                 if (constructors == null) constructors = new ConstructorCandidateCollection();
 228                                         }
 229                                 }
 230                                 return constructors;
 231                         }
 232                 }
 233
 234                 /// <summary>
 235                 /// Gets the properties set.
 236                 /// </summary>
 237                 /// <value>The properties.</value>
 238                 public PropertySetCollection Properties
 239                 {
 240                         get
 241                         {
 242                                 if (properties == null)
 243                                 {
 244                                         lock (this)
 245                                         {
 246                                                 if (properties == null) properties = new PropertySetCollection();
 247                                         }
 248                                 }
 249                                 return properties;
 250                         }
 251                 }
 252
 253                 /// <summary>
 254                 /// Gets or sets the configuration.
 255                 /// </summary>
 256                 /// <value>The configuration.</value>
 257                 public IConfiguration Configuration
 258                 {
 259                         get { return configuration; }
 260                         set { configuration = value; }
 261                 }
 262
 263                 /// <summary>
 264                 /// Gets the lifecycle steps.
 265                 /// </summary>
 266                 /// <value>The lifecycle steps.</value>
 267                 public LifecycleStepCollection LifecycleSteps
 268                 {
 269                         get
 270                         {
 271                                 if (lifecycleSteps == null)
 272                                 {
 273                                         lock (this)
 274                                         {
 275                                                 if (lifecycleSteps == null) lifecycleSteps = new LifecycleStepCollection();
 276                                         }
 277                                 }
 278                                 return lifecycleSteps;
 279                         }
 280                 }
 281
 282                 /// <summary>
 283                 /// Gets or sets the lifestyle type.
 284                 /// </summary>
 285                 /// <value>The type of the lifestyle.</value>
 286                 public LifestyleType LifestyleType
 287                 {
 288                         get { return lifestyleType; }
 289                         set { lifestyleType = value; }
 290                 }
 291
 292                 /// <summary>
 293                 /// Gets or sets the strategy for
 294                 /// inspecting public properties
 295                 /// on the components
 296                 /// </summary>
 297                 public PropertiesInspectionBehavior InspectionBehavior
 298                 {
 299                         get { return inspectionBehavior; }
 300                         set { inspectionBehavior = value; }
 301                 }
 302
 303                 /// <summary>
 304                 /// Gets or sets the custom lifestyle.
 305                 /// </summary>
 306                 /// <value>The custom lifestyle.</value>
 307                 public Type CustomLifestyle
 308                 {
 309                         get { return customLifestyle; }
 310                         set { customLifestyle = value; }
 311                 }
 312
 313                 /// <summary>
 314                 /// Gets or sets the custom component activator.
 315                 /// </summary>
 316                 /// <value>The custom component activator.</value>
 317                 public Type CustomComponentActivator
 318                 {
 319                         get { return customComponentActivator; }
 320                         set { customComponentActivator = value; }
 321                 }
 322
 323                 /// <summary>
 324                 /// Gets the interceptors.
 325                 /// </summary>
 326                 /// <value>The interceptors.</value>
 327                 public InterceptorReferenceCollection Interceptors
 328                 {
 329                         get
 330                         {
 331                                 if (interceptors == null)
 332                                 {
 333                                         lock (this)
 334                                         {
 335                                                 if (interceptors == null) interceptors = new InterceptorReferenceCollection();
 336                                         }
 337                                 }
 338                                 return interceptors;
 339                         }
 340                 }
 341
 342                 /// <summary>
 343                 /// Gets the parameter collection.
 344                 /// </summary>
 345                 /// <value>The parameters.</value>
 346                 public ParameterModelCollection Parameters
 347                 {
 348                         get
 349                         {
 350                                 if (parameters == null)
 351                                 {
 352                                         lock (this)
 353                                         {
 354                                                 if (parameters == null) parameters = new ParameterModelCollection();
 355                                         }
 356                                 }
 357                                 return parameters;
 358                         }
 359                 }
 360
 361                 /// <summary>
 362                 /// Dependencies are kept within constructors and
 363                 /// properties. Others dependencies must be
 364                 /// registered here, so the kernel (as a matter
 365                 /// of fact the handler) can check them
 366                 /// </summary>
 367                 public DependencyModelCollection Dependencies
 368                 {
 369                         get
 370                         {
 371                                 if (dependencies == null)
 372                                 {
 373                                         lock (this)
 374                                         {
 375                                                 if (dependencies == null) dependencies = new DependencyModelCollection();
 376                                         }
 377                                 }
 378                                 return dependencies;
 379                         }
 380                 }
 381
 382                 /// <summary>
 383                 /// Gets or sets the custom dependencies.
 384                 /// </summary>
 385                 /// <value>The custom dependencies.</value>
 386                 public IDictionary CustomDependencies
 387                 {
 388                         get
 389                         {
 390                                 lock (this)
 391                                 {
 392                                         if (customDependencies == null) customDependencies = new HybridDictionary();
 393                                 }
 394                                 return customDependencies;
 395                         }
 396                         set { customDependencies = value; }
 397                 }
 398         }
 399 }