Lifecycles

Über die Lifecycles - eine Klasse die das Interface ILifecycle implementiert - in LightCore werden die verschiedenen Gültigkeitsbereiche der vom LightCore-Container erzeugten Instanzen gesteuert.

LightCore bringt von Haus aus vier Lifecycle mit. Den TransientLifecycle, SingletonLifecycle, ThreadSingletonLifecycle und HttpRequestLifecycle.

Den gewünschten Lifecycle für eine Instanz, wird beim Registrieren des Types angegeben.

Via Code:

		
			var builder = new ContainerBuilder();
			builder.Register<IFoo, Foo>().ControlledBy<TransientLifecycle>();
		
	

Via Xml:

		
            <Registration Lifecycle="Transient" ContractType="LightCore.TestTypes.IFoo" ImplementationType="LightCore.TestTypes.Foo">
		
	

TransientLifecycle

Der TransientLifecycle erzeugt jedes Mal eine neue Instanz des registrierten Typen, wenn aus dem Container eine Instanz angefordert wird. Dieser Lifecycle ist Standard, wenn nichts anderes definiert wird. Das bedeutet, wenn bei der Registration eines Typen kein anderer Lifecycle mit übergeben wurde, und auch am ContainerBuilder per DefaultControlledBy keinen Wert übergeben wurde, wird der TransientLifecycle verwendet.

		
			var builder = new ContainerBuilder();
			builder.Register<ILampenfassung, Glühbirne>().ControlledBy<TransientLifecycle>();
		
	

SingletonLifecycle

Der SingletonLifecycle ist dem Singleton-Muster nachempfunden. Von dem mit dem SingletonLifecycle registrierten Typen wird immer ein und dieselbe Instanz zurückgeben, wenn beim Container eine Instanz angefordert wird.

		
			var builder = new ContainerBuilder();
			builder.Register<ILampenfassung, Glühbirne>().ControlledBy<SingletonLifecycle>();
		
	

ThreadSingletonLifecycle

Der ThreadSingletonLifecycle ähnelt dem vorherigen SingletonLifecycle. Jedoch ist hier der Singleton auf einen Thread beschränkt. Das heisst, bei einem zweiten Thread, gibt es neue Instanzen, greift der vorherige Thread wieder auf den Container zu, bekommt er wieder seine Instanz.

		
			var builder = new ContainerBuilder();
			builder.Register<ILampenfassung, Glühbirne>().ControlledBy<ThreadSingletonLifecycle>();
		
	

HttpRequestLifecycle

Beim HttpRequestLifecycle wird für jeden HttpRequest jeweils eine Instanz des registrierten Typen erzeugt. Sobald der Request endet verliert die Instanz ihre Gültigkeit.

		
			var builder = new ContainerBuilder();
			builder.Register<ILampenfassung, Glühbirne>().ControlledBy<HttpRequestLifecycle>();
		
	

Weiterführende Themen zu Lifecycle

Einen Standard-Lifecycle festlegen

Es ist möglich den Standard-Lifecycle zu ändern, dazu die Methode DefaultControllerBy<TLifecycle> vom ContainerBuilder aufgerufen werden, und der neue Standard-Lifecycle übergeben werden. Der vom Builder erzeugte Container, wird dann den übergebenen Lifecycle als Standard-Lifecycle verwenden.

Davon gibt es auch die untypisierte Variante, die eine Type-Instanz des Lifecycles entgegennimmt.

		
			var builder = new ContainerBuilder();
			builder.DefaultControlledBy<SingletonLifecycle>();
		
	

Einen eigenen Lifecycle entwickeln

Sollten die von LightCore mitgelieferten Lifecycles nicht ausreichen, so ist es möglich einen eigenen Lifecycle zu schreiben. Dazu muss das Interface ILifecycle aus dem Namespace LightCore.Lifecycle implementiert werden.

Im folgenden Beispiel wurde ein fiktiver Lifecycle erstellt, der aus Sicherheitsgründen nicht zulässt, dass eine Instanz öfter als drei Mal wiederverwendet wird.

		
			public class SecurityLifecycle : ILifecycle
			{
				private int _count;
				private object _instance;
				private readonly object _lock = new object();
				
				public object ReceiveInstanceInLifecycle(Func<object> newInstanceResolver)
				{
					lock(_lock)
					{
						if (this._instance == null || this._count > 3)
						{
							this._instance = newInstanceResolver();
							this._count = 0;
						}
						
						this._count += 1;
						return this._instance;
					}
				}
			}
		
	

Als weitere Beispiele eignen sich die mitgelieferten Lifecycles von LightCore.

Lifecycle in der XML-Konfiguration festlegen

Auch bei der Registriertung von Typen über XML ist es möglich den Lifecycle mit anzugeben.

		
			<?xml version="1.0" encoding="utf-8"?>
			<LightCoreConfiguration xmlns="clr-namespace:LightCore.Configuration;assembly=LightCore.Configuration">  
				<LightCoreConfiguration.TypeAliases>  
					<TypeAlias Alias="SingletonLifecycle" Type="LightCore.Lifecycle.SingletonLifecycle, LightCore" />  
				</LightCoreConfiguration.TypeAliases>  
				<LightCoreConfiguration.Registrations>  
				<Registration 
					ContractType="LightCore.TestTypes.ILampenfassung{2}, LightCore.TestTypes" 
					ImplementationType="LightCore.TestTypes.Gluehbirne{2}, LightCore.TestTypes"
					Lifecycle="SingletonLifecycle" />  
				 </LightCoreConfiguration.Registrations>  
			 </LightCoreConfiguration>
		
	

Ein gutes Vorgehen ist es, sich Aliases für die Lifecycle die man verwendet, zu definieren. Die mitgelieferten Lifecycles von LightCore besitzen standardmässig schon Aliaseinträge. So kann einfach "Transient", "Singleton", etc... genutzt werden. Im Beispiel wurde ein Aliase für den SingletonLifecycle definiert.

		
			<LightCoreConfiguration.TypeAliases>  
				<TypeAlias Alias="SingletonLifecycle" Type="LightCore.Lifecycle.SingletonLifecycle, LightCore" />  
			</LightCoreConfiguration.TypeAliases> 
		
	

Bei der Registration eines Typen wird dann den Aliase im Registration Attribute Lifecycle angegeben.

		
			<Registration 
				ContractType="…" 
				ImplementationType="…"
				Lifecycle="SingletonLifecycle" />
		
	

Zusätzlich ist es möglich den Standard-Lifecycle über die XML-Konfiguration zu ändern.

		
			<LightCoreConfiguration 
				xmlns="clr-namespace:LightCore.Configuration;assembly=LightCore.Configuration" 
				DefaultLifecycle="LightCore.Lifecycle.SingletonLifecycle, LightCore">
		
	

Weitere Informationen zur XML-Konfiguration finden sie hier.