InversionOfControl/Castle.Windsor/WindsorContainer.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.Windsor
  16 {
  17         using System;
  18         using System.Collections;
  19
  20         using Castle.Core;
  21         using Castle.MicroKernel;
  22         using Castle.MicroKernel.Registration;
  23         using Castle.Windsor.Configuration;
  24         using Castle.Windsor.Configuration.Interpreters;
  25
  26         /// <summary>
  27         /// Implementation of <see cref="IWindsorContainer"/>
  28         /// which delegates to <see cref="IKernel"/> implementation.
  29         /// </summary>
  30         [Serializable]
  31         public class WindsorContainer : MarshalByRefObject, IWindsorContainer
  32         {
  33                 #region Fields
  34
  35                 private readonly string name = Guid.NewGuid().ToString();
  36                 private readonly IDictionary childContainers = Hashtable.Synchronized(new Hashtable());
  37
  38                 private IKernel kernel;
  39                 private IWindsorContainer parent;
  40                 private IComponentsInstaller installer;
  41
  42                 #endregion
  43
  44                 #region Constructors
  45
  46                 /// <summary>
  47                 /// Constructs a container without any external
  48                 /// configuration reference
  49                 /// </summary>
  50                 public WindsorContainer() : this(new DefaultKernel(), new Installer.DefaultComponentInstaller())
  51                 {
  52                 }
  53
  54                 /// <summary>
  55                 /// Constructs a container using the specified
  56                 /// <see cref="IConfigurationStore"/> implementation.
  57                 /// </summary>
  58                 /// <param name="store">The instance of an <see cref="IConfigurationStore"/> implementation.</param>
  59                 public WindsorContainer(IConfigurationStore store) : this()
  60                 {
  61                         kernel.ConfigurationStore = store;
  62
  63                         RunInstaller();
  64                 }
  65
  66                 /// <summary>
  67                 /// Constructs a container using the specified
  68                 /// <see cref="IConfigurationInterpreter"/> implementation.
  69                 /// </summary>
  70                 /// <param name="interpreter">The instance of an <see cref="IConfigurationInterpreter"/> implementation.</param>
  71                 public WindsorContainer(IConfigurationInterpreter interpreter) : this()
  72                 {
  73                         if (interpreter == null) throw new ArgumentNullException("interpreter");
  74
  75                         interpreter.ProcessResource(interpreter.Source, kernel.ConfigurationStore);
  76
  77                         RunInstaller();
  78                 }
  79
  80                 /// <summary>
  81                 /// Initializes a new instance of the <see cref="WindsorContainer"/> class.
  82                 /// </summary>
  83                 /// <param name="interpreter">The interpreter.</param>
  84                 /// <param name="environmentInfo">The environment info.</param>
  85                 public WindsorContainer(IConfigurationInterpreter interpreter, IEnvironmentInfo environmentInfo) : this()
  86                 {
  87                         if (interpreter == null) throw new ArgumentNullException("interpreter");
  88                         if (environmentInfo == null) throw new ArgumentNullException("environmentInfo");
  89
  90                         interpreter.EnvironmentName = environmentInfo.GetEnvironmentName();
  91                         interpreter.ProcessResource(interpreter.Source, kernel.ConfigurationStore);
  92
  93                         RunInstaller();
  94                 }
  95
  96                 /// <summary>
  97                 /// Initializes a new instance of the <see cref="WindsorContainer"/> class using a
  98                 /// xml file to configure it.
  99                 /// <para>
 100                 /// Equivalent to the use of <c>new WindsorContainer(new XmlInterpreter(xmlFile))</c>
 101                 /// </para>
 102                 /// </summary>
 103                 /// <param name="xmlFile">The XML file.</param>
 104                 public WindsorContainer(String xmlFile) : this(new XmlInterpreter(xmlFile))
 105                 {
 106                 }
 107
 108                 /// <summary>
 109                 /// Constructs a container using the specified <see cref="IKernel"/>
 110                 /// implementation. Rarely used.
 111                 /// </summary>
 112                 /// <remarks>
 113                 /// This constructs sets the Kernel.ProxyFactory property to
 114                 /// <see cref="Proxy.DefaultProxyFactory"/>
 115                 /// </remarks>
 116                 /// <param name="kernel">Kernel instance</param>
 117                 /// <param name="installer">Installer instance</param>
 118                 public WindsorContainer(IKernel kernel, IComponentsInstaller installer) : this(Guid.NewGuid().ToString(), kernel, installer)
 119                 {
 120                 }
 121
 122                 /// <summary>
 123                 /// Constructs a container using the specified <see cref="IKernel"/>
 124                 /// implementation. Rarely used.
 125                 /// </summary>
 126                 /// <remarks>
 127                 /// This constructs sets the Kernel.ProxyFactory property to
 128                 /// <see cref="Proxy.DefaultProxyFactory"/>
 129                 /// </remarks>
 130                 /// <param name="name">Container's name</param>
 131                 /// <param name="kernel">Kernel instance</param>
 132                 /// <param name="installer">Installer instance</param>
 133                 public WindsorContainer(String name, IKernel kernel, IComponentsInstaller installer)
 134                 {
 135                         if (name == null) throw new ArgumentNullException("name");
 136                         if (kernel == null) throw new ArgumentNullException("kernel");
 137                         if (installer == null) throw new ArgumentNullException("installer");
 138
 139                         this.name = name;
 140                         this.kernel = kernel;
 141                         this.kernel.ProxyFactory = new Proxy.DefaultProxyFactory();
 142                         this.installer = installer;
 143                 }
 144
 145                 /// <summary>
 146                 /// Constructs with a given <see cref="IProxyFactory"/>.
 147                 /// </summary>
 148                 /// <param name="proxyFactory">A instance of an <see cref="IProxyFactory"/>.</param>
 149                 public WindsorContainer(IProxyFactory proxyFactory)
 150                 {
 151                         if (proxyFactory == null) throw new ArgumentNullException("proxyFactory");
 152
 153                         kernel = new DefaultKernel(proxyFactory);
 154
 155                         installer = new Installer.DefaultComponentInstaller();
 156                 }
 157
 158                 /// <summary>
 159                 /// Constructs a container assigning a parent container
 160                 /// before starting the dependency resolution.
 161                 /// </summary>
 162                 /// <param name="parent">The instance of an <see cref="IWindsorContainer"/></param>
 163                 /// <param name="interpreter">The instance of an <see cref="IConfigurationInterpreter"/> implementation</param>
 164                 public WindsorContainer(IWindsorContainer parent, IConfigurationInterpreter interpreter) : this()
 165                 {
 166                         if (parent == null) throw new ArgumentNullException("parent");
 167                         if (interpreter == null) throw new ArgumentNullException("interpreter");
 168
 169                         parent.AddChildContainer(this);
 170
 171                         interpreter.ProcessResource(interpreter.Source, kernel.ConfigurationStore);
 172
 173                         RunInstaller();
 174                 }
 175
 176                 /// <summary>
 177                 /// Initializes a new instance of the <see cref="WindsorContainer"/> class.
 178                 /// </summary>
 179                 /// <param name="name">The container's name.</param>
 180                 /// <param name="parent">The parent.</param>
 181                 /// <param name="interpreter">The interpreter.</param>
 182                 public WindsorContainer(string name, IWindsorContainer parent, IConfigurationInterpreter interpreter) : this()
 183                 {
 184                         if (name == null) throw new ArgumentNullException("name");
 185                         if (parent == null) throw new ArgumentNullException("parent");
 186                         if (interpreter == null) throw new ArgumentNullException("interpreter");
 187
 188                         this.name = name;
 189
 190                         parent.AddChildContainer(this);
 191
 192                         interpreter.ProcessResource(interpreter.Source, kernel.ConfigurationStore);
 193
 194                         RunInstaller();
 195                 }
 196
 197                 #endregion
 198
 199                 #region IWindsorContainer Members
 200
 201                 /// <summary>
 202                 /// Gets the container's name
 203                 /// </summary>
 204                 /// <remarks>
 205                 /// Only useful when child containers are being used
 206                 /// </remarks>
 207                 /// <value>The container's name.</value>
 208                 public string Name
 209                 {
 210                         get { return name; }
 211                 }
 212
 213                 /// <summary>
 214                 /// Returns the inner instance of the MicroKernel
 215                 /// </summary>
 216                 public virtual IKernel Kernel
 217                 {
 218                         get { return kernel; }
 219                 }
 220
 221                 /// <summary>
 222                 /// Gets or sets the parent container if this instance
 223                 /// is a sub container.
 224                 /// </summary>
 225                 public virtual IWindsorContainer Parent
 226                 {
 227                         get { return parent; }
 228                         set
 229                         {
 230                                 if( value == null )
 231                                 {
 232                                         if (parent != null)
 233                                         {
 234                                                 parent.RemoveChildContainer(this);
 235                                                 parent = null;
 236                                         }
 237                                 }
 238                                 else
 239                                 {
 240                                         if (value != parent)
 241                                         {
 242                                                 parent = value;
 243                                                 parent.AddChildContainer(this);
 244                                         }
 245                                 }
 246                         }
 247                 }
 248
 249                 /// <summary>
 250                 /// Registers a facility within the kernel.
 251                 /// </summary>
 252                 /// <param name="key"></param>
 253                 /// <param name="facility"></param>
 254                 public virtual IWindsorContainer AddFacility(String key, IFacility facility)
 255                 {
 256                         kernel.AddFacility(key, facility);
 257                         return this;
 258                 }
 259
 260                 /// <summary>
 261                 /// Adds a component to be managed by the container
 262                 /// </summary>
 263                 /// <param name="key"></param>
 264                 /// <param name="classType"></param>
 265                 public virtual IWindsorContainer AddComponent(String key, Type classType)
 266                 {
 267                         kernel.AddComponent(key, classType);
 268                         return this;
 269                 }
 270
 271                 /// <summary>
 272                 /// Adds a component to be managed by the container
 273                 /// </summary>
 274                 /// <param name="key"></param>
 275                 /// <param name="serviceType"></param>
 276                 /// <param name="classType"></param>
 277                 public virtual IWindsorContainer AddComponent(String key, Type serviceType, Type classType)
 278                 {
 279                         kernel.AddComponent(key, serviceType, classType);
 280                         return this;
 281                 }
 282
 283                 /// <summary>
 284                 /// Adds a component to be managed by the container
 285                 /// </summary>
 286                 /// <param name="key">The key by which the component gets indexed.</param>
 287                 /// <param name="classType">The <see cref="Type"/> to manage.</param>
 288                 /// <param name="lifestyle">The <see cref="LifestyleType"/> with which to manage the component.</param>
 289                 public IWindsorContainer AddComponentLifeStyle(string key, Type classType, LifestyleType lifestyle)
 290                 {
 291                         kernel.AddComponent(key, classType, lifestyle, true);
 292                         return this;
 293                 }
 294
 295                 /// <summary>
 296                 /// Adds a component to be managed by the container
 297                 /// </summary>
 298                 /// <param name="key">The key by which the component gets indexed.</param>
 299                 /// <param name="serviceType">The service <see cref="Type"/> that the component implements.</param>
 300                 /// <param name="classType">The <see cref="Type"/> to manage.</param>
 301                 /// <param name="lifestyle">The <see cref="LifestyleType"/> with which to manage the component.</param>
 302                 public IWindsorContainer AddComponentLifeStyle(string key, Type serviceType, Type classType, LifestyleType lifestyle)
 303                 {
 304                         kernel.AddComponent(key, serviceType, classType, lifestyle, true);
 305                         return this;
 306                 }
 307
 308                 public virtual IWindsorContainer AddComponentWithProperties(string key, Type classType, IDictionary extendedProperties)
 309                 {
 310                         kernel.AddComponentWithExtendedProperties(key, classType, extendedProperties);
 311                         return this;
 312                 }
 313
 314                 public virtual IWindsorContainer AddComponentWithProperties(string key, Type serviceType, Type classType,
 315                                                                IDictionary extendedProperties)
 316                 {
 317                         kernel.AddComponentWithExtendedProperties(key, serviceType, classType, extendedProperties);
 318                         return this;
 319                 }
 320
 321                 /// <summary>
 322                 /// Adds a component to be managed by the container.
 323                 /// The key to obtain the component will be the FullName of the type.
 324                 /// </summary>
 325                 /// <typeparam name="T">The <see cref="Type"/> to manage.</typeparam>
 326                 public IWindsorContainer AddComponent<T>()
 327                 {
 328                         Type t = typeof(T);
 329                         AddComponent(t.FullName, t);
 330                         return this;
 331                 }
 332
 333                 /// <summary>
 334                 /// Adds a component to be managed by the container
 335                 /// </summary>
 336                 /// <typeparam name="T">The <see cref="Type"/> to manage.</typeparam>
 337                 /// <param name="key">The key by which the component gets indexed.</param>
 338                 public IWindsorContainer AddComponent<T>(string key)
 339                 {
 340                         AddComponent(key, typeof(T));
 341                         return this;
 342                 }
 343
 344                 /// <summary>
 345                 /// Adds a component to be managed by the container.
 346                 /// The key to obtain the component will be the FullName of the type.
 347                 /// </summary>
 348                 /// <typeparam name="T">The <see cref="Type"/> to manage.</typeparam>
 349                 /// <param name="lifestyle">The <see cref="LifestyleType"/> with which to manage the component.</param>
 350                 public IWindsorContainer AddComponentLifeStyle<T>(LifestyleType lifestyle)
 351                 {
 352                         Type t = typeof(T);
 353                         AddComponentLifeStyle(t.FullName, t, lifestyle);
 354                         return this;
 355                 }
 356
 357                 /// <summary>
 358                 /// Adds a component to be managed by the container
 359                 /// </summary>
 360                 /// <typeparam name="I">The service <see cref="Type"/> that the component implements.</typeparam>
 361                 /// <typeparam name="T">The <see cref="Type"/> to manage.</typeparam>
 362                 /// <param name="key">The key by which the component gets indexed.</param>
 363                 public IWindsorContainer AddComponent<I, T>(string key) where T : class
 364                 {
 365                         AddComponent(key, typeof(I), typeof(T));
 366                         return this;
 367                 }
 368
 369                 /// <summary>
 370                 /// Adds a component to be managed by the container
 371                 /// The key to obtain the component will be the FullName of the type.
 372                 /// </summary>
 373                 /// <typeparam name="I">The service <see cref="Type"/> that the component implements.</typeparam>
 374                 /// <typeparam name="T">The <see cref="Type"/> to manage.</typeparam>
 375                 /// <param name="lifestyle">The <see cref="LifestyleType"/> with which to manage the component.</param>
 376                 public IWindsorContainer AddComponentLifeStyle<I, T>(LifestyleType lifestyle) where T : class
 377                 {
 378                         Type t = typeof(T);
 379                         AddComponentLifeStyle(t.FullName, typeof(I), t, lifestyle);
 380                         return this;
 381                 }
 382
 383                 /// <summary>
 384                 /// Adds a component to be managed by the container
 385                 /// </summary>
 386                 /// <typeparam name="T">The <see cref="Type"/> to manage.</typeparam>
 387                 /// <param name="key">The key by which the component gets indexed.</param>
 388                 /// <param name="lifestyle">The <see cref="LifestyleType"/> with which to manage the component.</param>
 389                 public IWindsorContainer AddComponentLifeStyle<T>(string key, LifestyleType lifestyle)
 390                 {
 391                         AddComponentLifeStyle(key, typeof(T), lifestyle);
 392                         return this;
 393                 }
 394
 395                 /// <summary>
 396                 /// Adds a component to be managed by the container
 397                 /// The key to obtain the component will be the FullName of the type.
 398                 /// </summary>
 399                 /// <typeparam name="I">The service <see cref="Type"/> that the component implements.</typeparam>
 400                 /// <typeparam name="T">The <see cref="Type"/> to manage.</typeparam>
 401                 public IWindsorContainer AddComponent<I, T>() where T : class
 402                 {
 403                         Type t = typeof(T);
 404                         AddComponent(t.FullName, typeof(I), t);
 405                         return this;
 406                 }
 407
 408                 /// <summary>
 409                 /// Adds a component to be managed by the container
 410                 /// </summary>
 411                 /// <typeparam name="I">The service <see cref="Type"/> that the component implements.</typeparam>
 412                 /// <typeparam name="T">The <see cref="Type"/> to manage.</typeparam>
 413                 /// <param name="key">The key by which the component gets indexed.</param>
 414                 /// <param name="lifestyle">The <see cref="LifestyleType"/> with which to manage the component.</param>
 415                 public IWindsorContainer AddComponentLifeStyle<I, T>(string key, LifestyleType lifestyle) where T : class
 416                 {
 417                         AddComponentLifeStyle(key, typeof(I), typeof(T), lifestyle);
 418                         return this;
 419                 }
 420
 421                 /// <summary>
 422                 /// Adds a concrete class as a component and specify the extended properties.
 423                 /// Used by facilities, mostly.
 424                 /// The key to obtain the component will be the FullName of the type.
 425                 /// </summary>
 426                 /// <typeparam name="T"></typeparam>
 427                 /// <param name="extendedProperties"></param>
 428                 public IWindsorContainer AddComponentWithProperties<T>(IDictionary extendedProperties)
 429                 {
 430                         Type t = typeof(T);
 431                         AddComponentWithProperties(t.FullName, t, extendedProperties);
 432                         return this;
 433                 }
 434
 435                 /// <summary>
 436                 /// Adds a concrete class as a component and specify the extended properties.
 437                 /// Used by facilities, mostly.
 438                 /// </summary>
 439                 /// <typeparam name="T"></typeparam>
 440                 /// <param name="key"></param>
 441                 /// <param name="extendedProperties"></param>
 442                 public IWindsorContainer AddComponentWithProperties<T>(string key, IDictionary extendedProperties)
 443                 {
 444                         AddComponentWithProperties(key, typeof(T), extendedProperties);
 445                         return this;
 446                 }
 447
 448                 /// <summary>
 449                 /// Adds a concrete class and an interface
 450                 /// as a component and specify the extended properties.
 451                 /// Used by facilities, mostly.
 452                 /// The key to obtain the component will be the FullName of the type.
 453                 /// </summary>
 454                 /// <typeparam name="I"></typeparam>
 455                 /// <typeparam name="T"></typeparam>
 456                 /// <param name="extendedProperties"></param>
 457                 public IWindsorContainer AddComponentLifeStyle<I, T>(IDictionary extendedProperties) where T : class
 458                 {
 459                         Type t = typeof(T);
 460                         AddComponentWithProperties(t.FullName, typeof(I), t, extendedProperties);
 461                         return this;
 462                 }
 463
 464                 /// <summary>
 465                 /// Adds a concrete class and an interface
 466                 /// as a component and specify the extended properties.
 467                 /// Used by facilities, mostly.
 468                 /// </summary>
 469                 /// <typeparam name="I"></typeparam>
 470                 /// <typeparam name="T"></typeparam>
 471                 /// <param name="key"></param>
 472                 /// <param name="extendedProperties"></param>
 473                 public IWindsorContainer AddComponentLifeStyle<I, T>(string key, IDictionary extendedProperties) where T : class
 474                 {
 475                         AddComponentWithProperties(key, typeof(I), typeof(T), extendedProperties);
 476                         return this;
 477                 }
 478
 479                 /// <summary>
 480                 /// Registers the components described by the <see cref="ComponentRegistration{S}"/>s
 481                 /// with the <see cref="IWindsorContainer"/>.
 482                 /// <param name="registrations">The component registrations.</param>
 483                 /// <returns>The container.</returns>
 484                 /// </summary>
 485                 public IWindsorContainer Register(params IRegistration[] registrations)
 486                 {
 487                         Kernel.Register(registrations);
 488                         return this;
 489                 }
 490
 491                 /// <summary>
 492                 /// Returns a component instance by the key
 493                 /// </summary>
 494                 /// <param name="key"></param>
 495                 /// <returns></returns>
 496                 public virtual object Resolve(String key)
 497                 {
 498                         return kernel[key];
 499                 }
 500
 501                 /// <summary>
 502                 /// Returns a component instance by the service
 503                 /// </summary>
 504                 /// <param name="service"></param>
 505                 /// <param name="arguments"></param>
 506                 /// <returns></returns>
 507                 public virtual object Resolve(Type service, IDictionary arguments)
 508                 {
 509                         return kernel.Resolve(service, arguments);
 510                 }
 511
 512                 /// <summary>
 513                 /// Returns a component instance by the service
 514                 /// </summary>
 515                 /// <param name="service"></param>
 516                 /// <param name="argumentsAsAnonymousType"></param>
 517                 /// <returns></returns>
 518                 public virtual object Resolve(Type service, object argumentsAsAnonymousType)
 519                 {
 520                         return Resolve(service, new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
 521                 }
 522
 523                 /// <summary>
 524                 /// Returns a component instance by the key
 525                 /// </summary>
 526                 /// <param name="key"></param>
 527                 /// <param name="arguments"></param>
 528                 /// <returns></returns>
 529                 public virtual object Resolve(String key, IDictionary arguments)
 530                 {
 531                         return kernel.Resolve(key, arguments);
 532                 }
 533
 534                 /// <summary>
 535                 /// Returns a component instance by the key
 536                 /// </summary>
 537                 /// <param name="key"></param>
 538                 /// <param name="argumentsAsAnonymousType"></param>
 539                 /// <returns></returns>
 540                 public virtual object Resolve(String key, object argumentsAsAnonymousType)
 541                 {
 542                         return Resolve(key, new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
 543                 }
 544
 545                 /// <summary>
 546                 /// Returns a component instance by the service
 547                 /// </summary>
 548                 /// <param name="service"></param>
 549                 /// <returns></returns>
 550                 public virtual object Resolve(Type service)
 551                 {
 552                         return kernel[service];
 553                 }
 554
 555                 /// <summary>
 556                 /// Resolve all valid components that match this type.
 557                 /// </summary>
 558                 /// <typeparam name="T">The service type</typeparam>
 559                 public T[] ResolveAll<T>()
 560                 {
 561                         return (T[]) ResolveAll(typeof(T));
 562                 }
 563
 564
 565                 public Array ResolveAll(Type service)
 566                 {
 567                         return kernel.ResolveAll(service, new Hashtable());
 568                 }
 569
 570                 public Array ResolveAll(Type service, IDictionary arguments)
 571                 {
 572                         return kernel.ResolveAll(service, arguments);
 573                 }
 574
 575                 public Array ResolveAll(Type service, object argumentsAsAnonymousType)
 576                 {
 577                         return ResolveAll(service, new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
 578                 }
 579
 580                 /// <summary>
 581                 /// Resolve all valid components that match this type.
 582                 /// <typeparam name="T">The service type</typeparam>
 583                 /// <param name="arguments">Arguments to resolve the service</param>
 584                 /// </summary>
 585                 public T[] ResolveAll<T>(IDictionary arguments)
 586                 {
 587                         return (T[]) ResolveAll(typeof (T), arguments);
 588                 }
 589
 590                 /// <summary>
 591                 /// Resolve all valid components that match this type.
 592                 /// <typeparam name="T">The service type</typeparam>
 593                 /// <param name="argumentsAsAnonymousType">Arguments to resolve the service</param>
 594                 /// </summary>
 595                 public T[] ResolveAll<T>(object argumentsAsAnonymousType)
 596                 {
 597                         return ResolveAll<T>(new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
 598                 }
 599
 600                 /// <summary>
 601                 /// Shortcut to the method <see cref="Resolve(String)"/>
 602                 /// </summary>
 603                 public virtual object this[String key]
 604                 {
 605                         get { return Resolve(key); }
 606                 }
 607
 608                 /// <summary>
 609                 /// Shortcut to the method <see cref="Resolve(Type)"/>
 610                 /// </summary>
 611                 public virtual object this[Type service]
 612                 {
 613                         get { return Resolve(service); }
 614                 }
 615
 616                 /// <summary>
 617                 /// Returns a component instance by the key
 618                 /// </summary>
 619                 /// <param name="key"></param>
 620                 /// <param name="service"></param>
 621                 /// <returns></returns>
 622                 public virtual object Resolve(String key, Type service)
 623                 {
 624             return kernel.Resolve(key, service);
 625                 }
 626
 627                 /// <summary>
 628                 /// Returns a component instance by the key
 629                 /// </summary>
 630                 /// <param name="key"></param>
 631                 /// <param name="service"></param>
 632                 /// <param name="arguments"></param>
 633                 /// <returns></returns>
 634                 public virtual object Resolve(String key, Type service, IDictionary arguments)
 635                 {
 636                         return kernel.Resolve(key, service, arguments);
 637                 }
 638
 639                 /// <summary>
 640                 /// Returns a component instance by the key
 641                 /// </summary>
 642                 /// <param name="key"></param>
 643                 /// <param name="service"></param>
 644                 /// <param name="argumentsAsAnonymousType"></param>
 645                 /// <returns></returns>
 646                 public virtual object Resolve(String key, Type service, object argumentsAsAnonymousType)
 647                 {
 648                         return Resolve(key, service, new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
 649                 }
 650
 651                 /// <summary>
 652                 /// Returns a component instance by the service
 653                 /// </summary>
 654                 /// <typeparam name="T"></typeparam>
 655                 /// <param name="arguments"></param>
 656                 /// <returns></returns>
 657                 public T Resolve<T>(IDictionary arguments)
 658                 {
 659                         return (T) Resolve(typeof(T), arguments);
 660                 }
 661
 662                 /// <summary>
 663                 /// Returns a component instance by the service
 664                 /// </summary>
 665                 /// <typeparam name="T"></typeparam>
 666                 /// <param name="argumentsAsAnonymousType"></param>
 667                 /// <returns></returns>
 668                 public T Resolve<T>(object argumentsAsAnonymousType)
 669                 {
 670                         return Resolve<T>(new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
 671                 }
 672
 673                 /// <summary>
 674                 /// Returns a component instance by the key
 675                 /// </summary>
 676                 /// <param name="key"></param>
 677                 /// <param name="arguments"></param>
 678                 /// <returns></returns>
 679                 public virtual T Resolve<T>(String key, IDictionary arguments)
 680                 {
 681                         return (T) Resolve(key, typeof(T), arguments);
 682                 }
 683
 684                 /// <summary>
 685                 /// Returns a component instance by the key
 686                 /// </summary>
 687                 /// <param name="key"></param>
 688                 /// <param name="argumentsAsAnonymousType"></param>
 689                 /// <returns></returns>
 690                 public virtual T Resolve<T>(String key, object argumentsAsAnonymousType)
 691                 {
 692                         return Resolve<T>(key, new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
 693                 }
 694
 695                 /// <summary>
 696                 /// Returns a component instance by the service
 697                 /// </summary>
 698                 /// <typeparam name="T"></typeparam>
 699                 /// <returns></returns>
 700                 public T Resolve<T>()
 701                 {
 702                         return (T) Resolve(typeof(T));
 703                 }
 704
 705                 /// <summary>
 706                 /// Returns a component instance by the key
 707                 /// </summary>
 708                 /// <param name="key"></param>
 709                 /// <returns></returns>
 710                 public virtual T Resolve<T>(String key)
 711                 {
 712                         return (T) Resolve(key, typeof(T));
 713                 }
 714
 715                 /// <summary>
 716                 /// Releases a component instance
 717                 /// </summary>
 718                 /// <param name="instance"></param>
 719                 public virtual void Release(object instance)
 720                 {
 721                         kernel.ReleaseComponent(instance);
 722                 }
 723
 724                 /// <summary>
 725                 /// Registers a subcontainer. The components exposed
 726                 /// by this container will be accessible from subcontainers.
 727                 /// </summary>
 728                 /// <param name="childContainer"></param>
 729                 public virtual void AddChildContainer(IWindsorContainer childContainer)
 730                 {
 731                         if (childContainer == null) throw new ArgumentNullException("childContainer");
 732
 733                         if (!childContainers.Contains(childContainer.Name))
 734                         {
 735                                 lock (childContainers.SyncRoot)
 736                                 {
 737                                         if (!childContainers.Contains(childContainer.Name))
 738                                         {
 739                                                 kernel.AddChildKernel(childContainer.Kernel);
 740                                                 childContainers.Add(childContainer.Name, childContainer);
 741                                                 childContainer.Parent = this;
 742                                         }
 743                                 }
 744                         }
 745                 }
 746
 747                 /// <summary>
 748                 /// Removes (unregisters) a subcontainer.  The components exposed by this container
 749                 /// will no longer be accessible to the child container.
 750                 /// </summary>
 751                 /// <param name="childContainer"></param>
 752                 public virtual void RemoveChildContainer(IWindsorContainer childContainer)
 753                 {
 754                         if (childContainer == null) throw new ArgumentNullException("childContainer");
 755
 756                         if (childContainers.Contains(childContainer.Name))
 757                         {
 758                                 lock (childContainers.SyncRoot)
 759                                 {
 760                                         if (childContainers.Contains(childContainer.Name))
 761                                         {
 762                                                 kernel.RemoveChildKernel(childContainer.Kernel);
 763                                                 childContainers.Remove(childContainer.Name);
 764                                                 childContainer.Parent = null;
 765                                         }
 766                                 }
 767                         }
 768                 }
 769
 770                 /// <summary>
 771                 /// Gets a child container instance by name.
 772                 /// </summary>
 773                 /// <param name="name">The container's name.</param>
 774                 /// <returns>The child container instance or null</returns>
 775                 public IWindsorContainer GetChildContainer(string name)
 776                 {
 777                         return childContainers[name] as IWindsorContainer;
 778                 }
 779
 780                 #endregion
 781
 782                 #region IServiceProviderEx Members
 783
 784                 /// <summary>
 785                 /// Gets the service object of the specified type.
 786                 /// </summary>
 787                 /// <returns>
 788                 /// A service object of type serviceType.
 789                 /// </returns>
 790                 /// <param name="serviceType">An object that specifies the type of service object to get. </param>
 791                 public object GetService(Type serviceType)
 792                 {
 793                         return kernel.GetService(serviceType);
 794                 }
 795
 796                 /// <summary>
 797                 /// Gets the service object of the specified type.
 798                 /// </summary>
 799                 /// <returns>
 800                 /// A service object of type serviceType.
 801                 /// </returns>
 802                 public T GetService<T>() where T : class
 803                 {
 804                         return kernel.GetService<T>();
 805                 }
 806
 807                 #endregion
 808
 809                 #region IDisposable Members
 810
 811                 /// <summary>
 812                 /// Executes Dispose on underlying <see cref="IKernel"/>
 813                 /// </summary>
 814                 public virtual void Dispose()
 815                 {
 816                         Parent = null;
 817                         childContainers.Clear();
 818                         kernel.Dispose();
 819                 }
 820
 821                 #endregion
 822
 823                 #region Protected Operations Members
 824
 825                 public IComponentsInstaller Installer
 826                 {
 827                         get { return installer; }
 828                 }
 829
 830                 protected virtual void RunInstaller()
 831                 {
 832                         if (installer != null)
 833                         {
 834                                 installer.SetUp(this, kernel.ConfigurationStore);
 835                         }
 836                 }
 837
 838                 #endregion
 839         }
 840 }