Tools/DynamicProxy/Castle.DynamicProxy/Builder/CodeGenerators/ClassProxyGenerator.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.DynamicProxy.Builder.CodeGenerators
  16 {
  17         using System;
  18         using System.Text;
  19         using System.Reflection;
  20         using System.Runtime.Serialization;
  21         using System.Collections;
  22         using System.Collections.Specialized;
  23         using System.Threading;
  24
  25         using Castle.DynamicProxy.Builder.CodeBuilder;
  26         using Castle.DynamicProxy.Builder.CodeBuilder.SimpleAST;
  27         using Castle.DynamicProxy.Builder.CodeBuilder.Utils;
  28
  29         /// <summary>
  30         /// Summary description for ClassProxyGenerator.
  31         /// </summary>
  32         [CLSCompliant(false)]
  33         public class ClassProxyGenerator : BaseCodeGenerator
  34         {
  35                 private bool _delegateToBaseGetObjectData;
  36
  37                 protected ConstructorInfo _serializationConstructor;
  38
  39                 public ClassProxyGenerator(ModuleScope scope) : base(scope)
  40                 {
  41                 }
  42
  43                 public ClassProxyGenerator(ModuleScope scope, GeneratorContext context) : base(scope, context)
  44                 {
  45                 }
  46
  47                 protected override Type InvocationType
  48                 {
  49                         get { return Context.SameClassInvocation; }
  50                 }
  51
  52                 protected override String GenerateTypeName(Type type, Type[] interfaces)
  53                 {
  54                         StringBuilder sb = new StringBuilder();
  55                         foreach (Type inter in interfaces)
  56                         {
  57                                 sb.Append('_');
  58                 sb.Append(GetTypeName(inter));
  59                         }
  60                         return String.Format("CProxyType{0}{3}{1}{2}", GetTypeName(type), sb.ToString(), interfaces.Length, NormalizeNamespaceName(type.Namespace));
  61                 }
  62
  63                 /// <summary>
  64                 /// Generates one public constructor receiving
  65                 /// the <see cref="IInterceptor"/> instance and instantiating a hashtable
  66                 /// </summary>
  67                 protected virtual EasyConstructor GenerateConstructor( ConstructorInfo baseConstructor )
  68                 {
  69                         ArrayList arguments = new ArrayList();
  70
  71                         ArgumentReference arg1 = new ArgumentReference( Context.Interceptor );
  72                         ArgumentReference arg2 = new ArgumentReference( typeof(object[]) );
  73
  74                         arguments.Add( arg1 );
  75
  76                         ParameterInfo[] parameters = baseConstructor.GetParameters();
  77
  78                         if (Context.HasMixins)
  79                         {
  80                                 arguments.Add( arg2 );
  81                         }
  82
  83                         ArgumentReference[] originalArguments =
  84                                 ArgumentsUtil.ConvertToArgumentReference(parameters);
  85
  86                         arguments.AddRange(originalArguments);
  87
  88                         EasyConstructor constructor = MainTypeBuilder.CreateConstructor(
  89                                 (ArgumentReference[]) arguments.ToArray( typeof(ArgumentReference) ) );
  90
  91                         GenerateConstructorCode(constructor.CodeBuilder, arg1, SelfReference.Self, arg2);
  92
  93                         constructor.CodeBuilder.InvokeBaseConstructor( baseConstructor, originalArguments );
  94
  95                         constructor.CodeBuilder.AddStatement( new ReturnStatement() );
  96
  97                         return constructor;
  98                 }
  99
 100                 protected void GenerateSerializationConstructor()
 101                 {
 102                         ArgumentReference arg1 = new ArgumentReference( typeof(SerializationInfo) );
 103                         ArgumentReference arg2 = new ArgumentReference( typeof(StreamingContext) );
 104
 105                         EasyConstructor constr = MainTypeBuilder.CreateConstructor( arg1, arg2 );
 106
 107                         constr.CodeBuilder.AddStatement( new ExpressionStatement(
 108                                 new ConstructorInvocationExpression( _serializationConstructor,
 109                                 arg1.ToExpression(), arg2.ToExpression() )) );
 110
 111                         Type[] object_arg = new Type[] { typeof (String), typeof(Type) };
 112                         MethodInfo getValueMethod = typeof (SerializationInfo).GetMethod("GetValue", object_arg);
 113
 114                         VirtualMethodInvocationExpression getInterceptorInvocation =
 115                                 new VirtualMethodInvocationExpression(arg1, getValueMethod,
 116                                 new FixedReference("__interceptor").ToExpression(),
 117                                 new TypeTokenExpression( Context.Interceptor ) );
 118
 119                         VirtualMethodInvocationExpression getMixinsInvocation =
 120                                 new VirtualMethodInvocationExpression(arg1, getValueMethod,
 121                                 new FixedReference("__mixins").ToExpression(),
 122                                 new TypeTokenExpression( typeof(object[]) ) );
 123
 124                         constr.CodeBuilder.AddStatement( new AssignStatement(
 125                                 InterceptorField, getInterceptorInvocation) );
 126
 127                         constr.CodeBuilder.AddStatement( new AssignStatement(
 128                                 CacheField, new NewInstanceExpression(
 129                                 typeof(HybridDictionary).GetConstructor( new Type[0] )) ) );
 130
 131                         constr.CodeBuilder.AddStatement( new AssignStatement(
 132                                 MixinField,
 133                                 getMixinsInvocation) );
 134
 135                         // Initialize the delegate fields
 136                         foreach(CallableField field in _cachedFields)
 137                         {
 138                                 field.WriteInitialization(constr.CodeBuilder, SelfReference.Self, MixinField);
 139                         }
 140
 141                         constr.CodeBuilder.AddStatement( new ReturnStatement() );
 142                 }
 143
 144                 protected override void CustomizeGetObjectData(AbstractCodeBuilder codebuilder,
 145                                                                ArgumentReference arg1, ArgumentReference arg2)
 146                 {
 147                         Type[] key_and_object = new Type[] {typeof (String), typeof (Object)};
 148                         Type[] key_and_bool = new Type[] {typeof (String), typeof (bool)};
 149                         MethodInfo addValueMethod = typeof (SerializationInfo).GetMethod("AddValue", key_and_object);
 150                         MethodInfo addValueBoolMethod = typeof (SerializationInfo).GetMethod("AddValue", key_and_bool);
 151
 152                         codebuilder.AddStatement( new ExpressionStatement(
 153                                 new VirtualMethodInvocationExpression(arg1, addValueBoolMethod,
 154                                 new FixedReference("__delegateToBase").ToExpression(),
 155                                 new FixedReference( _delegateToBaseGetObjectData ? 1 : 0 ).ToExpression() ) ) );
 156
 157                         if (_delegateToBaseGetObjectData)
 158                         {
 159                                 MethodInfo baseGetObjectData = _baseType.GetMethod("GetObjectData",
 160                                         new Type[] { typeof(SerializationInfo), typeof(StreamingContext) });
 161
 162                                 codebuilder.AddStatement( new ExpressionStatement(
 163                                         new MethodInvocationExpression( baseGetObjectData,
 164                                                 arg1.ToExpression(), arg2.ToExpression() )) );
 165                         }
 166                         else
 167                         {
 168                                 LocalReference members_ref = codebuilder.DeclareLocal( typeof(MemberInfo[]) );
 169                                 LocalReference data_ref = codebuilder.DeclareLocal( typeof(object[]) );
 170
 171                                 MethodInfo getSerMembers = typeof(FormatterServices).GetMethod("GetSerializableMembers",
 172                                         new Type[] { typeof(Type) });
 173                                 MethodInfo getObjData = typeof(FormatterServices).GetMethod("GetObjectData",
 174                                         new Type[] { typeof(object), typeof(MemberInfo[]) });
 175
 176                                 codebuilder.AddStatement( new AssignStatement( members_ref,
 177                                         new MethodInvocationExpression( null, getSerMembers,
 178                                         new TypeTokenExpression( _baseType ) )) );
 179
 180                                 codebuilder.AddStatement( new AssignStatement( data_ref,
 181                                         new MethodInvocationExpression( null, getObjData,
 182                                         SelfReference.Self.ToExpression(), members_ref.ToExpression() )) );
 183
 184                                 codebuilder.AddStatement( new ExpressionStatement(
 185                                         new VirtualMethodInvocationExpression(arg1, addValueMethod,
 186                                         new FixedReference("__data").ToExpression(),
 187                                         data_ref.ToExpression() ) ) );
 188                         }
 189                 }
 190
 191                 public virtual Type GenerateCode(Type baseClass)
 192                 {
 193                         return GenerateCode(baseClass, new Type[0]);
 194                 }
 195
 196                 public virtual Type GenerateCode(Type baseClass, Type[] interfaces)
 197                 {
 198                         if (baseClass.IsSerializable)
 199                         {
 200                                 _delegateToBaseGetObjectData = VerifyIfBaseImplementsGetObjectData(baseClass);
 201                                 interfaces = AddISerializable( interfaces );
 202                         }
 203
 204                         ReaderWriterLock rwlock = ModuleScope.RWLock;
 205
 206                         rwlock.AcquireReaderLock(-1);
 207
 208                         Type cacheType = GetFromCache(baseClass, interfaces);
 209
 210                         if (cacheType != null)
 211                         {
 212                                 rwlock.ReleaseReaderLock();
 213
 214                                 return cacheType;
 215                         }
 216
 217                         rwlock.UpgradeToWriterLock(-1);
 218
 219                         try
 220                         {
 221                                 cacheType = GetFromCache(baseClass, interfaces);
 222
 223                                 if (cacheType != null)
 224                                 {
 225                                         return cacheType;
 226                                 }
 227
 228                                 CreateTypeBuilder( GenerateTypeName(baseClass, interfaces), baseClass, interfaces );
 229                                 GenerateFields();
 230
 231                                 if (baseClass.IsSerializable)
 232                                 {
 233                                         ImplementGetObjectData( interfaces );
 234                                 }
 235
 236                                 ImplementCacheInvocationCache();
 237                                 GenerateTypeImplementation( baseClass, true );
 238                                 GenerateInterfaceImplementation(interfaces);
 239                                 GenerateConstructors(baseClass);
 240
 241                                 if (_delegateToBaseGetObjectData)
 242                                 {
 243                                         GenerateSerializationConstructor();
 244                                 }
 245
 246                                 return CreateType();
 247                         }
 248                         finally
 249                         {
 250                                 rwlock.ReleaseWriterLock();
 251                         }
 252                 }
 253
 254                 public virtual Type GenerateCustomCode(Type baseClass, Type[] interfaces)
 255                 {
 256                         if (!Context.HasMixins)
 257                         {
 258                                 return GenerateCode(baseClass);
 259                         }
 260
 261                         _mixins = Context.MixinsAsArray();
 262                         Type[] mixinInterfaces = InspectAndRegisterInterfaces( _mixins );
 263                         interfaces = Join(interfaces, mixinInterfaces);
 264
 265                         return GenerateCode(baseClass, mixinInterfaces);
 266                 }
 267
 268                 protected virtual void GenerateConstructors(Type baseClass)
 269                 {
 270                         ConstructorInfo[] constructors =
 271                                 baseClass.GetConstructors( BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic );
 272
 273                         foreach(ConstructorInfo constructor in constructors)
 274                         {
 275                                 if (constructor.IsPrivate)
 276                                 {
 277                                         continue;
 278                                 }
 279                 if (constructor.IsAssembly && !IsInternalToDynamicProxy(baseClass.Assembly))
 280                 {
 281                     continue;
 282                 }
 283                                 GenerateConstructor(constructor);
 284                         }
 285                 }
 286
 287                 protected bool VerifyIfBaseImplementsGetObjectData(Type baseType)
 288                 {
 289                         // If base type implements ISerializable, we have to make sure
 290                         // the GetObjectData is marked as virtual
 291
 292                         if (typeof(ISerializable).IsAssignableFrom(baseType))
 293                         {
 294                                 MethodInfo getObjectDataMethod = baseType.GetMethod("GetObjectData",
 295                                         new Type[] { typeof(SerializationInfo), typeof(StreamingContext) });
 296
 297                                 if (getObjectDataMethod==null)//explicit interface implementation
 298                                 {
 299                                         return false;
 300                                 }
 301
 302                                 if (!getObjectDataMethod.IsVirtual || getObjectDataMethod.IsFinal)
 303                                 {
 304                                         String message = String.Format("The type {0} implements ISerializable, but GetObjectData is not marked as virtual",
 305                                                 baseType.FullName);
 306                                         throw new ProxyGenerationException(message);
 307                                 }
 308
 309                                 Context.AddMethodToSkip(getObjectDataMethod);
 310
 311                                 _serializationConstructor = baseType.GetConstructor(
 312                                         BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic,
 313                                         null,
 314                                         new Type[] { typeof(SerializationInfo), typeof(StreamingContext) },
 315                                         null);
 316
 317                                 if (_serializationConstructor == null)
 318                                 {
 319                                         String message = String.Format("The type {0} implements ISerializable, but failed to provide a deserialization constructor",
 320                                                 baseType.FullName);
 321                                         throw new ProxyGenerationException(message);
 322                                 }
 323
 324                                 return true;
 325                         }
 326                         return false;
 327                 }
 328
 329                 protected void SkipDefaultInterfaceImplementation(Type[] interfaces)
 330                 {
 331                         foreach( Type inter in interfaces )
 332                         {
 333                                 Context.AddInterfaceToSkip(inter);
 334                         }
 335                 }
 336
 337                 protected Type[] Join(Type[] interfaces, Type[] mixinInterfaces)
 338                 {
 339                         if (interfaces == null) interfaces = new Type[0];
 340                         if (mixinInterfaces == null) mixinInterfaces = new Type[0];
 341                         Type[] union = new Type[ interfaces.Length + mixinInterfaces.Length ];
 342                         Array.Copy( interfaces, 0, union, 0, interfaces.Length );
 343                         Array.Copy( mixinInterfaces, 0, union, interfaces.Length, mixinInterfaces.Length );
 344                         return union;
 345                 }
 346         }
 347 }