Tools/Castle.DynamicProxy2/Castle.DynamicProxy/Generators/Emitters/PropertyEmitter.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 namespace Castle.DynamicProxy.Generators.Emitters
  16 {
  17     using System;
  18     using System.Reflection;
  19     using System.Reflection.Emit;
  20
  21     public class PropertyEmitter : IMemberEmitter
  22     {
  23         private PropertyBuilder builder;
  24         private AbstractTypeEmitter parentTypeEmitter;
  25         private MethodEmitter getMethod;
  26         private MethodEmitter setMethod;
  27
  28         private static readonly MethodInfo newDefinePropertyMethodInfo = typeof (TypeBuilder).GetMethod("DefineProperty", new Type[]
  29                                                                                                               {
  30                                                                                                                   typeof (string), typeof (PropertyAttributes),
  31                                                                                                                   typeof (CallingConventions), typeof (Type),
  32                                                                                                                   typeof (Type[]), typeof (Type[]), typeof (Type[]),
  33                                                                                                                   typeof (Type[][]), typeof (Type[][])
  34                                                                                                               });
  35
  36         // private ParameterInfo[] indexParameters;
  37
  38         private delegate PropertyBuilder DefineProperty_Clr2_0(
  39             string name, PropertyAttributes attributes, Type propertyType, Type[] parameters);
  40
  41         public delegate PropertyBuilder DefineProperty_Clr_2_0_SP1(string name,
  42                                                                    PropertyAttributes attributes,
  43                                                                    CallingConventions callingConvention,
  44                                                                    Type returnType,
  45                                                                    Type[] returnTypeRequiredCustomModifiers,
  46                                                                    Type[] returnTypeOptionalCustomModifiers,
  47                                                                    Type[] parameterTypes,
  48                                                                    Type[][] parameterTypeRequiredCustomModifiers,
  49                                                                    Type[][] parameterTypeOptionalCustomModifiers);
  50
  51         public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, String name, PropertyAttributes attributes,
  52                                Type propertyType)
  53         {
  54             this.parentTypeEmitter = parentTypeEmitter;
  55
  56             // DYNPROXY-73 - AmbiguousMatchException for properties
  57             // This is a workaround for a framework limitation in CLR 2.0
  58             // This limitation was removed in CLR 2.0 SP1, but we don't want to
  59             // tie ourselves to that version. This perform the lookup for the new overload
  60             // dynamically, so we have a nice fallback on vanilla CLR 2.0
  61             DefineProperty_Clr2_0 oldDefineProperty = parentTypeEmitter.TypeBuilder.DefineProperty;
  62             DefineProperty_Clr_2_0_SP1 newDefinedProperty = (DefineProperty_Clr_2_0_SP1)
  63                 Delegate.CreateDelegate(typeof(DefineProperty_Clr_2_0_SP1), parentTypeEmitter.TypeBuilder, newDefinePropertyMethodInfo);
  64
  65             if(newDefinedProperty==null)
  66             {
  67                    builder = oldDefineProperty(name, attributes, propertyType, new Type[0]);
  68             }
  69             else
  70             {
  71                 builder = parentTypeEmitter.TypeBuilder.DefineProperty(
  72                 name, attributes, CallingConventions.HasThis, propertyType,
  73                 null, null, new Type[0], null, null);
  74             }
  75         }
  76
  77         public MethodEmitter GetMethod
  78         {
  79             get { return getMethod; }
  80             set { getMethod = value; }
  81         }
  82
  83         public MethodEmitter SetMethod
  84         {
  85             get { return setMethod; }
  86             set { setMethod = value; }
  87         }
  88
  89         public MethodEmitter CreateGetMethod()
  90         {
  91             return CreateGetMethod(MethodAttributes.Public |
  92                                    MethodAttributes.Virtual |
  93                                    MethodAttributes.SpecialName);
  94         }
  95
  96         public MethodEmitter CreateGetMethod(MethodAttributes attrs, params Type[] parameters)
  97         {
  98             if (getMethod != null)
  99             {
 100                 throw new InvalidOperationException("A getMethod exists");
 101             }
 102
 103             if (parameters.Length == 0)
 104             {
 105                 getMethod = new MethodEmitter(parentTypeEmitter, "get_" + builder.Name, attrs);
 106             }
 107             else
 108             {
 109                 getMethod = new MethodEmitter(parentTypeEmitter, "get_" + builder.Name,
 110                                               attrs,
 111                                               ReturnType,
 112                                               parameters);
 113             }
 114
 115             return getMethod;
 116         }
 117
 118         public MethodEmitter CreateSetMethod()
 119         {
 120             return CreateSetMethod(MethodAttributes.Public |
 121                                    MethodAttributes.Virtual |
 122                                    MethodAttributes.SpecialName);
 123         }
 124
 125         public MethodEmitter CreateSetMethod(Type arg)
 126         {
 127             return CreateSetMethod(MethodAttributes.Public |
 128                                    MethodAttributes.Virtual |
 129                                    MethodAttributes.SpecialName, arg);
 130         }
 131
 132         public MethodEmitter CreateSetMethod(MethodAttributes attrs, params Type[] parameters)
 133         {
 134             if (setMethod != null)
 135             {
 136                 throw new InvalidOperationException("A setMethod exists");
 137             }
 138
 139             if (parameters.Length == 0)
 140             {
 141                 setMethod = new MethodEmitter(parentTypeEmitter, "set_" + builder.Name, attrs);
 142             }
 143             else
 144             {
 145                 setMethod = new MethodEmitter(parentTypeEmitter, "set_" + builder.Name,
 146                                               attrs, typeof (void),
 147                                               parameters);
 148             }
 149
 150             return setMethod;
 151         }
 152
 153         public MemberInfo Member
 154         {
 155             get { return null; }
 156         }
 157
 158         public Type ReturnType
 159         {
 160             get { return builder.PropertyType; }
 161         }
 162
 163         public void Generate()
 164         {
 165             if (setMethod != null)
 166             {
 167                 setMethod.Generate();
 168                 builder.SetSetMethod(setMethod.MethodBuilder);
 169             }
 170
 171             if (getMethod != null)
 172             {
 173                 getMethod.Generate();
 174                 builder.SetGetMethod(getMethod.MethodBuilder);
 175             }
 176         }
 177
 178         public void EnsureValidCodeBlock()
 179         {
 180             if (setMethod != null)
 181             {
 182                 setMethod.EnsureValidCodeBlock();
 183             }
 184
 185             if (getMethod != null)
 186             {
 187                 getMethod.EnsureValidCodeBlock();
 188             }
 189         }
 190     }
 191 }