Tools/Castle.DynamicProxy2/Castle.DynamicProxy/AbstractInvocation.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
  16 {
  17         using System;
  18         using System.Diagnostics;
  19         using System.Reflection;
  20         using System.Runtime.Serialization;
  21         using Castle.Core.Interceptor;
  22
  23         [Serializable]
  24         public abstract class AbstractInvocation : IInvocation, ISerializable
  25         {
  26                 private readonly object proxy;
  27                 private readonly object target;
  28                 private readonly IInterceptor[] interceptors;
  29                 private readonly Type targetType;
  30                 private readonly MethodInfo targetMethod;
  31                 private readonly MethodInfo interfMethod;
  32                 private object returnValue;
  33                 private object[] arguments;
  34                 private int execIndex = -1;
  35                 private Type[] genericMethodArguments = null;
  36
  37                 protected AbstractInvocation(
  38                         object target, object proxy, IInterceptor[] interceptors,
  39                         Type targetType, MethodInfo targetMethod, object[] arguments)
  40                 {
  41                         this.proxy = proxy;
  42                         this.target = target;
  43                         this.interceptors = interceptors;
  44                         this.targetType = targetType;
  45                         this.targetMethod = targetMethod;
  46                         this.arguments = arguments;
  47                 }
  48
  49                 protected AbstractInvocation(
  50                         object target, object proxy, IInterceptor[] interceptors,
  51                         Type targetType, MethodInfo targetMethod, MethodInfo interfMethod,
  52                         object[] arguments)
  53                         : this(target, proxy, interceptors, targetType, targetMethod, arguments)
  54                 {
  55                         this.interfMethod = interfMethod;
  56                 }
  57
  58                 public void SetGenericMethodArguments(Type[] arguments)
  59                 {
  60                         genericMethodArguments = arguments;
  61                 }
  62
  63                 public Type[] GenericArguments
  64                 {
  65                         get { return genericMethodArguments; }
  66                 }
  67
  68                 public object Proxy
  69                 {
  70                         get { return proxy; }
  71                 }
  72
  73                 public object InvocationTarget
  74                 {
  75                         get { return target; }
  76                 }
  77
  78                 public Type TargetType
  79                 {
  80                         get { return targetType; }
  81                 }
  82
  83                 public MethodInfo Method
  84                 {
  85                         get
  86                         {
  87                                 if (interfMethod == null)
  88                                 {
  89                                         return targetMethod;
  90                                 }
  91                                 else
  92                                 {
  93                                         return interfMethod;
  94                                 }
  95                         }
  96                 }
  97
  98                 public MethodInfo GetConcreteMethod()
  99                 {
 100                         return EnsureClosedMethod(Method);
 101                 }
 102
 103                 public MethodInfo MethodInvocationTarget
 104                 {
 105                         get { return targetMethod; }
 106                 }
 107
 108                 public MethodInfo GetConcreteMethodInvocationTarget()
 109                 {
 110                         return EnsureClosedMethod(MethodInvocationTarget);
 111                 }
 112
 113                 public object ReturnValue
 114                 {
 115                         get { return returnValue; }
 116                         set { returnValue = value; }
 117                 }
 118
 119                 public object[] Arguments
 120                 {
 121                         get { return arguments; }
 122                 }
 123
 124                 public void SetArgumentValue(int index, object value)
 125                 {
 126                         arguments[index] = value;
 127                 }
 128
 129                 public object GetArgumentValue(int index)
 130                 {
 131                         return arguments[index];
 132                 }
 133
 134                 public void Proceed()
 135                 {
 136                         execIndex++;
 137
 138                         if (execIndex == interceptors.Length)
 139                         {
 140                                 InvokeMethodOnTarget();
 141                         }
 142                         else if (execIndex > interceptors.Length)
 143                         {
 144                                 throw new InvalidOperationException(
 145                                         @"Proceed() cannot delegate to another interceptor. This usually signify a bug in the calling code");
 146                         }
 147                         else
 148                         {
 149                                 interceptors[execIndex].Intercept(this);
 150                         }
 151                 }
 152
 153                 public void GetObjectData(SerializationInfo info, StreamingContext context)
 154                 {
 155                         info.SetType(typeof(RemotableInvocation));
 156                         info.AddValue("invocation", new RemotableInvocation(this));
 157                 }
 158
 159                 protected abstract void InvokeMethodOnTarget();
 160
 161                 private MethodInfo EnsureClosedMethod(MethodInfo method)
 162                 {
 163                         if (method.ContainsGenericParameters)
 164                         {
 165                                 Debug.Assert(genericMethodArguments != null);
 166                                 return method.GetGenericMethodDefinition().MakeGenericMethod(genericMethodArguments);
 167                         }
 168                         else
 169                         {
 170                                 return method;
 171                         }
 172                 }
 173         }
 174 }