/// <summary>
/// Defines that the object created by the binding shall be registered on the specified event broker.
/// </summary>
/// <typeparam name="T">The type of the binding.</typeparam>
/// <param name="syntax">The syntax.</param>
/// <param name="eventBrokerName">Name of the event broker.</param>
/// <returns>The syntax.</returns>
public static IBindingOnSyntax <T> RegisterOnEventBroker <T>(
this IBindingOnSyntax <T> syntax, string eventBrokerName)
{
return
(syntax.OnActivation((ctx, instance) => ctx.ContextPreservingGet <IEventBroker>(eventBrokerName).Register(instance))
.OnDeactivation((ctx, instance) => ctx.ContextPreservingGet <IEventBroker>(eventBrokerName).Unregister(instance)));
}
public static IBindingOnSyntax <T> ConfigureUsing <T>(this IBindingOnSyntax <T> bindingSyntax,
IConfigurer <T> configurer)
{
return
(bindingSyntax.OnActivation(
t =>
configurer.Configure(t, bindingSyntax.BindingConfiguration.Metadata.Name)));
}
public static IBindingOnSyntax <T> Configure <T>(this IBindingOnSyntax <T> bindingSyntax)
{
return
(bindingSyntax.OnActivation(
(c, t) =>
c.Kernel.Get <IConfigurer <T> >()
.Configure(t, bindingSyntax.BindingConfiguration.Metadata.Name)));
}
/// <summary>
/// Defines that the object created by a binding owns an event broker.
/// Object created in the object tree below this binding can use this event broker.
/// </summary>
/// <typeparam name="T">The type of the binding.</typeparam>
/// <param name="syntax">The syntax.</param>
/// <param name="eventBrokerName">Name of the event broker.</param>
/// <returns>The syntax</returns>
public static IBindingOnSyntax <T> OwnsEventBroker <T>(this IBindingOnSyntax <T> syntax, string eventBrokerName)
{
string namedScopeName = "EventBrokerScope" + eventBrokerName;
syntax.DefinesNamedScope(namedScopeName);
syntax.Kernel.Bind <IEventBroker>().To <EventBroker>().InNamedScope(namedScopeName).Named(eventBrokerName);
syntax.Kernel.Bind <IEventBroker>().ToMethod(ctx => ctx.ContextPreservingGet <IEventBroker>(eventBrokerName)).WhenTargetNamed(eventBrokerName);
return(syntax);
}
public static IBindingOnSyntax <T> ConfigureUsing <T>(this IBindingOnSyntax <T> bindingSyntax,
Func <IContext, IConfigurer <T> > configurerFactory)
{
return
(bindingSyntax.OnActivation(
(c, t) =>
configurerFactory(c)
.Configure(t, bindingSyntax.BindingConfiguration.Metadata.Name)));
}
/// <summary>
/// Defines the a binding defines a named scope.
/// </summary>
/// <typeparam name="T">The type of the binding.</typeparam>
/// <param name="syntax">The syntax.</param>
/// <param name="scopeName">The name of the scope.</param>
public static void DefinesNamedScope <T>(this IBindingOnSyntax <T> syntax, string scopeName)
{
var callback = syntax.BindingConfiguration.ProviderCallback;
syntax.BindingConfiguration.ProviderCallback =
context =>
{
context.Parameters.Add(new NamedScopeParameter(scopeName));
return(callback(context));
};
}
/// <summary>
/// Indicates that binding should be intercepted via the argument validation interceptor.
/// The interceptor will be created via the kernel when the method is called.
/// </summary>
/// <returns>The binding builder.</returns>
public static IBindingOnSyntax <T> ValidateArguments <T>(this IBindingOnSyntax <T> syntax, params Type[] argsTypes)
{
foreach (var argsType in argsTypes)
{
syntax.Intercept().With(request =>
{
var validatorType = typeof(IValidator <>).MakeGenericType(argsType);
var validator = request.Kernel.Get(validatorType) as IValidator;
return(new ArgumentValidationInterceptor(argsType, validator));
});
}
return(syntax);
}
/// <summary>
/// Indicates that instances associated with this binding will be proxied.
/// Only methods that match the specified predicate will be intercepted.
/// </summary>
/// <typeparam name="T">The type associated with this binding.</typeparam>
/// <param name="bindingSyntax">The binding syntax target.</param>
/// <param name="methodPredicate">The method predicate that defines if a method shall be intercepted.</param>
/// <param name="additionalInterfaces">The additional interfaces for the proxy.</param>
/// <returns>An <see cref="IAdviceTargetSyntax" /> instance which allows the attachment of an <see cref="IInterceptor" />.</returns>
public static IAdviceTargetSyntax Intercept <T>(this IBindingOnSyntax <T> bindingSyntax, Predicate <MethodInfo> methodPredicate, params Type[] additionalInterfaces)
{
IKernel kernel = bindingSyntax.Kernel;
foreach (var additionalInterface in additionalInterfaces)
{
bindingSyntax.BindingConfiguration.Parameters.Add(new AdditionalInterfaceParameter(additionalInterface));
}
IAdvice advice = kernel.Components.Get <IAdviceFactory>()
.Create(context => ReferenceEquals(bindingSyntax.BindingConfiguration, context.Binding.BindingConfiguration), methodPredicate);
kernel.Components.Get <IAdviceRegistry>().Register(advice);
return(new AdviceBuilder(advice));
}
public static IBindingOnSyntax <T> RegisterOnEventAggregator <T>(this IBindingOnSyntax <T> syntax)
{
return
(syntax.OnActivation((ctx, instance) => ctx.Kernel.Get <IEventAggregator>().Subscribe(instance))
.OnDeactivation((ctx, instance) => ctx.Kernel.Get <IEventAggregator>().Unsubscribe(instance)));
}
/// <summary>
/// Specifies the arrangements to make before the mock is injected.
/// </summary>
/// <typeparam name="T">The service type.</typeparam>
/// <param name="arrangeActions">A delegate that contains the arrangements to make. Usually,
/// it will contain a series of Mock.Arrange statements for the necessary arrangements and expectations.</param>
/// <param name="builder">The fluent syntax.</param>
/// <returns>The fluent syntax.</returns>
public static IBindingOnSyntax <T> AndArrange <T>(this IBindingOnSyntax <T> builder, Action <T> arrangeActions)
{
return(ProfilerInterceptor.GuardInternal(() => builder.OnActivation(arrangeActions)));
}
public static IBindingOnSyntax <TInitializable> InitializeOnActivation <TInitializable>(this IBindingOnSyntax <TInitializable> kernelBinding)
where TInitializable : IInitializable
{
return(kernelBinding.OnActivation(x => x.Initialize()));
}
/// <summary>
/// Indicates that instances associated with this binding will be proxied.
/// </summary>
/// <typeparam name="T">The type associated with this binding.</typeparam>
/// <param name="bindingSyntax">The binding syntax target.</param>
/// <param name="additionalInterfaces">The additional interfaces for the proxy.</param>
/// <returns>
/// An <see cref="IAdviceTargetSyntax"/> instance which allows the attachment of an <see cref="IInterceptor"/>.
/// </returns>
public static IAdviceTargetSyntax Intercept <T>(this IBindingOnSyntax <T> bindingSyntax, params Type[] additionalInterfaces)
{
return(Intercept(bindingSyntax,
mi => mi.DeclaringType != typeof(object),
additionalInterfaces));
}
/// <summary>
/// Indicates that instances associated with this binding will be proxied.
/// </summary>
/// <typeparam name="T">The type associated with this binding.</typeparam>
/// <param name="bindingSyntax">The binding syntax target.</param>
/// <param name="additionalInterfaces">The additional interfaces for the proxy.</param>
/// <returns>
/// An <see cref="IAdviceTargetSyntax"/> instance which allows the attachment of an <see cref="IInterceptor"/>.
/// </returns>
public static IAdviceTargetSyntax Intercept <T>(this IBindingOnSyntax <T> bindingSyntax, params Type[] additionalInterfaces)
{
return(DoIntercept(bindingSyntax, additionalInterfaces));
}
/// <summary>
/// Defines that the object created by the binding shall be registered on the default global event broker.
/// </summary>
/// <typeparam name="T">The type of the binding.</typeparam>
/// <param name="syntax">The syntax.</param>
/// <returns>The syntax.</returns>
public static IBindingOnSyntax <T> RegisterOnGlobalEventBroker <T>(
this IBindingOnSyntax <T> syntax)
{
return(RegisterOnEventBroker(syntax, EventBrokerModule.DefaultGlobalEventBrokerName));
}
/// <summary>
/// Indicates that instances associated with this binding will be proxied.
/// </summary>
/// <typeparam name="T">The type associated with this binding.</typeparam>
/// <param name="bindingSyntax">The binding syntax target.</param>
/// <returns>
/// An <see cref="IAdviceTargetSyntax"/> instance which allows the attachment of an <see cref="IInterceptor"/>.
/// </returns>
public static IAdviceTargetSyntax Intercept <T>(this IBindingOnSyntax <T> bindingSyntax)
{
return(DoIntercept(bindingSyntax));
}
/// <summary>
/// Indicates that binding should be intercepted via the trace interceptor.
/// The interceptor will be created via the kernel when the method is called.
/// </summary>
/// <returns>The binding builder.</returns>
public static IBindingOnSyntax <T> Trace <T>(this IBindingOnSyntax <T> syntax)
{
syntax.Intercept().With <TraceInterceptor>().InOrder(0);
return(syntax);
}