public static void Register <TInterface, TImplementation>(this IContainer scope,
RegistrationLifestyle lifestyle = RegistrationLifestyle.Transient) where TImplementation : TInterface
{
scope.Registration(new[] { new RegistrationDefinition {
ExportType = typeof(TInterface), ActivationType = typeof(TImplementation)
} });
}
public static IEnumerable <RegistrationDefinition> Definitions(RegistrationLifestyle lifestyle = RegistrationLifestyle.Transient, object lifestyleInfo = null)
{
yield return(new RegistrationDefinition {
ExportType = typeof(ISingletonService), ActivationType = typeof(SingletonService), RegistrationLifestyle = RegistrationLifestyle.Singleton
});
yield return(new RegistrationDefinition {
ExportType = typeof(ISmallObjectService), ActivationType = typeof(SmallObjectService), RegistrationLifestyle = lifestyle, LifestyleInformation = lifestyleInfo
});
yield return(new RegistrationDefinition {
ExportType = typeof(ITransientService), ActivationType = typeof(TransientService)
});
}
private ILifecycle GetLifecycle(RegistrationLifestyle lifestyle)
{
ILifecycle lifecycle = null;
switch (lifestyle)
{
case RegistrationLifestyle.Singleton:
lifecycle = new SingletonLifecycle();
break;
case RegistrationLifestyle.SingletonPerScope:
lifecycle = new ContainerLifecycle();
break;
case RegistrationLifestyle.SingletonPerObjectGraph:
case RegistrationLifestyle.Transient:
lifecycle = new TransientLifecycle();
break;
}
return(lifecycle);
}
public void RegisterFactory <TResult>(Func <TResult> factory, RegistrationMode mode, RegistrationLifestyle lifestyle) where TResult : class
{
switch (lifestyle)
{
case RegistrationLifestyle.Singleton:
_container.Register(Component.For <TResult>().UsingFactoryMethod(factory).LifeStyle.Singleton);
break;
case RegistrationLifestyle.SingletonPerScope:
_container.Register(Component.For <TResult>().UsingFactoryMethod(factory)
.LifeStyle.Scoped());
break;
case RegistrationLifestyle.Transient:
_container.Register(Component.For <TResult>().UsingFactoryMethod(factory).LifeStyle.Transient);
break;
}
}
public void RegisterFactory <TResult>(Func <TResult> factory, RegistrationMode mode, RegistrationLifestyle lifestyle) where TResult : class
{
var binding = _configuration.Bind <TResult>().ToMethod(context => factory());
switch (lifestyle)
{
case RegistrationLifestyle.Singleton:
binding.InSingletonScope();
break;
case RegistrationLifestyle.Transient:
binding.InTransientScope();
break;
default:
throw new NotSupportedException();
}
}
public void RegisterFactory <T1, T2, T3, TResult>(Func <T1, T2, T3, TResult> factory, RegistrationMode mode, RegistrationLifestyle lifestyle) where TResult : class
{
IReuse reuse = null;
switch (lifestyle)
{
case RegistrationLifestyle.Singleton:
reuse = new SingletonReuse();
break;
case RegistrationLifestyle.SingletonPerScope:
reuse = new CurrentScopeReuse();
break;
case RegistrationLifestyle.SingletonPerObjectGraph:
throw new NotSupportedException("");
}
_container.RegisterDelegate(r => factory(r.Resolve <T1>(), r.Resolve <T2>(), r.Resolve <T3>()), reuse);
}
public void RegisterFactory <T1, T2, T3, TResult>(Func <T1, T2, T3, TResult> factory, RegistrationMode mode, RegistrationLifestyle lifestyle) where TResult : class
{
_container.Configure(c =>
{
var export = c.ExportFactory(factory);
switch (lifestyle)
{
case RegistrationLifestyle.Singleton:
export.Lifestyle.Singleton();
break;
case RegistrationLifestyle.SingletonPerScope:
export.Lifestyle.SingletonPerScope();
break;
case RegistrationLifestyle.SingletonPerObjectGraph:
export.Lifestyle.SingletonPerObjectGraph();
break;
}
});
}
public void RegisterFactory <T1, TResult>(Func <T1, TResult> factory, RegistrationMode mode, RegistrationLifestyle lifestyle) where TResult : class
{
switch (lifestyle)
{
case RegistrationLifestyle.Transient:
_serviceCollection.AddTransient(provider => factory(provider.GetService <T1>()));
break;
case RegistrationLifestyle.Singleton:
_serviceCollection.AddSingleton(provider => factory(provider.GetService <T1>()));
break;
case RegistrationLifestyle.SingletonPerScope:
_serviceCollection.AddScoped(provider => factory(provider.GetService <T1>()));
break;
}
}
public void RegisterFactory <T1, T2, T3, TResult>(Func <T1, T2, T3, TResult> factory, RegistrationMode mode, RegistrationLifestyle lifestyle) where TResult : class
{
var registration = _container.Register <T1, T2, T3, TResult>((serviceFactory, arg1, arg2, arg3) => factory(arg1, arg2, arg3));
switch (lifestyle)
{
case RegistrationLifestyle.Singleton:
registration.SetDefaultLifetime <PerContainerLifetime>();
break;
case RegistrationLifestyle.SingletonPerScope:
registration.SetDefaultLifetime <PerScopeLifetime>();
break;
}
}
public void RegisterFactory <T1, T2, T3, TResult>(Func <T1, T2, T3, TResult> factory, RegistrationMode mode, RegistrationLifestyle lifestyle) where TResult : class
{
// requires t1, t2, t3 to be a reference type where no other containers require this
throw new NotSupportedException();
}
public void RegisterFactory <TResult>(Func <TResult> factory, RegistrationMode mode, RegistrationLifestyle lifestyle) where TResult : class
{
switch (lifestyle)
{
case RegistrationLifestyle.Singleton:
_container.RegisterSingleton(factory);
break;
case RegistrationLifestyle.Transient:
_container.Register(factory);
break;
}
}
public void RegisterFactory <T1, T2, T3, TResult>(Func <T1, T2, T3, TResult> factory, RegistrationMode mode, RegistrationLifestyle lifestyle) where TResult : class
{
var register = _builder.Register(c => factory(c.Resolve <T1>(), c.Resolve <T2>(), c.Resolve <T3>()));
switch (lifestyle)
{
case RegistrationLifestyle.Singleton:
register.SingleInstance();
break;
case RegistrationLifestyle.SingletonPerScope:
register.InstancePerLifetimeScope();
break;
}
}
public void RegisterFactory <T1, TResult>(Func <T1, TResult> factory, RegistrationMode mode, RegistrationLifestyle lifestyle) where TResult : class
{
var lifecycle = GetLifecycle(lifestyle);
_container.Configure(r => r.For <TResult>(lifecycle).Use(context => factory(context.GetInstance <T1>())));
}