Ioc依赖注入：Unity4.0.1 在项目中的应用 (MVC和API)

使用unity的好处网上有很多，百度一下即可

这里引用了一篇关于面向接口编程的好处的文章作为引申：https://blog.csdn.net/cyy19970527/article/details/83177996

在mvc中使用unity

需要引用unity包，我安装的版本为 unity-4.0.1

尽管现在unity最新版本已经更新到5.11.2了，但是在使用配置文件注入的时候，总是报以下错误,

百度查找到一篇文章说是版本问题： https://blog.csdn.net/weixin_34124577/article/details/93533679

接下来直接上测试代码：项目结构使用简单的三层结构

dal层

namespace dal
{
    //声明一个接口层，获取名称
    public interface iadao
    {
        string getname();
    }
}

//实现1
public class a1dao : iadao
{
    public string getname()
    {
        return "我叫a1";
    }
}


//实现2
public class a2dao : iadao
{
    public string getname()
    {
        return "我叫a2";
    }
}

bll层

namespace bll
{
    //声明一个bll层接口
    public interface ia
    {
        string getname();
    }
}

//实现1
public class a1 : ia
{
    iadao _a1;

    //构造函数注入
    [injectionconstructor]
    public a1(iadao a1)
    {
        _a1 = a1;
    }

    public string getname()
    {
        return _a1.getname();
    }
}

//实现2
public class a2 : ia
{
    //属性注入 "a2dao" 是区分两个不同实现的标识,在配置文件中声明该名称
    [dependency("a2dao")]
    public dal.iadao _a1 { get; set; }

    public string getname()
    {
        return _a1.getname();
    }
}

在控制器中调用

public class homecontroller : controller
{
    //通过属性注入
    [dependency("a2")]
    public ia _a2 { get; set; }


    private ia _ia;
    
    //构造函数注入
    [injectionconstructor]
    public homecontroller(ia ia)    //如果都通过构造函数注入,则通过该方式区分([dependency("a1")]ia a1,[dependency("a2")]ia a2)
    {
        _ia = ia;
    }

    public actionresult index()
    {
        viewbag.name = _ia.getname();   //通过构造函数注入获取

        viewbag.a2name = _a2.getname();  //通过属性注入获取

        return view();
    }
}

显示结果：

接下来说如何配置

1,首先要引用unity插件

2,然后在app_start 文件夹下创建一个注册配置类unityconfig (引用插件的时候会自动创建,自定义也可以)，用来注册配置文件unity.config中的配置，

   /// <summary>
    /// 配置文件公用类
    /// </summary>
    public class unityconfig
    {
        /// <summary>
        /// mvc注入  在全局方法中调用该方法，实现全局注册
        /// </summary>
        public static void start()
        {
            var container = apicontainer.getunitycontainer();
            registertypes(container);

            dependencyresolver.setresolver(new unitydependencyresolver(container));   //mvc注入
        }

        /// <summary>
        /// 使用配置文件注册
        /// </summary>
        /// <param name="container"></param>
        private static void registertypes(iunitycontainer container)
        {
            //使用单独的unity.config配置文件
            var filepath = httpruntime.appdomainapppath;
            var context = httpcontext.current;
            if (context != null)
            {
                filepath = context.server.mappath("~/");
            }
            var getfile = filepath + "unity.config";
            var filemap = new execonfigurationfilemap { execonfigfilename = getfile };
            configuration configuration = configurationmanager.openmappedexeconfiguration(filemap, configurationuserlevel.none);
            var unitysection = (unityconfigurationsection)configuration.getsection("unity");
            container.loadconfiguration(unitysection, "defaultcontainer");

            //在app.config或者web.config中配置
            //unityconfigurationsection section = (unityconfigurationsection)configurationmanager.getsection("unity");
            //container.loadconfiguration(section, "defaultcontainer");  //或者section.configure(container, "defaultcontainer");
        }
    }

 3，然后同样在app_start 文件夹下创建一个unitydependencyresolver 类，同时实现接口：idependencyresolver

 1 /// <summary>
 2 /// 用于自动实现对象类
 3 /// </summary>
 4 public class unitydependencyresolver : idependencyresolver
 5 {
 6     iunitycontainer container;
 7     public unitydependencyresolver(iunitycontainer container)
 8     {
 9         this.container = container;
10     }
11 
12     public object getservice(type servicetype)
13     {
14         try
15         {
16             return container.resolve(servicetype);
17         }
18         catch
19         {
20             return null;
21         }
22     }
23 
24     public ienumerable<object> getservices(type servicetype)
25     {
26         try
27         {
28             return container.resolveall(servicetype);
29         }
30         catch
31         {
32             return new list<object>();
33         }
34     }
35 }

4，写一个unity公共类，也可以将该类集成到项目中

    /// <summary>
    /// unity公共类
    /// </summary>
    public class apicontainer
    {
        private readonly static iunitycontainer _container = null;

        /// <summary>
        /// 初始化容器
        /// </summary>
        /// <returns></returns>
        static apicontainer()
        {
            //新建容器构建器，用于注册组件和服务
            _container = new unitycontainer();
        }

        /// <summary>
        /// 对外开放函数 获取unity容器
        /// </summary>
        /// <returns></returns>
        public static iunitycontainer getunitycontainer()
        {
            return _container;
        }

        /// <summary>
        /// 获取实例
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <returns></returns>
        public static t getserver<t>()
        {
            return _container.resolve<t>();
        }

        /// <summary>
        /// 可以根据configname获取实例
        /// </summary>
        /// <typeparam name="t"></typeparam>
        /// <param name="configname">配置文件中指定的文字</param>
        /// <returns></returns>
        public static t getserver<t>(string configname)
        {
            return _container.resolve<t>(configname);
        }

        /// <summary>
        /// 返回构结函数带参数
        /// </summary>
        /// <typeparam name="t">依赖对象</typeparam>
        /// <param name="configname">配置文件中指定的文字(没写会报异常)</param>
        /// <param name="parameterlist">参数集合（参数名，参数值）</param>
        /// <returns></returns>
        public static t getserver<t>(dictionary<string, object> parameterlist)
        {
            var list = new parameteroverrides();
            foreach (keyvaluepair<string, object> item in parameterlist)
            {
                list.add(item.key, item.value);
            }
            return _container.resolve<t>(list.ontype<t>());
        }


    }

5，在项目根目录下创建一个 unity.config 文件，配置如下

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configsections>
    <section name="unity" type="microsoft.practices.unity.configuration.unityconfigurationsection,microsoft.practices.unity.configuration"/>
  </configsections>
  <unity>
    <containers>
      <container name="defaultcontainer">
        <register type="bll.ia,bll" mapto="bll.a1, bll"/>
        <register type="bll.ia,bll" mapto="bll.a2, bll"  name="a2" />
        <register type="dal.iadao,dal" mapto="dal.a1dao, dal"/>
        <register type="dal.iadao,dal" mapto="dal.a2dao, dal" name="a2dao"/>
      </container>
    </containers>
  </unity>
</configuration>

6，在全局中注册 global.asax.cs

public class mvcapplication : system.web.httpapplication
{
    protected void application_start()
    {
        arearegistration.registerallareas();
        filterconfig.registerglobalfilters(globalfilters.filters);
        routeconfig.registerroutes(routetable.routes);
        bundleconfig.registerbundles(bundletable.bundles);

        unityconfig.start();   //全局注册   可通过构造函数or属性调用
    }
}

到此全部结束

如果要在 webapi中使用unity，则除了引用unity插件，还要引用 unity.webapi 插件，引用版本如下：

然后需要调整一处地方,将mvc的注入方式换成webapi的注入方式，如下：

using system;
using microsoft.practices.unity;
using microsoft.practices.unity.webapi;
using system.web.http;

namespace api.app_start
{
    /// <summary>
    /// 配置文件公用类
    /// </summary>
    public class unityconfig
    {
        public static void start()
        {
            //dependencyresolver.setresolver(new unitydependencyresolver(container));   //mvc注入方式

            globalconfiguration.configuration.dependencyresolver = new unitydependencyresolver(getconfiguredcontainer());   //api注入方式
        }
    }
}

 另外需要去掉上边代码中的 unitydependencyresolver : idependencyresolver 实现。api的不需要实现如下接口, 去掉如下图的实现。

 

其他的地方都一样。

 

参考文章：

https://www.cnblogs.com/qqlin/archive/2012/10/18/2720828.html

https://blog.csdn.net/hezheqiang/article/details/80255280