public DefaultPool(int initialSize, int maxsize, IComponentActivator componentActivator)
{
available = new Stack <Burden>(initialSize);
this.initialSize = initialSize;
this.maxsize = maxsize;
this.componentActivator = componentActivator;
}
public Burden ActivateNewInstance(IComponentActivator componentActivator, bool trackedExternally)
{
ResolutionContext resolutionContext;
try
{
resolutionContext = resolutionStack.Peek();
}
catch (InvalidOperationException)
{
throw new ComponentActivatorException(
"Not in a resolution context. 'ActivateNewInstance' method can only be called withing a resoltion scope. (after 'EnterResolutionContext' was called within a handler)");
}
var activator = componentActivator as IDependencyAwareActivator;
if (activator != null)
{
trackedExternally |= activator.IsManagedExternally(resolutionContext.Handler.ComponentModel);
}
var burden = resolutionContext.CreateBurden(trackedExternally);
burden.SetRootInstance(componentActivator.Create(this));
return(burden);
}
/// <summary>
/// Initializes a new instance of the <see cref = "CreateOnUIThreadActivator" /> class.
/// </summary>
/// <param name = "model">The model.</param>
/// <param name = "kernel">The kernel.</param>
/// <param name = "onCreation">Delegate called on construction.</param>
/// <param name = "onDestruction">Delegate called on destruction.</param>
public CreateOnUIThreadActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation,
ComponentInstanceDelegate onDestruction)
: base(model, kernel, onCreation, onDestruction)
{
customActivator = CreateCustomActivator(model, kernel);
performCreation = PerformCreation;
}
public DefaultPool(int initialSize, int maxsize, IComponentActivator componentActivator)
{
available = new Stack<Burden>(initialSize);
this.initialSize = initialSize;
this.maxsize = maxsize;
this.componentActivator = componentActivator;
}
/// <summary>
/// Initializes a new instance of the <see cref = "CreateOnUIThreadActivator" /> class.
/// </summary>
/// <param name = "model">The model.</param>
/// <param name = "kernel">The kernel.</param>
/// <param name = "onCreation">Delegate called on construction.</param>
/// <param name = "onDestruction">Delegate called on destruction.</param>
public CreateOnUIThreadActivator(ComponentModel model, IKernel kernel, ComponentInstanceDelegate onCreation,
ComponentInstanceDelegate onDestruction)
: base(model, kernel, onCreation, onDestruction)
{
customActivator = CreateCustomActivator(model, kernel);
performCreation = PerformCreation;
}
public DefaultContainer(ILocator componentLocator)
{
this.componentLocator = componentLocator;
this.componentRegistry = new DefaultComponentRegistry();
this.componentCache = new DefaultComponentCache();
this.componentActivator = new DefaultComponentActivator(this.componentRegistry, this.componentCache);
}
public DefaultPool(int initialsize, int maxsize, IComponentActivator componentActivator)
{
this.initialsize = initialsize;
this.maxsize = maxsize;
this.componentActivator = componentActivator;
InitPool();
}
public DefaultPool(int initialsize, int maxsize, IComponentActivator componentActivator, IKernel kernel)
{
this.initialsize = initialsize;
this.maxsize = maxsize;
this.componentActivator = componentActivator;
this.kernel = kernel;
InitPool();
}
/// <summary>
/// Creates an implementation of
/// <see cref = "ILifestyleManager" />
/// based
/// on
/// <see cref = "LifestyleType" />
/// and invokes
/// <see cref = "ILifestyleManager.Init" />
/// to initialize the newly created manager.
/// </summary>
/// <param name = "activator"></param>
/// <returns></returns>
protected virtual ILifestyleManager CreateLifestyleManager(IComponentActivator activator)
{
ILifestyleManager manager;
var type = ComponentModel.LifestyleType;
switch (type)
{
case LifestyleType.Thread:
#if SILVERLIGHT
manager = new PerThreadThreadStaticLifestyleManager();
#else
manager = new PerThreadLifestyleManager();
#endif
break;
case LifestyleType.Transient:
manager = new TransientLifestyleManager();
break;
#if (!SILVERLIGHT && !CLIENTPROFILE)
case LifestyleType.PerWebRequest:
manager = new PerWebRequestLifestyleManager();
break;
#endif
case LifestyleType.Custom:
manager = ComponentModel.CustomLifestyle.CreateInstance <ILifestyleManager>();
break;
case LifestyleType.Pooled:
{
var initial = ExtendedPropertiesConstants.Pool_Default_InitialPoolSize;
var maxSize = ExtendedPropertiesConstants.Pool_Default_MaxPoolSize;
if (ComponentModel.ExtendedProperties.Contains(ExtendedPropertiesConstants.Pool_InitialPoolSize))
{
initial = (int)ComponentModel.ExtendedProperties[ExtendedPropertiesConstants.Pool_InitialPoolSize];
}
if (ComponentModel.ExtendedProperties.Contains(ExtendedPropertiesConstants.Pool_MaxPoolSize))
{
maxSize = (int)ComponentModel.ExtendedProperties[ExtendedPropertiesConstants.Pool_MaxPoolSize];
}
manager = new PoolableLifestyleManager(initial, maxSize);
}
break;
default:
//this includes LifestyleType.Undefined, LifestyleType.Singleton and invalid values
manager = new SingletonLifestyleManager();
break;
}
manager.Init(activator, Kernel, model);
return(manager);
}
public override void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
{
base.Init(componentActivator, kernel, model);
manager = kernel.GetSubSystem("scope") as IScopeManager;
if (manager == null)
{
throw new InvalidOperationException("Scope Subsystem not found. Did you forget to add it?");
}
}
public override void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
{
base.Init(componentActivator, kernel, model);
manager = kernel.GetSubSystem("scope") as IScopeManager;
if (manager == null)
{
throw new InvalidOperationException("Scope Subsystem not found. Did you forget to add it?");
}
}
public DefaultPool(int initialsize, int maxsize, IComponentActivator componentActivator)
{
this.initialsize = initialsize;
this.maxsize = maxsize;
this.componentActivator = componentActivator;
this.rwlock = new ReaderWriterLock();
InitPool();
}
public Registration(
IComponentDescriptor descriptor,
IComponentActivator activator,
IEnumerable <IParameter> parameters,
ComponentLifestyle lifestyle)
{
_descriptor = Enforce.ArgumentNotNull(descriptor, "descriptor");
_activator = Enforce.ArgumentNotNull(activator, "activator");
_lifestyle = lifestyle;
_scope = scope.InstanceScopeFactory.ToScope(lifestyle);
}
public virtual void Init(IKernel kernel)
{
this.kernel = kernel;
this.kernel.AddedAsChildKernel += new EventHandler(OnAddedAsChildKernel);
IComponentActivator activator = kernel.CreateComponentActivator(ComponentModel);
lifestyleManager = CreateLifestyleManager(activator);
EnsureDependenciesCanBeSatisfied();
}
public DefaultPool(int initialsize, int maxsize, IComponentActivator componentActivator)
{
this.initialsize = initialsize;
this.maxsize = maxsize;
this.componentActivator = componentActivator;
this.rwlock = new ReaderWriterLock();
// Thread thread = new Thread(new ThreadStart(InitPool));
// thread.Start();
InitPool();
}
public DefaultPool(int initialsize, int maxsize, IComponentActivator componentActivator)
{
this.initialsize = initialsize;
this.maxsize = maxsize;
this.componentActivator = componentActivator;
this.rwlock = new ReaderWriterLock();
// Thread thread = new Thread(new ThreadStart(InitPool));
// thread.Start();
InitPool();
}
public override void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
{
base.Init(componentActivator, kernel, model);
// check ILoggerFactory is registered (logging is enabled)
if (kernel.HasComponent(typeof(ILoggerFactory)))
{
// get logger factory instance
ILoggerFactory loggerFactory = kernel.Resolve<ILoggerFactory>();
// create logger
_Logger = loggerFactory.Create(GetType());
}
else
_Logger = NullLogger.Instance;
}
public object GetInstance(CreationContext context, IComponentActivator activator)
{
if (perThreadLookup == null)
{
perThreadLookup = new Dictionary<IComponentActivator, object>();
}
object instance;
if (!perThreadLookup.TryGetValue(activator, out instance))
{
instance = activator.Create(context);
perThreadLookup.Add(activator, instance);
perContainerLookup.Add(activator, instance);
}
return instance;
}
public override void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
{
Contract.Ensures(_Lifestyle1 != null);
Contract.Ensures(Initialized);
// check ILoggerFactory is registered
if (kernel.HasComponent(typeof(ILoggerFactory)))
{
// get logger factory instance
var loggerFactory = kernel.Resolve <ILoggerFactory>();
// create logger
_Logger = loggerFactory.Create(typeof(WrapperResolveLifestyleManager <T>));
}
else
{
_Logger = NullLogger.Instance;
}
if (_Logger.IsDebugEnabled)
{
_Logger.DebugFormat("initializing (for component: {0})", string.Join(",", model.Services));
}
_LifestyleKernel.Register(Component.For <T>().LifeStyle.Transient.Named("T.lifestyle"));
kernel.AddChildKernel(_LifestyleKernel);
try
{
_Lifestyle1 = _LifestyleKernel.Resolve <T>();
}
finally
{
kernel.RemoveChildKernel(_LifestyleKernel);
}
_Lifestyle1.Init(componentActivator, kernel, model);
base.Init(componentActivator, kernel, model);
Contract.Assume(_Lifestyle1 != null,
"lifestyle1 can't be null because the Resolve<T> call will throw an exception if a matching service wasn't found");
_Logger.Debug("initialized");
_Initialized = true;
}
public override void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
{
base.Init(componentActivator, kernel, model);
// check ILoggerFactory is registered (logging is enabled)
if (kernel.HasComponent(typeof(ILoggerFactory)))
{
// get logger factory instance
ILoggerFactory loggerFactory = kernel.Resolve <ILoggerFactory>();
// create logger
_Logger = loggerFactory.Create(GetType());
}
else
{
_Logger = NullLogger.Instance;
}
}
public Renderer(IServiceProvider serviceProvider, ILoggerFactory loggerFactory, IComponentActivator componentActivator)
{
if (serviceProvider is null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (loggerFactory is null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
// Even though IComponentActivator is not marked as nullable, we do allow null because that's how the framework internally indicates
// that we should use default activation logic.
_serviceProvider = serviceProvider;
_logger = loggerFactory.CreateLogger <Renderer>();
_componentFactory = new ComponentFactory(componentActivator);
}
protected virtual ILifestyleManager CreateLifestyleManager(IComponentActivator activator)
{
ILifestyleManager manager = null;
if (ComponentModel.LifestyleType == LifestyleType.Undefined ||
ComponentModel.LifestyleType == LifestyleType.Singleton)
{
manager = new Lifestyle.SingletonLifestyleManager();
}
else if (ComponentModel.LifestyleType == LifestyleType.Thread)
{
manager = new Lifestyle.PerThreadLifestyleManager();
}
else if (ComponentModel.LifestyleType == LifestyleType.Transient)
{
manager = new Lifestyle.TransientLifestyleManager();
}
else if (ComponentModel.LifestyleType == LifestyleType.Custom)
{
manager = (ILifestyleManager)
Activator.CreateInstance(ComponentModel.CustomLifestyle);
}
else if (ComponentModel.LifestyleType == LifestyleType.Pooled)
{
int initial = ExtendedPropertiesConstants.Pool_Default_InitialPoolSize;
int maxSize = ExtendedPropertiesConstants.Pool_Default_MaxPoolSize;
if (ComponentModel.ExtendedProperties.Contains(ExtendedPropertiesConstants.Pool_InitialPoolSize))
{
initial = (int)ComponentModel.ExtendedProperties[ExtendedPropertiesConstants.Pool_InitialPoolSize];
}
if (ComponentModel.ExtendedProperties.Contains(ExtendedPropertiesConstants.Pool_MaxPoolSize))
{
maxSize = (int)ComponentModel.ExtendedProperties[ExtendedPropertiesConstants.Pool_MaxPoolSize];
}
manager = new Lifestyle.PoolableLifestyleManager(initial, maxSize);
}
manager.Init(activator, Kernel);
return(manager);
}
public Renderer(IServiceProvider serviceProvider, ILoggerFactory loggerFactory, IComponentActivator componentActivator)
{
if (serviceProvider is null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (loggerFactory is null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
if (componentActivator is null)
{
throw new ArgumentNullException(nameof(componentActivator));
}
_serviceProvider = serviceProvider;
_logger = loggerFactory.CreateLogger <Renderer>();
_componentFactory = new ComponentFactory(componentActivator);
}
public virtual IComponentActivator CreateComponentActivator(ComponentModel model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
IComponentActivator activator = null;
if (model.CustomComponentActivator == null)
{
activator = new DefaultComponentActivator(model, this,
new ComponentInstanceDelegate(RaiseComponentCreated),
new ComponentInstanceDelegate(RaiseComponentDestroyed));
}
else
{
try
{
activator = (IComponentActivator)
Activator.CreateInstance(model.CustomComponentActivator,
new object[]
{
model, this,
new ComponentInstanceDelegate(RaiseComponentCreated),
new ComponentInstanceDelegate(RaiseComponentDestroyed)
});
}
catch (Exception e)
{
throw new KernelException("Could not instantiate custom activator", e);
}
}
return(activator);
}
public Resolver(IComponentActivator activator, IComponentLookup componentLookup)
{
this.activator = activator;
this.componentLookup = componentLookup;
}
public Burden ActivateNewInstance(IComponentActivator componentActivator, bool trackedExternally)
{
ResolutionContext resolutionContext;
try
{
resolutionContext = resolutionStack.Peek();
}
catch (InvalidOperationException)
{
throw new ComponentActivatorException(
"Not in a resolution context. 'ActivateNewInstance' method can only be called withing a resoltion scope. (after 'EnterResolutionContext' was called within a handler)");
}
var activator = componentActivator as IDependencyAwareActivator;
if (activator != null)
{
trackedExternally |= activator.IsManagedExternally(resolutionContext.Handler.ComponentModel);
}
var burden = resolutionContext.CreateBurden(trackedExternally);
burden.SetRootInstance(componentActivator.Create(this));
return burden;
}
/// <summary>
/// Inits the specified component activator.
/// </summary>
/// <param name="componentActivator">The component activator.</param>
/// <param name="kernel">The kernel.</param>
public override void Init(IComponentActivator componentActivator, IKernel kernel)
{
base.Init(componentActivator, kernel);
_requestScope = Kernel[typeof(IRequestScope)] as IRequestScope;
}
public IPool Create(int initialsize, int maxSize, IComponentActivator activator)
{
return(new EmptyPool());
}
public virtual void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
{
this.componentActivator = componentActivator;
this.kernel = kernel;
this.model = model;
}
public Renderer(IServiceProvider serviceProvider, ILoggerFactory loggerFactory, IComponentActivator componentActivator)
{
if (serviceProvider is null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (loggerFactory is null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
if (componentActivator is null)
{
throw new ArgumentNullException(nameof(componentActivator));
}
_serviceProvider = serviceProvider;
_logger = loggerFactory.CreateLogger <Renderer>();
_componentFactory = new ComponentFactory(componentActivator);
if (TestableMetadataUpdate.IsSupported)
{
HotReloadManager.OnDeltaApplied += RenderRootComponentsOnHotReload;
}
}
public override void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
{
lifestyle1.Init(componentActivator, kernel, model);
lifestyle2.Init(componentActivator, kernel, model);
}
public override void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
{
base.Init(componentActivator, kernel, model);
}
/// <summary>
/// Creates an implementation of
/// <see cref = "ILifestyleManager" />
/// based
/// on
/// <see cref = "LifestyleType" />
/// and invokes
/// <see cref = "ILifestyleManager.Init" />
/// to initialize the newly created manager.
/// </summary>
/// <param name = "activator"></param>
/// <returns></returns>
protected virtual ILifestyleManager CreateLifestyleManager(IComponentActivator activator)
{
ILifestyleManager manager = null;
LifestyleType type = ComponentModel.LifestyleType;
switch (type)
{
case LifestyleType.Thread:
#if (!SILVERLIGHT)
manager = new PerThreadLifestyleManager();
#else
manager = new PerThreadThreadStaticLifestyleManager();
#endif
break;
case LifestyleType.Transient:
manager = new TransientLifestyleManager();
break;
#if (!SILVERLIGHT)
case LifestyleType.PerWebRequest:
manager = new PerWebRequestLifestyleManager();
break;
#endif
case LifestyleType.Custom:
manager = (ILifestyleManager)Activator.CreateInstance(ComponentModel.CustomLifestyle);
break;
case LifestyleType.Pooled:
{
int initial = ExtendedPropertiesConstants.Pool_Default_InitialPoolSize;
int maxSize = ExtendedPropertiesConstants.Pool_Default_MaxPoolSize;
if (ComponentModel.ExtendedProperties.Contains(ExtendedPropertiesConstants.Pool_InitialPoolSize))
initial = (int)ComponentModel.ExtendedProperties[ExtendedPropertiesConstants.Pool_InitialPoolSize];
if (ComponentModel.ExtendedProperties.Contains(ExtendedPropertiesConstants.Pool_MaxPoolSize))
maxSize = (int)ComponentModel.ExtendedProperties[ExtendedPropertiesConstants.Pool_MaxPoolSize];
manager = new PoolableLifestyleManager(initial, maxSize);
}
break;
default:
//this includes LifestyleType.Undefined, LifestyleType.Singleton and invalid values
manager = new SingletonLifestyleManager();
break;
}
manager.Init(activator, Kernel, model);
return manager;
}
public IPool Create(int initialsize, int maxSize, IComponentActivator activator)
{
return new DefaultPool(initialsize, maxSize, activator);
}
/// <summary>
/// Creates an implementation of <see cref="ILifestyleManager"/> based
/// on <see cref="LifestyleType"/> and invokes <see cref="ILifestyleManager.Init"/>
/// to initialize the newly created manager.
/// </summary>
/// <param name="activator"></param>
/// <returns></returns>
protected virtual ILifestyleManager CreateLifestyleManager(IComponentActivator activator)
{
ILifestyleManager manager = null;
LifestyleType type = ComponentModel.LifestyleType;
if (type == LifestyleType.Undefined || type == LifestyleType.Singleton)
{
manager = new SingletonLifestyleManager();
}
else if (type == LifestyleType.Thread)
{
manager = new PerThreadLifestyleManager();
}
else if (type == LifestyleType.Transient)
{
manager = new TransientLifestyleManager();
}
else if (type == LifestyleType.PerWebRequest)
{
manager = new PerWebRequestLifestyleManager();
}
else if (type == LifestyleType.Custom)
{
manager = (ILifestyleManager)
Activator.CreateInstance(ComponentModel.CustomLifestyle);
}
else if (type == LifestyleType.Pooled)
{
int initial = ExtendedPropertiesConstants.Pool_Default_InitialPoolSize;
int maxSize = ExtendedPropertiesConstants.Pool_Default_MaxPoolSize;
if (ComponentModel.ExtendedProperties.Contains(ExtendedPropertiesConstants.Pool_InitialPoolSize))
{
initial = (int)ComponentModel.ExtendedProperties[ExtendedPropertiesConstants.Pool_InitialPoolSize];
}
if (ComponentModel.ExtendedProperties.Contains(ExtendedPropertiesConstants.Pool_MaxPoolSize))
{
maxSize = (int)ComponentModel.ExtendedProperties[ExtendedPropertiesConstants.Pool_MaxPoolSize];
}
manager = new PoolableLifestyleManager(initial, maxSize);
}
manager.Init(activator, Kernel, model);
return manager;
}
/// <summary>
/// Creates an implementation of
/// <see cref = "ILifestyleManager" />
/// based
/// on
/// <see cref = "LifestyleType" />
/// and invokes
/// <see cref = "ILifestyleManager.Init" />
/// to initialize the newly created manager.
/// </summary>
/// <param name = "activator"></param>
/// <returns></returns>
protected virtual ILifestyleManager CreateLifestyleManager(IComponentActivator activator)
{
ILifestyleManager manager;
var type = ComponentModel.LifestyleType;
switch (type)
{
case LifestyleType.Scoped:
var scopeManager = Kernel.GetSubSystem("scope") as IScopeManager;
if (scopeManager == null)
{
throw new InvalidOperationException("Scope Subsystem not found. Did you forget to add it?");
}
manager = new ScopedLifestyleManager(new CurrentScopeAccessor(scopeManager, ComponentModel));
break;
case LifestyleType.Thread:
#if SILVERLIGHT
manager = new PerThreadThreadStaticLifestyleManager();
#else
manager = new PerThreadLifestyleManager();
#endif
break;
case LifestyleType.Transient:
manager = new TransientLifestyleManager();
break;
#if (!SILVERLIGHT && !CLIENTPROFILE)
case LifestyleType.PerWebRequest:
manager = new PerWebRequestLifestyleManager();
break;
#endif
case LifestyleType.Custom:
manager = ComponentModel.CustomLifestyle.CreateInstance<ILifestyleManager>();
break;
case LifestyleType.Pooled:
{
var initial = ExtendedPropertiesConstants.Pool_Default_InitialPoolSize;
var maxSize = ExtendedPropertiesConstants.Pool_Default_MaxPoolSize;
if (ComponentModel.ExtendedProperties.Contains(ExtendedPropertiesConstants.Pool_InitialPoolSize))
{
initial = (int)ComponentModel.ExtendedProperties[ExtendedPropertiesConstants.Pool_InitialPoolSize];
}
if (ComponentModel.ExtendedProperties.Contains(ExtendedPropertiesConstants.Pool_MaxPoolSize))
{
maxSize = (int)ComponentModel.ExtendedProperties[ExtendedPropertiesConstants.Pool_MaxPoolSize];
}
manager = new PoolableLifestyleManager(initial, maxSize);
}
break;
default:
//this includes LifestyleType.Undefined, LifestyleType.Singleton and invalid values
manager = new SingletonLifestyleManager();
break;
}
manager.Init(activator, Kernel, ComponentModel);
return manager;
}
/// <summary>
/// Creates an implementation of
/// <see cref = "ILifestyleManager" />
/// based
/// on
/// <see cref = "LifestyleType" />
/// and invokes
/// <see cref = "ILifestyleManager.Init" />
/// to initialize the newly created manager.
/// </summary>
/// <param name = "activator"></param>
/// <returns></returns>
protected virtual ILifestyleManager CreateLifestyleManager(IComponentActivator activator)
{
ILifestyleManager manager;
var type = ComponentModel.LifestyleType;
switch (type)
{
case LifestyleType.Scoped:
var scopeManager = Kernel.GetSubSystem("scope") as IScopeManager;
if (scopeManager == null)
{
throw new InvalidOperationException("Scope Subsystem not found. Did you forget to add it?");
}
manager = new ScopedLifestyleManager(new CurrentScopeAccessor(scopeManager, ComponentModel));
break;
case LifestyleType.Thread:
#if SILVERLIGHT
manager = new PerThreadThreadStaticLifestyleManager();
#else
manager = new PerThreadLifestyleManager();
#endif
break;
case LifestyleType.Transient:
manager = new TransientLifestyleManager();
break;
#if (!SILVERLIGHT && !CLIENTPROFILE)
case LifestyleType.PerWebRequest:
manager = new PerWebRequestLifestyleManager();
break;
#endif
case LifestyleType.Custom:
manager = ComponentModel.CustomLifestyle.CreateInstance <ILifestyleManager>();
break;
case LifestyleType.Pooled:
{
var initial = ExtendedPropertiesConstants.Pool_Default_InitialPoolSize;
var maxSize = ExtendedPropertiesConstants.Pool_Default_MaxPoolSize;
if (ComponentModel.ExtendedProperties.Contains(ExtendedPropertiesConstants.Pool_InitialPoolSize))
{
initial = (int)ComponentModel.ExtendedProperties[ExtendedPropertiesConstants.Pool_InitialPoolSize];
}
if (ComponentModel.ExtendedProperties.Contains(ExtendedPropertiesConstants.Pool_MaxPoolSize))
{
maxSize = (int)ComponentModel.ExtendedProperties[ExtendedPropertiesConstants.Pool_MaxPoolSize];
}
manager = new PoolableLifestyleManager(initial, maxSize);
}
break;
default:
//this includes LifestyleType.Undefined, LifestyleType.Singleton and invalid values
manager = new SingletonLifestyleManager();
break;
}
manager.Init(activator, Kernel, ComponentModel);
return(manager);
}
public LazyComponentInterceptor(IComponentActivator activator, CreationContext context)
{
this.activator = activator;
this.context = context;
}
public override void Init(IComponentActivator componentActivator, IKernel kernel)
{
base.Init(componentActivator, kernel);
pool = InitPool(initialSize, maxSize);
}
public ComponentFactory(IComponentActivator componentActivator)
{
_componentActivator = componentActivator ?? throw new ArgumentNullException(nameof(componentActivator));
}
public LazyComponentActivator(ComponentModel model, IComponentActivator innerActivator)
{
this.innerActivator = innerActivator;
this.model = model;
}
public void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
{
activator = componentActivator;
}
public Resolver(IComponentActivator activator, IComponentLookup componentLookup)
{
this.activator = activator;
this.componentLookup = componentLookup;
}
public override void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
{
base.Init(componentActivator, kernel, model);
pool = CreatePool(initialSize, maxSize);
}
public void Init(IComponentActivator componentActivator, IKernel kernel, ComponentModel model)
{
_perWebRequestLifestyleManager.Init(componentActivator, kernel, model);
_perThreadLifestyleManager.Init(componentActivator, kernel, model);
}
/// <summary>
/// Creates an implementation of <see cref = "ILifestyleManager" /> based on <see cref = "LifestyleType" /> and invokes <see cref = "ILifestyleManager.Init" /> to initialize the newly created manager.
/// </summary>
/// <param name = "model"> </param>
/// <param name = "activator"> </param>
/// <returns> </returns>
public virtual ILifestyleManager CreateLifestyleManager(ComponentModel model, IComponentActivator activator)
{
ILifestyleManager manager;
var type = model.LifestyleType;
switch (type)
{
case LifestyleType.Scoped:
manager = new ScopedLifestyleManager(CreateScopeAccessor(model));
break;
case LifestyleType.Bound:
manager = new ScopedLifestyleManager(CreateScopeAccessorForBoundLifestyle(model));
break;
case LifestyleType.Thread:
manager = new ScopedLifestyleManager(new ThreadScopeAccessor());
break;
case LifestyleType.Transient:
manager = new TransientLifestyleManager();
break;
#if !(SILVERLIGHT || CLIENTPROFILE)
case LifestyleType.PerWebRequest:
manager = new ScopedLifestyleManager(new WebRequestScopeAccessor());
break;
#endif
case LifestyleType.Custom:
manager = model.CustomLifestyle.CreateInstance <ILifestyleManager>();
break;
case LifestyleType.Pooled:
var initial = ExtendedPropertiesConstants.Pool_Default_InitialPoolSize;
var maxSize = ExtendedPropertiesConstants.Pool_Default_MaxPoolSize;
if (model.ExtendedProperties.Contains(ExtendedPropertiesConstants.Pool_InitialPoolSize))
{
initial = (int)model.ExtendedProperties[ExtendedPropertiesConstants.Pool_InitialPoolSize];
}
if (model.ExtendedProperties.Contains(ExtendedPropertiesConstants.Pool_MaxPoolSize))
{
maxSize = (int)model.ExtendedProperties[ExtendedPropertiesConstants.Pool_MaxPoolSize];
}
manager = new PoolableLifestyleManager(initial, maxSize);
break;
default:
//this includes LifestyleType.Undefined, LifestyleType.Singleton and invalid values
manager = new SingletonLifestyleManager();
break;
}
manager.Init(activator, this, model);
return(manager);
}
public TestRenderer(IServiceProvider serviceProvider, IComponentActivator componentActivator)
: base(serviceProvider, NullLoggerFactory.Instance, componentActivator)
{
Dispatcher = Dispatcher.CreateDefault();
}
public IPool Create(int initialsize, int maxSize, IComponentActivator activator)
{
return(new DefaultPool(initialsize, maxSize, activator));
}
public override ILifestyleManager CreateLifestyleManager(ComponentModel model, IComponentActivator activator)
{
if (model.LifestyleType == LifestyleType.PerWebRequest)
{
var manager = new ScopedLifestyleManager(new PerRequestScopeAccessor());
manager.Init(activator, this, model);
return(manager);
}
return(base.CreateLifestyleManager(model, activator));
}