InversionOfControl/Castle.MicroKernel/ModelBuilder/Inspectors/MethodMetaInspector.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.Collections;
  19         using System.Configuration;
  20         using System.Reflection;
  21
  22         using Castle.Core;
  23         using Castle.Core.Configuration;
  24
  25         using Castle.MicroKernel.SubSystems.Conversion;
  26
  27         /// <summary>
  28         /// Base for inspectors that want configuration associated with methods.
  29         /// For each child a <see cref="MethodMetaModel"/> is created
  30         /// and added to ComponentModel's methods collection
  31         /// </summary>
  32         /// <remarks>
  33         /// Implementors should override the <see cref="ObtainNodeName"/> return
  34         /// the name of the node to be inspected. For example:
  35         /// <code>
  36         /// <![CDATA[
  37         ///   <transactions>
  38         ///     <method name="Save" transaction="requires" />
  39         ///   </transactions>
  40         /// ]]>
  41         /// </code>
  42         /// </remarks>
  43         public abstract class MethodMetaInspector : IContributeComponentModelConstruction
  44         {
  45                 private static readonly BindingFlags AllMethods =
  46                         BindingFlags.Public|BindingFlags.NonPublic|
  47                         BindingFlags.Instance|BindingFlags.Static|
  48                         BindingFlags.IgnoreCase|BindingFlags.IgnoreReturn;
  49
  50                 private ITypeConverter converter;
  51
  52                 public virtual void ProcessModel(IKernel kernel, ComponentModel model)
  53                 {
  54                         if (model == null) throw new ArgumentNullException("model");
  55
  56                         if (model.Configuration == null || model.Implementation == null) return;
  57
  58                         IConfiguration methodsNode = model.Configuration.Children[ObtainNodeName()];
  59
  60                         if (methodsNode == null) return;
  61
  62                         EnsureHasReferenceToConverter(kernel);
  63
  64                         foreach(IConfiguration methodNode in methodsNode.Children)
  65                         {
  66                                 String name = methodNode.Name;
  67
  68                                 if ("method".Equals(name))
  69                                 {
  70                                         name = methodNode.Attributes["name"];
  71                                 }
  72
  73                                 AssertNameIsNotNull(name, model);
  74
  75                                 MethodMetaModel metaModel = new MethodMetaModel(methodNode);
  76
  77                                 if (IsValidMeta(model, metaModel))
  78                                 {
  79                                         if (ShouldUseMetaModel)
  80                                         {
  81                                                 // model.MethodMetaModels.Add( metaModel );
  82                                         }
  83
  84                                         String signature = methodNode.Attributes["signature"];
  85
  86                                         MethodInfo[] methods = GetMethods(model.Implementation, name, signature);
  87
  88                                         if (methods.Length == 0)
  89                                         {
  90                                                 String message = String.Format( "The class {0} has tried to expose configuration for " +
  91                                                         "a method named {1} which could not be found.", model.Implementation.FullName, name );
  92
  93                                                 throw new ConfigurationErrorsException(message);
  94                                         }
  95
  96                                         ProcessMeta(model, methods, metaModel);
  97
  98                                         if (ShouldUseMetaModel)
  99                                         {
 100                                                 // RegisterMethodsForFastAccess(methods, signature, metaModel, model);
 101                                         }
 102                                 }
 103                         }
 104                 }
 105
 106                 protected virtual void ProcessMeta(ComponentModel model, MethodInfo[] methods, MethodMetaModel metaModel)
 107                 {
 108                 }
 109
 110                 protected virtual bool IsValidMeta(ComponentModel model, MethodMetaModel metaModel)
 111                 {
 112                         return true;
 113                 }
 114
 115                 protected virtual bool ShouldUseMetaModel
 116                 {
 117                         get { return false; }
 118                 }
 119
 120                 protected abstract String ObtainNodeName();
 121
 122                 private void AssertNameIsNotNull(string name, ComponentModel model)
 123                 {
 124                         if (name == null)
 125                         {
 126                                 String message = String.Format("The configuration nodes within 'methods' " +
 127                                         "for the component '{0}' does not have a name. You can either name " +
 128                                         "the node as the method name or provide an attribute 'name'", model.Name);
 129
 130                                 throw new ConfigurationErrorsException(message);
 131                         }
 132                 }
 133
 134                 private void EnsureHasReferenceToConverter(IKernel kernel)
 135                 {
 136                         if (converter != null) return;
 137
 138                         converter = (ITypeConverter)
 139                                 kernel.GetSubSystem( SubSystemConstants.ConversionManagerKey );
 140                 }
 141
 142                 private MethodInfo[] GetMethods(Type implementation, String name, String signature)
 143                 {
 144                         if (signature == null || signature.Length == 0)
 145                         {
 146                                 MethodInfo[] allmethods = implementation.GetMethods(AllMethods);
 147
 148                                 ArrayList methods = new ArrayList();
 149
 150                                 foreach(MethodInfo method in allmethods)
 151                                 {
 152                                         if (String.Compare(method.Name, name, true) == 0)
 153                                         {
 154                                                 methods.Add(method);
 155                                         }
 156                                 }
 157
 158                                 return (MethodInfo[]) methods.ToArray( typeof(MethodInfo) );
 159                         }
 160                         else
 161                         {
 162                                 MethodInfo methodInfo = implementation.GetMethod(name, AllMethods, null, ConvertSignature(signature), null );
 163
 164                                 if (methodInfo == null) return new MethodInfo[0];
 165
 166                                 return new MethodInfo[] { methodInfo };
 167                         }
 168                 }
 169
 170                 private Type[] ConvertSignature(string signature)
 171                 {
 172                         String[] parameters = signature.Split(';');
 173
 174                         ArrayList types = new ArrayList();
 175
 176                         foreach(String param in parameters)
 177                         {
 178                                 try
 179                                 {
 180                                         types.Add( converter.PerformConversion( param, typeof(Type) ) );
 181                                 }
 182                                 catch(Exception)
 183                                 {
 184                                         String message = String.Format("The signature {0} contains an entry type {1} " +
 185                                                 "that could not be converted to System.Type. Check the inner exception for " +
 186                                                 "details", signature, param);
 187
 188                                         throw new ConfigurationErrorsException(message);
 189                                 }
 190                         }
 191
 192                         return (Type[]) types.ToArray( typeof(Type) );
 193                 }
 194         }
 195 }