Inhalt

Einführung

Im folgenden Dokument gibt es einen kurzen Rundflug über die Benutzung von LightCore. Für die erweiterten Features bitte die Weiteren Dokumente im rechten Menü ansehen.

Kenne das Framework

Um LightCore grundlegend nutzen zu können, ist nur eine Referenz auf die LightCore.dll nötig. Daneben gibt es weitere, optionale Komponenten, die wie folgt beschrieben werden:

LightCore.dll: Kernkomponente, wird immer benötigt
LightCore.Configuration.dll: Optional, wird benötigt wenn LightCore über Xml konfiguriert werden soll
LightCore.Integration.Web.dll: Optional, bietet eine Integration für ASP.NET und ASP.NET MVC
LightCore.CommonServiceLocator.dll: Optional, stellt einen Adapter bereit, um LightCore mit dem CSL (Common Service Locator) zu nutzen

Weitere Dateien die mit ausgeliefert werden:

LightCore.xsd: Sollte der eigenen Solution / dem eigenen Projekt hinzugefügt werden, damit gibt es Intellisense für die LightCore-Konfiguration
SampleConfiguration.xml: Beispiel für eine Konfiguration einmal per .NET app- / web.config und einmal ohne.

Simples Beispiel

Mithilfe der Klasse ContainerBuilder im Namespace LightCore, können Registrierungen beim Anwendungsstart vorgenommen werden. Wird die Methode Build() darauf aufgerufen, gibt der ContainerBuilder den fertig konfigurierten Container zurück.
Am besten ist es, wenn der Container anwendungsweit gehalten wird (Application / static).

Bei der Benutzung von LightCore wird meist zuerst eine Registrierung vorgenommen und anschliessend im Programm benutzt,
indem Instanzen angefordert werden.

Folgend ein ganz einfaches Beispiel:

        
            var builder = new ContainerBuilder();
            builder.Register<IFoo, Foo>();
            
            IContainer container = builder.Build();
            IFoo foo = container.Resolve<IFoo>();

Bei der Register()-Methode wird per generischen Typparametern zuerst der Typ des Kontrakts und anschliessend der gewünschten Implementation gesetzt. Anschliessend kann per Resolve() Aufruf eine Instanz angefordert werden.

Registrierung von Abhängigkeiten

Das war nur eine mögliche Option, Abhängigkeiten zu registrieren. Es ist auch möglich zwei Type-Instanzen an die Register()-Methode zu übergeben, falls die Registrierung erst zur Laufzeit entschieden werden soll:

        
            Type typeOfContract = typeof(IFoo);
            Type typeOfImplementation = typeof(Foo);
            
            builder.Register(typeOfContract, typeOfImplementation);

Die dritte Möglichkeit - Delegates bzw. Lambda Expressions - ist flexibel und auch schnell bei der Auflösung.
Per Argument (Hier im Code c), kann auf den Container zugegriffen werden, um innere Abhängigkeiten aufzulösen. So kann eine ganze Objekthierarchie nur mit Delegates und new-Aufrufen zusammengebaut werden.

        
            builder.Register<IFoo>(c => new Foo());
            builder.Register<IFoo>(c => new Foo(c.Resolve<IBar>()));
            builder.Register<IFoo>(c => FooFactory.GetFoo());

Zusätzlich ist es möglich, Abhängigkeiten über Xml zu konfigurieren, mehr dazu hier.

Falls dies noch nicht reicht, kann per eigener Implementation der abstrakten Klasse RegistrationModule eine eigene Logik bereitstellen, die von irgendwo her und auf irgendeine Art Abhängigkeiten registriert.