private static ComponentRegistration <T> SetLifeStyle <T>(LifeStyleType lifeStyle, ComponentRegistration <T> registration) where T : class
{
if (lifeStyle == LifeStyleType.Singleton)
{
return(registration.LifestyleSingleton());
}
else if (lifeStyle == LifeStyleType.Transient)
{
return(registration.LifestyleTransient());
}
else if (lifeStyle == LifeStyleType.PerWebRequest)
{
return(registration.LifestylePerWebRequest());
}
else if (lifeStyle == LifeStyleType.PerThread)
{
return(registration.LifestylePerThread());
}
else if (lifeStyle == LifeStyleType.Scoped)
{
return(registration.LifestyleScoped());
}
return(registration);
}
/// <summary>
/// 注册组件
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="registration"></param>
/// <param name="lifeStyle"></param>
/// <returns></returns>
private static ComponentRegistration <T> ApplyLifestyle <T>(ComponentRegistration <T> registration, DependencyLifeStyle lifeStyle) where T : class
{
switch (lifeStyle)
{
case DependencyLifeStyle.Transient: return(registration.LifestyleTransient());
case DependencyLifeStyle.Singleton: return(registration.LifestyleSingleton());
#if !CORE
case DependencyLifeStyle.PerRequest: return(registration.LifestylePerWebRequest());
#endif
default:
return(registration);
}
}
public static ComponentRegistration <T> SetLifeStyle <T>(this ComponentRegistration <T> registration, LifetimeScope lifeTimeKey) where T : class
{
switch (lifeTimeKey)
{
case LifetimeScope.Unowned:
return(registration.LifestyleCustom <NoTrackLifestyleManager>());
case LifetimeScope.Singleton:
return(registration);
case LifetimeScope.PerHttpRequest:
return(registration.LifestylePerWebRequest());
case LifetimeScope.PerThread:
return(registration.LifestylePerThread());
default:
return(registration.LifestyleTransient());
}
}
internal static ComponentRegistration <T> ApplyLifestyle <T>(this ComponentRegistration <T> registration,
LifetimeType lifetimeType, bool classicWeb = false)
where T : class
{
switch (lifetimeType)
{
case LifetimeType.Transient:
return(registration.LifestyleTransient());
//return registration.LifestyleCustom<MsScopedTransientLifestyleManager>();
case LifetimeType.Singleton:
return(registration.LifestyleSingleton());
//return registration.LifestyleCustom<MsScopedLifestyleManager>();
case LifetimeType.Scoped:
//return classicWeb ? registration.LifestylePerWebRequest() : registration.LifestyleCustom<MyScopedSingletonLifestyleManager>(); //registration.LifestyleScoped();////
return(classicWeb ? registration.LifestylePerWebRequest() : registration.LifestyleScoped()); ////
default:
return(registration);
}
}
private static ComponentRegistration <object> ConfigureLifecycle(this ComponentRegistration <object> registrationBuilder, ServiceLifetime serviceLifetime)
{
switch (serviceLifetime)
{
case ServiceLifetime.Transient:
registrationBuilder.LifestyleTransient();
break;
case ServiceLifetime.Scoped:
registrationBuilder.LifestylePerWebRequest();
break;
case ServiceLifetime.Singleton:
registrationBuilder.LifestyleSingleton();
break;
default:
throw new InvalidOperationException("Unknown ServiceLifetime: " + serviceLifetime);
}
return(registrationBuilder);
}
public ComponentRegistration <T> SetLifestyle <T>(ComponentRegistration <T> descriptor) where T : class
{
return(descriptor.LifestylePerWebRequest());
}
private static ComponentRegistration<object> InitializeLifeStyle(IComponent component, ComponentRegistration<object> componentFor)
{
switch (component.LifeStyle)
{
case (LifeStyle.Singleton):
return componentFor.LifestyleSingleton();
case (LifeStyle.Transient):
return componentFor.LifestyleTransient();
case (LifeStyle.WebRequest):
return componentFor.LifestylePerWebRequest();
case (LifeStyle.Pooled):
return componentFor.LifestylePooled();
default:
throw new ContainerException("LifeStyle not allowed " + component.LifeStyle);
}
}
private ComponentRegistration<ILendingLibraryDbContext> ConfigureLifestylePerRequest(ComponentRegistration<ILendingLibraryDbContext> componentRegistration)
{
return componentRegistration.LifestylePerWebRequest();
}
