InversionOfControl/Castle.MicroKernel/ModelBuilder/Inspectors/PropertiesDependenciesModelInspector.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.Reflection;
  19
  20         using Castle.Core;
  21         using Castle.MicroKernel.SubSystems.Conversion;
  22         using Castle.Core.Configuration;
  23
  24         /// <summary>
  25         /// This implementation of <see cref="IContributeComponentModelConstruction"/>
  26         /// collects all potential writable puplic properties exposed by the component
  27         /// implementation and populates the model with them.
  28         /// The Kernel might be able to set some of these properties when the component
  29         /// is requested.
  30         /// </summary>
  31         [Serializable]
  32         public class PropertiesDependenciesModelInspector : IContributeComponentModelConstruction
  33         {
  34                 [NonSerialized]
  35                 private IConversionManager converter;
  36
  37                 /// <summary>
  38                 /// Initializes a new instance of the <see cref="PropertiesDependenciesModelInspector"/> class.
  39                 /// </summary>
  40                 public PropertiesDependenciesModelInspector()
  41                 {
  42                 }
  43
  44                 /// <summary>
  45                 /// Adds the properties as optional dependencies of this component.
  46                 /// </summary>
  47                 /// <param name="kernel"></param>
  48                 /// <param name="model"></param>
  49                 public virtual void ProcessModel(IKernel kernel, ComponentModel model)
  50                 {
  51                         if (converter == null)
  52                         {
  53                                 converter = (IConversionManager)
  54                                         kernel.GetSubSystem( SubSystemConstants.ConversionManagerKey );
  55                         }
  56
  57                         InspectProperties(model);
  58                 }
  59
  60                 protected virtual void InspectProperties(ComponentModel model)
  61                 {
  62                         if (model.InspectionBehavior == PropertiesInspectionBehavior.Undefined)
  63                         {
  64                                 model.InspectionBehavior = GetInspectionBehaviorFromTheConfiguration(model.Configuration);
  65                         }
  66
  67                         if (model.InspectionBehavior == PropertiesInspectionBehavior.None)
  68                         {
  69                                 // Nothing to be inspected
  70                                 return;
  71                         }
  72
  73                         BindingFlags bindingFlags;
  74
  75                         if (model.InspectionBehavior == PropertiesInspectionBehavior.DeclaredOnly)
  76                         {
  77                                 bindingFlags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
  78                         }
  79                         else // if (model.InspectionBehavior == PropertiesInspectionBehavior.All) or Undefined
  80                         {
  81                                 bindingFlags = BindingFlags.Public | BindingFlags.Instance;
  82                         }
  83
  84                         Type targetType = model.Implementation;
  85
  86                         PropertyInfo[] properties = targetType.GetProperties(bindingFlags);
  87
  88                         foreach(PropertyInfo property in properties)
  89                         {
  90                                 if (!property.CanWrite || property.GetSetMethod() == null)
  91                                 {
  92                                         continue;
  93                                 }
  94
  95                                 ParameterInfo[] indexerParams = property.GetIndexParameters();
  96
  97                                 if (indexerParams != null && indexerParams.Length != 0)
  98                                 {
  99                                         continue;
 100                                 }
 101
 102                                 if (property.IsDefined(typeof(DoNotWireAttribute), true))
 103                                 {
 104                                         continue;
 105                                 }
 106
 107                                 DependencyModel dependency;
 108
 109                                 Type propertyType = property.PropertyType;
 110
 111                                 // All these dependencies are simple guesses
 112                                 // So we make them optional (the 'true' parameter below)
 113
 114                                 if ( converter.IsSupportedAndPrimitiveType(propertyType) )
 115                                 {
 116                                         dependency = new DependencyModel(DependencyType.Parameter, property.Name, propertyType, true);
 117                                 }
 118                                 else if (propertyType.IsInterface || propertyType.IsClass)
 119                                 {
 120                                         dependency = new DependencyModel(DependencyType.Service, property.Name, propertyType, true);
 121                                 }
 122                                 else
 123                                 {
 124                                         // What is it?!
 125                                         // Awkward type, probably.
 126
 127                                         continue;
 128                                 }
 129
 130                                 model.Properties.Add( new PropertySet(property, dependency) );
 131                         }
 132                 }
 133
 134                 private PropertiesInspectionBehavior GetInspectionBehaviorFromTheConfiguration(IConfiguration config)
 135                 {
 136                         if (config == null || config.Attributes["inspectionBehavior"] == null)
 137                         {
 138                                 // return default behavior
 139                                 return PropertiesInspectionBehavior.All;
 140                         }
 141
 142                         String enumStringVal = config.Attributes["inspectionBehavior"];
 143
 144                         try
 145                         {
 146                                 return (PropertiesInspectionBehavior)
 147                                         Enum.Parse(typeof(PropertiesInspectionBehavior), enumStringVal, true);
 148                         }
 149                         catch(Exception)
 150                         {
 151                                 String[] enumNames = Enum.GetNames(typeof(PropertiesInspectionBehavior));
 152
 153                                 String message = String.Format("Error on properties inspection. " +
 154                                         "Could not convert the inspectionBehavior attribute value into an expected enum value. " +
 155                                         "Value found is '{0}' while possible values are '{1}'",
 156                                                 enumStringVal, String.Join(",", enumNames));
 157
 158                                 throw new KernelException(message);
 159                         }
 160                 }
 161         }
 162 }