Tools/DynamicProxy/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
  20         using Castle.DynamicProxy.Builder;
  21
  22         /// <summary>
  23         /// Generates a Java style proxy. This overrides the .Net proxy requirements
  24         /// that forces one to extend MarshalByRefObject or (for a different purpose)
  25         /// ContextBoundObject to have a Proxiable class.
  26         /// </summary>
  27         /// <remarks>
  28         /// The <see cref="ProxyGenerator"/> should be used to generate a class
  29         /// implementing the specified interfaces. The dynamic implementation will
  30         /// only calls the internal <see cref="IInterceptor"/> instance.
  31         /// </remarks>
  32         /// <remarks>
  33         /// Please note that this proxy implementation currently doesn't not supports ref and out arguments
  34         /// in methods.
  35         /// Also note that only virtual methods can be proxied in a class.
  36         /// </remarks>
  37         /// <example>
  38         /// <code>
  39         /// MyInvocationHandler interceptor = ...
  40         /// ProxyGenerator generator = new ProxyGenerator();
  41         /// IInterfaceExposed proxy =
  42         ///             generator.CreateProxy( new Type[] { typeof(IInterfaceExposed) }, interceptor );
  43         /// </code>
  44         /// </example>
  45         public class ProxyGenerator
  46         {
  47                 private IProxyBuilder _builder;
  48
  49                 public ProxyGenerator(IProxyBuilder builder)
  50                 {
  51                         _builder = builder;
  52                 }
  53
  54                 public ProxyGenerator() : this( new DefaultProxyBuilder() )
  55                 {
  56                 }
  57
  58                 public IProxyBuilder ProxyBuilder
  59                 {
  60                         get { return _builder; }
  61                         set { _builder = value; }
  62                 }
  63
  64                 public virtual object CreateClassProxy(Type baseClass, IInterceptor interceptor,
  65                         params object[] argumentsForConstructor)
  66                 {
  67                         return CreateClassProxy (baseClass, interceptor, true, argumentsForConstructor);
  68                 }
  69
  70                 public virtual object CreateClassProxy(Type baseClass, IInterceptor interceptor, bool checkAbstract,
  71                         params object[] argumentsForConstructor)
  72                 {
  73                         AssertUtil.IsClass(baseClass, "baseClass", checkAbstract);
  74                         AssertUtil.NotNull(interceptor, "interceptor");
  75
  76                         Type newType = ProxyBuilder.CreateClassProxy(baseClass);
  77                         return CreateClassProxyInstance( newType, interceptor, argumentsForConstructor );
  78                 }
  79
  80                 public virtual object CreateClassProxy(Type baseClass, Type[] interfaces,
  81                         IInterceptor interceptor, params object[] argumentsForConstructor)
  82                 {
  83                         return CreateClassProxy(baseClass, interfaces, interceptor, true, argumentsForConstructor);
  84                 }
  85
  86                 public virtual object CreateClassProxy(Type baseClass, Type[] interfaces,
  87                         IInterceptor interceptor, bool checkAbstract, params object[] argumentsForConstructor)
  88                 {
  89                         AssertUtil.IsClass(baseClass, "baseClass", checkAbstract);
  90                         AssertUtil.NotNull(interceptor, "interceptor");
  91                         AssertUtil.NotNull(interfaces, "interfaces");
  92
  93                         Type newType = ProxyBuilder.CreateClassProxy(baseClass, interfaces);
  94
  95                         return CreateClassProxyInstance( newType, interceptor, argumentsForConstructor );
  96                 }
  97
  98                 public virtual object CreateCustomClassProxy(Type baseClass,
  99                         IInterceptor interceptor, GeneratorContext context,
 100                         params object[] argumentsForConstructor)
 101                 {
 102                         return  CreateCustomClassProxy(baseClass, interceptor, context, true, argumentsForConstructor);
 103                 }
 104
 105                 public virtual object CreateCustomClassProxy(Type baseClass,
 106                         IInterceptor interceptor, GeneratorContext context, bool checkAbstract,
 107                         params object[] argumentsForConstructor)
 108                 {
 109                         AssertUtil.IsClass(baseClass, "baseClass", checkAbstract);
 110                         AssertUtil.NotNull(interceptor, "interceptor");
 111                         AssertUtil.NotNull(context, "context");
 112
 113                         Type newType = ProxyBuilder.CreateCustomClassProxy(baseClass, context);
 114                         return CreateCustomClassProxyInstance( newType, interceptor, context,
 115                                 argumentsForConstructor );
 116                 }
 117
 118                 /// <summary>
 119                 /// Generates a proxy implementing all the specified interfaces and
 120                 /// redirecting method invocations to the specifed interceptor.
 121                 /// </summary>
 122                 /// <param name="theInterface">Interface to be implemented</param>
 123                 /// <param name="interceptor">instance of <see cref="IInterceptor"/></param>
 124         /// <param name="target">The proxy target.</param>
 125                 /// <returns>Proxy instance</returns>
 126                 public virtual object CreateProxy(Type theInterface, IInterceptor interceptor, object target)
 127                 {
 128                         return CreateProxy(new Type[] {theInterface}, interceptor, target);
 129                 }
 130
 131                 /// <summary>
 132                 /// Generates a proxy implementing all the specified interfaces and
 133                 /// redirecting method invocations to the specifed interceptor.
 134                 /// </summary>
 135                 /// <param name="interfaces">Array of interfaces to be implemented</param>
 136                 /// <param name="interceptor">instance of <see cref="IInterceptor"/></param>
 137         /// <param name="target">The proxy target.</param>
 138                 /// <returns>Proxy instance</returns>
 139                 public virtual object CreateProxy(Type[] interfaces, IInterceptor interceptor, object target)
 140                 {
 141                         AssertUtil.IsInterface(interfaces, "interfaces");
 142                         AssertUtil.NotNull(interceptor, "interceptor");
 143                         AssertUtil.NotNull(target, "target");
 144
 145                         Type newType = ProxyBuilder.CreateInterfaceProxy(interfaces, target.GetType());
 146                         return CreateProxyInstance( newType, interceptor, target );
 147                 }
 148
 149                 /// <summary>
 150                 ///
 151                 /// </summary>
 152                 /// <param name="theInterface"></param>
 153                 /// <param name="interceptor"></param>
 154                 /// <param name="context"></param>
 155         /// <param name="target">The proxy target.</param>
 156                 /// <returns></returns>
 157                 public virtual object CreateCustomProxy(Type theInterface,
 158                         IInterceptor interceptor, object target, GeneratorContext context )
 159                 {
 160                         return CreateCustomProxy( new Type[] { theInterface }, interceptor, target, context );
 161                 }
 162
 163                 /// <summary>
 164                 ///
 165                 /// </summary>
 166                 /// <param name="interfaces"></param>
 167                 /// <param name="interceptor"></param>
 168                 /// <param name="context"></param>
 169         /// <param name="target">The proxy target.</param>
 170                 /// <returns></returns>
 171                 public virtual object CreateCustomProxy(Type[] interfaces,
 172                         IInterceptor interceptor, object target, GeneratorContext context )
 173                 {
 174                         AssertUtil.IsInterface(interfaces, "interfaces");
 175                         AssertUtil.NotNull(interceptor, "interceptor");
 176                         AssertUtil.NotNull(target, "target");
 177                         AssertUtil.NotNull(context, "context");
 178
 179                         Type newType = ProxyBuilder.CreateCustomInterfaceProxy(interfaces, target.GetType(), context);
 180                         return CreateCustomProxyInstance( newType, interceptor, target, context );
 181                 }
 182
 183                 protected virtual object CreateProxyInstance(Type type, IInterceptor interceptor, object target)
 184                 {
 185                         return Activator.CreateInstance(type, new object[] {interceptor, target});
 186                 }
 187
 188                 protected virtual object CreateCustomProxyInstance(Type type, IInterceptor interceptor,
 189                         object target, GeneratorContext context)
 190                 {
 191                         if (context.HasMixins)
 192                         {
 193                                 return Activator.CreateInstance( type, new object[] { interceptor, target, context.MixinsAsArray() } );
 194                         }
 195                         return CreateProxyInstance( type, interceptor, target );
 196                 }
 197
 198                 protected virtual object CreateClassProxyInstance(Type type, IInterceptor interceptor,
 199                         params object[] argumentsForConstructor)
 200                 {
 201                         ArrayList args = new ArrayList();
 202                         args.Add(interceptor);
 203                         args.AddRange(argumentsForConstructor);
 204
 205                         return Activator.CreateInstance(type, args.ToArray());
 206                 }
 207
 208                 protected virtual object CreateCustomClassProxyInstance(Type type, IInterceptor interceptor,
 209                         GeneratorContext context, params object[] argumentsForConstructor)
 210                 {
 211                         if (context.HasMixins)
 212                         {
 213                                 ArrayList args = new ArrayList();
 214                                 args.Add(interceptor);
 215                                 args.Add(context.MixinsAsArray());
 216                                 args.AddRange(argumentsForConstructor);
 217
 218                                 return Activator.CreateInstance( type, args.ToArray() );
 219                         }
 220                         return CreateClassProxyInstance( type, interceptor, argumentsForConstructor );
 221                 }
 222
 223                 protected virtual object CreateCustomClassProxyInstance(Type type, IInterceptor interceptor,
 224                         GeneratorContext context, object target)
 225                 {
 226                         return CreateProxyInstance( type, interceptor, target );
 227                 }
 228         }
 229 }