Tools/Castle.DynamicProxy2/Castle.DynamicProxy/Generators/Emitters/CustomAttributeUtil.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
  16 namespace Castle.DynamicProxy.Generators.Emitters
  17 {
  18         using System;
  19         using System.Collections;
  20         using System.Diagnostics;
  21         using System.Reflection;
  22         using System.Reflection.Emit;
  23
  24         internal class CustomAttributeUtil
  25         {
  26                 public static CustomAttributeBuilder CreateCustomAttribute(Attribute attribute)
  27                 {
  28                         Type attType = attribute.GetType();
  29
  30                         ConstructorInfo ci;
  31
  32                         object[] ctorArgs = GetConstructorAndArgs(attType, attribute, out ci);
  33
  34                         PropertyInfo[] properties;
  35
  36                         object[] propertyValues = GetPropertyValues(attType, out properties, attribute);
  37
  38                         FieldInfo[] fields;
  39
  40                         object[] fieldValues = GetFieldValues(attType, out fields, attribute);
  41
  42                         // here we are going to try to initialize the attribute with the collected arguments
  43                         // if we are good (created successfuly) we return it, otherwise, it is ignored.
  44                         try
  45                         {
  46                                 Activator.CreateInstance(attType, ctorArgs);
  47                                 return new CustomAttributeBuilder(ci, ctorArgs, properties, propertyValues, fields, fieldValues);
  48                         }
  49                         catch
  50                         {
  51                                 // there is no real way to log a warning here...
  52                                 Trace.WriteLine(@"Dynamic Proxy 2: Unable to find matching parameters for replicating attribute " + attType.FullName +
  53                                                 ".");
  54                                 return null;
  55                         }
  56                 }
  57
  58                 private static object[] GetConstructorAndArgs(Type attType, Attribute attribute, out ConstructorInfo ci)
  59                 {
  60                         object[] ctorArgs = new object[0];
  61
  62                         ci = attType.GetConstructors()[0];
  63
  64                         ParameterInfo[] constructorParams = ci.GetParameters();
  65
  66                         if (constructorParams.Length != 0)
  67                         {
  68                                 ctorArgs = new object[constructorParams.Length];
  69
  70                                 InitializeConstructorArgs(attType, attribute, ctorArgs, constructorParams);
  71                         }
  72
  73                         return ctorArgs;
  74                 }
  75
  76                 private static object[] GetPropertyValues(Type attType, out PropertyInfo[] properties, Attribute attribute)
  77                 {
  78                         ArrayList selectedProps = new ArrayList();
  79
  80                         foreach(PropertyInfo pi in attType.GetProperties(BindingFlags.Instance | BindingFlags.Public))
  81                         {
  82                                 if (pi.CanRead && pi.CanWrite)
  83                                 {
  84                                         selectedProps.Add(pi);
  85                                 }
  86                         }
  87
  88                         properties = (PropertyInfo[]) selectedProps.ToArray(typeof(PropertyInfo));
  89
  90                         object[] propertyValues = new object[properties.Length];
  91
  92                         for(int i = 0; i < properties.Length; i++)
  93                         {
  94                                 PropertyInfo propInfo = properties[i];
  95                                 propertyValues[i] = propInfo.GetValue(attribute, null);
  96                         }
  97
  98                         return propertyValues;
  99                 }
 100
 101                 private static object[] GetFieldValues(Type attType, out FieldInfo[] fields, Attribute attribute)
 102                 {
 103                         fields = attType.GetFields(BindingFlags.Public | BindingFlags.Instance);
 104
 105                         object[] values = new object[fields.Length];
 106
 107                         for(int i = 0; i < fields.Length; i++)
 108                         {
 109                                 FieldInfo fieldInfo = fields[i];
 110                                 values[i] = fieldInfo.GetValue(attribute);
 111                         }
 112
 113                         return values;
 114                 }
 115
 116                 /// <summary>
 117                 /// Here we try to match a constructor argument to its value.
 118                 /// Since we can't get the values from the assembly, we use some heuristics to get it.
 119                 /// a/ we first try to match all the properties on the attributes by name (case insensitive) to the argument
 120                 /// b/ if we fail we try to match them by property type, with some smarts about convertions (i,e: can use Guid for string).
 121                 /// </summary>
 122                 private static void InitializeConstructorArgs(Type attType, Attribute attribute, object[] args,
 123                                                               ParameterInfo[] parameterInfos)
 124                 {
 125                         for(int i = 0; i < args.Length; i++)
 126                         {
 127                                 args[i] = GetArgValue(attType, attribute, parameterInfos[i]);
 128                         }
 129                 }
 130
 131                 private static object GetArgValue(Type attType, Attribute attribute, ParameterInfo parameterInfo)
 132                 {
 133                         Type paramType = parameterInfo.ParameterType;
 134
 135                         PropertyInfo[] propertyInfos = attType.GetProperties();
 136                         //first try to find a property with
 137                         foreach(PropertyInfo propertyInfo in propertyInfos)
 138                         {
 139                                 if (propertyInfo.CanRead == false && propertyInfo.GetIndexParameters().Length != 0)
 140                                 {
 141                                         continue;
 142                                 }
 143
 144                                 if (string.Compare(propertyInfo.Name, parameterInfo.Name, true) == 0)
 145                                 {
 146                                         return ConvertValue(propertyInfo.GetValue(attribute, null), paramType);
 147                                 }
 148                         }
 149
 150
 151                         PropertyInfo bestMatch = null;
 152                         //now we try to find it by type
 153                         foreach(PropertyInfo propertyInfo in propertyInfos)
 154                         {
 155                                 if (propertyInfo.CanRead == false && propertyInfo.GetIndexParameters().Length != 0)
 156                                         continue;
 157                                 bestMatch = ReplaceIfBetterMatch(parameterInfo, propertyInfo, bestMatch);
 158                         }
 159                         if (bestMatch != null)
 160                         {
 161                                 return ConvertValue(bestMatch.GetValue(attribute, null), paramType);
 162                         }
 163                         return GetDefaultValueFor(paramType);
 164                 }
 165
 166                 /// <summary>
 167                 /// We have the following rules here.
 168                 /// Try to find a matching type, failing that, if the parameter is string, get the first property (under the assumption that
 169                 /// we can convert it.
 170                 /// </summary>
 171                 private static PropertyInfo ReplaceIfBetterMatch(ParameterInfo parameterInfo, PropertyInfo propertyInfo,
 172                                                                  PropertyInfo bestMatch)
 173                 {
 174                         bool notBestMatch = bestMatch == null || bestMatch.PropertyType != parameterInfo.ParameterType;
 175                         if (propertyInfo.PropertyType == parameterInfo.ParameterType && notBestMatch)
 176                                 return propertyInfo;
 177                         if (parameterInfo.ParameterType == typeof(string) && notBestMatch)
 178                                 return propertyInfo;
 179                         return bestMatch;
 180                 }
 181
 182                 /// <summary>
 183                 /// Attributes can only accept simple types, so we return null for null,
 184                 /// if the value is passed as string we call to string (should help with converting),
 185                 /// otherwise, we use the value as is (enums, integer, etc).
 186                 /// </summary>
 187                 private static object ConvertValue(object obj, Type paramType)
 188                 {
 189                         if (obj == null)
 190                                 return null;
 191                         if (paramType == typeof(String))
 192                                 return obj.ToString();
 193                         return obj;
 194                 }
 195
 196                 private static object GetDefaultValueFor(Type type)
 197                 {
 198                         if (type == typeof(bool))
 199                         {
 200                                 return false;
 201                         }
 202                         else if (type.IsEnum)
 203                         {
 204                                 return Enum.GetValues(type).GetValue(0);
 205                         }
 206                         else if (type == typeof(char))
 207                         {
 208                                 return char.MinValue;
 209                         }
 210                         else if (type.IsPrimitive)
 211                         {
 212                                 return 0;
 213                         }
 214
 215                         return null;
 216                 }
 217         }
 218 }