InversionOfControl/Castle.MicroKernel/ModelBuilder/Inspectors/LifestyleModelInspector.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.ModelBuilder.Inspectors
  16 {
  17         using System;
  18         using System.Configuration;
  19
  20         using Castle.Core;
  21
  22         /// <summary>
  23         /// Inspects the component configuration and the type looking for a
  24         /// definition of lifestyle type. The configuration preceeds whatever
  25         /// is defined in the component.
  26         /// </summary>
  27         /// <remarks>
  28         /// This inspector is not guarantee to always set up an lifestyle type.
  29         /// If nothing could be found it wont touch the model. In this case is up to
  30         /// the kernel to estabish a default lifestyle for components.
  31         /// </remarks>
  32         [Serializable]
  33         public class LifestyleModelInspector : IContributeComponentModelConstruction
  34         {
  35                 /// <summary>
  36                 /// Seaches for the lifestyle in the configuration and, if unsuccessful
  37                 /// look for the lifestyle attribute in the implementation type.
  38                 /// </summary>
  39                 public virtual void ProcessModel(IKernel kernel, ComponentModel model)
  40                 {
  41                         if (!ReadLifestyleFromConfiguration(model))
  42                         {
  43                                 ReadLifestyleFromType(model);
  44                         }
  45                 }
  46
  47                 /// <summary>
  48                 /// Reads the attribute "lifestyle" associated with the
  49                 /// component configuration and tries to convert to <see cref="LifestyleType"/>
  50                 /// enum type.
  51                 /// </summary>
  52                 protected virtual bool ReadLifestyleFromConfiguration(ComponentModel model)
  53                 {
  54                         if (model.Configuration != null)
  55                         {
  56                                 String lifestyle = model.Configuration.Attributes["lifestyle"];
  57
  58                                 if (lifestyle != null)
  59                                 {
  60                                         try
  61                                         {
  62                                                 LifestyleType type = (LifestyleType)
  63                                                         Enum.Parse(typeof(LifestyleType), lifestyle, true);
  64
  65                                                 model.LifestyleType = type;
  66
  67                                         }
  68                                         catch(Exception)
  69                                         {
  70                                                 String message = String.Format(
  71                                                         "Could not convert the specified attribute value " +
  72                                                         "{0} to a valid LifestyleType enum type", lifestyle);
  73
  74                                                 throw new ConfigurationErrorsException(message);
  75                                         }
  76
  77                                         if (model.LifestyleType == LifestyleType.Pooled)
  78                                         {
  79                                                 ExtractPoolConfig(model);
  80                                         }
  81                                         else if(model.LifestyleType == LifestyleType.Custom)
  82                                         {
  83                                                 ExtractCustomConfig(model);
  84                                         }
  85
  86
  87                                         return true;
  88                                 }
  89                         }
  90
  91                         return false;
  92                 }
  93
  94                 private void ExtractPoolConfig(ComponentModel model)
  95                 {
  96                         String initial = model.Configuration.Attributes["initialPoolSize"];
  97                         String maxSize = model.Configuration.Attributes["maxPoolSize"];
  98
  99                         if (initial != null)
 100                         {
 101                                 model.ExtendedProperties[ExtendedPropertiesConstants.Pool_InitialPoolSize] = Convert.ToInt32(initial);
 102                         }
 103                         if (maxSize != null)
 104                         {
 105                                 model.ExtendedProperties[ExtendedPropertiesConstants.Pool_MaxPoolSize] = Convert.ToInt32(maxSize);
 106                         }
 107                 }
 108
 109                 private void ExtractCustomConfig(ComponentModel model)
 110                 {
 111                         String customLifestyleType = model.Configuration.Attributes["customLifestyleType"];
 112
 113                         if(customLifestyleType != null)
 114                         {
 115                                 try
 116                                 {
 117                                         model.CustomLifestyle = Type.GetType(customLifestyleType, true, false);
 118                                 }
 119                                 catch(Exception)
 120                                 {
 121                                         String message = String.Format(
 122                                                 "The Type {0} specified  in the customLifestyleType attribute could not be loaded.", customLifestyleType);
 123
 124                                         throw new ConfigurationErrorsException(message);
 125                                 }
 126                         }
 127                         else
 128                         {
 129                                 string message = @"The attribute 'customLifestyleType' must be specified in conjunction with the 'lifestyle' attribute set to ""custom"".";
 130
 131                                 throw new ConfigurationErrorsException(message);
 132                         }
 133                 }
 134
 135                 /// <summary>
 136                 /// Check if the type expose one of the lifestyle attributes
 137                 /// defined in Castle.Model namespace.
 138                 /// </summary>
 139                 protected virtual void ReadLifestyleFromType(ComponentModel model)
 140                 {
 141                         object[] attributes = model.Implementation.GetCustomAttributes(
 142                                 typeof(LifestyleAttribute), true );
 143
 144                         if (attributes.Length != 0)
 145                         {
 146                                 LifestyleAttribute attribute = (LifestyleAttribute)
 147                                         attributes[0];
 148
 149                                 model.LifestyleType = attribute.Lifestyle;
 150
 151                                 if (model.LifestyleType == LifestyleType.Custom)
 152                                 {
 153                                         CustomLifestyleAttribute custom = (CustomLifestyleAttribute)
 154                                                 attribute;
 155                                         model.CustomLifestyle = custom.LifestyleHandlerType;
 156                                 }
 157                                 else if (model.LifestyleType == LifestyleType.Pooled)
 158                                 {
 159                                         PooledAttribute pooled = (PooledAttribute) attribute;
 160                                         model.ExtendedProperties[ExtendedPropertiesConstants.Pool_InitialPoolSize] = pooled.InitialPoolSize;
 161                                         model.ExtendedProperties[ExtendedPropertiesConstants.Pool_MaxPoolSize] = pooled.MaxPoolSize;
 162                                 }
 163                         }
 164                 }
 165         }
 166 }