ASP.NET MVC重构：DI服务与带构造函数对象的结合疑问

背景 #

我们正在重构一款业务逻辑存于助手类的ASP.NET MVC应用，计划将依赖注入（DI）服务注入到控制器中。目前有两个关于DI服务的处理困惑：

• 希望能像助手类那样，为DI服务设置必填属性；
• 内部业务逻辑可能会用到DI服务，但从控制器传递所有内部类所需的DI服务显得十分繁琐。

邮件服务示例对比 #

DI模式当前写法（单次发送） #

在Startup.cs中初始化邮件服务，配置SMTP server、SMTP port等基础参数，但不设置From用户（因应用中From用户不固定，需作为参数传入），调用方式如下：

_mailService.Send(from, to, subject, message)

原助手类写法（批量发送） #

MailHelper mailhelper = new MailHelper(from, to);
mailhelper.Send(subject1, message1);
mailhelper.Send(subject2, message2);
mailhelper.Send(subject3, message3);

猜测的DI模式批量写法 #

_mailService.NewBatch(from, to);
_mailService.Send(subject1, message1);
_mailService.Send(subject2, message2);
_mailService.Send(subject3, message3);

具体疑问 #

1. 若上述示例中忘记调用_mailService.NewBatch(from, to)，是否需要在服务内部自行跟踪状态？虽可在未调用NewBatch时调用Send抛出异常，但助手类通过构造函数可避免此问题，且DI服务生命周期长，可能留存旧的from和to值；
2. 若同时使用助手类与DI服务，是否需要将所有DI服务作为参数传入助手类的构造函数？即使是助手类内部深层逻辑所需的服务（如日志服务）？

关于疑问1：DI服务的状态跟踪与必填参数处理 #

你猜测的写法存在状态污染风险——DI服务（如注册为Singleton或Scoped）会在多个请求/调用间复用，留存旧的from/to值会导致严重逻辑错误。推荐两种解决思路：

方案1：创建「单次批量上下文」类 #

让核心邮件服务保持无状态，单独封装承载会话级状态的「批量邮件上下文」类，通过构造函数强制必填参数：

// 核心邮件服务（注册为Singleton/Scoped，无状态）
public interface IMailCoreService
{
    void Send(string from, string to, string subject, string message);
}

// 批量邮件上下文（每次批量发送时新建实例）
public class MailBatchContext
{
    private readonly IMailCoreService _mailCoreService;
    public string From { get; }
    public string To { get; }

    // 构造函数强制校验必填参数，避免遗漏
    public MailBatchContext(IMailCoreService mailCoreService, string from, string to)
    {
        _mailCoreService = mailCoreService ?? throw new ArgumentNullException(nameof(mailCoreService));
        From = !string.IsNullOrEmpty(from) ? from : throw new ArgumentException("From不能为空", nameof(from));
        To = !string.IsNullOrEmpty(to) ? to : throw new ArgumentException("To不能为空", nameof(to));
    }

    public void Send(string subject, string message)
    {
        _mailCoreService.Send(From, To, subject, message);
    }
}

调用方式和原助手类几乎一致，同时利用DI注入核心服务：

// 控制器注入IMailCoreService
private readonly IMailCoreService _mailCoreService;

public MyController(IMailCoreService mailCoreService)
{
    _mailCoreService = mailCoreService;
}

public IActionResult SendBatch()
{
    var batch = new MailBatchContext(_mailCoreService, "from@example.com", "to@example.com");
    batch.Send("主题1", "内容1");
    batch.Send("主题2", "内容2");
    return Ok();
}

这种方式既保留了原助手类构造函数强制必填的优点，又避免了DI生命周期带来的状态污染。

方案2：用工厂模式创建有状态服务实例 #

如果一定要把批量逻辑封装在服务里，可以注册邮件服务工厂，每次批量发送时获取全新实例：

public interface IMailBatchService
{
    void Initialize(string from, string to);
    void Send(string subject, string message);
}

public class MailBatchService : IMailBatchService
{
    private readonly IMailCoreService _mailCoreService;
    private string _from;
    private string _to;

    public MailBatchService(IMailCoreService mailCoreService)
    {
        _mailCoreService = mailCoreService;
    }

    public void Initialize(string from, string to)
    {
        _from = !string.IsNullOrEmpty(from) ? from : throw new ArgumentException("From不能为空", nameof(from));
        _to = !string.IsNullOrEmpty(to) ? to : throw new ArgumentException("To不能为空", nameof(to));
    }

    public void Send(string subject, string message)
    {
        if (string.IsNullOrEmpty(_from) || string.IsNullOrEmpty(_to))
        {
            throw new InvalidOperationException("请先调用Initialize初始化From和To");
        }
        _mailCoreService.Send(_from, _to, subject, message);
    }
}

// 工厂接口
public interface IMailBatchServiceFactory
{
    IMailBatchService Create();
}

public class MailBatchServiceFactory : IMailBatchServiceFactory
{
    private readonly IServiceProvider _serviceProvider;

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

    public IMailBatchService Create()
    {
        // 每次创建全新实例，避免状态复用
        return ActivatorUtilities.CreateInstance<MailBatchService>(_serviceProvider);
    }
}

Startup注册：

services.AddSingleton<IMailCoreService, MailCoreService>();
services.AddSingleton<IMailBatchServiceFactory, MailBatchServiceFactory>();

调用方式：

private readonly IMailBatchServiceFactory _batchFactory;

public MyController(IMailBatchServiceFactory batchFactory)
{
    _batchFactory = batchFactory;
}

public IActionResult SendBatch()
{
    var batchService = _batchFactory.Create();
    batchService.Initialize("from@example.com", "to@example.com");
    batchService.Send("主题1", "内容1");
    batchService.Send("主题2", "内容2");
    return Ok();
}

这种方式通过工厂创建全新实例，降低了状态残留风险，但仍需确保先调用Initialize。

关于疑问2：助手类与DI服务的共存处理 #

不需要手动传入所有DI服务，推荐两种方式：

方式1：让助手类通过DI自动获取依赖 #

如果助手类使用场景固定，可将其注册为DI服务，让容器自动注入所需依赖（包括深层的日志服务等）：

public class MailHelper
{
    private readonly IMailCoreService _mailCoreService;
    private readonly ILogger<MailHelper> _logger;
    public string From { get; }
    public string To { get; }

    // DI容器自动注入IMailCoreService和ILogger
    public MailHelper(IMailCoreService mailCoreService, ILogger<MailHelper> logger, string from, string to)
    {
        _mailCoreService = mailCoreService;
        _logger = logger;
        From = from;
        To = to;
    }

    public void Send(string subject, string message)
    {
        _logger.LogInformation("准备发送邮件");
        _mailCoreService.Send(From, To, subject, message);
    }
}

用ActivatorUtilities创建实例（自动从DI获取已注册服务，再传入手动参数）：

// 控制器注入IServiceProvider
private readonly IServiceProvider _serviceProvider;

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

public IActionResult UseHelper()
{
    var helper = ActivatorUtilities.CreateInstance<MailHelper>(_serviceProvider, "from@example.com", "to@example.com");
    helper.Send("主题", "内容");
    return Ok();
}

方式2：助手类只接收直接依赖，深层依赖由DI注入 #

如果助手类只是业务逻辑封装，可改成静态类或实例类，方法只接收当前直接需要的DI服务，深层逻辑的依赖由DI容器注入到对应服务中，无需层层传递：

public static class MailHelper
{
    // 只传入当前方法需要的依赖
    public static void SendBatch(IMailCoreService mailCoreService, ILogger logger, string from, string to, IEnumerable<(string Subject, string Message)> messages)
    {
        foreach (var (subject, message) in messages)
        {
            logger.LogInformation("发送邮件：{Subject}", subject);
            mailCoreService.Send(from, to, subject, message);
        }
    }
}

调用时仅传入控制器已注入的依赖：

private readonly IMailCoreService _mailCoreService;
private readonly ILogger<MyController> _logger;

public MyController(IMailCoreService mailCoreService, ILogger<MyController> logger)
{
    _mailCoreService = mailCoreService;
    _logger = logger;
}

public IActionResult UseHelper()
{
    var messages = new List<(string, string)>
    {
        ("主题1", "内容1"),
        ("主题2", "内容2")
    };
    MailHelper.SendBatch(_mailCoreService, _logger, "from@example.com", "to@example.com", messages);
    return Ok();
}

内容的提问来源于stack exchange，提问作者roberth