Samples/InversionOfControl/AnotherExtendingSample/StartableFacility.cs

   1 // Copyright 2004-2007 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 Extending2
  16 {
  17         using System;
  18         using System.Collections;
  19
  20         using Castle.Core;
  21         using Castle.Core.Configuration;
  22
  23         using Castle.MicroKernel;
  24         using Castle.MicroKernel.LifecycleConcerns;
  25         using Castle.MicroKernel.ModelBuilder;
  26
  27         /// <summary>
  28         /// Summary description for StartableFacility.
  29         /// </summary>
  30         public class StartableFacility : IFacility
  31         {
  32                 private ArrayList _waitList = new ArrayList();
  33                 private IKernel _kernel;
  34
  35                 public void Init(IKernel kernel, IConfiguration facilityConfig)
  36                 {
  37                         _kernel = kernel;
  38
  39                         kernel.ComponentModelBuilder.AddContributor( new StartableInspector() );
  40                         kernel.ComponentRegistered +=
  41                                 new ComponentDataDelegate(OnComponentRegistered);
  42                 }
  43
  44                 public void Terminate()
  45                 {
  46                         // Nothing to do
  47                 }
  48
  49                 private class StartableInspector : IContributeComponentModelConstruction
  50                 {
  51                         public void ProcessModel(IKernel kernel, ComponentModel model)
  52                         {
  53                                 bool startable =
  54                                         typeof(IStartable).IsAssignableFrom(model.Implementation);
  55
  56                                 model.ExtendedProperties["startable"] = startable;
  57
  58                                 if (startable)
  59                                 {
  60                                         model.LifecycleSteps.Add(
  61                                                 LifecycleStepType.Commission, new StartableConcern() );
  62                                 }
  63                         }
  64
  65                         private class StartableConcern : ILifecycleConcern
  66                         {
  67                                 public void Apply(ComponentModel model, object component)
  68                                 {
  69                                         (component as IStartable).Start();
  70                                 }
  71                         }
  72                 }
  73
  74                 private void OnComponentRegistered(String key, IHandler handler)
  75                 {
  76                         bool startable = (bool)
  77                                 handler.ComponentModel.ExtendedProperties["startable"];
  78
  79                         if (startable)
  80                         {
  81                                 if (handler.CurrentState == HandlerState.WaitingDependency)
  82                                 {
  83                                         _waitList.Add( handler );
  84                                 }
  85                                 else
  86                                 {
  87                                         Start( key );
  88                                 }
  89                         }
  90
  91                         CheckWaitingList();
  92                 }
  93
  94                 /// <summary>
  95                 /// For each new component registered,
  96                 /// some components in the WaitingDependency
  97                 /// state may have became valid, so we check them
  98                 /// </summary>
  99                 private void CheckWaitingList()
 100                 {
 101                         IHandler[] handlers = (IHandler[])
 102                                 _waitList.ToArray( typeof(IHandler) );
 103
 104                         foreach(IHandler handler in handlers)
 105                         {
 106                                 if (handler.CurrentState == HandlerState.Valid)
 107                                 {
 108                                         Start( handler.ComponentModel.Name );
 109
 110                                         _waitList.Remove(handler);
 111                                 }
 112                         }
 113                 }
 114
 115                 /// <summary>
 116                 /// Request the component instance
 117                 /// </summary>
 118                 /// <param name="key"></param>
 119                 private void Start(String key)
 120                 {
 121                         try
 122                         {
 123                                 object instace = _kernel[key];
 124                         }
 125                         catch(Exception ex)
 126                         {
 127                                 throw ex;
 128                         }
 129                 }
 130         }
 131 }