InversionOfControl/Castle.Windsor/Proxy/DefaultProxyFactory.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.Windsor.Proxy
  16 {
  17         using System;
  18         using System.Reflection;
  19         using System.Runtime.Serialization;
  20         using Castle.Core;
  21         using Castle.Core.Interceptor;
  22         using Castle.DynamicProxy;
  23         using Castle.MicroKernel;
  24         using Castle.MicroKernel.Proxy;
  25
  26         /// <summary>
  27         /// This implementation of <see cref="IProxyFactory"/> relies
  28         /// on DynamicProxy to expose proxy capabilies.
  29         /// </summary>
  30         /// <remarks>
  31         /// Note that only virtual methods can be intercepted in a
  32         /// concrete class. However, if the component
  33         /// was registered with a service interface, we proxy
  34         /// the interface and the methods don't need to be virtual,
  35         /// </remarks>
  36         [Serializable]
  37         public class DefaultProxyFactory : AbstractProxyFactory, IDeserializationCallback
  38         {
  39                 [NonSerialized]
  40                 protected ProxyGenerator generator;
  41
  42                 /// <summary>
  43                 /// Constructs a DefaultProxyFactory
  44                 /// </summary>
  45                 public DefaultProxyFactory()
  46                 {
  47                         Init();
  48                 }
  49
  50                 /// <summary>
  51                 /// Creates the proxy for the supplied component.
  52                 /// </summary>
  53                 /// <param name="kernel">The kernel.</param>
  54                 /// <param name="target">The target.</param>
  55                 /// <param name="model">The model.</param>
  56                 /// <param name="constructorArguments">The constructor arguments.</param>
  57                 /// <returns>The component proxy.</returns>
  58                 public override object Create(IKernel kernel, object target, ComponentModel model,
  59                                               params object[] constructorArguments)
  60                 {
  61                         object proxy;
  62
  63                         IInterceptor[] interceptors = ObtainInterceptors(kernel, model);
  64
  65                         ProxyOptions proxyOptions = ProxyUtil.ObtainProxyOptions(model, true);
  66                         ProxyGenerationOptions proxyGenOptions = CreateProxyGenerationOptionsFrom(proxyOptions);
  67
  68                         CustomizeOptions(proxyGenOptions, kernel, model, constructorArguments);
  69
  70                         Type[] interfaces = proxyOptions.AdditionalInterfaces;
  71
  72                         if (model.Service.IsInterface)
  73                         {
  74                                 if (proxyOptions.OmitTarget)
  75                                 {
  76                                         proxy = generator.CreateInterfaceProxyWithoutTarget(model.Service, interfaces,
  77                                                                                             proxyGenOptions, interceptors);
  78                                 }
  79                                 else if (proxyOptions.AllowChangeTarget)
  80                                 {
  81                                         proxy = generator.CreateInterfaceProxyWithTargetInterface(model.Service, target,
  82                                                                                                       proxyGenOptions, interceptors);
  83                                 }
  84                                 else
  85                                 {
  86                                         if (!proxyOptions.UseSingleInterfaceProxy)
  87                                         {
  88                                                 interfaces = CollectInterfaces(interfaces, model);
  89                                         }
  90
  91                                         proxy = generator.CreateInterfaceProxyWithTarget(model.Service, interfaces,
  92                                                                                                                                          target, proxyGenOptions, interceptors);
  93                                 }
  94                         }
  95                         else
  96                         {
  97                                 proxy = generator.CreateClassProxy(model.Implementation, interfaces, proxyGenOptions,
  98                                                                    constructorArguments, interceptors);
  99                         }
 100
 101                         CustomizeProxy(proxy, proxyGenOptions, kernel, model);
 102
 103                         return proxy;
 104                 }
 105
 106                 protected static ProxyGenerationOptions CreateProxyGenerationOptionsFrom(ProxyOptions proxyOptions)
 107                 {
 108                         ProxyGenerationOptions proxyGenOptions = new ProxyGenerationOptions();
 109
 110                         if (proxyOptions.Hook != null)
 111                         {
 112                                 proxyGenOptions.Hook = new ProxyGenerationHookAdapter(proxyOptions.Hook);
 113                         }
 114
 115                         if (proxyOptions.UseMarshalByRefAsBaseClass)
 116                         {
 117                                 proxyGenOptions.BaseTypeForInterfaceProxy = typeof(MarshalByRefObject);
 118                         }
 119
 120                         return proxyGenOptions;
 121                 }
 122
 123                 protected virtual void CustomizeProxy(object proxy, ProxyGenerationOptions options,
 124                                                       IKernel kernel, ComponentModel model)
 125                 {
 126                 }
 127
 128                 protected virtual void CustomizeOptions(ProxyGenerationOptions options, IKernel kernel,
 129                                                         ComponentModel model, object[] arguments)
 130                 {
 131                 }
 132
 133                 /// <summary>
 134                 /// Determines if the component requiries a target instance for proxying.
 135                 /// </summary>
 136                 /// <param name="kernel">The kernel.</param>
 137                 /// <param name="model">The model.</param>
 138                 /// <returns>true if an instance is required.</returns>
 139                 public override bool RequiresTargetInstance(IKernel kernel, ComponentModel model)
 140                 {
 141                         ProxyOptions proxyOptions = ProxyUtil.ObtainProxyOptions(model, true);
 142
 143                         return model.Service.IsInterface && !proxyOptions.OmitTarget;
 144                 }
 145
 146                 protected Type[] CollectInterfaces(Type[] interfaces, ComponentModel model)
 147                 {
 148                         Type[] modelInterfaces = model.Implementation.FindInterfaces(
 149                                 new TypeFilter(EmptyTypeFilter), model.Service);
 150
 151                         if (interfaces == null || interfaces.Length == 0)
 152                         {
 153                                 interfaces = modelInterfaces;
 154                         }
 155                         else if (modelInterfaces != null && modelInterfaces.Length > 0)
 156                         {
 157                                 Type[] allInterfaces = new Type[interfaces.Length + modelInterfaces.Length];
 158                                 interfaces.CopyTo(allInterfaces, 0);
 159                                 modelInterfaces.CopyTo(allInterfaces, interfaces.Length);
 160                                 interfaces = allInterfaces;
 161                         }
 162
 163                         return interfaces;
 164                 }
 165
 166                 private bool EmptyTypeFilter(Type type, object criteria)
 167                 {
 168                         Type mainInterface = (Type) criteria;
 169
 170                         return !type.IsAssignableFrom(mainInterface);
 171                 }
 172
 173                 #region IDeserializationCallback
 174
 175                 public void OnDeserialization(object sender)
 176                 {
 177                         Init();
 178                 }
 179
 180                 #endregion
 181
 182                 private void Init()
 183                 {
 184                         generator = new ProxyGenerator();
 185                 }
 186         }
 187 }