"Turn" IOC container feature injection second: initial engine to find the corresponding IOC container

This article describes how to use the reflection class to find the assembly classes for all DLLs under the Site Bin folder, which describes how to initialize an IOC container engine.

At present, there are many IOC containers, such as NINJECT,AUTOFAC, and so on, each container driver is different, in order to facilitate decoupling, good use of different IOC container, there must be a public interface.

1. Iengine (Engine interface)

    Public interface Iengine {//#region Initialize//void Initialize ();        #endregion #region Containermanager icontainermanger containermanager {get;}        #endregion #region Resolve T resolve<t> (params parameter[] parameters) where T:class;        T resolve<t> (string name, params parameter[] parameters) where T:class;        Object Resolve (type type, params parameter[] parameters);        Object Resolve (Type type, string name, params parameter[] parameters);        #endregion #region tryresolve T tryresolve<t> (params parameter[] parameters) where T:class;        T tryresolve<t> (string name, params parameter[] parameters) where T:class;        Object Tryresolve (type type, params parameter[] parameters);        Object Tryresolve (Type type, string name, params parameter[] parameters); #endregion #region resolveall ienumerable<object> resolveall (Type servicetype);        Ienumerable<t> resolveall<t> (); #endregion}

Interface main constraints: parsing, trying to parse, parsing all three methods, all using an instance and generic two version of the original written. PS: Generics are the constrained version of an instance, but threads are safe.

2.EngineContext (Engine context)

    public class Enginecontext {#region initializtion Methods//<summary>///Ensure method is instantiated synchronously </summary>//<param name= "forcerecreate" ></param>//<returns></returns        > [MethodImpl (methodimploptions.synchronized)] public static iengine Initialize (bool forcerecreate) {if (singleton<iengine>. Instance = = NULL | | forcerecreate) {singleton<iengine>.                Instance = Createengineinstance (); Singleton<iengine>.            Instance.initialize (); } return singleton<iengine>.        Instance; } #endregion public static Iengine createengineinstance () {var typeFinder = new Webapptyp            Efinder (); var engines = typefinder.findclassesoftype<iengine> ().            ToArray (); if (engines. Length > 0) {var defaultengine = (iengine) activator.createinstAnce (Engines[0]);            return defaultengine;            } else {throw new ApplicationException ("IOC container not Found"); }} public static Iengine the current {get {if (Singleton<iengi Ne>.                Instance = = null) {Initialize (false); } return singleton<iengine>.            Instance; }        }    }

Engine context: To ensure high-performance container-driven and unique instances of system threads, use a singleton class for managed

3.Singleton (Single row Class)

<summary>////single-row mode maintains uniqueness for high performance//</summary> public class Singleton {//<summary&gt        ;         Dictionary array//</summary> private static readonly Idictionary<type, object> allsingletons;        Static Singleton () {allsingletons=new dictionary<type, object> (); public static Idictionary<type, object> allsingletons {get {R}            Eturn allsingletons; }}}///<summary>//single-row generic mode///</summary>//<typeparam name= "T" ></typepar        Am> public class Singleton<t>: Singleton {private static T _instance;            public static T Instance {get {return _instance;                } set {_instance = value;            Allsingletons[typeof (T)] = value;  }}//<summary>  Single-row generic array pattern///</summary>//<typeparam name= "T" ></typeparam> public class SINGLETONLIST&L T T>: singleton<ilist<t>> {static singletonlist () {singleton<ilist<t> .        Instance=new list<t> (); } public New static ilist<t> Instance {get {return singleton&lt ; ilist<t>>.            Instance; }}}///<summary>///single-row dictionary mode///</summary>//<typeparam name= "TKey" ></typ eparam>//<typeparam name= "TValue" ></typeparam> public class Singletondictionary<tkey, Tvalue&gt ; : Singleton<idictionary<tkey, tvalue>> {static singletondictionary () {singleton& Lt;dictionary<tkey,tvalue>>.        Instance=new Dictionary<tkey, tvalue> (); } public new static Idictionary<tkey, tvalue> Instance {get {return singleton<dictionary<tkey, tvalue>>.            Instance; }        }    }

Singleton class: Prevents duplicate instances from being created.

The above is mainly the container interface, context and other encapsulation, to use the specific IOC that must inherit iengine this interface.

The Ninject interface class is used here:

4.NinjectEngine (implement Iengine interface)

public class Ninjectengine:iengine {#region Properties public icontainermanger Containermanager {            Get        Private set;            } public Itypefinder TypeFinder {get;        Private set; } #endregion #region. ctor Public Ninjectengine (Itypefinder typeFinder): This (typefinder,new Container            Manager ()) {} public ninjectengine (Itypefinder TypeFinder, Containermanager Containermanager) {            if (TypeFinder = = null) {throw new ArgumentException ("No Reflection Class finder"); } this.            TypeFinder = TypeFinder; This.            Containermanager = Containermanager;        Initializecontainer ();  } #endregion #region Methods private void Initializecontainer () {var attrdependency = new Dependencyattributeregistrator (this. TypeFinder, this.            Containermanager);      Attrdependency.registerservices ();  } public T resolve<t> (params parameter[] parameters) where T:class {return Containerma Nager.        Resolve<t> (null, parameters); Public T resolve<t> (string name, params parameter[] parameters) where T:class {return        Containermanager.resolve<t> (name, parameters); } public Object Resolve (type type, params parameter[] parameters) {return Containermanager.resol        ve (type, null, parameters); public object Resolve (type type, string name, params parameter[] parameters) {return Containermanager .        Resolve (type, name, parameters); } public T tryresolve<t> (params parameter[] parameters) where T:class {return containerm Anager.        Tryresolve<t> (null, parameters); Public T tryresolve<t> (string name, params parameter[] parameters) where T:class {Retu RN Containermanager.tryresolve<T> (name, parameters); } public Object Tryresolve (type type, params parameter[] parameters) {return containermanager.tr        Yresolve (type, null, parameters); public object Tryresolve (type type, string name, params parameter[] parameters) {return Contai        Nermanager.tryresolve (type, name, parameters); } public ienumerable<object> ResolveAll (Type servicetype) {return containermanager.resolve        All (servicetype); } public ienumerable<t> resolveall<t> () {return containermanager.resolveall<t>        (); } #endregion}

The approximate process for engine initialization is this. interface = = Assembly Lookup = = To implement the IOC container class of the interface \ = Write a single column = Create a container-driven context

"Turn" IOC container feature injection second: initial engine to find the corresponding IOC container