/// <summary>
/// Provides a handler for all methods, async or otherwise.
/// </summary>
public InvocationHandler(Func <Invocation, Task <object> > asyncHandler, Func <object, MethodInfo, PropertyInfo, bool> proxyPredicate = null, AsyncInvocationMode asyncMode = AsyncInvocationMode.Throw)
{
this.asyncHandler = asyncHandler;
this.proxyPredicate = proxyPredicate ?? ((x, method, property) => true);
this.asyncMode = asyncMode;
}
/// <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>
/// <param name="predicate">Optional predicate to determine if the interception should happen. Useful
/// improving performance in certain situations</param>
/// <param name="asyncMode">Controls what happens when an async invocation handler performs async related actions
/// where the original method being proxied is not an async method.</param>
/// <returns>The new instance of the proxy that is an instance of T</returns>
public static T CreateProxy <T>(Func <Invocation, Task <object> > invocationHandler, ProxyPredicate <T> predicate = null,
AsyncInvocationMode asyncMode = AsyncInvocationMode.Throw)
{
return(CreateProxy(default(T), invocationHandler, predicate, asyncMode));
}
/// <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>
/// <param name="predicate">Optional predicate to determine if the interception should happen. Useful
/// improving performance in certain situations</param>
/// <param name="asyncMode">Controls what happens when an async invocation handler performs async related actions
/// where the original method being proxied is not an async method.</param>
/// <returns>The new instance of the proxy that is an instance of T</returns>
public static T CreateProxy <T>(T target, Func <Invocation, Task <object> > invocationHandler, ProxyPredicate <T> predicate = null,
AsyncInvocationMode asyncMode = AsyncInvocationMode.Throw)
{
return(Proxy <T> .CreateProxy(target, invocationHandler, predicate, asyncMode));
}
