控制反转与依赖注入的核心概念

在软件工程中，控制反转（IoC, Inversion of Control）是一种设计原则，它将对象创建和依赖管理的控制权从业务代码转移给外部容器。开发者不再手动实例化依赖对象，而是向容器发出请求，由容器负责组装和提供这些资源。

依赖注入（DI, Dependency Injection）是 IoC 的一种具体实现方式。当容器根据配置或约定，将依赖对象自动"注入"到目标类的构造函数、属性或方法中时，这个过程即为依赖注入。这种方式极大地降低了组件间的耦合度，提升了代码的可测试性和可维护性。

在 .NET 生态中，Unity 是一个轻量级且功能强大的依赖注入容器。本文将深入探讨 Unity 容器的多种注入方式及其在 ASP.NET MVC 中的集成方案。

环境准备与 Unity 引入

在开始之前，需要通过 NuGet 包管理器将 Unity 引入项目。对于控制台或类库项目，安装 Unity 包即可；如果需要基于 XML 配置文件进行注册，还需安装 Unity.Configuration 包。在 ASP.NET MVC 项目中，则应安装 Unity.Mvc 包。

构造函数注入 (Constructor Injection)

构造函数注入是最推荐且最常用的注入方式。IoC 容器在解析目标类型时，会自动寻找其构造函数，并递归解析构造函数参数所需的依赖实例。

以下示例展示了一个订单处理服务如何依赖日志服务：

public interface ILogger 
{
    void Record(string message);
}

public class FileLogger : ILogger 
{
    public void Record(string message) 
    {
        Console.WriteLine($"[FileLog] {message}");
    }
}

public interface IOrderProcessor 
{
    void Execute(string orderId);
}

public class OrderProcessor : IOrderProcessor 
{
    private readonly ILogger _logger;

    // 容器会自动解析并注入 ILogger 的实现
    public OrderProcessor(ILogger logger) 
    {
        _logger = logger;
    }

    public void Execute(string orderId) 
    {
        _logger.Record($"Initiating process for order: {orderId}");
    }
}

在应用程序入口处配置并解析容器：

class Program 
{
    static void Main(string[] args) 
    {
        using (var container = new UnityContainer()) 
        {
            // 注册接口与实现的映射关系
            container.RegisterType<ILogger, FileLogger>();
            container.RegisterType<IOrderProcessor, OrderProcessor>();

            // 解析根对象，容器会自动处理其依赖链
            var processor = container.Resolve<IOrderProcessor>();
            processor.Execute("ORD-9527");
        }
    }
}

属性注入 (Property Injection)

属性注入适用于那些"非必须"的依赖，或者在对象创建后需要重新赋值的场景。在 Unity 中，只需在目标属性上标记 [Dependency] 特性，容器在实例化对象后会自动为该属性赋值。

public class OrderProcessor : IOrderProcessor 
{
    // 标记该属性需要由容器注入
    [Dependency]
    public ILogger Logger { get; set; }

    public void Execute(string orderId) 
    {
        if (Logger != null) 
        {
            Logger.Record($"Initiating process for order: {orderId}");
        }
    }
}

基于 XML 配置文件的容器注册

硬编码注册方式在修改依赖关系时需要重新编译。为了实现更高的灵活性，可以将映射关系转移到 XML 配置文件中。这在企业级应用中非常常见。

在 App.config 或 Web.config 中添加以下配置节点：

<configuration>
  <configSections>
    <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Unity.Configuration" />
  </configSections>
  
  <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
    <containers>
      <container name="PrimaryContainer">
        <!-- 注册日志服务 -->
        <register type="MyApp.Core.ILogger, MyApp.Core" 
                  mapTo="MyApp.Infrastructure.FileLogger, MyApp.Infrastructure">
          <lifetime type="singleton" />
        </register>
        
        <!-- 注册订单处理服务 -->
        <register type="MyApp.Core.IOrderProcessor, MyApp.Core" 
                  mapTo="MyApp.Services.OrderProcessor, MyApp.Services" />
      </container>
    </containers>
  </unity>
</configuration>

在代码中加载并应用该配置：

var container = new UnityContainer();
var section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");

// 将配置文件中的指定容器节点加载到当前 UnityContainer 实例
section.Configure(container, "PrimaryContainer");

var processor = container.Resolve<IOrderProcessor>();
processor.Execute("ORD-1024");

方法注入 (Method Injection)

方法注入允许通过调用特定的初始化方法来注入依赖。这通常用于处理复杂的初始化逻辑或当依赖项需要在对象生命周期的特定阶段注入时。使用 [InjectionMethod] 特性标记目标方法。

public class OrderProcessor : IOrderProcessor 
{
    private ILogger _logger;

    [InjectionMethod]
    public void InitializeDependencies(ILogger logger) 
    {
        _logger = logger;
    }

    public void Execute(string orderId) 
    {
        _logger?.Record($"Initiating process for order: {orderId}");
    }
}

ASP.NET MVC 中的 Unity 集成

在 Web 应用程序中，手动管理控制器的依赖是不现实的。通过 Unity.Mvc 包，可以将 Unity 容器无缝集成到 MVC 的依赖解析管道中。

1. 配置 Unity 容器

在项目根目录创建 UnityConfig.cs 类，负责注册所有依赖关系并设置 MVC 的依赖解析器：

public static class UnityConfig 
{
    public static void RegisterComponents() 
    {
        var container = new UnityContainer();

        // 注册业务依赖
        container.RegisterType<ILogger, FileLogger>();
        container.RegisterType<IOrderProcessor, OrderProcessor>();

        // 替换 MVC 默认的依赖解析器
        DependencyResolver.SetResolver(new UnityDependencyResolver(container));
    }
}

2. 在应用程序启动时初始化

修改 Global.asax.cs，在 Application_Start 方法中调用配置逻辑：

public class MvcApplication : System.Web.HttpApplication 
{
    protected void Application_Start() 
    {
        AreaRegistration.RegisterAllAreas();
        FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
        RouteConfig.RegisterRoutes(RouteTable.Routes);
        BundleConfig.RegisterBundles(BundleTable.Bundles);

        // 初始化 Unity 容器
        UnityConfig.RegisterComponents();
    }
}

3. 在 Controller 中注入依赖

现在，MVC 框架在创建 Controller 实例时，会自动通过 Unity 容器解析并注入所需的依赖。可以使用构造函数注入，也可以使用属性注入：

public class OrderController : Controller 
{
    [Dependency]
    public IOrderProcessor Processor { get; set; }

    public ActionResult ProcessOrder(string id) 
    {
        Processor.Execute(id);
        return View();
    }
}