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