Microsoft实现的IOC DI之 Unity 、Service Locator、MEF-白红宇

Microsoft实现的IOC DI之 Unity 、Service Locator、MEF

阅读量：5818 次

发布时间：2019-06-18

本文共 4022 字，大约阅读时间需要 13 分钟。

这几个工具的站点

Microsoft Unity

Service Locator

MEF .net4.0内含,3.x前在codeplex上开源

Utility

The main reasons to use Unity (or any other IoC container) are if:

Ø You have dependencies between your objects .

Ø You need to manage the lifetime of an object .

Ø You want to manage dependencies at runtime, such as cache, constructors, and properties .

Ø You need to intercept the creation of an object .

Unity is a lightweight, extensible dependency injection container that supports interception, constructor injection, property injection, and method call injection. You can use Unity in a variety of different ways to help decouple the components of your applications, to maximize coherence in components, and to simplify design, implementation, testing, and administration of these applications.

Unity is a general-purpose container for use in any type of Microsoft® .NET Framework-based application. It provides all of the features commonly found in dependency injection mechanisms, including methods to register type mappings and object instances, resolve objects, manage object lifetimes, and inject dependent objects into the parameters of constructors and methods and as the value of properties of objects it resolves.

例子

[InjectionConstructor]

public Writer(ILogger logger)

{

this.logger = logger;

}

//Prepare the container

var container = new UnityContainer();

//We specify that the logger to be used is the FileLogger

container.RegisterType<ILogger, FileLogger>();

//and how to instantiate a new Writer

container.RegisterType<Writer>();

//Here Unity knows how to create the new constructor

var writer = container.Resolve<Writer>();

writer.Write("Some Text.");

通过UnityContainer实现注入

Service Locator

例子

/// <summary>

/// Utility to configure the container

/// </summary>

public sealed class UnityContainerConfigurator

{

/// <summary>

/// Configures this instance.

/// </summary>

/// <returns></returns>

public static IUnityContainer Configure()

{

var container = new UnityContainer()

.RegisterType<ILogger, FileLogger>()

.RegisterType<Writer>();

return container;

}

// create a new instance of Microsoft Unity container

var provider = new UnityServiceLocator(UnityContainerConfigurator.Configure());

// assign the container to the Service Locator provider

ServiceLocator.SetLocatorProvider(() => provider);

// resolve objects using the service locator

var writer = ServiceLocator.Current.GetInstance<Writer>();

writer.Write("Some Text.");

ServiceLocator的实现非常简单,而且代码也很少

MEF

The main reasons to use MEF are if:

Ø You need to implement external and reusable extensions in your client application, but you might have different implementations in different hosts .

Ø You need to auto-discover the available extensions at runtime .

Ø You need a more powerful and extensible framework than a normal Dependency Injection framework, and you want to get rid of the various boot-strapper and initializer objects .

Ø You need to implement extensibility and/or modularity in your components .

If your application doesn’t require any of the items in these lists, you probably should not implement the IoC pattern, and you might not need to use Unity and MEF .