Tools/Castle.DynamicProxy2/Castle.DynamicProxy/ProxyGenerator.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;
  16
  17 namespace Castle.DynamicProxy
  18 {
  19         using System;
  20         using Castle.Core.Interceptor;
  21
  22         [CLSCompliant(true)]
  23         public class ProxyGenerator
  24         {
  25                 private readonly IProxyBuilder proxyBuilder;
  26
  27                 #region Constructors
  28
  29                 /// <summary>
  30                 /// Initializes a new instance of the <see cref="ProxyGenerator"/> class.
  31                 /// </summary>
  32                 /// <param name="builder">The builder.</param>
  33                 public ProxyGenerator(IProxyBuilder builder)
  34                 {
  35                         proxyBuilder = builder;
  36                 }
  37
  38                 /// <summary>
  39                 /// Initializes a new instance of the <see cref="ProxyGenerator"/> class.
  40                 /// </summary>
  41                 public ProxyGenerator() : this(new DefaultProxyBuilder())
  42                 {
  43                 }
  44
  45                 #endregion
  46
  47                 #region Properties
  48
  49                 /// <summary>
  50                 /// Gets the proxy builder instance.
  51                 /// </summary>
  52                 /// <value>The proxy builder.</value>
  53                 public IProxyBuilder ProxyBuilder
  54                 {
  55                         get { return proxyBuilder; }
  56                 }
  57
  58                 #endregion
  59
  60                 #region CreateInterfaceProxyWithTarget
  61 #if DOTNET2
  62
  63                 public T CreateInterfaceProxyWithTarget<T>(object target, params IInterceptor[] interceptors)
  64                 {
  65                         return (T) CreateInterfaceProxyWithTarget(typeof(T), target, ProxyGenerationOptions.Default, interceptors);
  66                 }
  67
  68                 public T CreateInterfaceProxyWithTarget<T>(object target, ProxyGenerationOptions options,
  69                                                            params IInterceptor[] interceptors)
  70                 {
  71                         return (T) CreateInterfaceProxyWithTarget(typeof(T), target, options, interceptors);
  72                 }
  73 #endif
  74
  75                 public object CreateInterfaceProxyWithTarget(Type theInterface, object target, params IInterceptor[] interceptors)
  76                 {
  77                         return CreateInterfaceProxyWithTarget(theInterface, target, ProxyGenerationOptions.Default, interceptors);
  78                 }
  79
  80                 public object CreateInterfaceProxyWithTarget(Type theInterface, object target, ProxyGenerationOptions options,
  81                                                              params IInterceptor[] interceptors)
  82                 {
  83                         return CreateInterfaceProxyWithTarget(theInterface, null, target, options, interceptors);
  84                 }
  85
  86                 public object CreateInterfaceProxyWithTarget(Type theInterface, Type[] interfaces,
  87                                                              object target, params IInterceptor[] interceptors)
  88                 {
  89                         return CreateInterfaceProxyWithTarget(theInterface, interfaces, target, ProxyGenerationOptions.Default, interceptors);
  90                 }
  91
  92                 public object CreateInterfaceProxyWithTarget(Type theInterface, Type[] interfaces, object target,
  93                                                              ProxyGenerationOptions options, params IInterceptor[] interceptors)
  94                 {
  95                         if (theInterface == null)
  96                         {
  97                                 throw new ArgumentNullException("theInterface");
  98                         }
  99                         if (target == null)
 100                         {
 101                                 throw new ArgumentNullException("target");
 102                         }
 103                         if (interceptors == null)
 104                         {
 105                                 throw new ArgumentNullException("interceptors");
 106                         }
 107
 108                         if (!theInterface.IsInterface)
 109                         {
 110                                 throw new ArgumentException("Specified type is not an interface", "theInterface");
 111                         }
 112
 113                         if (!theInterface.IsAssignableFrom(target.GetType()))
 114                         {
 115                                 throw new ArgumentException("Target does not implement interface " + theInterface.FullName, "target");
 116                         }
 117
 118                         if (theInterface.IsGenericTypeDefinition)
 119                         {
 120                                 throw new ArgumentException("You can't specify a generic interface definition", "theInterface");
 121                         }
 122
 123                         Type targetType = target.GetType();
 124                         Type generatedType;
 125
 126                         if (theInterface.IsGenericType)
 127                         {
 128                                 generatedType =
 129                                         CreateInterfaceProxyTypeWithTarget(theInterface.GetGenericTypeDefinition(), interfaces,
 130                                                                            targetType.GetGenericTypeDefinition(), options);
 131                         }
 132                         else
 133                         {
 134                                 generatedType = CreateInterfaceProxyTypeWithTarget(theInterface, interfaces, targetType, options);
 135                         }
 136
 137                         if (theInterface.IsGenericType)
 138                         {
 139                                 Type[] args = theInterface.GetGenericArguments();
 140                                 generatedType = generatedType.MakeGenericType(args);
 141                         }
 142
 143                         ArrayList argsForCtor = new ArrayList();
 144                         argsForCtor.AddRange(options.MixinInterfaceImplementationsAsArray());
 145                         argsForCtor.Add(interceptors);
 146                         argsForCtor.Add(target);
 147                         return Activator.CreateInstance(generatedType, argsForCtor.ToArray());
 148                 }
 149
 150                 #endregion
 151
 152                 #region CreateInterfaceProxyWithTargetInterface
 153
 154                 public object CreateInterfaceProxyWithTargetInterface(Type theInterface, object target,
 155                                                                       params IInterceptor[] interceptors)
 156                 {
 157                         return CreateInterfaceProxyWithTargetInterface(theInterface, target, ProxyGenerationOptions.Default, interceptors);
 158                 }
 159
 160                 public object CreateInterfaceProxyWithTargetInterface(Type theInterface, object target,
 161                                                                       ProxyGenerationOptions options,
 162                                                                       params IInterceptor[] interceptors)
 163                 {
 164                         if (!theInterface.IsInstanceOfType(target))
 165                         {
 166                                 throw new ArgumentException("targetType");
 167                         }
 168                         if (theInterface == null)
 169                         {
 170                                 throw new ArgumentNullException("theInterface");
 171                         }
 172                         if (target == null)
 173                         {
 174                                 throw new ArgumentNullException("target");
 175                         }
 176                         if (interceptors == null)
 177                         {
 178                                 throw new ArgumentNullException("interceptors");
 179                         }
 180
 181                         if (!theInterface.IsInterface)
 182                         {
 183                                 throw new ArgumentException("Specified type is not an interface", "theInterface");
 184                         }
 185
 186                         if (!theInterface.IsAssignableFrom(target.GetType()))
 187                         {
 188                                 throw new ArgumentException("Target does not implement interface " + theInterface.FullName, "target");
 189                         }
 190
 191                         if (theInterface.IsGenericTypeDefinition)
 192                         {
 193                                 throw new ArgumentException("You can't specify a generic interface definition", "theInterface");
 194                         }
 195
 196                         Type generatedType;
 197
 198                         if (theInterface.IsGenericType)
 199                         {
 200                                 generatedType =
 201                                         CreateInterfaceProxyTypeWithTargetInterface(theInterface.GetGenericTypeDefinition(), null,
 202                                                                                     theInterface.GetGenericTypeDefinition(), options);
 203                         }
 204                         else
 205                         {
 206                                 generatedType = CreateInterfaceProxyTypeWithTargetInterface(theInterface, null, theInterface, options);
 207                         }
 208
 209                         if (theInterface.IsGenericType)
 210                         {
 211                                 Type[] args = theInterface.GetGenericArguments();
 212                                 generatedType = generatedType.MakeGenericType(args);
 213                         }
 214
 215                         return Activator.CreateInstance(generatedType, new object[] {interceptors, target});
 216                 }
 217
 218                 #endregion
 219
 220                 #region CreateInterfaceProxyWithoutTarget
 221 #if DOTNET2
 222                 public T CreateInterfaceProxyWithoutTarget<T>(IInterceptor interceptor)
 223                 {
 224                         return (T) CreateInterfaceProxyWithoutTarget(typeof(T), interceptor);
 225                 }
 226
 227                 public T CreateInterfaceProxyWithoutTarget<T>(params IInterceptor[] interceptors)
 228                 {
 229                         return (T) CreateInterfaceProxyWithoutTarget(typeof(T), interceptors);
 230                 }
 231 #endif
 232                 public object CreateInterfaceProxyWithoutTarget(Type theInterface, IInterceptor interceptor)
 233                 {
 234                         return CreateInterfaceProxyWithoutTarget(theInterface, new Type[0],
 235                                                                  ProxyGenerationOptions.Default,
 236                                                                  interceptor);
 237                 }
 238
 239                 public object CreateInterfaceProxyWithoutTarget(Type theInterface, params IInterceptor[] interceptors)
 240                 {
 241                         return CreateInterfaceProxyWithoutTarget(theInterface, new Type[0], ProxyGenerationOptions.Default, interceptors);
 242                 }
 243
 244                 public object CreateInterfaceProxyWithoutTarget(Type theInterface, Type[] interfaces,
 245                                                                 params IInterceptor[] interceptors)
 246                 {
 247                         return CreateInterfaceProxyWithoutTarget(theInterface, interfaces, ProxyGenerationOptions.Default, interceptors);
 248                 }
 249
 250                 public object CreateInterfaceProxyWithoutTarget(Type theInterface, Type[] interfaces, ProxyGenerationOptions options,
 251                                                                 params IInterceptor[] interceptors)
 252                 {
 253                         if (theInterface == null)
 254                         {
 255                                 throw new ArgumentNullException("theInterface");
 256                         }
 257                         if (interceptors == null)
 258                         {
 259                                 throw new ArgumentNullException("interceptors");
 260                         }
 261
 262                         if (!theInterface.IsInterface)
 263                         {
 264                                 throw new ArgumentException("Specified type is not an interface", "theInterface");
 265                         }
 266
 267                         if (theInterface.IsGenericTypeDefinition)
 268                         {
 269                                 throw new ArgumentException("You can't specify a generic interface definition", "theInterface");
 270                         }
 271
 272                         Type generatedType;
 273
 274                         if (theInterface.IsGenericType)
 275                         {
 276                                 generatedType = CreateInterfaceProxyTypeWithoutTarget(theInterface.GetGenericTypeDefinition(), interfaces, options);
 277                         }
 278                         else
 279                         {
 280                                 generatedType = CreateInterfaceProxyTypeWithoutTarget(theInterface, interfaces, options);
 281                         }
 282
 283                         if (theInterface.IsGenericType)
 284                         {
 285                                 Type[] args = theInterface.GetGenericArguments();
 286                                 generatedType = generatedType.MakeGenericType(args);
 287                         }
 288
 289                         return Activator.CreateInstance(generatedType, new object[] {interceptors, new object(),});
 290                 }
 291
 292                 #endregion
 293
 294                 #region CreateClassProxy
 295 #if DOTNET2
 296                 public T CreateClassProxy<T>(params IInterceptor[] interceptors)
 297                 {
 298                         return (T) CreateClassProxy(typeof(T), ProxyGenerationOptions.Default, interceptors);
 299                 }
 300
 301                 public object CreateClassProxy(Type targetType, params IInterceptor[] interceptors)
 302                 {
 303                         return CreateClassProxy(targetType, ProxyGenerationOptions.Default, interceptors);
 304                 }
 305 #endif
 306                 /// <summary>
 307                 /// Creates the class proxy.
 308                 /// </summary>
 309                 /// <param name="targetType">Type of the target.</param>
 310                 /// <param name="interfaces">The interfaces.</param>
 311                 /// <param name="interceptors">The interceptors.</param>
 312                 /// <returns></returns>
 313                 public object CreateClassProxy(Type targetType, Type[] interfaces, params IInterceptor[] interceptors)
 314                 {
 315                         return CreateClassProxy(targetType, interfaces, ProxyGenerationOptions.Default, interceptors);
 316                 }
 317
 318                 /// <summary>
 319                 /// Creates the class proxy.
 320                 /// </summary>
 321                 /// <param name="targetType">Type of the target.</param>
 322                 /// <param name="interceptors">The interceptors.</param>
 323                 /// <param name="constructorArgs">The constructor args.</param>
 324                 /// <returns></returns>
 325                 public object CreateClassProxy(Type targetType, IInterceptor[] interceptors,
 326                                                params object[] constructorArgs)
 327                 {
 328                         return CreateClassProxy(targetType, null, ProxyGenerationOptions.Default,
 329                                                 constructorArgs, interceptors);
 330                 }
 331
 332                 /// <summary>
 333                 ///
 334                 /// </summary>
 335                 /// <param name="targetType"></param>
 336                 /// <param name="options"></param>
 337                 /// <param name="interceptors"></param>
 338                 /// <returns></returns>
 339                 public object CreateClassProxy(Type targetType, ProxyGenerationOptions options, params IInterceptor[] interceptors)
 340                 {
 341                         return CreateClassProxy(targetType, null, options, interceptors);
 342                 }
 343
 344                 public object CreateClassProxy(Type targetType, Type[] interfaces,
 345                                                ProxyGenerationOptions options, params IInterceptor[] interceptors)
 346                 {
 347                         return CreateClassProxy(targetType, interfaces, options, null, interceptors);
 348                 }
 349
 350                 /// <summary>
 351                 /// Creates the class proxy.
 352                 /// </summary>
 353                 /// <param name="targetType">Type of the target.</param>
 354                 /// <param name="interfaces">The interfaces.</param>
 355                 /// <param name="options">The options.</param>
 356                 /// <param name="constructorArgs">The constructor args.</param>
 357                 /// <param name="interceptors">The interceptors.</param>
 358                 /// <returns></returns>
 359                 public object CreateClassProxy(Type targetType, Type[] interfaces, ProxyGenerationOptions options,
 360                                                object[] constructorArgs, params IInterceptor[] interceptors)
 361                 {
 362                         if (targetType == null)
 363                         {
 364                                 throw new ArgumentNullException("targetType");
 365                         }
 366                         if (options == null)
 367                         {
 368                                 throw new ArgumentNullException("options");
 369                         }
 370                         if (!targetType.IsClass)
 371                         {
 372                                 throw new ArgumentException("'targetType' must be a class", "targetType");
 373                         }
 374
 375                         Type proxyType;
 376
 377 #if DOTNET2
 378                         if (targetType.IsGenericTypeDefinition)
 379                         {
 380                                 throw new ArgumentException("You can't specify a generic type definition", "baseClass");
 381                         }
 382
 383
 384                         if (targetType.IsGenericType)
 385                         {
 386                                 proxyType = CreateClassProxyType(targetType.GetGenericTypeDefinition(), interfaces, options);
 387                         }
 388                         else
 389 #endif
 390                         {
 391                                 proxyType = CreateClassProxyType(targetType, interfaces, options);
 392                         }
 393
 394                         #if DOTNET2
 395                         if (targetType.IsGenericType)
 396                         {
 397                                 proxyType = proxyType.MakeGenericType(targetType.GetGenericArguments());
 398                         }
 399                         #endif
 400
 401                         object[] args = GetConstructorArguments(constructorArgs, interceptors, options);
 402
 403                         return Activator.CreateInstance(proxyType, args);
 404                 }
 405
 406                 private static object[] GetConstructorArguments(object[] constructorArgs, IInterceptor[] interceptors, ProxyGenerationOptions options)
 407                 {
 408                         ArrayList args = new ArrayList();
 409                         args.AddRange(options.MixinInterfaceImplementationsAsArray());
 410
 411                         args.Add(interceptors);
 412
 413
 414                         if (constructorArgs != null && constructorArgs.Length != 0)
 415                         {
 416                                 args.AddRange(constructorArgs);
 417                         }
 418                         return args.ToArray();
 419                 }
 420
 421                 #endregion
 422
 423                 protected Type CreateClassProxyType(Type baseClass, Type[] interfaces, ProxyGenerationOptions options)
 424                 {
 425                         options.Initialize();
 426                         return ProxyBuilder.CreateClassProxy(baseClass, interfaces, options);
 427                 }
 428
 429                 protected Type CreateInterfaceProxyTypeWithTarget(Type theInterface, Type[] interfaces, Type targetType,
 430                                                                   ProxyGenerationOptions options)
 431                 {
 432                         options.Initialize();
 433                         return ProxyBuilder.CreateInterfaceProxyTypeWithTarget(theInterface, interfaces, targetType, options);
 434                 }
 435
 436                 protected Type CreateInterfaceProxyTypeWithTargetInterface(Type theInterface, Type[] interfaces, Type targetType,
 437                                                                            ProxyGenerationOptions options)
 438                 {
 439                         options.Initialize();
 440                         return ProxyBuilder.CreateInterfaceProxyTypeWithTargetInterface(theInterface, options);
 441                 }
 442
 443                 protected Type CreateInterfaceProxyTypeWithoutTarget(Type theInterface, Type[] interfaces,
 444                                                                      ProxyGenerationOptions options)
 445                 {
 446                         options.Initialize();
 447                         return ProxyBuilder.CreateInterfaceProxyTypeWithoutTarget(theInterface, interfaces, options);
 448                 }
 449         }
 450 }