static void Main(string[] args)
{
using (var kernel = new StandardKernel())
{
// an interceptor can be used to automatically generate decorator classes
var interceptor = new ActionInterceptor(invocation =>
{
Console.WriteLine("Before " + invocation.Request.Method.DeclaringType.Name + "." + invocation.Request.Method.Name);
invocation.Proceed();
Console.WriteLine("After" + invocation.Request.Method.DeclaringType.Name + "." + invocation.Request.Method.Name);
});
kernel.Bind <InterfaceB>().To <ObjectB>()
.Intercept().With(interceptor);
// the benefit is that we can write an interceptor once, not a decorator per interface
// this is useful for cross-cutting concerns like auditing, logging, etc.
// gotcha: ObjectC.DoStuff needs to be virtual, since its a concrete class. the dynamic proxy can only intercept virtual methods.
kernel.Bind <ObjectC>().ToSelf()
.Intercept().With(interceptor);
var a = kernel.Get <ObjectA>();
a.DoStuff();
}
}
public InterceptorBaseTests()
{
_invocationList = new List <string>();
//using concrete classes because interception did NOT play well with Moq
_actionInterceptor = new ActionInterceptor()
{
PreInvocation = context => { _invocationList.Add(Pre); return(_PreReturnValue); },
PostSuccessInvocation = context => { _invocationList.Add(PostSuccess); },
PostErrorInvocation = (ex, context) => { _invocationList.Add(PostError); },
TransformExceptionInvocation = (ex, context) => { _invocationList.Add(TransformException); return(ex); }
};
_businessClasses = new Dictionary <ExceptionMode, IBusinessClass>();
foreach (var mode in Enum.GetValues(typeof(ExceptionMode)).Cast <ExceptionMode>())
{
_businessClasses[mode] = new ActionBusinessClass()
{
SomethingImportantInvocation = () => { RecordInvocation(nameof(IBusinessClass.SomethingImportant), mode); },
SomethingImportantAsyncInvocation = () => { return(RecordInvocationAsync(nameof(IBusinessClass.SomethingImportantAsync), mode)); },
FetchSomethingInvocation = () => { RecordInvocation(nameof(IBusinessClass.FetchSomething), mode); return(ExpectedFetchedValue); },
FetchSomethingAsyncInvocation = () => { return(RecordInvocationAsync(nameof(IBusinessClass.FetchSomethingAsync), mode, ExpectedFetchedValue)); }
};
}
}
public void ActionValueTypeWithSingleParameterInIntercepted <T>(T expectedValue)
where T : struct
{
// Given
var proxyFactory = Context.ProxyFactory;
var interceptor = new ActionInterceptor(true);
var decoratee = new FooActionValueTypeParameterIn <T>();
// When
var foo = proxyFactory.CreateDecorator <IFooActionValueTypeParameterIn <T> >(decoratee, interceptor);
foo.MethodWithOneParameter(expectedValue);
// Then
Assert.NotNull(foo);
Assert.Equal(0u, decoratee.CallCount);
Assert.Empty(decoratee.Parameters);
Assert.Single(interceptor.ForwardedInvocations);
var invocation = interceptor.ForwardedInvocations.Single();
invocation.ShouldInterceptMethodWithName(nameof(IFooActionValueTypeParameterIn <T> .MethodWithOneParameter));
invocation.ShouldHaveParameterInCountOf(1);
invocation.ShouldHaveParameterIn("first", typeof(T), expectedValue);
invocation.ShouldHaveNoParameterRef();
invocation.ShouldHaveNoParameterOut();
}
/// <summary>
/// Adds the method interceptor.
/// </summary>
/// <param name="kernel">The kernel.</param>
/// <param name="method">The method to intercept.</param>
/// <param name="action">The action to take in its place.</param>
public static void AddMethodInterceptor(this IKernel kernel,
MethodInfo method,
Action <IInvocation> action)
{
var interceptor = new ActionInterceptor(action);
kernel.Components.Get <IMethodInterceptorRegistry>().Add(method, interceptor);
}
public void ActionValueTypeWithSingleParameterRef <T>(T expectedValue)
where T : struct
{
// Given
var proxyFactory = Context.ProxyFactory;
var interceptor = new ActionInterceptor(false);
var decoratee = new FooActionValueTypeParameterRef <T>();
var actualValue = expectedValue;
// When
var foo = proxyFactory.CreateDecorator <IFooActionValueTypeParameterRef <T> >(decoratee, interceptor);
foo.MethodWithOneParameter(ref actualValue);
// Then
Assert.NotNull(foo);
Assert.Equal(1u, decoratee.CallCount);
Assert.Equal(expectedValue, decoratee.Parameters.SingleOrDefault());
Assert.Equal(default, actualValue);
static void Main(string[] args)
{
log4net.Config.XmlConfigurator.Configure();
ILog logger = LogManager.GetLogger(typeof(Program));
try
{
IKernel kernel = new StandardKernel();
var interceptor = new ActionInterceptor(invocation =>
{
var sw = new Stopwatch();
sw.Start();
try
{
invocation.Proceed();
}
finally
{
sw.Stop();
logger.DebugFormat("Die Ausführung der Methode {0} dauerte {1} ms",
invocation.Request.Method,
sw.ElapsedMilliseconds);
}
});
kernel.Bind <IUserRepository>().To <UserRepository>().Intercept()
.With(interceptor);
IUserRepository userRepo = kernel.Get <IUserRepository>();
foreach (var user in userRepo.GetAllUsers())
{
Console.WriteLine("{0}:\t {1} {2}", user.Id, user.FirstName, user.Name);
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
Console.ReadLine();
}
public void ActionWithoutParameters()
{
// Given
var proxyFactory = Context.ProxyFactory;
var interceptor = new ActionInterceptor();
// When
var foo = proxyFactory.CreateForInterface <IFooActionParameterless>(interceptor);
foo.MethodWithoutParameter();
// Then
Assert.NotNull(foo);
Assert.Single(interceptor.ForwardedInvocations);
var invocation = interceptor.ForwardedInvocations.Single();
invocation.ShouldInterceptMethodWithName(nameof(IFooActionParameterless.MethodWithoutParameter));
invocation.ShouldHaveNoParameterIn();
invocation.ShouldHaveNoParameterRef();
invocation.ShouldHaveNoParameterOut();
}
public void ActionWithoutParametersIntercepted()
{
// Given
var proxyFactory = Context.ProxyFactory;
var interceptor = new ActionInterceptor(true);
var decoratee = new FooActionParameterless();
// When
var foo = proxyFactory.CreateDecorator <IFooActionParameterless>(decoratee, interceptor);
foo.MethodWithoutParameter();
// Then
Assert.NotNull(foo);
Assert.Equal(0u, decoratee.CallCount);
Assert.Single(interceptor.ForwardedInvocations);
var invocation = interceptor.ForwardedInvocations.Single();
invocation.ShouldInterceptMethodWithName(nameof(IFooActionParameterless.MethodWithoutParameter));
invocation.ShouldHaveNoParameterIn();
invocation.ShouldHaveNoParameterRef();
invocation.ShouldHaveNoParameterOut();
}
public void ActionValueTypeWithSingleParameterRef <T>(T expectedValue)
where T : struct
{
// Given
var proxyFactory = Context.ProxyFactory;
var interceptor = new ActionInterceptor();
// When
var foo = proxyFactory.CreateForInterface <IFooActionValueTypeParameterRef <T> >(interceptor);
foo.MethodWithOneParameter(ref expectedValue);
// Then
Assert.NotNull(foo);
Assert.Single(interceptor.ForwardedInvocations);
var invocation = interceptor.ForwardedInvocations.Single();
invocation.ShouldInterceptMethodWithName(nameof(IFooActionValueTypeParameterRef <T> .MethodWithOneParameter));
invocation.ShouldHaveNoParameterIn();
invocation.ShouldHaveParameterRefCountOf(1);
invocation.ShouldHaveParameterRef("first", typeof(T), expectedValue);
invocation.ShouldHaveNoParameterOut();
}
