MonoRail/Castle.MonoRail.Framework/Services/AbstractServiceContainer.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 Castle.MonoRail.Framework.Services
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Specialized;
  20         using System.ComponentModel.Design;
  21
  22         public abstract class AbstractServiceContainer : MarshalByRefObject, IGenericServiceContainer
  23         {
  24                 private IServiceContainer parent;
  25                 private IDictionary type2Service;
  26
  27                 /// <summary>
  28                 /// Initializes a new instance of the <see cref="AbstractServiceContainer"/> class.
  29                 /// </summary>
  30                 public AbstractServiceContainer()
  31                 {
  32                 }
  33
  34                 /// <summary>
  35                 /// Initializes a new instance of the <see cref="AbstractServiceContainer"/> class.
  36                 /// </summary>
  37                 /// <param name="parent">The parent.</param>
  38                 public AbstractServiceContainer(IServiceContainer parent)
  39                 {
  40                         this.parent = parent;
  41                 }
  42
  43                 #region IGenericServiceContainer
  44
  45                 public T GetService<T>()
  46                 {
  47                         return (T) GetService(typeof(T));
  48                 }
  49
  50                 #endregion
  51
  52                 #region IServiceContainer
  53
  54                 /// <summary>
  55                 /// Adds the specified service to the service container.
  56                 /// </summary>
  57                 /// <param name="serviceType">The type of service to add.</param>
  58                 /// <param name="serviceInstance">An instance of the service type to add. This object must implement or inherit from the type indicated by the serviceType parameter.</param>
  59                 public void AddService(Type serviceType, object serviceInstance)
  60                 {
  61                         AddService(serviceType, serviceInstance, false);
  62                 }
  63
  64                 /// <summary>
  65                 /// Adds the specified service to the service container, and optionally promotes the service to any parent service containers.
  66                 /// </summary>
  67                 /// <param name="serviceType">The type of service to add.</param>
  68                 /// <param name="serviceInstance">An instance of the service type to add. This object must implement or inherit from the type indicated by the serviceType parameter.</param>
  69                 /// <param name="promote">true to promote this request to any parent service containers; otherwise, false.</param>
  70                 public void AddService(Type serviceType, object serviceInstance, bool promote)
  71                 {
  72                         if (promote)
  73                         {
  74                                 IServiceContainer parentContainer = ParentContainer;
  75
  76                                 if (parentContainer != null)
  77                                 {
  78                                         parentContainer.AddService(serviceType, serviceInstance, promote);
  79                                         return;
  80                                 }
  81                         }
  82
  83                         if (type2Service == null)
  84                         {
  85                                 type2Service = new HybridDictionary();
  86                         }
  87
  88                         type2Service[serviceType] = serviceInstance;
  89                 }
  90
  91                 /// <summary>
  92                 /// Adds the specified service to the service container.
  93                 /// </summary>
  94                 /// <param name="serviceType">The type of service to add.</param>
  95                 /// <param name="callback">A callback object that is used to create the service. This allows a service to be declared as available, but delays the creation of the object until the service is requested.</param>
  96                 public void AddService(Type serviceType, ServiceCreatorCallback callback)
  97                 {
  98                         throw new NotImplementedException();
  99                 }
 100
 101                 /// <summary>
 102                 /// Adds the specified service to the service container, and optionally promotes the service to parent service containers.
 103                 /// </summary>
 104                 /// <param name="serviceType">The type of service to add.</param>
 105                 /// <param name="callback">A callback object that is used to create the service. This allows a service to be declared as available, but delays the creation of the object until the service is requested.</param>
 106                 /// <param name="promote">true to promote this request to any parent service containers; otherwise, false.</param>
 107                 public void AddService(Type serviceType, ServiceCreatorCallback callback, bool promote)
 108                 {
 109                         throw new NotImplementedException();
 110                 }
 111
 112                 /// <summary>
 113                 /// Removes the specified service type from the service container.
 114                 /// </summary>
 115                 /// <param name="serviceType">The type of service to remove.</param>
 116                 public void RemoveService(Type serviceType)
 117                 {
 118                         RemoveService(serviceType, false);
 119                 }
 120
 121                 /// <summary>
 122                 /// Removes the specified service type from the service container, and optionally promotes the service to parent service containers.
 123                 /// </summary>
 124                 /// <param name="serviceType">The type of service to remove.</param>
 125                 /// <param name="promote">true to promote this request to any parent service containers; otherwise, false.</param>
 126                 public void RemoveService(Type serviceType, bool promote)
 127                 {
 128                         if (promote)
 129                         {
 130                                 IServiceContainer parentContainer = ParentContainer;
 131
 132                                 if (parentContainer != null)
 133                                 {
 134                                         parentContainer.RemoveService(serviceType, promote);
 135                                         return;
 136                                 }
 137                         }
 138
 139                         if (type2Service != null)
 140                         {
 141                                 type2Service.Remove(serviceType);
 142                         }
 143                 }
 144
 145                 /// <summary>
 146                 /// Gets the service object of the specified type.
 147                 /// </summary>
 148                 /// <param name="serviceType">An object that specifies the type of service object to get.</param>
 149                 /// <returns>
 150                 /// A service object of type serviceType.-or- null if there is no service object of type serviceType.
 151                 /// </returns>
 152                 public object GetService(Type serviceType)
 153                 {
 154                         object service = null;
 155
 156                         if (serviceType == typeof(IServiceContainer))
 157                         {
 158                                 return this;
 159                         }
 160
 161                         if (type2Service != null)
 162                         {
 163                                 service = type2Service[serviceType];
 164                         }
 165
 166                         if (service == null && parent != null)
 167                         {
 168                                 service = parent.GetService(serviceType);
 169                         }
 170
 171                         return service;
 172                 }
 173
 174                 #endregion
 175
 176                 /// <summary>
 177                 /// Gets or sets the parent container.
 178                 /// </summary>
 179                 /// <value>The parent.</value>
 180                 public IServiceContainer Parent
 181                 {
 182                         get { return parent; }
 183                         set { parent = value; }
 184                 }
 185
 186                 private IServiceContainer ParentContainer
 187                 {
 188                         get
 189                         {
 190                                 IServiceContainer container = null;
 191
 192                                 if (parent != null)
 193                                 {
 194                                         container = (IServiceContainer) parent.GetService(typeof(IServiceContainer));
 195                                 }
 196
 197                                 return container;
 198                         }
 199                 }
 200         }
 201 }