InversionOfControl/Castle.MicroKernel/DefaultKernel.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.MicroKernel
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Generic;
  20         using System.Reflection;
  21         using System.Runtime.Serialization;
  22         using Castle.Core;
  23         using Castle.Core.Internal;
  24         using Castle.MicroKernel.ComponentActivator;
  25         using Castle.MicroKernel.Handlers;
  26         using Castle.MicroKernel.ModelBuilder;
  27         using Castle.MicroKernel.Proxy;
  28         using Castle.MicroKernel.Registration;
  29         using Castle.MicroKernel.Releasers;
  30         using Castle.MicroKernel.Resolvers;
  31         using Castle.MicroKernel.SubSystems.Configuration;
  32         using Castle.MicroKernel.SubSystems.Conversion;
  33         using Castle.MicroKernel.SubSystems.Naming;
  34         using Castle.MicroKernel.SubSystems.Resource;
  35
  36         /// <summary>
  37         /// Default implementation of <see cref="IKernel"/>.
  38         /// This implementation is complete and also support a kernel
  39         /// hierarchy (sub containers).
  40         /// </summary>
  41         [Serializable]
  42         public class DefaultKernel : KernelEventSupport, IKernel, IDeserializationCallback
  43         {
  44                 #region Fields
  45
  46                 /// <summary>
  47                 /// The parent kernel, if exists.
  48                 /// </summary>
  49                 private IKernel parentKernel;
  50
  51                 /// <summary>
  52                 /// The implementation of <see cref="IHandlerFactory"/>
  53                 /// </summary>
  54                 private IHandlerFactory handlerFactory;
  55
  56                 /// <summary>
  57                 /// The implementation of <see cref="IComponentModelBuilder"/>
  58                 /// </summary>
  59                 private IComponentModelBuilder modelBuilder;
  60
  61                 /// <summary>
  62                 /// The dependency resolver.
  63                 /// </summary>
  64                 private IDependencyResolver resolver;
  65
  66                 /// <summary>
  67                 /// Implements a policy to control component's
  68                 /// disposal that the usef forgot.
  69                 /// </summary>
  70                 private IReleasePolicy releaserPolicy;
  71
  72                 /// <summary>
  73                 /// Holds the implementation of <see cref="IProxyFactory"/>
  74                 /// </summary>
  75                 private IProxyFactory proxyFactory;
  76
  77                 /// <summary>
  78                 /// List of <see cref="IFacility"/> registered.
  79                 /// </summary>
  80                 private IList facilities;
  81
  82                 /// <summary>
  83                 /// Map of subsystems registered.
  84                 /// </summary>
  85                 private IDictionary subsystems;
  86
  87                 /// <summary>
  88                 /// List of sub containers.
  89                 /// </summary>
  90                 private IList childKernels;
  91
  92                 #endregion
  93
  94                 #region Constructors
  95
  96                 /// <summary>
  97                 /// Constructs a DefaultKernel with no component
  98                 /// proxy support.
  99                 /// </summary>
 100                 public DefaultKernel() : this(new NotSupportedProxyFactory())
 101                 {
 102                 }
 103
 104                 /// <summary>
 105                 /// Constructs a DefaultKernel with the specified
 106                 /// implementation of <see cref="IProxyFactory"/> and <see cref="IDependencyResolver"/>
 107                 /// </summary>
 108                 /// <param name="resolver"></param>
 109                 /// <param name="proxyFactory"></param>
 110                 public DefaultKernel(IDependencyResolver resolver, IProxyFactory proxyFactory)
 111                         : this(proxyFactory)
 112                 {
 113                         this.resolver = resolver;
 114                         this.resolver.Initialize(RaiseDependencyResolving);
 115                 }
 116
 117                 /// <summary>
 118                 /// Constructs a DefaultKernel with the specified
 119                 /// implementation of <see cref="IProxyFactory"/>
 120                 /// </summary>
 121                 public DefaultKernel(IProxyFactory proxyFactory)
 122                 {
 123                         this.proxyFactory = proxyFactory;
 124
 125                         childKernels = new ArrayList();
 126                         facilities = new ArrayList();
 127                         subsystems = new Hashtable();
 128
 129                         RegisterSubSystems();
 130
 131                         releaserPolicy = new LifecycledComponentsReleasePolicy();
 132                         handlerFactory = new DefaultHandlerFactory(this);
 133                         modelBuilder = new DefaultComponentModelBuilder(this);
 134                         resolver = new DefaultDependencyResolver(this);
 135                         resolver.Initialize(new DependencyDelegate(RaiseDependencyResolving));
 136                 }
 137
 138                 public DefaultKernel(SerializationInfo info, StreamingContext context)
 139                         : base(info, context)
 140                 {
 141                         MemberInfo[] members = FormatterServices.GetSerializableMembers(GetType(), context);
 142
 143                         object[] kernelmembers = (object[])info.GetValue("members", typeof(object[]));
 144
 145                         FormatterServices.PopulateObjectMembers(this, members, kernelmembers);
 146                 }
 147
 148                 #endregion
 149
 150                 #region Overridables
 151
 152                 protected virtual void RegisterSubSystems()
 153                 {
 154                         AddSubSystem(SubSystemConstants.ConfigurationStoreKey,
 155                                                  new DefaultConfigurationStore());
 156
 157                         AddSubSystem(SubSystemConstants.ConversionManagerKey,
 158                                                  new DefaultConversionManager());
 159
 160                         AddSubSystem(SubSystemConstants.NamingKey,
 161                                                  new DefaultNamingSubSystem());
 162
 163                         AddSubSystem(SubSystemConstants.ResourceKey,
 164                                                  new DefaultResourceSubSystem());
 165                 }
 166
 167                 #endregion
 168
 169                 #region IKernel Members
 170
 171                 public virtual void AddComponent(String key, Type classType)
 172                 {
 173                         AddComponent(key, classType, classType);
 174                 }
 175
 176                 /// <summary>
 177                 /// Adds a concrete class
 178                 /// as a component with the specified <paramref name="lifestyle"/>.
 179                 /// </summary>
 180                 /// <param name="key">The key with which to index the component.</param>
 181                 /// <param name="classType">The <see cref="Type"/> of the component.</param>
 182                 /// <param name="lifestyle">The specified <see cref="LifestyleType"/> for the component.</param>
 183                 /// <remarks>
 184                 /// If you have indicated a lifestyle for the specified <paramref name="classType"/> using
 185                 /// attributes, this method will not overwrite that lifestyle. To do that, use the
 186                 /// <see cref="IKernel.AddComponent(string,Type,LifestyleType,bool)"/> method.
 187                 /// </remarks>
 188                 /// <exception cref="ArgumentNullException">
 189                 /// Thrown if <paramref name="key"/> or <paramref name="classType"/>
 190                 /// are <see langword="null"/>.
 191                 /// </exception>
 192                 /// <exception cref="ArgumentException">
 193                 /// Thrown if <paramref name="lifestyle"/> is <see cref="LifestyleType.Undefined"/>.
 194                 /// </exception>
 195                 public void AddComponent(string key, Type classType, LifestyleType lifestyle)
 196                 {
 197                         AddComponent(key, classType, classType, lifestyle);
 198                 }
 199
 200                 /// <summary>
 201                 /// Adds a concrete class
 202                 /// as a component with the specified <paramref name="lifestyle"/>.
 203                 /// </summary>
 204                 /// <param name="key">The key with which to index the component.</param>
 205                 /// <param name="classType">The <see cref="Type"/> of the component.</param>
 206                 /// <param name="lifestyle">The specified <see cref="LifestyleType"/> for the component.</param>
 207                 /// <param name="overwriteLifestyle">
 208                 /// If <see langword="true"/>, then ignores all other configurations
 209                 /// for lifestyle and uses the value in the <paramref name="lifestyle"/> parameter.
 210                 /// </param>
 211                 /// <remarks>
 212                 /// If you have indicated a lifestyle for the specified <paramref name="classType"/> using
 213                 /// attributes, this method will not overwrite that lifestyle. To do that, use the
 214                 /// <see cref="IKernel.AddComponent(string,Type,Type,LifestyleType,bool)"/> method.
 215                 /// </remarks>
 216                 /// <exception cref="ArgumentNullException">
 217                 /// Thrown if <paramref name="key"/> or <paramref name="classType"/>
 218                 /// are <see langword="null"/>.
 219                 /// </exception>
 220                 /// <exception cref="ArgumentException" />
 221                 /// Thrown if <paramref name="lifestyle"/> is <see cref="LifestyleType.Undefined"/>.
 222                 public void AddComponent(string key, Type classType, LifestyleType lifestyle, bool overwriteLifestyle)
 223                 {
 224                         AddComponent(key, classType, classType, lifestyle, overwriteLifestyle);
 225                 }
 226
 227                 public virtual void AddComponent(String key, Type serviceType, Type classType)
 228                 {
 229                         AddComponent(key, serviceType, classType, LifestyleType.Singleton);
 230                 }
 231
 232                 /// <summary>
 233                 /// Adds a concrete class and an interface
 234                 /// as a component with the specified <paramref name="lifestyle"/>.
 235                 /// </summary>
 236                 /// <param name="key">The key with which to index the component.</param>
 237                 /// <param name="serviceType">The service <see cref="Type"/> that this component implements.</param>
 238                 /// <param name="classType">The <see cref="Type"/> of the component.</param>
 239                 /// <param name="lifestyle">The specified <see cref="LifestyleType"/> for the component.</param>
 240                 /// <remarks>
 241                 /// If you have indicated a lifestyle for the specified <paramref name="classType"/> using
 242                 /// attributes, this method will not overwrite that lifestyle. To do that, use the
 243                 /// <see cref="AddComponent(string,Type,Type,LifestyleType,bool)"/> method.
 244                 /// </remarks>
 245                 /// <exception cref="ArgumentNullException">
 246                 /// Thrown if <paramref name="key"/>, <paramref name="serviceType"/>, or <paramref name="classType"/>
 247                 /// are <see langword="null"/>.
 248                 /// </exception>
 249                 /// <exception cref="ArgumentException">
 250                 /// Thrown if <paramref name="lifestyle"/> is <see cref="LifestyleType.Undefined"/>.
 251                 /// </exception>
 252                 public void AddComponent(string key, Type serviceType, Type classType, LifestyleType lifestyle)
 253                 {
 254                         AddComponent(key, serviceType, classType, lifestyle, false);
 255                 }
 256
 257                 /// <summary>
 258                 /// Adds a concrete class and an interface
 259                 /// as a component with the specified <paramref name="lifestyle"/>.
 260                 /// </summary>
 261                 /// <param name="key">The key with which to index the component.</param>
 262                 /// <param name="serviceType">The service <see cref="Type"/> that this component implements.</param>
 263                 /// <param name="classType">The <see cref="Type"/> of the component.</param>
 264                 /// <param name="lifestyle">The specified <see cref="LifestyleType"/> for the component.</param>
 265                 /// <param name="overwriteLifestyle">
 266                 /// If <see langword="true"/>, then ignores all other configurations
 267                 /// for lifestyle and uses the value in the <paramref name="lifestyle"/> parameter.
 268                 /// </param>
 269                 /// <remarks>
 270                 /// If you have indicated a lifestyle for the specified <paramref name="classType"/> using
 271                 /// attributes, this method will not overwrite that lifestyle. To do that, use the
 272                 /// <see cref="AddComponent(string,Type,Type,LifestyleType,bool)"/> method.
 273                 /// </remarks>
 274                 /// <exception cref="ArgumentNullException">
 275                 /// Thrown if <paramref name="key"/>, <paramref name="serviceType"/>, or <paramref name="classType"/>
 276                 /// are <see langword="null"/>.
 277                 /// </exception>
 278                 /// <exception cref="ArgumentException">
 279                 /// Thrown if <paramref name="lifestyle"/> is <see cref="LifestyleType.Undefined"/>.
 280                 /// </exception>
 281                 public void AddComponent(string key, Type serviceType, Type classType, LifestyleType lifestyle,
 282                                                                  bool overwriteLifestyle)
 283                 {
 284                         if (key == null) throw new ArgumentNullException("key");
 285                         if (serviceType == null) throw new ArgumentNullException("serviceType");
 286                         if (classType == null) throw new ArgumentNullException("classType");
 287                         if (LifestyleType.Undefined == lifestyle)
 288                                 throw new ArgumentException("The specified lifestyle must be Thread, Transient, or Singleton.", "lifestyle");
 289
 290                         ComponentModel model = ComponentModelBuilder.BuildModel(key, serviceType, classType, null);
 291
 292                         if (overwriteLifestyle || LifestyleType.Undefined == model.LifestyleType)
 293                         {
 294                                 model.LifestyleType = lifestyle;
 295                         }
 296
 297                         RaiseComponentModelCreated(model);
 298
 299                         IHandler handler = HandlerFactory.Create(model);
 300                         RegisterHandler(key, handler);
 301                 }
 302
 303                 /// <summary>
 304                 ///
 305                 /// </summary>
 306                 /// <param name="key"></param>
 307                 /// <param name="classType"></param>
 308                 /// <param name="parameters"></param>
 309                 public virtual void AddComponentWithExtendedProperties(String key, Type classType, IDictionary parameters)
 310                 {
 311                         if (key == null) throw new ArgumentNullException("key");
 312                         if (parameters == null) throw new ArgumentNullException("parameters");
 313                         if (classType == null) throw new ArgumentNullException("classType");
 314
 315                         ComponentModel model = ComponentModelBuilder.BuildModel(key, classType, classType, parameters);
 316                         RaiseComponentModelCreated(model);
 317                         IHandler handler = HandlerFactory.Create(model);
 318                         RegisterHandler(key, handler);
 319                 }
 320
 321                 /// <summary>
 322                 ///
 323                 /// </summary>
 324                 /// <param name="key"></param>
 325                 /// <param name="serviceType"></param>
 326                 /// <param name="classType"></param>
 327                 /// <param name="parameters"></param>
 328                 public virtual void AddComponentWithExtendedProperties(String key, Type serviceType, Type classType,
 329                                                                                                                            IDictionary parameters)
 330                 {
 331                         if (key == null) throw new ArgumentNullException("key");
 332                         if (parameters == null) throw new ArgumentNullException("parameters");
 333                         if (serviceType == null) throw new ArgumentNullException("serviceType");
 334                         if (classType == null) throw new ArgumentNullException("classType");
 335
 336                         ComponentModel model = ComponentModelBuilder.BuildModel(key, serviceType, classType, parameters);
 337                         RaiseComponentModelCreated(model);
 338                         IHandler handler = HandlerFactory.Create(model);
 339                         RegisterHandler(key, handler);
 340                 }
 341
 342                 /// <summary>
 343                 ///
 344                 /// </summary>
 345                 /// <param name="model"></param>
 346                 public virtual void AddCustomComponent(ComponentModel model)
 347                 {
 348                         if (model == null) throw new ArgumentNullException("model");
 349
 350                         RaiseComponentModelCreated(model);
 351                         IHandler handler = HandlerFactory.Create(model);
 352
 353                         object skipRegistration = model.ExtendedProperties[ComponentModel.SkipRegistration];
 354
 355                         if (skipRegistration != null)
 356                         {
 357                                 RegisterHandler(model.Name, handler, (bool)skipRegistration);
 358                         }
 359                         else
 360                         {
 361                                 RegisterHandler(model.Name, handler);
 362                         }
 363                 }
 364
 365                 /// <summary>
 366                 /// Used mostly by facilities. Adds an instance
 367                 /// to be used as a component.
 368                 /// </summary>
 369                 /// <param name="key"></param>
 370                 /// <param name="instance"></param>
 371                 public void AddComponentInstance(String key, object instance)
 372                 {
 373                         if (key == null) throw new ArgumentNullException("key");
 374                         if (instance == null) throw new ArgumentNullException("instance");
 375
 376                         Type classType = instance.GetType();
 377
 378                         ComponentModel model = new ComponentModel(key, classType, classType);
 379                         model.CustomComponentActivator = typeof(ExternalInstanceActivator);
 380                         model.ExtendedProperties["instance"] = instance;
 381
 382                         RaiseComponentModelCreated(model);
 383                         IHandler handler = HandlerFactory.Create(model);
 384                         RegisterHandler(key, handler);
 385                 }
 386
 387                 /// <summary>
 388                 /// Used mostly by facilities. Adds an instance
 389                 /// to be used as a component.
 390                 /// </summary>
 391                 /// <param name="key"></param>
 392                 /// <param name="serviceType"></param>
 393                 /// <param name="instance"></param>
 394                 public void AddComponentInstance(String key, Type serviceType, object instance)
 395                 {
 396                         AddComponentInstance(key, serviceType, instance.GetType(), instance);
 397                 }
 398
 399                 public void AddComponentInstance(string key, Type serviceType, Type classType, object instance)
 400                 {
 401                         if (key == null) throw new ArgumentNullException("key");
 402                         if (serviceType == null) throw new ArgumentNullException("serviceType");
 403                         if (instance == null) throw new ArgumentNullException("instance");
 404                         if (classType == null) throw new ArgumentNullException("classType");
 405
 406                         ComponentModel model = new ComponentModel(key, serviceType, classType);
 407                         model.CustomComponentActivator = typeof(ExternalInstanceActivator);
 408                         model.ExtendedProperties["instance"] = instance;
 409
 410                         RaiseComponentModelCreated(model);
 411                         IHandler handler = HandlerFactory.Create(model);
 412                         RegisterHandler(key, handler);
 413                 }
 414
 415                 /// <summary>
 416                 /// Adds a concrete class as a component
 417                 /// </summary>
 418                 public void AddComponent<T>()
 419                 {
 420                         Type classType = typeof(T);
 421                         AddComponent(classType.FullName, classType);
 422                 }
 423
 424                 /// <summary>
 425                 /// Adds a concrete class
 426                 /// as a component with the specified <paramref name="lifestyle"/>.
 427                 /// </summary>
 428                 /// <param name="lifestyle">The specified <see cref="LifestyleType"/> for the component.</param>
 429                 /// <remarks>
 430                 /// If you have indicated a lifestyle for the specified T using
 431                 /// attributes, this method will not overwrite that lifestyle. To do that, use the
 432                 /// <see cref="AddComponent(string,Type,LifestyleType,bool)"/> method.
 433                 /// </remarks>
 434                 /// <exception cref="ArgumentException">
 435                 /// Thrown if <paramref name="lifestyle"/> is <see cref="LifestyleType.Undefined"/>.
 436                 /// </exception>
 437                 public void AddComponent<T>(LifestyleType lifestyle)
 438                 {
 439                         Type classType = typeof(T);
 440                         AddComponent(classType.FullName, classType, lifestyle);
 441                 }
 442
 443                 /// <summary>
 444                 /// Adds a concrete class
 445                 /// as a component with the specified <paramref name="lifestyle"/>.
 446                 /// </summary>
 447                 /// <param name="lifestyle">The specified <see cref="LifestyleType"/> for the component.</param>
 448                 /// <param name="overwriteLifestyle">If <see langword="true"/>, then ignores all other configurations
 449                 /// for lifestyle and uses the value in the <paramref name="lifestyle"/> parameter.</param>
 450                 /// <remarks>
 451                 /// If you have indicated a lifestyle for the specified T using
 452                 /// attributes, this method will not overwrite that lifestyle. To do that, use the
 453                 /// <see cref="AddComponent(string,Type,LifestyleType,bool)"/> method.
 454                 /// </remarks>
 455                 /// <exception cref="ArgumentException"/>
 456                 /// Thrown if
 457                 /// <paramref name="lifestyle"/>
 458                 ///  is
 459                 /// <see cref="LifestyleType.Undefined"/>
 460                 /// .
 461                 public void AddComponent<T>(LifestyleType lifestyle, bool overwriteLifestyle)
 462                 {
 463                         Type classType = typeof(T);
 464                         AddComponent(classType.FullName, classType, lifestyle, overwriteLifestyle);
 465                 }
 466
 467                 /// <summary>
 468                 /// Adds a concrete class and an interface
 469                 /// as a component
 470                 /// </summary>
 471                 /// <param name="serviceType">The service <see cref="Type"/> that this component implements.</param>
 472                 public void AddComponent<T>(Type serviceType)
 473                 {
 474                         Type classType = typeof(T);
 475                         AddComponent(classType.FullName, serviceType, classType);
 476                 }
 477
 478                 /// <summary>
 479                 /// Adds a concrete class and an interface
 480                 /// as a component with the specified <paramref name="lifestyle"/>.
 481                 /// </summary>
 482                 /// <param name="serviceType">The service <see cref="Type"/> that this component implements.</param>
 483                 /// <param name="lifestyle">The specified <see cref="LifestyleType"/> for the component.</param>
 484                 /// <remarks>
 485                 /// If you have indicated a lifestyle for the specified T using
 486                 /// attributes, this method will not overwrite that lifestyle. To do that, use the
 487                 /// <see cref="AddComponent(string,Type,Type,LifestyleType,bool)"/> method.
 488                 /// </remarks>
 489                 /// <exception cref="ArgumentNullException">
 490                 /// are <see langword="null"/>.
 491                 /// </exception>
 492                 /// <exception cref="ArgumentException">
 493                 /// Thrown if <paramref name="lifestyle"/> is <see cref="LifestyleType.Undefined"/>.
 494                 /// </exception>
 495                 public void AddComponent<T>(Type serviceType, LifestyleType lifestyle)
 496                 {
 497                         Type classType = typeof(T);
 498                         AddComponent(classType.FullName, serviceType, classType, lifestyle);
 499                 }
 500
 501                 /// <summary>
 502                 /// Adds a concrete class and an interface
 503                 /// as a component with the specified <paramref name="lifestyle"/>.
 504                 /// </summary>
 505                 /// <param name="serviceType">The service <see cref="Type"/> that this component implements.</param>
 506                 /// <param name="lifestyle">The specified <see cref="LifestyleType"/> for the component.</param>
 507                 /// <param name="overwriteLifestyle">If <see langword="true"/>, then ignores all other configurations
 508                 /// for lifestyle and uses the value in the <paramref name="lifestyle"/> parameter.</param>
 509                 /// <remarks>
 510                 /// attributes, this method will not overwrite that lifestyle. To do that, use the
 511                 /// <see cref="AddComponent(string,Type,Type,LifestyleType,bool)"/> method.
 512                 /// </remarks>
 513                 /// <exception cref="ArgumentNullException">
 514                 /// are <see langword="null"/>.
 515                 /// </exception>
 516                 /// <exception cref="ArgumentException">
 517                 /// Thrown if <paramref name="lifestyle"/> is <see cref="LifestyleType.Undefined"/>.
 518                 /// </exception>
 519                 public void AddComponent<T>(Type serviceType, LifestyleType lifestyle, bool overwriteLifestyle)
 520                 {
 521                         Type classType = typeof(T);
 522                         AddComponent(classType.FullName, serviceType, classType, lifestyle, overwriteLifestyle);
 523                 }
 524
 525                 /// <summary>
 526                 /// Used mostly by facilities. Adds an instance
 527                 /// to be used as a component.
 528                 /// </summary>
 529                 /// <param name="instance"></param>
 530                 public void AddComponentInstance<T>(object instance)
 531                 {
 532                         Type serviceType = typeof(T);
 533                         AddComponentInstance(serviceType.FullName, serviceType, instance);
 534                 }
 535
 536                 /// <summary>
 537                 /// Used mostly by facilities. Adds an instance
 538                 /// to be used as a component.
 539                 /// </summary>
 540                 /// <param name="serviceType"></param>
 541                 /// <param name="instance"></param>
 542                 public void AddComponentInstance<T>(Type serviceType, object instance)
 543                 {
 544                         Type classType = typeof(T);
 545                         AddComponentInstance(classType.FullName, serviceType, classType, instance);
 546                 }
 547
 548                 /// <summary>
 549                 /// Registers the components described by the <see cref="ComponentRegistration{S}"/>s
 550                 /// with the <see cref="IKernel"/>.
 551                 /// <param name="registrations">The component registrations.</param>
 552                 /// <returns>The kernel.</returns>
 553                 /// </summary>
 554                 public IKernel Register(params IComponentRegistration[] registrations)
 555                 {
 556                         if (registrations == null)
 557                         {
 558                                 throw new ArgumentNullException("registrations");
 559                         }
 560
 561                         foreach(IComponentRegistration registration in registrations)
 562                         {
 563                                 registration.Register(this);
 564                         }
 565
 566                         return this;
 567                 }
 568
 569                 /// <summary>
 570                 /// Returns the component instance by the service type
 571                 /// using dynamic arguments
 572                 /// </summary>
 573                 /// <param name="arguments"></param>
 574                 /// <returns></returns>
 575                 public T Resolve<T>(IDictionary arguments)
 576                 {
 577                         Type serviceType = typeof(T);
 578                         return (T)Resolve(serviceType, arguments);
 579                 }
 580
 581                 /// <summary>
 582                 /// Returns the component instance by the service type
 583                 /// using dynamic arguments
 584                 /// </summary>
 585                 /// <param name="argumentsAsAnonymousType"></param>
 586                 /// <returns></returns>
 587                 public T Resolve<T>(object argumentsAsAnonymousType)
 588                 {
 589                         return Resolve<T>(new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
 590                 }
 591
 592                 /// <summary>
 593                 /// Returns the component instance by the component key
 594                 /// </summary>
 595                 /// <returns></returns>
 596                 public T Resolve<T>()
 597                 {
 598                         Type serviceType = typeof(T);
 599                         return (T)Resolve(serviceType);
 600                 }
 601
 602                 /// <summary>
 603                 /// Returns true if the specified component was
 604                 /// found and could be removed (i.e. no other component depends on it)
 605                 /// </summary>
 606                 /// <param name="key">The component's key</param>
 607                 /// <returns></returns>
 608                 public virtual bool RemoveComponent(String key)
 609                 {
 610                         if (key == null) throw new ArgumentNullException("key");
 611
 612                         if (NamingSubSystem.Contains(key))
 613                         {
 614                                 IHandler handler = GetHandler(key);
 615
 616                                 if (handler.ComponentModel.Dependers.Length == 0)
 617                                 {
 618                                         NamingSubSystem.UnRegister(key);
 619
 620                                         IHandler[] assignableHandlers = GetAssignableHandlers(handler.ComponentModel.Service);
 621                                         if (assignableHandlers.Length > 0)
 622                                         {
 623                                                 NamingSubSystem[handler.ComponentModel.Service] = assignableHandlers[0];
 624                                         }
 625                                         else
 626                                         {
 627                                                 NamingSubSystem.UnRegister(handler.ComponentModel.Service);
 628                                         }
 629
 630                                         foreach (ComponentModel model in handler.ComponentModel.Dependents)
 631                                         {
 632                                                 model.RemoveDepender(handler.ComponentModel);
 633                                         }
 634
 635                                         RaiseComponentUnregistered(key, handler);
 636
 637                                         DisposeHandler(handler);
 638
 639                                         return true;
 640                                 }
 641                                 else
 642                                 {
 643                                         // We can't remove this component as there are
 644                                         // others which depends on it
 645
 646                                         return false;
 647                                 }
 648                         }
 649
 650                         if (Parent != null)
 651                         {
 652                                 return Parent.RemoveComponent(key);
 653                         }
 654
 655                         return false;
 656                 }
 657
 658                 public virtual bool HasComponent(String key)
 659                 {
 660                         if (key == null) throw new ArgumentNullException("key");
 661
 662                         if (NamingSubSystem.Contains(key))
 663                         {
 664                                 return true;
 665                         }
 666
 667                         if (Parent != null)
 668                         {
 669                                 return Parent.HasComponent(key);
 670                         }
 671
 672                         return false;
 673                 }
 674
 675                 public virtual bool HasComponent(Type serviceType)
 676                 {
 677                         if (serviceType == null) throw new ArgumentNullException("serviceType");
 678
 679                         if (NamingSubSystem.Contains(serviceType))
 680                         {
 681                                 return true;
 682                         }
 683
 684                         if (serviceType.IsGenericType && NamingSubSystem.Contains(serviceType.GetGenericTypeDefinition()))
 685                         {
 686                                 return true;
 687                         }
 688
 689                         if (Parent != null)
 690                         {
 691                                 return Parent.HasComponent(serviceType);
 692                         }
 693
 694                         return false;
 695                 }
 696
 697                 public virtual object this[String key]
 698                 {
 699                         get
 700                         {
 701                                 if (key == null) throw new ArgumentNullException("key");
 702
 703                                 if (!HasComponent(key))
 704                                 {
 705                                         throw new ComponentNotFoundException(key);
 706                                 }
 707
 708                                 IHandler handler = GetHandler(key);
 709
 710                                 return ResolveComponent(handler);
 711                         }
 712                 }
 713
 714                 public virtual object this[Type service]
 715                 {
 716                         get
 717                         {
 718                                 if (service == null) throw new ArgumentNullException("service");
 719
 720                                 if (!HasComponent(service))
 721                                 {
 722                                         throw new ComponentNotFoundException(service);
 723                                 }
 724
 725                                 IHandler handler = GetHandler(service);
 726
 727                                 return ResolveComponent(handler, service);
 728                         }
 729                 }
 730
 731                 /// <summary>
 732                 /// Returns the component instance by the service type
 733                 /// </summary>
 734                 public object Resolve(Type service)
 735                 {
 736                         if (service == null) throw new ArgumentNullException("service");
 737
 738                         return this[service];
 739                 }
 740
 741                 /// <summary>
 742                 /// Returns all the valid component instances by
 743                 /// the service type
 744                 /// </summary>
 745                 /// <param name="service">The service type</param>
 746                 /// <param name="arguments">Arguments to resolve the services</param>
 747                 public Array ResolveAll(Type service, IDictionary arguments)
 748                 {
 749                         ArrayList list = new ArrayList();
 750                         IHandler[] handlers = GetAssignableHandlers(service);
 751                         foreach (IHandler handler in handlers)
 752                         {
 753                                 object component = ResolveComponent(handler, service, arguments);
 754                                 list.Add(component);
 755                         }
 756                         return list.ToArray(service);
 757                 }
 758
 759                 /// <summary>
 760                 /// Returns all the valid component instances by
 761                 /// the service type
 762                 /// </summary>
 763                 /// <param name="service">The service type</param>
 764                 /// <param name="argumentsAsAnonymousType">Arguments to resolve the services</param>
 765                 public Array ResolveAll(Type service, object argumentsAsAnonymousType)
 766                 {
 767                         return ResolveAll(service, new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
 768                 }
 769
 770                 /// <summary>
 771                 /// Returns the component instance by the service type
 772                 /// using dynamic arguments
 773                 /// </summary>
 774                 /// <param name="service"></param>
 775                 /// <param name="arguments"></param>
 776                 /// <returns></returns>
 777                 public object Resolve(Type service, IDictionary arguments)
 778                 {
 779                         if (service == null) throw new ArgumentNullException("service");
 780                         if (arguments == null) throw new ArgumentNullException("arguments");
 781
 782                         if (!HasComponent(service))
 783                         {
 784                                 throw new ComponentNotFoundException(service);
 785                         }
 786
 787                         IHandler handler = GetHandler(service);
 788
 789                         return ResolveComponent(handler, service, arguments);
 790                 }
 791
 792                 /// <summary>
 793                 /// Returns the component instance by the service type
 794                 /// using dynamic arguments
 795                 /// </summary>
 796                 /// <param name="service"></param>
 797                 /// <param name="argumentsAsAnonymousType"></param>
 798                 /// <returns></returns>
 799                 public object Resolve(Type service, object argumentsAsAnonymousType)
 800                 {
 801                         return Resolve(service, new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
 802                 }
 803
 804                 /// <summary>
 805                 /// Returns the component instance by the component key
 806                 /// using dynamic arguments
 807                 /// </summary>
 808                 /// <param name="key"></param>
 809                 /// <param name="arguments"></param>
 810                 /// <returns></returns>
 811                 public object Resolve(string key, IDictionary arguments)
 812                 {
 813                         if (key == null) throw new ArgumentNullException("key");
 814                         if (arguments == null) throw new ArgumentNullException("arguments");
 815
 816                         if (!HasComponent(key))
 817                         {
 818                                 throw new ComponentNotFoundException(key);
 819                         }
 820
 821                         IHandler handler = GetHandler(key);
 822
 823                         return ResolveComponent(handler, arguments);
 824                 }
 825
 826                 /// <summary>
 827                 /// Returns the component instance by the component key
 828                 /// using dynamic arguments
 829                 /// </summary>
 830                 /// <param name="key"></param>
 831                 /// <param name="argumentsAsAnonymousType"></param>
 832                 /// <returns></returns>
 833                 public object Resolve(string key, object argumentsAsAnonymousType)
 834                 {
 835                         return Resolve(key, new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
 836                 }
 837
 838                 /// <summary>
 839                 /// Associates objects with a component handler,
 840                 /// allowing it to use the specified dictionary
 841                 /// when resolving dependencies
 842                 /// </summary>
 843                 /// <param name="service"></param>
 844                 /// <param name="dependencies"></param>
 845                 public void RegisterCustomDependencies(Type service, IDictionary dependencies)
 846                 {
 847                         IHandler handler = GetHandler(service);
 848
 849                         foreach (DictionaryEntry entry in dependencies)
 850                         {
 851                                 handler.AddCustomDependencyValue(entry.Key.ToString(), entry.Value);
 852                         }
 853                 }
 854
 855                 /// <summary>
 856                 /// Associates objects with a component handler,
 857                 /// allowing it to use the specified dictionary
 858                 /// when resolving dependencies
 859                 /// </summary>
 860                 /// <param name="service"></param>
 861                 /// <param name="dependenciesAsAnonymousType"></param>
 862                 public void RegisterCustomDependencies(Type service, object dependenciesAsAnonymousType)
 863                 {
 864                         RegisterCustomDependencies(service, new ReflectionBasedDictionaryAdapter(dependenciesAsAnonymousType));
 865                 }
 866
 867                 /// <summary>
 868                 /// Associates objects with a component handler,
 869                 /// allowing it to use the specified dictionary
 870                 /// when resolving dependencies
 871                 /// </summary>
 872                 /// <param name="key"></param>
 873                 /// <param name="dependencies"></param>
 874                 public void RegisterCustomDependencies(String key, IDictionary dependencies)
 875                 {
 876                         IHandler handler = GetHandler(key);
 877
 878                         foreach (DictionaryEntry entry in dependencies)
 879                         {
 880                                 handler.AddCustomDependencyValue(entry.Key.ToString(), entry.Value);
 881                         }
 882                 }
 883
 884                 /// <summary>
 885                 /// Associates objects with a component handler,
 886                 /// allowing it to use the specified dictionary
 887                 /// when resolving dependencies
 888                 /// </summary>
 889                 /// <param name="key"></param>
 890                 /// <param name="dependenciesAsAnonymousType"></param>
 891                 public void RegisterCustomDependencies(String key, object dependenciesAsAnonymousType)
 892                 {
 893                         RegisterCustomDependencies(key, new ReflectionBasedDictionaryAdapter(dependenciesAsAnonymousType));
 894                 }
 895
 896                 /// <summary>
 897                 /// Returns a component instance by the key
 898                 /// </summary>
 899                 /// <param name="key"></param>
 900                 /// <param name="service"></param>
 901                 /// <returns></returns>
 902                 public virtual object Resolve(String key, Type service)
 903                 {
 904                         if (key == null) throw new ArgumentNullException("key");
 905                         if (service == null) throw new ArgumentNullException("service");
 906
 907                         if (!HasComponent(key))
 908                         {
 909                                 throw new ComponentNotFoundException(key);
 910                         }
 911
 912                         IHandler handler = GetHandler(key);
 913
 914                         return ResolveComponent(handler, service);
 915                 }
 916
 917
 918                 public TService[] ResolveServices<TService>()
 919                 {
 920                         List<TService> services = new List<TService>();
 921                         IHandler[] handlers = GetHandlers(typeof(TService));
 922
 923                         foreach (IHandler handler in handlers)
 924                         {
 925                                 if (handler.CurrentState == HandlerState.Valid)
 926                                 {
 927                                         services.Add((TService)ResolveComponent(handler));
 928                                 }
 929                         }
 930
 931                         return services.ToArray();
 932                 }
 933
 934                 /// <summary>
 935                 /// Returns a component instance by the key
 936                 /// </summary>
 937                 /// <param name="key"></param>
 938                 /// <param name="service"></param>
 939                 /// <param name="arguments"></param>
 940                 /// <returns></returns>
 941                 public virtual object Resolve(String key, Type service, IDictionary arguments)
 942                 {
 943                         if (key == null) throw new ArgumentNullException("key");
 944                         if (service == null) throw new ArgumentNullException("service");
 945
 946                         if (!HasComponent(key))
 947                         {
 948                                 throw new ComponentNotFoundException(key);
 949                         }
 950
 951                         IHandler handler = GetHandler(key);
 952
 953                         return ResolveComponent(handler, service, arguments);
 954                 }
 955
 956                 /// <summary>
 957                 /// Resolves the specified key.
 958                 /// </summary>
 959                 /// <param name="key">The key.</param>
 960                 /// <param name="service">The service.</param>
 961                 /// <param name="argumentsAsAnonymousType">Type of the arguments as anonymous.</param>
 962                 /// <returns></returns>
 963                 public virtual object Resolve(String key, Type service, object argumentsAsAnonymousType)
 964                 {
 965                         return Resolve(key, service, new ReflectionBasedDictionaryAdapter(argumentsAsAnonymousType));
 966                 }
 967
 968                 /// <summary>
 969                 /// Releases a component instance. This allows
 970                 /// the kernel to execute the proper decomission
 971                 /// lifecycles on the component instance.
 972                 /// </summary>
 973                 /// <param name="instance"></param>
 974                 public virtual void ReleaseComponent(object instance)
 975                 {
 976                         if (ReleasePolicy.HasTrack(instance))
 977                         {
 978                                 ReleasePolicy.Release(instance);
 979                         }
 980                         else
 981                         {
 982                                 if (Parent != null)
 983                                 {
 984                                         Parent.ReleaseComponent(instance);
 985                                 }
 986                         }
 987                 }
 988
 989                 public IHandlerFactory HandlerFactory
 990                 {
 991                         get { return handlerFactory; }
 992                 }
 993
 994                 public IComponentModelBuilder ComponentModelBuilder
 995                 {
 996                         get { return modelBuilder; }
 997                         set { modelBuilder = value; }
 998                 }
 999
1000                 public IProxyFactory ProxyFactory
1001                 {
1002                         get { return proxyFactory; }
1003                         set { proxyFactory = value; }
1004                 }
1005
1006                 public virtual IConfigurationStore ConfigurationStore
1007                 {
1008                         get { return GetSubSystem(SubSystemConstants.ConfigurationStoreKey) as IConfigurationStore; }
1009                         set { AddSubSystem(SubSystemConstants.ConfigurationStoreKey, value); }
1010                 }
1011
1012                 public virtual IHandler GetHandler(String key)
1013                 {
1014                         if (key == null) throw new ArgumentNullException("key");
1015
1016                         IHandler handler = NamingSubSystem.GetHandler(key);
1017
1018                         if (handler == null && Parent != null)
1019                         {
1020                                 handler = WrapParentHandler(Parent.GetHandler(key));
1021                         }
1022
1023                         return handler;
1024                 }
1025
1026                 public virtual IHandler GetHandler(Type service)
1027                 {
1028                         if (service == null) throw new ArgumentNullException("service");
1029
1030                         IHandler handler = NamingSubSystem.GetHandler(service);
1031
1032                         if (handler == null && service.IsGenericType)
1033                         {
1034                                 handler = NamingSubSystem.GetHandler(service.GetGenericTypeDefinition());
1035                         }
1036
1037                         if (handler == null && Parent != null)
1038                         {
1039                                 handler = WrapParentHandler(Parent.GetHandler(service));
1040                         }
1041
1042                         return handler;
1043                 }
1044
1045                 /// <summary>
1046                 /// Return handlers for components that
1047                 /// implements the specified service.
1048                 /// </summary>
1049                 /// <param name="service"></param>
1050                 /// <returns></returns>
1051                 public virtual IHandler[] GetHandlers(Type service)
1052                 {
1053                         IHandler[] result = NamingSubSystem.GetHandlers(service);
1054
1055                         // a complete generic type, Foo<Bar>, need to check if Foo<T> is registered
1056                         if (service.IsGenericType && !service.IsGenericTypeDefinition)
1057                         {
1058                                 IHandler[] genericResult = NamingSubSystem.GetHandlers(service.GetGenericTypeDefinition());
1059
1060                                 if (result.Length > 0)
1061                                 {
1062                                         IHandler[] mergedResult = new IHandler[result.Length + genericResult.Length];
1063                                         result.CopyTo(mergedResult, 0);
1064                                         genericResult.CopyTo(mergedResult, result.Length);
1065                                         result = mergedResult;
1066                                 }
1067                                 else
1068                                 {
1069                                         result = genericResult;
1070                                 }
1071                         }
1072
1073                         // If a parent kernel exists, we merge both results
1074                         if (Parent != null)
1075                         {
1076                                 IHandler[] parentResult = Parent.GetHandlers(service);
1077
1078                                 if (parentResult.Length > 0)
1079                                 {
1080                                         IHandler[] newResult = new IHandler[result.Length + parentResult.Length];
1081                                         result.CopyTo(newResult, 0);
1082                                         parentResult.CopyTo(newResult, result.Length);
1083                                         result = newResult;
1084                                 }
1085                         }
1086
1087                         return result;
1088                 }
1089
1090                 /// <summary>
1091                 /// Return handlers for components that
1092                 /// implements the specified service.
1093                 /// The check is made using IsAssignableFrom
1094                 /// </summary>
1095                 /// <param name="service"></param>
1096                 /// <returns></returns>
1097                 public virtual IHandler[] GetAssignableHandlers(Type service)
1098                 {
1099                         return NamingSubSystem.GetAssignableHandlers(service);
1100                 }
1101
1102                 public virtual IReleasePolicy ReleasePolicy
1103                 {
1104                         get { return releaserPolicy; }
1105                         set { releaserPolicy = value; }
1106                 }
1107
1108                 public virtual void AddFacility(String key, IFacility facility)
1109                 {
1110                         if (key == null) throw new ArgumentNullException("key");
1111                         if (facility == null) throw new ArgumentNullException("facility");
1112
1113                         facility.Init(this, ConfigurationStore.GetFacilityConfiguration(key));
1114
1115                         facilities.Add(facility);
1116                 }
1117
1118                 /// <summary>
1119                 /// Returns the facilities registered on the kernel.
1120                 /// </summary>
1121                 /// <returns></returns>
1122                 public virtual IFacility[] GetFacilities()
1123                 {
1124                         IFacility[] list = new IFacility[facilities.Count];
1125                         facilities.CopyTo(list, 0);
1126                         return list;
1127                 }
1128
1129                 public virtual void AddSubSystem(String key, ISubSystem subsystem)
1130                 {
1131                         if (key == null) throw new ArgumentNullException("key");
1132                         if (subsystem == null) throw new ArgumentNullException("facility");
1133
1134                         subsystem.Init(this);
1135                         subsystems[key] = subsystem;
1136                 }
1137
1138                 public virtual ISubSystem GetSubSystem(String key)
1139                 {
1140                         if (key == null) throw new ArgumentNullException("key");
1141
1142                         return subsystems[key] as ISubSystem;
1143                 }
1144
1145                 public virtual void AddChildKernel(IKernel childKernel)
1146                 {
1147                         if (childKernel == null) throw new ArgumentNullException("childKernel");
1148
1149                         childKernel.Parent = this;
1150                         childKernels.Add(childKernel);
1151                 }
1152
1153                 public virtual IKernel Parent
1154                 {
1155                         get { return parentKernel; }
1156                         set
1157                         {
1158                                 // TODO: should the raise add/removed as child kernel methods be invoked from within the subscriber/unsubscribe methods?
1159
1160                                 if (value == null)
1161                                 {
1162                                         if (parentKernel != null)
1163                                         {
1164                                                 UnsubscribeFromParentKernel();
1165                                                 RaiseRemovedAsChildKernel();
1166                                         }
1167
1168                                         parentKernel = null;
1169                                 }
1170                                 else
1171                                 {
1172                                         if ((parentKernel != value) && (parentKernel != null))
1173                                         {
1174                                                 throw new KernelException(
1175                                                         "You can not change the kernel parent once set, use the RemoveChildKernel and AddChildKernel methods together to achieve this.");
1176                                         }
1177                                         parentKernel = value;
1178                                         SubscribeToParentKernel();
1179                                         RaiseAddedAsChildKernel();
1180                                 }
1181                         }
1182                 }
1183
1184                 public IDependencyResolver Resolver
1185                 {
1186                         get { return resolver; }
1187                 }
1188
1189                 public virtual IComponentActivator CreateComponentActivator(ComponentModel model)
1190                 {
1191                         if (model == null) throw new ArgumentNullException("model");
1192
1193                         IComponentActivator activator;
1194
1195                         if (model.CustomComponentActivator == null)
1196                         {
1197                                 activator = new DefaultComponentActivator(model, this,
1198                                                                                                                   new ComponentInstanceDelegate(RaiseComponentCreated),
1199                                                                                                                   new ComponentInstanceDelegate(RaiseComponentDestroyed));
1200                         }
1201                         else
1202                         {
1203                                 try
1204                                 {
1205                                         activator = (IComponentActivator)
1206                                                                 Activator.CreateInstance(model.CustomComponentActivator,
1207                                                                                                                  new object[]
1208                                                                                 {
1209                                                                                         model,
1210                                                                                         this,
1211                                                                                         new ComponentInstanceDelegate(RaiseComponentCreated),
1212                                                                                         new ComponentInstanceDelegate(RaiseComponentDestroyed)
1213                                                                                 });
1214                                 }
1215                                 catch (Exception e)
1216                                 {
1217                                         throw new KernelException("Could not instantiate custom activator", e);
1218                                 }
1219                         }
1220
1221                         return activator;
1222                 }
1223
1224                 /// <summary>
1225                 /// Graph of components and iteractions.
1226                 /// </summary>
1227                 public GraphNode[] GraphNodes
1228                 {
1229                         get
1230                         {
1231                                 GraphNode[] nodes = new GraphNode[NamingSubSystem.ComponentCount];
1232
1233                                 int index = 0;
1234
1235                                 IHandler[] handlers = NamingSubSystem.GetHandlers();
1236
1237                                 foreach (IHandler handler in handlers)
1238                                 {
1239                                         nodes[index++] = handler.ComponentModel;
1240                                 }
1241
1242                                 return nodes;
1243                         }
1244                 }
1245
1246                 public virtual void RemoveChildKernel(IKernel childKernel)
1247                 {
1248                         if (childKernel == null) throw new ArgumentNullException("childKernel");
1249                         childKernel.Parent = null;
1250                         childKernels.Remove(childKernel);
1251                 }
1252
1253                 #endregion
1254
1255                 #region IServiceProviderEx Members
1256
1257                 /// <summary>
1258                 /// Gets the service object of the specified type.
1259                 /// </summary>
1260                 ///
1261                 /// <returns>
1262                 /// A service object of type serviceType.
1263                 /// </returns>
1264                 ///
1265                 /// <param name="serviceType">An object that specifies the type of service object to get. </param>
1266                 public object GetService(Type serviceType)
1267                 {
1268                         if (!HasComponent(serviceType))
1269                         {
1270                                 return null;
1271                         }
1272
1273                         return Resolve(serviceType);
1274                 }
1275
1276                 /// <summary>
1277                 /// Gets the service object of the specified type.
1278                 /// </summary>
1279                 ///
1280                 /// <returns>
1281                 /// A service object of type serviceType.
1282                 /// </returns>
1283                 public T GetService<T>() where T : class
1284                 {
1285                         Type serviceType = typeof(T);
1286
1287                         if (!HasComponent(serviceType))
1288                         {
1289                                 return null;
1290                         }
1291
1292                         return (T)Resolve(serviceType);
1293                 }
1294
1295                 #endregion
1296
1297                 #region IDisposable Members
1298
1299                 /// <summary>
1300                 /// Starts the process of component disposal.
1301                 /// </summary>
1302                 public virtual void Dispose()
1303                 {
1304                         DisposeSubKernels();
1305                         TerminateFacilities();
1306                         DisposeComponentsInstancesWithinTracker();
1307                         DisposeHandlers();
1308                         UnsubscribeFromParentKernel();
1309                 }
1310
1311                 private void TerminateFacilities()
1312                 {
1313                         foreach (IFacility facility in facilities)
1314                         {
1315                                 facility.Terminate();
1316                         }
1317                 }
1318
1319                 private void DisposeHandlers()
1320                 {
1321                         GraphNode[] nodes = GraphNodes;
1322                         IVertex[] vertices = TopologicalSortAlgo.Sort(nodes);
1323
1324                         for (int i = 0; i < vertices.Length; i++)
1325                         {
1326                                 ComponentModel model = (ComponentModel)vertices[i];
1327
1328                                 // Prevent the removal of a component that belongs
1329                                 // to other container
1330                                 if (!NamingSubSystem.Contains(model.Name)) continue;
1331
1332                                 RemoveComponent(model.Name);
1333                         }
1334                 }
1335
1336                 private void UnsubscribeFromParentKernel()
1337                 {
1338                         if (parentKernel != null)
1339                         {
1340                                 parentKernel.HandlerRegistered -= new HandlerDelegate(HandlerRegisteredOnParentKernel);
1341                                 parentKernel.ComponentRegistered -= new ComponentDataDelegate(RaiseComponentRegistered);
1342                                 parentKernel.ComponentUnregistered -= new ComponentDataDelegate(RaiseComponentUnregistered);
1343                         }
1344                 }
1345
1346                 private void SubscribeToParentKernel()
1347                 {
1348                         if (parentKernel != null)
1349                         {
1350                                 parentKernel.HandlerRegistered += new HandlerDelegate(HandlerRegisteredOnParentKernel);
1351                                 parentKernel.ComponentRegistered += new ComponentDataDelegate(RaiseComponentRegistered);
1352                                 parentKernel.ComponentUnregistered += new ComponentDataDelegate(RaiseComponentUnregistered);
1353                         }
1354                 }
1355
1356                 private void HandlerRegisteredOnParentKernel(IHandler handler, ref bool stateChanged)
1357                 {
1358                         RaiseHandlerRegistered(handler);
1359                 }
1360
1361                 private void DisposeComponentsInstancesWithinTracker()
1362                 {
1363                         ReleasePolicy.Dispose();
1364                 }
1365
1366                 private void DisposeSubKernels()
1367                 {
1368                         foreach (IKernel childKernel in childKernels)
1369                         {
1370                                 childKernel.Dispose();
1371                         }
1372                 }
1373
1374                 protected void DisposeHandler(IHandler handler)
1375                 {
1376                         if (handler == null) return;
1377
1378                         if (handler is IDisposable)
1379                         {
1380                                 ((IDisposable)handler).Dispose();
1381                         }
1382                 }
1383
1384                 #endregion
1385
1386                 #region Protected members
1387
1388                 protected virtual IHandler WrapParentHandler(IHandler parentHandler)
1389                 {
1390                         if (parentHandler == null) return null;
1391
1392                         // This has a very destructive side-effect. While the goal is to resolve on same-level containers,
1393                         // the resolver will invoke GetHandler recursively, leading to stack overflows
1394                         // return new ParentHandlerWithChildResolver(parentHandler, Resolver);
1395                         return parentHandler;
1396                 }
1397
1398                 protected INamingSubSystem NamingSubSystem
1399                 {
1400                         get { return GetSubSystem(SubSystemConstants.NamingKey) as INamingSubSystem; }
1401                 }
1402
1403                 protected void RegisterHandler(String key, IHandler handler)
1404                 {
1405                         RegisterHandler(key, handler, false);
1406                 }
1407
1408                 protected void RegisterHandler(String key, IHandler handler, bool skipRegistration)
1409                 {
1410                         if (!skipRegistration)
1411                         {
1412                                 NamingSubSystem.Register(key, handler);
1413                         }
1414
1415                         base.RaiseHandlerRegistered(handler);
1416                         base.RaiseComponentRegistered(key, handler);
1417                 }
1418
1419                 protected object ResolveComponent(IHandler handler)
1420                 {
1421                         return ResolveComponent(handler, handler.ComponentModel.Service);
1422                 }
1423
1424                 protected object ResolveComponent(IHandler handler, Type service)
1425                 {
1426                         return ResolveComponent(handler, service, null);
1427                 }
1428
1429                 protected object ResolveComponent(IHandler handler, IDictionary additionalArguments)
1430                 {
1431                         return ResolveComponent(handler, handler.ComponentModel.Service, additionalArguments);
1432                 }
1433
1434                 protected object ResolveComponent(IHandler handler, Type service, IDictionary additionalArguments)
1435                 {
1436                         CreationContext context = CreateCreationContext(handler, service, additionalArguments);
1437
1438                         object instance = handler.Resolve(context);
1439
1440                         ReleasePolicy.Track(instance, handler);
1441
1442                         return instance;
1443                 }
1444
1445                 protected CreationContext CreateCreationContext(IHandler handler, Type typeToExtractGenericArguments,
1446                                                                 IDictionary additionalArguments)
1447                 {
1448                         return new CreationContext(handler, typeToExtractGenericArguments, additionalArguments);
1449                 }
1450
1451                 #endregion
1452
1453                 #region Serialization and Deserialization
1454
1455                 public override void GetObjectData(SerializationInfo info, StreamingContext context)
1456                 {
1457                         base.GetObjectData(info, context);
1458
1459                         MemberInfo[] members = FormatterServices.GetSerializableMembers(GetType(), context);
1460
1461                         object[] kernelmembers = FormatterServices.GetObjectData(this, members);
1462
1463                         info.AddValue("members", kernelmembers, typeof(object[]));
1464                 }
1465
1466                 void IDeserializationCallback.OnDeserialization(object sender)
1467                 {
1468                 }
1469
1470                 #endregion
1471         }
1472 }