InversionOfControl/Castle.MicroKernel/Registration/ComponentRegiatration.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.Registration
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Generic;
  20         using Castle.Core;
  21         using Castle.Core.Configuration;
  22         using MicroKernel;
  23
  24         /// <summary>
  25         ///
  26         /// </summary>
  27         /// <typeparam name="S">The service type</typeparam>
  28         public class ComponentRegistration<S> : IComponentRegistration
  29         {
  30                 private String name;
  31                 private bool overwrite;
  32                 private readonly Type serviceType;
  33                 private Type classType;
  34                 private readonly List<ComponentDescriptor<S>> descriptors;
  35                 private ComponentModel componentModel;
  36
  37                 /// <summary>
  38                 /// Initializes a new instance of the <see cref="ComponentRegistration{S}"/> class.
  39                 /// </summary>
  40                 public ComponentRegistration()
  41                         : this(typeof(S))
  42                 {
  43                 }
  44
  45                 protected ComponentRegistration(Type serviceType)
  46                 {
  47                         overwrite = false;
  48                         this.serviceType = serviceType;
  49                         descriptors = new List<ComponentDescriptor<S>>();
  50                 }
  51
  52                 internal bool Overwrite
  53                 {
  54                         get { return overwrite; }
  55                 }
  56
  57                 /// <summary>
  58                 /// With the overwrite.
  59                 /// </summary>
  60                 /// <returns></returns>
  61                 public ComponentRegistration<S> OverWrite()
  62                 {
  63                         overwrite = true;
  64                         return this;
  65                 }
  66
  67                 /// <summary>
  68                 /// With the name.
  69                 /// </summary>
  70                 /// <param name="name">The name.</param>
  71                 /// <returns></returns>
  72                 public ComponentRegistration<S> Named(String name)
  73                 {
  74                         if (this.name != null)
  75                         {
  76                                 String message = String.Format("This component has " +
  77                                         "already been assigned name '{0}'", this.name);
  78
  79                                 throw new ComponentRegistrationException(message);
  80                         }
  81
  82                         this.name = name;
  83                         return this;
  84                 }
  85
  86                 public ComponentRegistration<S> ImplementedBy<C>()
  87                 {
  88                         return ImplementedBy(typeof(C));
  89                 }
  90
  91                 public ComponentRegistration<S> ImplementedBy(Type type)
  92                 {
  93                         if (classType != null)
  94                         {
  95                                 String message = String.Format("This component has " +
  96                                         "already been assigned implementation {0}", classType.FullName);
  97                                 throw new ComponentRegistrationException(message);
  98                         }
  99
 100                         classType = type;
 101                         return this;
 102                 }
 103
 104                 /// <summary>
 105                 /// With the instance.
 106                 /// </summary>
 107                 /// <param name="instance">The instance.</param>
 108                 /// <returns></returns>
 109                 public ComponentRegistration<S> Instance(S instance)
 110                 {
 111                         return AddDescriptor(new ComponentInstanceDescriptior<S>(instance));
 112                 }
 113
 114                 /// <summary>
 115                 /// Gets the proxy.
 116                 /// </summary>
 117                 /// <value>The proxy.</value>
 118                 public Proxy.ProxyGroup<S> Proxy
 119                 {
 120                         get { return new Proxy.ProxyGroup<S>(this); }
 121                 }
 122
 123                 /// <summary>
 124                 /// Gets the with lifestyle.
 125                 /// </summary>
 126                 /// <value>The with lifestyle.</value>
 127                 public Lifestyle.LifestyleGroup<S> LifeStyle
 128                 {
 129                         get { return new Lifestyle.LifestyleGroup<S>(this); }
 130                 }
 131
 132                 /// <summary>
 133                 /// With the activator.
 134                 /// </summary>
 135                 /// <returns></returns>
 136                 public ComponentRegistration<S> Activator<A>() where A : IComponentActivator
 137                 {
 138                         return AddAttributeDescriptor("componentActivatorType", typeof(A).AssemblyQualifiedName);
 139                 }
 140
 141                 /// <summary>
 142                 /// With the extended properties.
 143                 /// </summary>
 144                 /// <param name="properties">The properties.</param>
 145                 /// <returns></returns>
 146                 public ComponentRegistration<S> ExtendedProperties(params Property[] properties)
 147                 {
 148                         return AddDescriptor(new ExtendedPropertiesDescriptor<S>(properties));
 149                 }
 150
 151                 /// <summary>
 152                 /// With the extended properties.
 153                 /// </summary>
 154                 /// <param name="anonymous">The properties.</param>
 155                 /// <returns></returns>
 156                 public ComponentRegistration<S> ExtendedProperties(object anonymous)
 157                 {
 158                         return AddDescriptor(new ExtendedPropertiesDescriptor<S>(anonymous));
 159                 }
 160
 161                 /// <summary>
 162                 /// With the custom dependencies.
 163                 /// </summary>
 164                 /// <param name="dependencies">The dependencies.</param>
 165                 /// <returns></returns>
 166                 public ComponentRegistration<S> CustomDependencies(params Property[] dependencies)
 167                 {
 168                         return AddDescriptor(new CustomDependencyDescriptor<S>(dependencies));
 169                 }
 170
 171                 /// <summary>
 172                 /// With the custom dependencies.
 173                 /// </summary>
 174                 /// <param name="dependencies">The dependencies.</param>
 175                 /// <returns></returns>
 176                 public ComponentRegistration<S> CustomDependencies(IDictionary dependencies)
 177                 {
 178                         return AddDescriptor(new CustomDependencyDescriptor<S>(dependencies));
 179                 }
 180
 181                 /// <summary>
 182                 /// With the custom dependencies.
 183                 /// </summary>
 184                 /// <param name="anonymous">The dependencies.</param>
 185                 /// <returns></returns>
 186                 public ComponentRegistration<S> CustomDependencies(object anonymous)
 187                 {
 188                         return AddDescriptor(new CustomDependencyDescriptor<S>(anonymous));
 189                 }
 190
 191                 /// <summary>
 192                 /// With the service overrides.
 193                 /// </summary>
 194                 /// <param name="overrides">The overrides.</param>
 195                 /// <returns></returns>
 196                 public ComponentRegistration<S> ServiceOverrides(params ServiceOverride[] overrides)
 197                 {
 198                         return AddDescriptor(new ServiceOverrideDescriptor<S>(overrides));
 199                 }
 200
 201                 /// <summary>
 202                 /// With the service overrides.
 203                 /// </summary>
 204                 /// <param name="overrides">The overrides.</param>
 205                 /// <returns></returns>
 206                 public ComponentRegistration<S> ServiceOverrides(IDictionary overrides)
 207                 {
 208                         return AddDescriptor(new ServiceOverrideDescriptor<S>(overrides));
 209                 }
 210
 211                 /// <summary>
 212                 /// With the service overrides.
 213                 /// </summary>
 214                 /// <param name="anonymous">The overrides.</param>
 215                 /// <returns></returns>
 216                 public ComponentRegistration<S> ServiceOverrides(object anonymous)
 217                 {
 218                         return AddDescriptor(new ServiceOverrideDescriptor<S>(anonymous));
 219                 }
 220
 221                 /// <summary>
 222                 /// With the configuration parameters.
 223                 /// </summary>
 224                 /// <param name="parameters">The parameters.</param>
 225                 /// <returns></returns>
 226                 public ComponentRegistration<S> Parameters(params Parameter[] parameters)
 227                 {
 228                         return AddDescriptor(new ParametersDescriptor<S>(parameters));
 229                 }
 230
 231                 /// <summary>
 232                 /// With the interceptors.
 233                 /// </summary>
 234                 /// <param name="interceptors">The interceptors.</param>
 235                 /// <returns></returns>
 236                 public Interceptor.InterceptorGroup<S> Interceptors(
 237                                 params InterceptorReference[] interceptors)
 238                 {
 239                         return new Interceptor.InterceptorGroup<S>(this, interceptors);
 240                 }
 241
 242                 /// <summary>
 243                 /// Ases the startable.
 244                 /// </summary>
 245                 /// <returns></returns>
 246                 public ComponentRegistration<S> Startable()
 247                 {
 248                         return AddDescriptor(new ExtendedPropertiesDescriptor<S>(
 249                                                 Property.ForKey("startable").Eq(true)));
 250                 }
 251
 252                 /// <summary>
 253                 /// Registers this component with the <see cref="IKernel"/>.
 254                 /// </summary>
 255                 /// <param name="kernel">The kernel.</param>
 256                 void IComponentRegistration.Register(IKernel kernel)
 257                 {
 258                         if (componentModel == null)
 259                         {
 260                                 InitializeDefaults();
 261                                 componentModel = BuildComponentModel(kernel);
 262                                 kernel.AddCustomComponent(componentModel);
 263                         }
 264                 }
 265
 266                 /// <summary>
 267                 /// Builds the component model.
 268                 /// </summary>
 269                 /// <returns></returns>
 270                 private ComponentModel BuildComponentModel(IKernel kernel)
 271                 {
 272                         IConfiguration configuration = EnsureComponentConfiguration(kernel);
 273                         foreach(ComponentDescriptor<S> descriptor in descriptors)
 274                         {
 275                                 descriptor.ApplyToConfiguration(kernel, configuration);
 276                         }
 277
 278                         ComponentModel model = kernel.ComponentModelBuilder.BuildModel(
 279                                 name, serviceType, classType, null);
 280                         foreach(ComponentDescriptor<S> descriptor in descriptors)
 281                         {
 282                                 descriptor.ApplyToModel(kernel, model);
 283                         }
 284
 285                         return model;
 286                 }
 287
 288                 /// <summary>
 289                 /// Adds the attribute descriptor.
 290                 /// </summary>
 291                 /// <param name="key">The key.</param>
 292                 /// <param name="value">The value.</param>
 293                 /// <returns></returns>
 294                 public ComponentRegistration<S> AddAttributeDescriptor(string key, string value)
 295                 {
 296                         AddDescriptor(new AttributeDescriptor<S>(key, value));
 297                         return this;
 298                 }
 299
 300                 /// <summary>
 301                 /// Adds the descriptor.
 302                 /// </summary>
 303                 /// <param name="descriptor">The descriptor.</param>
 304                 /// <returns></returns>
 305                 public ComponentRegistration<S> AddDescriptor(ComponentDescriptor<S> descriptor)
 306                 {
 307                         descriptor.Registration = this;
 308                         descriptors.Add(descriptor);
 309                         return this;
 310                 }
 311
 312                 internal void AddParameter(IKernel kernel, ComponentModel model, String key, String value)
 313                 {
 314                         IConfiguration parameters = EnsureParametersConfiguration(kernel);
 315                         MutableConfiguration parameter = new MutableConfiguration(key, value);
 316                         parameters.Children.Add(parameter);
 317                         model.Parameters.Add(key, value);
 318                 }
 319
 320                 internal void AddParameter(IKernel kernel, ComponentModel model, String key, IConfiguration value)
 321                 {
 322                         IConfiguration parameters = EnsureParametersConfiguration(kernel);
 323                         MutableConfiguration parameter = new MutableConfiguration(key);
 324                         parameter.Children.Add(value);
 325                         parameters.Children.Add(parameter);
 326                         model.Parameters.Add(key, value);
 327                 }
 328
 329                 private void InitializeDefaults()
 330                 {
 331                         if (classType == null)
 332                         {
 333                                 classType = serviceType;
 334                         }
 335
 336                         if (String.IsNullOrEmpty(name))
 337                         {
 338                                 name = classType.FullName;
 339                         }
 340                 }
 341
 342                 private IConfiguration EnsureParametersConfiguration(IKernel kernel)
 343                 {
 344                         IConfiguration configuration = EnsureComponentConfiguration(kernel);
 345                         IConfiguration parameters = configuration.Children["parameters"];
 346                         if (parameters == null)
 347                         {
 348                                 parameters = new MutableConfiguration("component");
 349                                 configuration.Children.Add(parameters);
 350                         }
 351                         return parameters;
 352                 }
 353
 354                 private IConfiguration EnsureComponentConfiguration(IKernel kernel)
 355                 {
 356                         IConfiguration configuration = kernel.ConfigurationStore.GetComponentConfiguration(name);
 357                         if (configuration == null)
 358                         {
 359                                 configuration = new MutableConfiguration("component");
 360                                 kernel.ConfigurationStore.AddComponentConfiguration(name, configuration);
 361                         }
 362                         return configuration;
 363                 }
 364         }
 365
 366         public class ComponentRegistration : ComponentRegistration<object>
 367         {
 368                 public ComponentRegistration(Type serviceType)
 369                         : base( serviceType )
 370                 {
 371                 }
 372         }
 373 }