Tools/Castle.DynamicProxy2/Castle.DynamicProxy/Generators/ClassProxyGenerator.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
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Generic;
  20         using System.Reflection;
  21         using System.Reflection.Emit;
  22         using System.Runtime.Serialization;
  23         using System.Threading;
  24         using System.Xml.Serialization;
  25         using Castle.Core.Interceptor;
  26         using Castle.DynamicProxy.Generators.Emitters;
  27         using Castle.DynamicProxy.Generators.Emitters.CodeBuilders;
  28         using Castle.DynamicProxy.Generators.Emitters.SimpleAST;
  29
  30         /// <summary>
  31         ///
  32         /// </summary>
  33         public class ClassProxyGenerator : BaseProxyGenerator
  34         {
  35                 private bool delegateToBaseGetObjectData = false;
  36
  37                 public ClassProxyGenerator(ModuleScope scope, Type targetType) : base(scope, targetType)
  38                 {
  39                         CheckNotGenericTypeDefinition(targetType, "targetType");
  40                 }
  41
  42                 public Type GenerateCode(Type[] interfaces, ProxyGenerationOptions options)
  43                 {
  44                         CheckNotGenericTypeDefinitions(interfaces, "interfaces");
  45                         Type type;
  46
  47                         ReaderWriterLock rwlock = Scope.RWLock;
  48
  49                         rwlock.AcquireReaderLock(-1);
  50
  51                         CacheKey cacheKey = new CacheKey(targetType, interfaces, options);
  52
  53                         Type cacheType = GetFromCache(cacheKey);
  54
  55                         if (cacheType != null)
  56                         {
  57                                 rwlock.ReleaseReaderLock();
  58
  59                                 return cacheType;
  60                         }
  61
  62                         rwlock.UpgradeToWriterLock(-1);
  63
  64                         try
  65                         {
  66                                 cacheType = GetFromCache(cacheKey);
  67
  68                                 if (cacheType != null)
  69                                 {
  70                                         return cacheType;
  71                                 }
  72
  73                                 String newName = targetType.Name + "Proxy" + Guid.NewGuid().ToString("N");
  74
  75                                 // Add Interfaces that the proxy implements
  76
  77                                 ArrayList interfaceList = new ArrayList();
  78
  79                                 if (interfaces != null)
  80                                 {
  81                                         interfaceList.AddRange(interfaces);
  82                                 }
  83
  84                                 AddDefaultInterfaces(interfaceList);
  85
  86                                 if (targetType.IsSerializable)
  87                                 {
  88                                         delegateToBaseGetObjectData = VerifyIfBaseImplementsGetObjectData(targetType);
  89
  90                                         if (!interfaceList.Contains(typeof(ISerializable)))
  91                                         {
  92                                                 interfaceList.Add(typeof(ISerializable));
  93                                         }
  94                                 }
  95
  96                                 ClassEmitter emitter = BuildClassEmitter(newName, targetType, interfaceList);
  97                                 SetGenerationOptions (options, emitter);
  98
  99                                 emitter.DefineCustomAttribute(new XmlIncludeAttribute(targetType));
 100
 101                                 // Custom attributes
 102
 103                                 ReplicateNonInheritableAttributes(targetType, emitter);
 104
 105                                 // Fields generations
 106
 107                                 FieldReference interceptorsField =
 108                                         emitter.CreateField("__interceptors", typeof(IInterceptor[]));
 109
 110                                 // Implement builtin Interfaces
 111                                 ImplementProxyTargetAccessor(targetType, emitter,interceptorsField);
 112
 113                                 emitter.DefineCustomAttributeFor(interceptorsField, new XmlIgnoreAttribute());
 114
 115                                 // Collect methods
 116
 117                                 PropertyToGenerate[] propsToGenerate;
 118                                 EventToGenerate[] eventToGenerates;
 119                                 MethodInfo[] methods = CollectMethodsAndProperties(emitter, targetType, out propsToGenerate, out eventToGenerates);
 120
 121                                 options.Hook.MethodsInspected();
 122
 123                                 // Constructor
 124
 125                                 ConstructorEmitter typeInitializer = GenerateStaticConstructor(emitter);
 126
 127                                 CreateInitializeCacheMethodBody(targetType, methods, emitter, typeInitializer);
 128                                 GenerateConstructors(emitter, targetType, interceptorsField);
 129                                 GenerateParameterlessConstructor(emitter, targetType, interceptorsField);
 130
 131                                 if (delegateToBaseGetObjectData)
 132                                 {
 133                                         GenerateSerializationConstructor(emitter, interceptorsField, delegateToBaseGetObjectData);
 134                                 }
 135
 136                                 // Implement interfaces
 137
 138                                 if (interfaces != null && interfaces.Length != 0)
 139                                 {
 140                                         foreach(Type inter in interfaces)
 141                                         {
 142                                                 ImplementBlankInterface(targetType, inter, emitter, interceptorsField, typeInitializer);
 143                                         }
 144                                 }
 145
 146                                 // Create callback methods
 147
 148                                 Dictionary<MethodInfo, MethodBuilder> method2Callback = new Dictionary<MethodInfo, MethodBuilder>();
 149
 150                                 foreach(MethodInfo method in methods)
 151                                 {
 152                                         method2Callback[method] = CreateCallbackMethod(emitter, method, method);
 153                                 }
 154
 155                                 // Create invocation types
 156
 157                                 Dictionary<MethodInfo, NestedClassEmitter> method2Invocation = new Dictionary<MethodInfo, NestedClassEmitter>();
 158
 159                                 foreach(MethodInfo method in methods)
 160                                 {
 161                                         MethodBuilder callbackMethod = method2Callback[method];
 162
 163                                         method2Invocation[method] = BuildInvocationNestedType(emitter, targetType,
 164                                                                                               emitter.TypeBuilder,
 165                                                                                               method, callbackMethod,
 166                                                                                               ConstructorVersion.WithoutTargetMethod);
 167                                 }
 168
 169                                 // Create methods overrides
 170
 171                                 Dictionary<MethodInfo, MethodEmitter> method2Emitter = new Dictionary<MethodInfo, MethodEmitter>();
 172
 173                                 foreach(MethodInfo method in methods)
 174                                 {
 175                                         if (method.IsSpecialName &&
 176                                             (method.Name.StartsWith("get_") || method.Name.StartsWith("set_") ||
 177                                              method.Name.StartsWith("add_") || method.Name.StartsWith("remove_")) ||
 178                                             methodsToSkip.Contains(method))
 179                                         {
 180                                                 continue;
 181                                         }
 182
 183                                         NestedClassEmitter nestedClass = method2Invocation[method];
 184
 185                                         MethodEmitter newProxiedMethod = CreateProxiedMethod(
 186                                                 targetType, method, emitter, nestedClass, interceptorsField, SelfReference.Self,
 187                                                 ConstructorVersion.WithoutTargetMethod, null);
 188
 189                                         ReplicateNonInheritableAttributes(method, newProxiedMethod);
 190
 191                                         method2Emitter[method] = newProxiedMethod;
 192                                 }
 193
 194                                 foreach(PropertyToGenerate propToGen in propsToGenerate)
 195                                 {
 196                                         if (propToGen.CanRead)
 197                                         {
 198                                                 NestedClassEmitter nestedClass = method2Invocation[propToGen.GetMethod];
 199
 200                                                 MethodAttributes atts = ObtainMethodAttributes(propToGen.GetMethod);
 201
 202                                                 MethodEmitter getEmitter = propToGen.Emitter.CreateGetMethod(atts);
 203
 204                                                 ImplementProxiedMethod(targetType, getEmitter,
 205                                                                        propToGen.GetMethod, emitter,
 206                                                                        nestedClass, interceptorsField, SelfReference.Self,
 207                                                                        ConstructorVersion.WithoutTargetMethod, null);
 208
 209                                                 ReplicateNonInheritableAttributes(propToGen.GetMethod, getEmitter);
 210                                         }
 211
 212                                         if (propToGen.CanWrite)
 213                                         {
 214                                                 NestedClassEmitter nestedClass = method2Invocation[propToGen.SetMethod];
 215
 216                                                 MethodAttributes atts = ObtainMethodAttributes(propToGen.SetMethod);
 217
 218                                                 MethodEmitter setEmitter = propToGen.Emitter.CreateSetMethod(atts);
 219
 220                                                 ImplementProxiedMethod(targetType, setEmitter,
 221                                                                        propToGen.SetMethod, emitter,
 222                                                                        nestedClass, interceptorsField, SelfReference.Self,
 223                                                                        ConstructorVersion.WithoutTargetMethod, null);
 224
 225                                                 ReplicateNonInheritableAttributes(propToGen.SetMethod, setEmitter);
 226                                         }
 227                                 }
 228
 229                                 foreach(EventToGenerate eventToGenerate in eventToGenerates)
 230                                 {
 231                                         NestedClassEmitter add_nestedClass = method2Invocation[eventToGenerate.AddMethod];
 232
 233                                         MethodAttributes add_atts = ObtainMethodAttributes(eventToGenerate.AddMethod);
 234
 235                                         MethodEmitter addEmitter = eventToGenerate.Emitter.CreateAddMethod(add_atts);
 236
 237                                         ImplementProxiedMethod(targetType, addEmitter,
 238                                                                eventToGenerate.AddMethod, emitter,
 239                                                                add_nestedClass, interceptorsField, SelfReference.Self,
 240                                                                ConstructorVersion.WithoutTargetMethod, null);
 241
 242                                         ReplicateNonInheritableAttributes(eventToGenerate.AddMethod, addEmitter);
 243
 244                                         NestedClassEmitter remove_nestedClass = method2Invocation[eventToGenerate.RemoveMethod];
 245
 246                                         MethodAttributes remove_atts = ObtainMethodAttributes(eventToGenerate.RemoveMethod);
 247
 248                                         MethodEmitter removeEmitter = eventToGenerate.Emitter.CreateRemoveMethod(remove_atts);
 249
 250                                         ImplementProxiedMethod(targetType, removeEmitter,
 251                                                                eventToGenerate.RemoveMethod, emitter,
 252                                                                remove_nestedClass, interceptorsField, SelfReference.Self,
 253                                                                ConstructorVersion.WithoutTargetMethod, null);
 254
 255                                         ReplicateNonInheritableAttributes(eventToGenerate.RemoveMethod, removeEmitter);
 256                                 }
 257
 258                                 ImplementGetObjectData(emitter, interceptorsField, interfaces);
 259
 260                                 // Complete type initializer code body
 261
 262                                 CompleteInitCacheMethod(typeInitializer.CodeBuilder);
 263
 264                                 // Build type
 265
 266                                 type = emitter.BuildType();
 267                                 InitializeStaticFields (type);
 268
 269                                 AddToCache(cacheKey, type);
 270                         }
 271                         finally
 272                         {
 273                                 rwlock.ReleaseWriterLock();
 274                         }
 275
 276                         Scope.SaveAssembly();
 277
 278                         return type;
 279                 }
 280
 281                 protected override Reference GetProxyTargetReference()
 282                 {
 283                         return SelfReference.Self;
 284                 }
 285
 286                 protected override bool CanOnlyProxyVirtual()
 287                 {
 288                         return true;
 289                 }
 290
 291                 protected void GenerateSerializationConstructor(ClassEmitter emitter, FieldReference interceptorField,
 292                                                                 bool delegateToBaseGetObjectData)
 293                 {
 294                         ArgumentReference arg1 = new ArgumentReference(typeof(SerializationInfo));
 295                         ArgumentReference arg2 = new ArgumentReference(typeof(StreamingContext));
 296
 297                         ConstructorEmitter constr = emitter.CreateConstructor(arg1, arg2);
 298
 299                         constr.CodeBuilder.AddStatement(
 300                                 new ConstructorInvocationStatement(serializationConstructor,
 301                                                                    arg1.ToExpression(), arg2.ToExpression()));
 302
 303                         Type[] object_arg = new Type[] {typeof(String), typeof(Type)};
 304                         MethodInfo getValueMethod = typeof(SerializationInfo).GetMethod("GetValue", object_arg);
 305
 306                         MethodInvocationExpression getInterceptorInvocation =
 307                                 new MethodInvocationExpression(arg1, getValueMethod,
 308                                                                new ConstReference("__interceptors").ToExpression(),
 309                                                                new TypeTokenExpression(typeof(IInterceptor[])));
 310
 311                         constr.CodeBuilder.AddStatement(new AssignStatement(
 312                                                                 interceptorField,
 313                                                                 new ConvertExpression(typeof(IInterceptor[]), typeof(object),
 314                                                                                       getInterceptorInvocation)));
 315
 316                         constr.CodeBuilder.AddStatement(new ReturnStatement());
 317                 }
 318
 319                 protected override void CustomizeGetObjectData(AbstractCodeBuilder codebuilder,
 320                                                                ArgumentReference arg1, ArgumentReference arg2)
 321                 {
 322                         Type[] key_and_object = new Type[] {typeof(String), typeof(Object)};
 323                         Type[] key_and_bool = new Type[] {typeof(String), typeof(bool)};
 324                         MethodInfo addValueMethod = typeof(SerializationInfo).GetMethod("AddValue", key_and_object);
 325                         MethodInfo addValueBoolMethod = typeof(SerializationInfo).GetMethod("AddValue", key_and_bool);
 326
 327                         codebuilder.AddStatement(new ExpressionStatement(
 328                                                         new MethodInvocationExpression(arg1, addValueBoolMethod,
 329                                                                                        new ConstReference("__delegateToBase").ToExpression(),
 330                                                                                        new ConstReference(delegateToBaseGetObjectData ? 1 : 0).
 331                                                                                         ToExpression())));
 332
 333                         if (delegateToBaseGetObjectData)
 334                         {
 335                                 MethodInfo baseGetObjectData = targetType.GetMethod("GetObjectData",
 336                                                                                     new Type[] {typeof(SerializationInfo), typeof(StreamingContext)});
 337
 338                                 codebuilder.AddStatement(new ExpressionStatement(
 339                                                                 new MethodInvocationExpression(baseGetObjectData,
 340                                                                                                arg1.ToExpression(), arg2.ToExpression())));
 341                         }
 342                         else
 343                         {
 344                                 LocalReference members_ref = codebuilder.DeclareLocal(typeof(MemberInfo[]));
 345                                 LocalReference data_ref = codebuilder.DeclareLocal(typeof(object[]));
 346
 347                                 MethodInfo getSerMembers = typeof(FormatterServices).GetMethod("GetSerializableMembers",
 348                                                                                                new Type[] {typeof(Type)});
 349                                 MethodInfo getObjData = typeof(FormatterServices).GetMethod("GetObjectData",
 350                                                                                             new Type[] {typeof(object), typeof(MemberInfo[])});
 351
 352                                 codebuilder.AddStatement(new AssignStatement(members_ref,
 353                                                                              new MethodInvocationExpression(null, getSerMembers,
 354                                                                                                             new TypeTokenExpression(targetType))));
 355
 356                                 codebuilder.AddStatement(new AssignStatement(data_ref,
 357                                                                              new MethodInvocationExpression(null, getObjData,
 358                                                                                                             SelfReference.Self.ToExpression(),
 359                                                                                                             members_ref.ToExpression())));
 360
 361                                 codebuilder.AddStatement(new ExpressionStatement(
 362                                                                 new MethodInvocationExpression(arg1, addValueMethod,
 363                                                                                                new ConstReference("__data").ToExpression(),
 364                                                                                                data_ref.ToExpression())));
 365                         }
 366                 }
 367         }
 368 }