C# Unity容器详解

目录

• 简介
• Unity容器基础
• 依赖注入的类型
• 注册与解析
• 生命周期管理
• 高级特性
• 在实际项目中的应用
• Unity容器与其他DI框架的比较
• 总结

简介

Unity容器是Microsoft开发的一个轻量级、可扩展的依赖注入(DI)容器，是.NET应用程序中实现控制反转(IoC)的强大工具。本文将深入探讨Unity容器的核心概念、使用方法以及在实际项目中的应用场景。

依赖注入是一种设计模式，它允许我们将对象的创建与使用分离，从而使代码更加模块化、可测试和可维护。Unity容器通过自动管理对象的创建和生命周期，简化了依赖注入的实现过程。

Unity容器基础

安装Unity容器

要开始使用Unity容器，首先需要通过NuGet包管理器安装相关包：

// 使用NuGet包管理器控制台
Install-Package Unity

基本概念

Unity容器的核心是IUnityContainer接口，它提供了注册、解析和管理对象生命周期的功能。以下是一个简单的示例：

using Unity;

// 创建容器
IUnityContainer container = new UnityContainer();

// 注册类型
container.RegisterType<ILogger, FileLogger>();

// 解析实例
ILogger logger = container.Resolve<ILogger>();

依赖注入的类型

Unity容器支持三种主要的依赖注入类型：

1. 构造函数注入

构造函数注入是最常用的依赖注入方式，它通过构造函数参数提供依赖项：

public class UserService
{
    private readonly ILogger _logger;
    private readonly IUserRepository _repository;

    // 构造函数注入
    public UserService(ILogger logger, IUserRepository repository)
    {
        _logger = logger;
        _repository = repository;
    }
}

// 注册
container.RegisterType<ILogger, FileLogger>();
container.RegisterType<IUserRepository, SqlUserRepository>();
container.RegisterType<UserService>();

// 解析 - Unity会自动注入所需的依赖
UserService service = container.Resolve<UserService>();

2. 属性注入

属性注入通过公共属性提供依赖项：

public class UserService
{
    // 属性注入
    [Dependency]
    public ILogger Logger { get; set; }

    [Dependency]
    public IUserRepository Repository { get; set; }
}

// 解析
UserService service = container.Resolve<UserService>();
// Unity会自动设置标记了[Dependency]特性的属性

3. 方法注入

方法注入通过方法参数提供依赖项：

public class UserService
{
    private ILogger _logger;
    private IUserRepository _repository;

    // 方法注入
    [InjectionMethod]
    public void Initialize(ILogger logger, IUserRepository repository)
    {
        _logger = logger;
        _repository = repository;
    }
}

注册与解析

基本注册

Unity容器提供了多种注册类型的方式：

// 接口到实现的映射
container.RegisterType<ILogger, FileLogger>();

// 具体类型注册
container.RegisterType<UserService>();

// 命名注册
container.RegisterType<ILogger, FileLogger>("FileLogger");
container.RegisterType<ILogger, DatabaseLogger>("DbLogger");

实例注册

除了类型注册外，还可以注册已存在的实例：

// 注册单例实例
var logger = new FileLogger("app.log");
container.RegisterInstance<ILogger>(logger);

// 命名实例注册
container.RegisterInstance<ILogger>("AppLogger", logger);

解析对象

注册完成后，可以通过以下方式解析对象：

// 基本解析
ILogger logger = container.Resolve<ILogger>();

// 解析命名注册
ILogger fileLogger = container.Resolve<ILogger>("FileLogger");
ILogger dbLogger = container.Resolve<ILogger>("DbLogger");

// 解析所有实现
IEnumerable<ILogger> allLoggers = container.ResolveAll<ILogger>();

生命周期管理

Unity容器支持多种生命周期管理策略，用于控制对象的创建和销毁：

1. 瞬态生命周期(Transient)

每次解析都会创建新实例：

// 默认为瞬态
container.RegisterType<ILogger, FileLogger>();

// 显式指定瞬态
container.RegisterType<ILogger, FileLogger>(TypeLifetime.Transient);

2. 单例生命周期(Singleton)

整个容器生命周期内只创建一个实例：

container.RegisterType<ILogger, FileLogger>(TypeLifetime.Singleton);

3. 每线程单例(Per Thread)

每个线程一个实例：

container.RegisterType<ILogger, FileLogger>(TypeLifetime.PerThread);

4. 外部控制生命周期(External)

实例由外部控制，容器不负责释放：

container.RegisterType<ILogger, FileLogger>(TypeLifetime.External);

5. 分层生命周期(Hierarchical)

在容器层次结构中的每个容器一个实例：

container.RegisterType<ILogger, FileLogger>(TypeLifetime.Hierarchical);

高级特性

1. 注入参数

可以在注册或解析时提供具体参数：

// 注册时提供参数
container.RegisterType<FileLogger>(
    new InjectionConstructor("app.log", LogLevel.Debug));

// 解析时提供参数
var logger = container.Resolve<FileLogger>(
    new ParameterOverride("fileName", "custom.log"),
    new ParameterOverride("level", LogLevel.Error));

2. 拦截器

Unity支持使用拦截器实现面向切面编程(AOP)：

// 安装拦截器扩展
Install-Package Unity.Interception

// 配置拦截器
container.AddNewExtension<Interception>();
container.RegisterType<ILogger, FileLogger>(
    new Interceptor<InterfaceInterceptor>(),
    new InterceptionBehavior<LoggingInterceptionBehavior>());

3. 子容器

可以创建子容器来隔离注册：

IUnityContainer parentContainer = new UnityContainer();
parentContainer.RegisterType<ILogger, FileLogger>();

// 创建子容器
IUnityContainer childContainer = parentContainer.CreateChildContainer();
childContainer.RegisterType<ILogger, DatabaseLogger>();

// 子容器解析优先使用自己的注册
ILogger logger = childContainer.Resolve<ILogger>(); // 返回DatabaseLogger实例

在实际项目中的应用

在ASP.NET Core中使用Unity

虽然ASP.NET Core内置了依赖注入容器，但如果你需要Unity的特定功能，可以集成它：

// 安装Unity.Microsoft.DependencyInjection包
Install-Package Unity.Microsoft.DependencyInjection

// 在Program.cs中配置
public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .UseUnityServiceProvider() // 使用Unity作为DI容器
        .ConfigureContainer<IUnityContainer>((context, container) =>
        {
            // 配置Unity容器
            container.RegisterType<ILogger, FileLogger>();
            container.RegisterType<IUserRepository, SqlUserRepository>();
        })
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });

在WPF应用中使用Unity

Unity容器非常适合用于WPF应用程序的MVVM模式实现：

public class App : Application
{
    private IUnityContainer _container;

    protected override void OnStartup(StartupEventArgs e)
    {
        base.OnStartup(e);

        _container = new UnityContainer();
        
        // 注册服务
        _container.RegisterType<IDialogService, DialogService>();
        _container.RegisterType<IUserService, UserService>();
        
        // 注册视图模型
        _container.RegisterType<MainViewModel>();
        _container.RegisterType<UserViewModel>();
        
        // 创建并显示主窗口
        var mainWindow = new MainWindow
        {
            DataContext = _container.Resolve<MainViewModel>()
        };
        
        mainWindow.Show();
    }
}

在单元测试中使用Unity

Unity容器使单元测试变得更加简单，特别是在需要模拟依赖项的情况下：

[TestClass]
public class UserServiceTests
{
    private IUnityContainer _container;
    
    [TestInitialize]
    public void Initialize()
    {
        _container = new UnityContainer();
        
        // 注册模拟对象
        var mockLogger = new Mock<ILogger>();
        var mockRepository = new Mock<IUserRepository>();
        
        _container.RegisterInstance(mockLogger.Object);
        _container.RegisterInstance(mockRepository.Object);
        _container.RegisterType<UserService>();
    }
    
    [TestMethod]
    public void CreateUser_ShouldLogAndSaveUser()
    {
        // 获取已配置的服务
        var service = _container.Resolve<UserService>();
        
        // 执行测试...
    }
}

Unity容器与其他DI框架的比较

Unity容器与其他流行的DI框架相比有其独特的优势和劣势：

特性	Unity	Autofac	Ninject	Microsoft.Extensions.DependencyInjection
性能	良好	优秀	一般	优秀
功能丰富度	高	非常高	高	中等
配置复杂度	中等	高	低	低
社区支持	中等	活跃	活跃	非常活跃
与ASP.NET Core集成	需要额外包	良好	良好	原生支持
AOP支持	良好	优秀	通过扩展	有限

Unity容器的主要优势在于：

• 微软官方支持（虽然现在是开源项目）
• 丰富的功能集
• 良好的性能
• 与其他微软技术的集成

总结

Unity容器是一个功能强大且灵活的依赖注入工具，它提供了丰富的特性来管理对象创建、依赖解析和生命周期控制。通过使用Unity容器，我们可以：

1. 降低代码耦合度，提高模块化
2. 简化单元测试，提高代码质量
3. 集中管理应用程序组件
4. 实现灵活的配置和扩展

无论是在Web应用、桌面应用还是服务应用中，Unity容器都能帮助我们构建更加健壮、可维护的软件系统。虽然在ASP.NET Core中，微软的内置DI容器已经成为主流选择，但在许多场景下，Unity容器的高级特性仍然使其成为一个有价值的选择。

要深入学习Unity容器，建议查阅官方文档和相关示例代码，以便更好地理解和应用这一强大工具。

---

参考资料：

1. Unity Container GitHub: https://github.com/unitycontainer/unity
2. Microsoft Docs: Dependency Injection
3. Unity Container Documentation
4. Patterns of Enterprise Application Architecture by Martin Fowler