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