public InvocationT(object proxy, InvocationHandler invocationHandler, MethodInfo method, PropertyInfo property, object[] arguments, Func <Invocation, T> implementation) : base(proxy, invocationHandler, method, property, arguments) { this.implementation = implementation; }
/// <summary> /// Creates a proxy for a given type. This method supports two discrete usage scenarios.<p/> /// If T is an interface, the target should be an implementation of that interface. In /// this scenario, T should be <i>explicitly</i> specified unless the type of <i>target</i> /// at the calling site is of that interface. In other words, if the calling site has the /// <i>target</i> declared as the concrete implementation, the proxy will be generated /// for the implementation, rather than for the interface. /// /// If T is a class, the target should be an instance of that class, and a subclassing /// proxy will be created for it. However, because target is specified in this case, /// the base class behavior will be ignored (it will all be delegated to the target). /// </summary> /// <typeparam name="T">The type to create the proxy for. May be an interface or a /// concrete base class.</typeparam> /// <param name="invocationHandler">This is where you get to inject your logic.</param> /// <returns>The new instance of the proxy that is an instance of T</returns> public static T CreateProxy <T>(InvocationHandler invocationHandler) { return(CreateProxy(default(T), invocationHandler)); }
/// <summary> /// Creates a proxy for a given type. This method supports two discrete usage scenarios.<p/> /// If T is an interface, the target should be an implementation of that interface. In /// this scenario, T should be <i>explicitly</i> specified unless the type of <i>target</i> /// at the calling site is of that interface. In other words, if the calling site has the /// <i>target</i> declared as the concrete implementation, the proxy will be generated /// for the implementation, rather than for the interface. /// /// If T is a class, the target should be an instance of that class, and a subclassing /// proxy will be created for it. However, because target is specified in this case, /// the base class behavior will be ignored (it will all be delegated to the target). /// </summary> /// <typeparam name="T">The type to create the proxy for. May be an interface or a /// concrete base class.</typeparam> /// <param name="target">The instance of T that should be the recipient of all invocations /// on the proxy via Invocation.Proceed.</param> /// <param name="invocationHandler">This is where you get to inject your logic.</param> /// <returns>The new instance of the proxy that is an instance of T</returns> public static T CreateProxy <T>(T target, InvocationHandler invocationHandler) { return(Proxy <T> .CreateProxy(target, invocationHandler)); }
public VoidInvocation(object proxy, InvocationHandler invocationHandler, MethodInfo method, PropertyInfo property, object[] arguments, Action <Invocation> implementation) : base(proxy, invocationHandler, method, property, arguments) { this.implementation = implementation; }