InversionOfControl/Castle.MicroKernel/Facilities/FactorySupport/FactorySupportFacility.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.Facilities.FactorySupport
  16 {
  17         using System;
  18         using Castle.Core;
  19         using Castle.Core.Configuration;
  20         using Castle.MicroKernel;
  21         using Castle.MicroKernel.Facilities;
  22
  23         public class FactorySupportFacility : AbstractFacility
  24         {
  25                 protected override void Init()
  26                 {
  27                         Kernel.ComponentModelCreated += new ComponentModelDelegate(Kernel_ComponentModelCreated);
  28                 }
  29
  30                 private void Kernel_ComponentModelCreated(ComponentModel model)
  31                 {
  32                         if (model.Configuration == null)
  33                         {
  34                                 return;
  35                         }
  36
  37                         String instanceAccessor = model.Configuration.Attributes["instance-accessor"];
  38                         String factoryId = model.Configuration.Attributes["factoryId"];
  39                         String factoryCreate = model.Configuration.Attributes["factoryCreate"];
  40
  41                         if ((factoryId != null && factoryCreate == null) ||
  42                             (factoryId == null && factoryCreate != null))
  43                         {
  44                                 String message = String.Format("When a factoryId is specified, you must specify " +
  45                                                                "the factoryCreate (which is the method to be called) as well - component {0}",
  46                                                                model.Name);
  47
  48                                 throw new FacilityException(message);
  49                         }
  50
  51                         if (instanceAccessor != null)
  52                         {
  53                                 model.Constructors.Clear();
  54                                 model.ExtendedProperties.Add("instance.accessor", instanceAccessor);
  55                                 model.CustomComponentActivator = typeof(AccessorActivator);
  56                         }
  57                         else if (factoryId != null)
  58                         {
  59                                 model.Constructors.Clear();
  60                                 model.ExtendedProperties.Add("factoryId", factoryId);
  61                                 model.ExtendedProperties.Add("factoryCreate", factoryCreate);
  62                                 model.CustomComponentActivator = typeof(FactoryActivator);
  63                         }
  64                 }
  65
  66                 #region Programmatic configuration support
  67
  68                 public void AddAccessor<TService, TFactory>(
  69                         string serviceKey, string instanceAccessorMethod)
  70                 {
  71                         AddAccessor<TService, TFactory>(serviceKey, instanceAccessorMethod,
  72                                                         typeof(TFactory).FullName);
  73                 }
  74
  75                 public void AddAccessor<TService, TFactory>(
  76                         string serviceKey, string instanceAccessorMethod, string factoryId)
  77                 {
  78                         IConfiguration cfg = new MutableConfiguration(serviceKey);
  79                         cfg.Attributes["instance-accessor"] = instanceAccessorMethod;
  80
  81                         AddFactoryComponent<TService, TFactory>(cfg, factoryId, serviceKey);
  82                 }
  83
  84                 public void AddFactory<TService, TFactory>(
  85                         string serviceKey, string factoryCreateMethodName)
  86                 {
  87                         AddFactory<TService, TFactory>(
  88                                 serviceKey, factoryCreateMethodName, typeof(TFactory).FullName);
  89                 }
  90
  91                 public void AddFactory<TService, TFactory>(
  92                         string serviceKey, string factoryCreateMethodName, string factoryId)
  93                 {
  94                         IConfiguration cfg = new MutableConfiguration(serviceKey);
  95                         cfg.Attributes["factoryCreate"] = factoryCreateMethodName;
  96
  97                         AddFactoryComponent<TService, TFactory>(cfg, factoryId, serviceKey);
  98                 }
  99
 100                 #region Helpers
 101
 102                 private void AddFactoryComponent<TService, TFactory>(
 103                         IConfiguration cfg, string factoryId, string serviceKey)
 104                 {
 105                         Type factoryType = typeof(TFactory);
 106                         Type serviceType = typeof(TService);
 107
 108                         EnsureFactoryIsRegistered(factoryId, factoryType);
 109
 110                         ComponentModel serviceModel = Kernel.ComponentModelBuilder.BuildModel(
 111                                 serviceKey, serviceType,
 112                                 factoryType, null);
 113
 114                         cfg.Attributes["factoryId"] = factoryId;
 115
 116                         serviceModel.Configuration = cfg;
 117
 118                         Kernel.AddCustomComponent(serviceModel);
 119                 }
 120
 121                 private void EnsureFactoryIsRegistered(string factoryId, Type factoryType)
 122                 {
 123                         if (!Kernel.HasComponent(factoryType))
 124                         {
 125                                 Kernel.AddComponent(factoryId, factoryType);
 126                         }
 127                 }
 128
 129                 #endregion
 130
 131                 #endregion
 132         }
 133 }