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