An introduction to Unity in the IOC framework

10 years Hedong, 10 years hexi, MO bullying Juvenile poor

Lifelong Learning, Excellence

What is Unity?

Unity is a lightweight, extensible, Dependency injection container developed by the patterns & practices team with the following features:

1. It provides a mechanism for creating (or assembling) object instances, which may also contain other dependent object instances.

2. Unity allows pre-configured objects to be injected into the class, implementing the inversion of Control (IoC) functionality. In unity, support for constructor injection (constructor injection), property setter Injection (attribute SetPoint injection), and method call injection (methods injection) are supported. PS: The method injected here is similar and slightly different from the interface injection defined by Martin Fowler.

3. Support the architecture of the container. A container can have child containers that allow queries to be positioned from the child container to the parent container's object.

4. The container can be prepared and configured through a configuration file.

5. The definition of the class is not affected (except for attribute-value injection and method injection), which is also a manifestation of lightweight containers.

6. Support for custom container extensions.

With unity, the basic steps are three-step.

1. Create a container;

2. Register the interface and class mappings in the container;

3. Parse the correct object from the container.

For the next explanation, we'll start by writing several interfaces and classes that need to be followed:

Preparation: ILogger Interface

     Public Interface ILogger    {        void Log (string  msg);    }

Subclasses inheriting the above interfaces

     Public class Dblogger:ilogger    {        publicvoid Log (string  msg)        {            Console.WriteLine (" the database record message is:" + msg);}    }

And

     Public class Filelogger:ilogger    {        publicvoid Log (string  msg)        {            Console.WriteLine (" the log file record message is:" + msg);}    }

Step1. Creating an Object Container

The simplest way to create a container instance in unity is to create it directly using the constructor, as shown in the following code:

New UnityContainer ();

Step2. Registering Interface Mappings

A set of register methods is provided in unity for us to register the interface mappings in the container, as shown in the following code:

Container. Registertype<ilogger, dblogger> ();

Step3. Get Object instance

A set of resolve methods is provided in unity to obtain an object instance, as shown in the following code:

var logger = container. Resolve<ilogger> ();

OK, that's so easy!

The test is as follows:

    classProgram {Static voidMain (string[] args) {            //Iunitycontainer container =NewUnityContainer (); Container. Registertype<ilogger, dblogger>(); varLogger = container. Resolve<ilogger>(); Logger. Log ("Sun Xing: See me 72 change"); //Container. Registertype<ilogger, filelogger>(); Logger= Container. Resolve<ilogger>(); Logger. Log ("two lang god: See me 73 change");        Console.readkey (); }    }

The output is as follows:

Simple introduction, not too much elaboration,

@ Chen Wolong's blog

An introduction to Unity in the IOC framework