public static IBindingNamedWithOrOnSyntax<T> AsEagerSingleton<T>(this IBindingInSyntax<T> binding)
{
var r = binding.InSingletonScope();
binding.Kernel.Bind<IEagerSingleton>().To<EagerSingleton<T>>().InSingletonScope();
return r;
}
/// <summary>
/// Set scope based on <see cref="BindingLifecycle">ActivationScope</see>
/// </summary>
/// <param name="syntax"><see cref="IBindingInSyntax{T}">Binding syntax</see> to set the scope for</param>
/// <param name="lifecycle"><see cref="BindingLifecycle"/> to use</param>
public static void WithLifecycle <T>(this IBindingInSyntax <T> syntax, BindingLifecycle lifecycle)
{
switch (lifecycle)
{
case BindingLifecycle.Singleton:
syntax.InSingletonScope();
break;
#if (false)
case BindingLifecycle.Request:
syntax.InRequestScope();
break;
#endif
#if (NET461)
case BindingLifecycle.Thread:
syntax.InThreadScope();
break;
#endif
case BindingLifecycle.Transient:
syntax.InTransientScope();
break;
}
}
public static IBindingNamedWithOrOnSyntax <T> InCommandScope <T>(this IBindingInSyntax <T> src, KernelMode mode)
{
return(mode switch
{
KernelMode.HangFireJob => src.InBackgroundJobScope(),
KernelMode.Web => src.InRequestScope(),
_ => throw new ArgumentOutOfRangeException(nameof(mode))
});
public IBindingNamedWithOrOnSyntax <T> InRequestScope <T>(IBindingInSyntax <T> syntax)
{
return(syntax
.InScope(context =>
RevoStartup.RequestScope(context)
?? (object)TaskContext.Current
?? StandardScopeCallbacks.Thread(context)));
}
public IBindingNamedWithOrOnSyntax <T> InTaskScope <T>(IBindingInSyntax <T> syntax)
{
return(syntax
.InScope(context =>
(object)TaskContext.Current
?? context.Kernel.Components.GetAll <INinjectHttpApplicationPlugin>()
.Select(c => c.GetRequestScope(context)).FirstOrDefault(s => s != null)
?? StandardScopeCallbacks.Thread(context)));
}
/// <summary>
/// Registers a component so all dependant components will resolve the same shared instance within the test
/// lifetime scope.
/// </summary>
public static IBindingNamedWithOrOnSyntax <T> InstancePerTest <T>(this IBindingInSyntax <T> binding)
{
if (binding == null)
{
throw new ArgumentNullException("binding");
}
return(binding.InNamedScope(NinjectDependencyResolver.TestLifetimeScopeTag));
}
/// <summary>
/// Defines that a binding is in the scope of its target.
/// </summary>
/// <typeparam name="T">The type of the binding.</typeparam>
/// <param name="syntax">The In syntax.</param>
/// <returns>The Named syntax.</returns>
public static IBindingNamedWithOrOnSyntax <T> InParentScope <T>(this IBindingInSyntax <T> syntax)
{
return(syntax.InScope(
context =>
{
const string ScopeParameterName = "NamedScopeInParentScope";
var parentContext = context.Request.ParentContext;
return GetOrAddScope(parentContext, ScopeParameterName);
}));
}
/// <summary>
/// Set scope based on <see cref="BindingLifecycle">ActivationScope</see>
/// </summary>
/// <param name="syntax"><see cref="IBindingInSyntax{T}">Binding syntax</see> to set the scope for</param>
/// <param name="lifecycle"><see cref="BindingLifecycle"/> to use</param>
public static void WithLifecycle <T>(this IBindingInSyntax <T> syntax, BindingLifecycle lifecycle)
{
switch (lifecycle)
{
case BindingLifecycle.Singleton:
syntax.InSingletonScope();
break;
case BindingLifecycle.Transient:
syntax.InTransientScope();
break;
}
}
/// <summary>
/// Sets up the behavior of a binding for one instance per unit of work.
/// A unit of work must be available at the time the binding is used for resolve.
/// Use <see cref="UnitOfWorkScope.Create"/> to create a scope of type unit of work and remember to dispose it when you're done with it.
/// </summary>
public static IBindingNamedWithOrOnSyntax <T> InUnitOfWorkScope <T>(this IBindingInSyntax <T> syntax)
{
return(syntax.InScope(
context =>
{
var currentUnitOfWork = UnitOfWorkScope.Current;
if (currentUnitOfWork == null)
{
throw new InvalidOperationException($"No unit-of-work context present for the IOC resolve of component {context?.Request?.Service}");
}
return currentUnitOfWork;
}));
}
/// <summary>
/// Defines that a binding is in the scope of its target.
/// </summary>
/// <typeparam name="T">The type of the binding.</typeparam>
/// <param name="syntax">The In syntax.</param>
/// <returns>The Named syntax.</returns>
public static IBindingNamedWithOrOnSyntax <T> InCallScope <T>(this IBindingInSyntax <T> syntax)
{
return(syntax.InScope(
context =>
{
const string ScopeParameterName = "NamedScopeInCallScope";
var rootContext = context;
while (!IsCurrentResolveRoot(rootContext) && rootContext.Request.ParentContext != null)
{
rootContext = rootContext.Request.ParentContext;
}
return GetOrAddScope(rootContext, ScopeParameterName);
}));
}
/// <summary>
/// Sets the lifecycle.
/// </summary>
protected virtual void SetLifecycle(IBindingInSyntax <object> syntax, DependencyLifecycle lifecycle)
{
if (lifecycle == DependencyLifecycle.SingleInstance)
{
syntax.InSingletonScope();
return;
}
if (lifecycle == DependencyLifecycle.TransientInstance)
{
syntax.InTransientScope();
return;
}
Should.MethodBeSupported(false,
"SetLifecycle(IBindingInSyntax<object> syntax, DependencyLifecycle lifecycle)");
}
/// <summary>
/// Defines that a binding is in the scope of its target.
/// </summary>
/// <typeparam name="T">The type of the binding.</typeparam>
/// <param name="syntax">The In syntax.</param>
/// <returns>The Named syntax.</returns>
public static IBindingNamedWithOrOnSyntax <T> InCallScope <T>(this IBindingInSyntax <T> syntax)
{
return(syntax.InScope(
context =>
{
const string ScopeParameterName = "NamedScopeInCallScope";
var rootContext = context.Request.ParentContext ?? context;
while (rootContext.Request.ParentContext != null &&
!IsBindingActivated(rootContext.Request.ParentContext))
{
rootContext = rootContext.Request.ParentContext;
}
return GetOrAddScope(rootContext, ScopeParameterName);
}));
}
private static IBindingNamedWithOrOnSyntax <object> InScope(this IBindingInSyntax <object> syntax, ServiceDescriptor s, ScopedBindingResolver scopeBindingResolver)
{
switch (s.Lifetime)
{
case ServiceLifetime.Singleton:
return(syntax.InSingletonScope());
case ServiceLifetime.Scoped:
return(scopeBindingResolver(s, syntax));
case ServiceLifetime.Transient:
return(syntax.InTransientScope());
}
throw new Exception("Invalid service descriptor binding");
}
public static IBindingNamedWithOrOnSyntax <T> SetLifeStyle <T>(this IBindingInSyntax <T> registration, LifetimeScope lifeTimeKey)
{
switch (lifeTimeKey)
{
case LifetimeScope.Unowned:
return(registration.InTransientScope());
case LifetimeScope.PerHttpRequest:
return(registration.InRequestScope());
case LifetimeScope.PerThread:
return(registration.InThreadScope());
default:
return(registration.InTransientScope());
}
}
public static IBindingNamedWithOrOnSyntax <T> ConfigureLifecycle <T>(
this IBindingInSyntax <T> bindingInSyntax,
ServiceLifetime lifecycleKind)
{
switch (lifecycleKind)
{
case ServiceLifetime.Singleton:
return(bindingInSyntax.InSingletonScope());
case ServiceLifetime.Scoped:
return(bindingInSyntax.InRequestScope());
case ServiceLifetime.Transient:
return(bindingInSyntax.InTransientScope());
default:
throw new NotSupportedException();
}
}
private static void inScope(this IBindingInSyntax <object> to, ServiceLifetime lifetime)
{
switch (lifetime)
{
case ServiceLifetime.Singleton:
to.InSingletonScope();
break;
case ServiceLifetime.Scoped:
to.InScope(ctx => ctx.Kernel);
break;
case ServiceLifetime.Transient:
to.InTransientScope();
break;
default:
throw new ArgumentOutOfRangeException(nameof(lifetime), lifetime, null);
}
}
/// <summary>
/// Sets the scope using the given syntax.
/// </summary>
/// <param name="syntax">The syntax that is used to set the scope.</param>
public void SetScope(IBindingInSyntax<object> syntax)
{
syntax.InRequestScope();
}
public static IBindingNamedWithOrOnSyntax <T> InRequestScope <T>(this IBindingInSyntax <T> syntax)
{
return(syntax.InScope(new Func <IContext, object>(RequestScopeExtensionMethod.GetScope)));
}
/// <summary>
/// Defines that a binding is in a named scope.
/// </summary>
/// <typeparam name="T">The type of the binding.</typeparam>
/// <param name="syntax">The In syntax.</param>
/// <param name="scopeParameterName">Name of the scope parameter.</param>
/// <returns>The Named syntax.</returns>
public static IBindingNamedWithOrOnSyntax <T> InNamedScope <T>(this IBindingInSyntax <T> syntax, string scopeParameterName)
{
return(syntax.InScope(context => GetNamedScope(context, scopeParameterName)));
}
public static void InPerUserCacheScope <T>(this IBindingInSyntax <T> parent)
{
parent.InScope(CacheScopeCallback);
}
/// <summary>
/// Sets the lifecycle.
/// </summary>
protected virtual void SetLifecycle(IBindingInSyntax<object> syntax, DependencyLifecycle lifecycle)
{
if (lifecycle == DependencyLifecycle.SingleInstance)
{
syntax.InSingletonScope();
return;
}
if (lifecycle == DependencyLifecycle.TransientInstance)
{
syntax.InTransientScope();
return;
}
Should.MethodBeSupported(false,
"SetLifecycle(IBindingInSyntax<object> syntax, DependencyLifecycle lifecycle)");
}
public static void InSessionScope <T>(this IBindingInSyntax <T> parent)
{
parent.InScope(SessionScopeCallback);
}
public static IBindingNamedWithOrOnSyntax <T> InSessionScope <T>(this IBindingInSyntax <T> binding)
{
return(binding.InScope(ctx => CurrentScope));
}
public static IBindingNamedWithOrOnSyntax <T> InTaskScope <T>(this IBindingInSyntax <T> syntax)
{
return(syntax.InScope(new Func <IContext, object>(NinjectExtensionInTaskScope.GetScope)));
}
/// <summary>
/// Uses the IUnitOfWorkScopeResolver to resolve the scope. A unit of work is typically a web request
/// or a job execution.
/// </summary>
public static IBindingNamedWithOrOnSyntax <T> InUnitOfWorkScope <T> (this IBindingInSyntax <T> syntax)
{
return(syntax.InScope(context => context.Kernel.Get <IUnitOfWorkScopeResolver> ()
.Resolve(context)));
}
/// <summary>
/// Sets the scope using the given syntax.
/// </summary>
/// <param name="syntax">The syntax that is used to set the scope.</param>
public void SetScope(IBindingInSyntax <object> syntax)
{
syntax.InTransientScope();
}
/// <summary>
/// Defines the unit of work scope on the requested service.
/// </summary>
/// <typeparam name="T">The requested service type.</typeparam>
/// <param name="syntax">The syntax.</param>
/// <returns>The binding.</returns>
public static IBindingNamedWithOrOnSyntax <T> InUnitOfWorkScope <T>(this IBindingInSyntax <T> syntax)
{
return(syntax.InNamedScope(ScopeName));
}
/// <summary>
/// Sets the scope using the given syntax.
/// </summary>
/// <param name="syntax">The syntax that is used to set the scope.</param>
public void SetScope(IBindingInSyntax<object> syntax)
{
syntax.InSingletonScope();
}
/// <summary>
/// Indicates that instances activated via the binding should be re-used
/// within the same background job type instance.
/// </summary>
/// <typeparam name="T">Type of the service.</typeparam>
/// <param name="syntax">Binding syntax.</param>
/// <returns>The syntax to define more information.</returns>
public static IBindingNamedWithOrOnSyntax <T> InBackgroundJobScope <T>(this IBindingInSyntax <T> syntax)
{
return(syntax.InScope(c => NinjectJobActivator.CurrentAsync));
}
/// <summary>
/// Indicates that instances activated via the binding should be re-used
/// within the same named scope (if available), or within the same background
/// job type instance.
/// </summary>
/// <typeparam name="T">Type of the service.</typeparam>
/// <param name="syntax">Binding syntax.</param>
/// <returns>The syntax to define more information.</returns>
public static IBindingNamedWithOrOnSyntax <T> InNamedOrBackgroundJobScope <T>(this IBindingInSyntax <T> syntax, Func <IContext, object> scopeCallback)
{
return(syntax.InScope(context => scopeCallback(context) ?? NinjectJobActivator.CurrentAsync));
}
/// <summary>
/// Sets the scope to request scope.
/// </summary>
/// <typeparam name="T">The type of the service.</typeparam>
/// <param name="syntax">The syntax.</param>
/// <returns>The syntax to define more information.</returns>
public static IBindingNamedWithOrOnSyntax <T> InRequestScope <T>(this IBindingInSyntax <T> syntax)
{
return(syntax.InScope(GetScope));
}
public static IBindingNamedWithOrOnSyntax <T> InCustomScope <T>(this IBindingInSyntax <T> bindingSyntax)
{
return(bindingSyntax.InScope(CustomScope.ResolutionRootFromRequest));
}
/// <summary>
/// Sets the scope using the given syntax.
/// </summary>
/// <param name="syntax">The syntax that is used to set the scope.</param>
public void SetScope(IBindingInSyntax <object> syntax)
{
syntax.InRequestScope();
}
/// <summary>
/// Sets the scope using the given syntax.
/// </summary>
/// <param name="syntax">The syntax that is used to set the scope.</param>
public void SetScope(IBindingInSyntax<object> syntax)
{
syntax.InTransientScope();
}
