/// <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;
}
}
/// <inheritdoc/>
public void Bind <T>(Type type, BindingLifecycle lifecycle)
{
lock (Kernel)
{
Kernel.Bind <T>().To(type).WithLifecycle(lifecycle);
_boundServices.Add(typeof(T));
}
}
/// <inheritdoc/>
public void Bind(Type service, Type type, BindingLifecycle lifecycle)
{
lock (Kernel)
{
Kernel.Bind(service).To(type).WithLifecycle(lifecycle);
_boundServices.Add(service);
}
}
/// <inheritdoc/>
public void Bind(Type service, Func <Type, object> resolveCallback, BindingLifecycle lifecycle)
{
lock (Kernel)
{
Kernel.Bind(service).ToMethod(c => resolveCallback(c.Request.Service)).WithLifecycle(lifecycle);
_boundServices.Add(service);
}
}
/// <inheritdoc/>
public void Bind <T>(Func <T> resolveCallback, BindingLifecycle lifecycle)
{
lock (Kernel)
{
Kernel.Bind <T>().ToMethod(c => resolveCallback()).WithLifecycle(lifecycle);
_boundServices.Add(typeof(T));
}
}
/// <summary>
/// Configure with a specific <see cref="IContainer"/>, <see cref="IDefaultConventions"/> and <see cref="IDefaultBindings"/>
/// </summary>
/// <param name="container"><see cref="IContainer"/> to configure with</param>
/// <param name="defaultObjectLifecycle">Default <see cref="BindingLifecycle"/> for object creation/management</param>
/// <param name="defaultConventions"><see cref="IDefaultConventions"/> to use</param>
/// <param name="defaultBindings"><see cref="IDefaultBindings"/> to use</param>
/// <param name="assembliesConfiguration"><see cref="AssembliesConfiguration"/> to use</param>
/// <returns></returns>
public static Configure With(IContainer container, BindingLifecycle defaultObjectLifecycle, IDefaultConventions defaultConventions, IDefaultBindings defaultBindings, AssembliesConfiguration assembliesConfiguration)
{
if (Instance == null)
{
lock (InstanceLock)
{
Instance = new Configure(container, defaultObjectLifecycle, defaultConventions, defaultBindings, assembliesConfiguration);
}
}
return(Instance);
}
/// <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;
}
}
ILifecycle GetInstanceScopeFor(BindingLifecycle lifecycle)
{
switch (lifecycle)
{
case BindingLifecycle.Transient: return(new TransientLifecycle());
case BindingLifecycle.Singleton: return(new SingletonLifecycle());
case BindingLifecycle.Thread: return(new ThreadLocalStorageLifecycle());
}
return(new TransientLifecycle());
}
void RegisterService(Type service, Type type, BindingLifecycle lifecycle)
{
Update(x =>
{
if (type.GetTypeInfo().IsGenericType)
{
x.RegisterGeneric(type).PerLifeStyle(lifecycle).As(service);
}
else
{
x.RegisterType(type).PerLifeStyle(lifecycle).As(service);
}
});
}
ILifecycle GetInstanceScopeFor(BindingLifecycle lifecycle)
{
switch (lifecycle)
{
case BindingLifecycle.Transient: return(new TransientLifecycle());
case BindingLifecycle.Request: throw new NotImplementedException();
case BindingLifecycle.Singleton: return(new SingletonLifecycle());
case BindingLifecycle.Thread: return(new ThreadLocalStorageLifecycle());
}
return(new TransientLifecycle());
}
Configure(IContainer container, BindingLifecycle defaultLifecycle, IDefaultConventions defaultConventions, IDefaultBindings defaultBindings)
{
SystemName = "[Not Set]";
container.DefaultLifecycle = defaultLifecycle;
container.Bind<IConfigure>(this);
Container = container;
ExcludeNamespacesForTypeDiscovery();
defaultBindings.Initialize(Container);
defaultConventions.Initialize();
InitializeProperties();
}
Configure(IContainer container, BindingLifecycle defaultObjectLifecycle, IDefaultConventions defaultConventions, IDefaultBindings defaultBindings)
{
DefaultObjectLifecycle = defaultObjectLifecycle;
container.Bind<IConfigure>(this);
Container = container;
ExcludeNamespacesForTypeDiscovery();
SetupServiceLocator();
defaultBindings.Initialize(container);
defaultConventions.Initialize();
InitializeProperties();
}
Configure(IContainer container, BindingLifecycle defaultLifecycle, IDefaultConventions defaultConventions, IDefaultBindings defaultBindings, AssembliesConfiguration assembliesConfiguration)
{
SystemName = "[Not Set]";
AssembliesConfiguration = assembliesConfiguration;
container.DefaultLifecycle = defaultLifecycle;
container.Bind <IConfigure>(this);
Container = container;
defaultBindings.Initialize(Container);
defaultConventions.Initialize();
InitializeProperties();
}
LifetimeManager GetLifetimeManagerFromBindingLifecycle(BindingLifecycle lifecycle)
{
switch (lifecycle)
{
case BindingLifecycle.Singleton:
return(new ContainerControlledLifetimeManager());
case BindingLifecycle.Thread:
return(new PerThreadLifetimeManager());
case BindingLifecycle.Transient:
return(new TransientLifetimeManager());
}
return(new PerResolveLifetimeManager());
}
Configure(IContainer container, BindingLifecycle defaultLifecycle, IDefaultConventions defaultConventions, IDefaultBindings defaultBindings, AssembliesConfiguration assembliesConfiguration)
{
SystemName = "[Not Set]";
AssembliesConfiguration = assembliesConfiguration;
container.DefaultLifecycle = defaultLifecycle;
container.Bind<IConfigure>(this);
Container = container;
defaultBindings.Initialize(Container);
defaultConventions.Initialize();
InitializeProperties();
}
PerLifeStyle <TLimit, TActivatorData, TRegistrationStyle>
(this global::Autofac.Builder.IRegistrationBuilder <TLimit, TActivatorData, TRegistrationStyle> builder,
BindingLifecycle lifecycle)
{
//no thread lifecycle
switch (lifecycle)
{
case BindingLifecycle.Transient:
return(builder.InstancePerDependency());
case BindingLifecycle.Singleton:
return(builder.SingleInstance());
default:
return(builder.InstancePerDependency());
}
}
InstanceScope GetInstanceScopeFor(BindingLifecycle lifecycle)
{
switch (lifecycle)
{
case BindingLifecycle.Transient:
{
return(InstanceScope.Transient);
};
case BindingLifecycle.Request: return(InstanceScope.PerRequest);
case BindingLifecycle.Singleton: return(InstanceScope.Singleton);
case BindingLifecycle.Thread: return(InstanceScope.ThreadLocal);
}
return(InstanceScope.Transient);
}
static Lifestyle ResolveLifestyle(BindingLifecycle lifecycle)
{
var lifestyle = Lifestyle.Transient;
switch (lifecycle)
{
case BindingLifecycle.Singleton:
lifestyle = Lifestyle.Singleton;
break;
case BindingLifecycle.Transient:
lifestyle = Lifestyle.Transient;
break;
case BindingLifecycle.Thread:
throw new NotSupportedException("Ref documentation: This lifestyle is deliberately left out of Simple Injector because it is considered to be harmful. Instead of using Per Thread lifestyle, you will usually be better of using one of the Scoped lifestyles.");
}
return(lifestyle);
}
/// <summary>
/// Register a binding of a type to a callback that can resolve it with a given lifecycle
/// </summary>
/// <typeparam name="T">Type to register</typeparam>
/// <param name="container"><see cref="global::SimpleInjector.Container"/> to register into</param>
/// <param name="resolveCallback"><see cref="Func{T}"/> that resolves the type</param>
/// <param name="lifecycle"><see cref="BindingLifecycle">Lifecycle</see> of the binding</param>
public static void Register <T>(this global::SimpleInjector.Container container, Func <Type> resolveCallback, BindingLifecycle lifecycle)
{
container.Register(typeof(T), resolveCallback, lifecycle);
}
public void Bind <T>(System.Func <System.Type> resolveCallback, BindingLifecycle lifecycle)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Register a binding of a type to a callback that can resolve an instance of the type with a given lifecycle
/// </summary>
/// <typeparam name="T">Type to register</typeparam>
/// <param name="container"><see cref="global::SimpleInjector.Container"/> to register into</param>
/// <param name="resolveCallback"><see cref="Func{T}"/> that resolves the type by returning an instance</param>
/// <param name="lifecycle"><see cref="BindingLifecycle">Lifecycle</see> of the binding</param>
public static void Register <T>(this global::SimpleInjector.Container container, Func <T> resolveCallback, BindingLifecycle lifecycle)
{
Func <Type> typeResolver = () => { return(resolveCallback.Invoke().GetType()); };
container.Register(typeof(T), typeResolver, lifecycle);
}
public void Bind(Type service, Type type, BindingLifecycle lifecycle)
{
_container.Register(service, () => type, lifecycle);
}
public void Bind(System.Type service, System.Type type, BindingLifecycle lifecycle)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Configure with a specific <see cref="IContainer"/>
/// </summary>
/// <param name="container"><see cref="IContainer"/> to configure with</param>
/// <param name="defaultObjectLifecycle">Default <see cref="BindingLifecycle"/> for object creation/management</param>
/// <param name="assembliesConfiguration"><see cref="AssembliesConfiguration"/> to use</param>
/// <param name="assemblyProvider"><see cref="IAssemblyProvider"/> to use for providing assemblies</param>
/// <param name="contractToImplementorsMap"><see cref="IContractToImplementorsMap"/> for keeping track of the relationship between contracts and implementors</param>
/// <returns>Configuration object to continue configuration on</returns>
public static Configure With(IContainer container, BindingLifecycle defaultObjectLifecycle, AssembliesConfiguration assembliesConfiguration, IAssemblyProvider assemblyProvider, IContractToImplementorsMap contractToImplementorsMap)
{
return With(container, defaultObjectLifecycle, new DefaultConventions(container), new DefaultBindings(assembliesConfiguration, assemblyProvider, contractToImplementorsMap), assembliesConfiguration);
}
public void Bind <T>(Type type, BindingLifecycle lifecycle)
{
_container.Register(typeof(T), () => type, lifecycle);
}
public void Bind(Type service, Func <Type> resolveCallback, BindingLifecycle lifecycle)
{
_container.Register(service, resolveCallback, lifecycle);
}
public void Bind <T>(Func <T> resolveCallback, BindingLifecycle lifecycle)
{
_container.Register <T>(resolveCallback, lifecycle);
}
public void Bind(Type service, Func <Type, object> resolveCallback, BindingLifecycle lifecycle)
{
_windsorContainer.Register(Component.For(service).UsingFactoryMethod(t => resolveCallback(service)).WithLifecycle(lifecycle));
}
static Container()
{
DefaultBindingLifecycle = BindingLifecycle.Transient;
}
/// <summary>
/// Configure with a specific <see cref="IContainer"/>
/// </summary>
/// <param name="container"><see cref="IContainer"/> to configure with</param>
/// <param name="defaultObjectLifecycle">Default <see cref="BindingLifecycle"/> for object creation/management</param>
/// <returns>Configuration object to continue configuration on</returns>
public static Configure With(IContainer container, BindingLifecycle defaultObjectLifecycle)
{
return With(container, defaultObjectLifecycle, new DefaultConventions(container), new DefaultBindings());
}
public void Bind(Type service, Type type, BindingLifecycle lifecycle)
{
_windsorContainer.Register(Component.For(service).Forward(type).ImplementedBy(type).WithLifecycle(lifecycle));
}
public void Bind <T>(Type type, BindingLifecycle lifecycle)
{
Bind(typeof(T), type, lifecycle);
}
/// <summary>
/// Register a binding of a type to a callback that can resolve an instance of the type with a given lifecycle
/// </summary>
/// <param name="container"><see cref="global::SimpleInjector.Container"/> to register into</param>
/// <param name="service"><see cref="Type"/> to register</param>
/// <param name="resolveCallback"><see cref="Func{T}"/> that resolves the instance</param>
/// <param name="lifecycle"><see cref="BindingLifecycle">Lifecycle</see> of the binding</param>
public static void Register(this global::SimpleInjector.Container container, Type service, Func <Type, object> resolveCallback, BindingLifecycle lifecycle)
{
var lifestyle = ResolveLifestyle(lifecycle);
container.Register(service, () => resolveCallback, lifestyle);
}
public void Bind(Type service, Func <Type, object> resolveCallback, BindingLifecycle lifecycle)
{
throw new NotImplementedException();
}
public void Bind <T>(Func <T> resolveCallback, BindingLifecycle lifecycle)
{
_windsorContainer.Register(Component.For <T>().UsingFactoryMethod(t => resolveCallback()).WithLifecycle(lifecycle));
}
/// <summary>
/// Configure with a specific <see cref="IContainer"/>, <see cref="IDefaultConventions"/> and <see cref="IDefaultBindings"/>
/// </summary>
/// <param name="container"><see cref="IContainer"/> to configure with</param>
/// <param name="defaultObjectLifecycle">Default <see cref="BindingLifecycle"/> for object creation/management</param>
/// <param name="defaultConventions"><see cref="IDefaultConventions"/> to use</param>
/// <param name="defaultBindings"><see cref="IDefaultBindings"/> to use</param>
/// <returns></returns>
public static Configure With(IContainer container, BindingLifecycle defaultObjectLifecycle, IDefaultConventions defaultConventions, IDefaultBindings defaultBindings)
{
if (Instance == null)
{
lock (InstanceLock)
{
Instance = new Configure(container, defaultObjectLifecycle, defaultConventions, defaultBindings);
}
}
return Instance;
}
