设计模式中的依赖注入

最新推荐文章于 2024-11-17 11:31:29 发布

你一身傲骨怎能输

最新推荐文章于 2024-11-17 11:31:29 发布

阅读量1k

点赞数 19

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/qq_33060405/article/details/143278791

版权

设计模式专栏收录该内容

20 篇文章 1 订阅

订阅专栏

依赖注入（Dependency Injection, DI）是一种设计模式，用于实现对象之间的解耦和提高代码的可维护性、可测试性。通过依赖注入，类不再直接创建其依赖对象，而是通过构造函数、属性或方法参数来获取这些依赖对象。这样可以使代码更加灵活和可测试。

依赖注入的类型

构造函数注入：通过构造函数传递依赖对象。
属性注入：通过属性设置依赖对象。
方法注入：通过方法参数传递依赖对象。

依赖注入的实现

在C#中，依赖注入通常与依赖注入容器（如ASP.NET Core内置的DI容器、Autofac、Ninject等）结合使用。下面是一个简单的示例，展示如何使用依赖注入来解耦组件。

示例：构造函数注入

假设我们有一个简单的日志记录系统，包含以下组件：

ILogger：日志记录接口。
ConsoleLogger：实现ILogger接口的控制台日志记录器。
Application：使用ILogger记录日志的应用程序类。

定义接口和实现

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

public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"Log: {message}");
    }
}

使用依赖注入的类

public class Application
{
    private readonly ILogger _logger;

    public Application(ILogger logger)
    {
        _logger = logger;
    }

    public void Run()
    {
        _logger.Log("Application is running.");
    }
}

配置依赖注入容器

在实际项目中，我们通常会使用依赖注入容器来管理依赖关系。在这个示例中，我们使用 .NET Core 内置的依赖注入容器。

using Microsoft.Extensions.DependencyInjection;

class Program
{
    static void Main(string[] args)
    {
        // 创建服务集合
        var serviceCollection = new ServiceCollection();

        // 注册服务
        serviceCollection.AddTransient<ILogger, ConsoleLogger>();
        serviceCollection.AddTransient<Application>();

        // 构建服务提供者
        var serviceProvider = serviceCollection.BuildServiceProvider();

        // 获取Application实例
        var app = serviceProvider.GetService<Application>();

        // 运行应用程序
        app.Run();
    }
}

解释

定义接口和实现：我们定义了ILogger接口和ConsoleLogger实现。
使用依赖注入的类：Application类通过构造函数注入ILogger依赖。
配置依赖注入容器：我们使用 .NET Core 内置的依赖注入容器来注册和解析依赖。

优点

解耦：通过依赖注入，Application类不再直接依赖于具体的ConsoleLogger实现，而是依赖于ILogger接口。这使得代码更加模块化和可维护。
可测试性：由于依赖关系是通过接口注入的，我们可以轻松地为Application类编写单元测试，并使用模拟对象（Mock）来替换实际的依赖。
灵活性：通过依赖注入容器，我们可以在运行时动态地替换依赖对象，增加了系统的灵活性。

单元测试示例

以下是一个使用Moq库编写的单元测试示例：

using Moq;
using Xunit;

public class ApplicationTests
{
    [Fact]
    public void Run_ShouldLogMessage()
    {
        // Arrange
        var mockLogger = new Mock<ILogger>();
        var app = new Application(mockLogger.Object);

        // Act
        app.Run();

        // Assert
        mockLogger.Verify(logger => logger.Log("Application is running."), Times.Once);
    }
}

解释

Arrange：在测试的Arrange阶段，我们创建了ILogger的模拟对象，并将其传递给Application类。
Act：在Act阶段，我们调用了Application类的Run方法。
Assert：在Assert阶段，我们验证了模拟对象的Log方法是否按预期被调用。

总结

依赖注入是一种强大的设计模式，可以显著提高代码的可依赖注入是一种强大的设计模式，可以显著提高代码的可维护性、可测试性和灵活性。通过依赖注入，我们可以轻松地管理对象之间的依赖关系，并在运行时动态地替换这些依赖对象。下面我们继续深入探讨依赖注入的更多细节和高级用法。

高级用法

1. 生命周期管理

依赖注入容器通常提供多种生命周期管理选项，以控制对象的创建和销毁时机。常见的生命周期包括：

Transient：每次请求都会创建一个新的实例。
Scoped：在一个作用域内（例如一个Web请求）共享同一个实例。
Singleton：在整个应用程序生命周期内共享同一个实例。

在ASP.NET Core中，我们可以通过以下方式配置生命周期：

serviceCollection.AddTransient<IService, Service>(); // Transient
serviceCollection.AddScoped<IService, Service>();    // Scoped
serviceCollection.AddSingleton<IService, Service>(); // Singleton

2. 条件绑定

有时我们需要根据特定条件来绑定不同的实现。例如，我们可以根据配置或环境变量来选择不同的日志记录器实现。

if (useConsoleLogger)
{
    serviceCollection.AddTransient<ILogger, ConsoleLogger>();
}
else
{
    serviceCollection.AddTransient<ILogger, FileLogger>();
}

3. 装饰器模式

装饰器模式允许我们在不修改原始类的情况下，动态地添加行为。我们可以结合依赖注入来实现装饰器模式。

public class LoggerDecorator : ILogger
{
    private readonly ILogger _innerLogger;

    public LoggerDecorator(ILogger innerLogger)
    {
        _innerLogger = innerLogger;
    }

    public void Log(string message)
    {
        // 添加额外的行为
        Console.WriteLine("Logging start");
        _innerLogger.Log(message);
        Console.WriteLine("Logging end");
    }
}

// 注册装饰器
serviceCollection.AddTransient<ILogger, ConsoleLogger>();
serviceCollection.AddTransient<ILogger, LoggerDecorator>();

4. 工厂模式

有时我们需要动态地创建对象，依赖注入容器可以与工厂模式结合使用。

public class ServiceFactory
{
    private readonly IServiceProvider _serviceProvider;

    public ServiceFactory(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public IService CreateService()
    {
        return _serviceProvider.GetService<IService>();
    }
}

// 注册工厂
serviceCollection.AddSingleton<ServiceFactory>();

实际案例：游戏开发中的依赖注入

假设我们正在开发一个复杂的RPG游戏，包含以下组件：

角色（Character）：游戏中的主要角色。
武器（Weapon）：角色可以装备的武器。
技能（Skill）：角色可以使用的技能。
敌人（Enemy）：游戏中的敌人。

我们希望通过依赖注入来管理这些组件之间的依赖关系。

定义接口和实现

public interface IWeapon
{
    void Attack();
}

public interface ISkill
{
    void Use();
}

public interface ICharacter
{
    void PerformAttack();
    void UseSkill();
}

public class Sword : IWeapon
{
    public void Attack()
    {
        Console.WriteLine("Swinging the sword!");
    }
}

public class Fireball : ISkill
{
    public void Use()
    {
        Console.WriteLine("Casting a fireball!");
    }
}

public class Character : ICharacter
{
    private readonly IWeapon _weapon;
    private readonly ISkill _skill;

    public Character(IWeapon weapon, ISkill skill)
    {
        _weapon = weapon;
        _skill = skill;
    }

    public void PerformAttack()
    {
        _weapon.Attack();
    }

    public void UseSkill()
    {
        _skill.Use();
    }
}

配置依赖注入容器

using Microsoft.Extensions.DependencyInjection;

class Program
{
    static void Main(string[] args)
    {
        // 创建服务集合
        var serviceCollection = new ServiceCollection();

        // 注册服务
        serviceCollection.AddTransient<IWeapon, Sword>();
        serviceCollection.AddTransient<ISkill, Fireball>();
        serviceCollection.AddTransient<ICharacter, Character>();

        // 构建服务提供者
        var serviceProvider = serviceCollection.BuildServiceProvider();

        // 获取角色实例
        var character = serviceProvider.GetService<ICharacter>();

        // 执行角色动作
       character.PerformAttack();
       character.UseSkill();

添加更多功能

为了展示依赖注入的灵活性，我们可以进一步扩展游戏的功能。例如，添加一个新的敌人系统，并让角色与敌人进行战斗。

定义敌人接口和实现

public interface IEnemy
{
    void TakeDamage(int amount);
}

public class Goblin : IEnemy
{
    public void TakeDamage(int amount)
    {
        Console.WriteLine($"Goblin takes {amount} damage!");
    }
}

扩展角色类

我们可以扩展Character类，使其能够攻击敌人。

public class Character : ICharacter
{
    private readonly IWeapon _weapon;
    private readonly ISkill _skill;
    private readonly IEnemy _enemy;

    public Character(IWeapon weapon, ISkill skill, IEnemy enemy)
    {
        _weapon = weapon;
        _skill = skill;
        _enemy = enemy;
    }

    public void PerformAttack()
    {
        _weapon.Attack();
        _enemy.TakeDamage(10); // 假设每次攻击造成10点伤害
    }

    public void UseSkill()
    {
        _skill.Use();
        _enemy.TakeDamage(20); // 假设每次技能造成20点伤害
    }
}

更新依赖注入配置

我们需要更新依赖注入容器的配置，以注册新的IEnemy依赖。

using Microsoft.Extensions.DependencyInjection;

class Program
{
    static void Main(string[] args)
    {
        // 创建服务集合
        var serviceCollection = new ServiceCollection();

        // 注册服务
        serviceCollection.AddTransient<IWeapon, Sword>();
        serviceCollection.AddTransient<ISkill, Fireball>();
        serviceCollection.AddTransient<IEnemy, Goblin>();
        serviceCollection.AddTransient<ICharacter, Character>();

        // 构建服务提供者
        var serviceProvider = serviceCollection.BuildServiceProvider();

        // 获取角色实例
        var character = serviceProvider.GetService<ICharacter>();

        // 执行角色动作
        character.PerformAttack();
        character.UseSkill();
    }
}

解释

定义敌人接口和实现：我们定义了IEnemy接口和Goblin实现。
扩展角色类：我们扩展了Character类，使其能够攻击敌人。
更新依赖注入配置：我们更新了依赖注入容器的配置，以注册新的IEnemy依赖。

优点

解耦：通过依赖注入，Character类不再直接依赖于具体的Sword、Fireball和Goblin实现，而是依赖于它们的接口。这使得代码更加模块化和可维护。
可测试性：由于依赖关系是通过接口注入的，我们可以轻松地为Character类编写单元测试，并使用模拟对象（Mock）来替换实际的依赖。
灵活性：通过依赖注入容器，我们可以在运行时动态地替换依赖对象，增加了系统的灵活性。