zoukankan      html  css  js  c++  java
  • Microsoft实现的IOC DI之 Unity 、Service Locator、MEF

    这几个工具的站点

    Microsoft Unity  http://unity.codeplex.com

    Service Locator http://commonservicelocator.codeplex.com

    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

    clip_image002

    例子

    /// <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 .

    clip_image004

    例子

    /// <summary>
    /// Logger customized for MEF
    /// </summary>
    [Export(typeof(ILogger))]
    public class MefLogger : ILogger
    {
        /// <summary>
        /// Writes the log.
        /// </summary>
        /// <param name="message">The message.</param>
        public void WriteLog(string message)
        {
            Console.WriteLine("String built from MEF: {0}.", message);
        }
    }

    /// <summary>
    /// Gets or sets the writer.
    /// </summary>
    /// <value>The writer.</value>
    [Import]
    public ILogger Writer { get; set; }
    public void Run()
    {
        // first we build the catalog
        var catalog = new AssemblyCatalog(Assembly.GetExecutingAssemb
        //create the container using the catalog
        var container = new CompositionContainer(catalog);
        container.ComposeParts(this);
        //use the resolved property
        Writer.WriteLog("Mef message");
    }

    简单比较

    Service Locator: 最简单的实现形式,对于比较简单的应用合适,本身的实现代码也很简单

    Utility:复杂度中等,介于Service Locator和MEF之间

    MEF:以一个完整的框架形式展现, .net 4内置支持,提供生命期等各种管理

    实例代码: http://cid-56b433ad3d1871e3.office.live.com/self.aspx/.Public/Ioc%5E_Di.rar

  • 相关阅读:
    高并发 内核优化
    mysql 读写分离
    Jmeter使用入门
    Jenkins+Jmeter+Ant接口持续集成
    Android客户端稳定性测试——Monkey
    SVN客户端项目递归删除.svn目录
    Windows 下 php5+apache+mysql5 手工搭建笔记
    熟悉常用的Linux操作
    C语言文法
    词法分析实验报告
  • 原文地址:https://www.cnblogs.com/2018/p/2045890.html
Copyright © 2011-2022 走看看