如何在DTO响应对象中实现业务逻辑？（ASP.NET Core MVC场景）

我是编程新手，正在基于ASP.NET Core MVC开发一个背单词的练手项目。我希望基于单词的其他属性计算出学习优先级，最终在DTO响应对象中返回这个值。

目前我把优先级计算逻辑写在UserWords对象的扩展方法里，代码如下：

using EnjOffer.Core.Domain.Entities;
using EnjOffer.Core.Services;

namespace EnjOffer.Core.DTO
{
    public class UserWordsResponse
    {
        public Guid UserWordId { get; set; }
        public string? Word { get; set; }
        public string? WordTranslation { get; set; }
        public DateTime? LastTimeEntered { get; set; }
        public int CorrectEnteredCount { get; set; }
        public int IncorrectEnteredCount { get; set; }
        public double Priority { get; set; }
        public Guid UserId { get; set; }

        public override bool Equals(object? obj)
        {
            if (obj == null)
            {
                return false;
            }

            if (obj.GetType() != typeof(UserWordsResponse))
            {
                return false;
            }
            UserWordsResponse userWord_to_compare = (UserWordsResponse)obj;
            return UserWordId == userWord_to_compare.UserWordId &&
                Word == userWord_to_compare.Word &&
                WordTranslation == userWord_to_compare.WordTranslation &&
                LastTimeEntered == userWord_to_compare.LastTimeEntered &&
                CorrectEnteredCount == userWord_to_compare.CorrectEnteredCount &&
                IncorrectEnteredCount == userWord_to_compare.IncorrectEnteredCount &&
                Priority == userWord_to_compare.Priority &&
                UserId == userWord_to_compare.UserId;
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Major Bug", "S3249:Classes directly extending \"object\" should not call \"base\" in \"GetHashCode\" or \"Equals\"", Justification = "<Pending>")]
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }

    public static class UserWordsResponseExtensions
    {
        public static UserWordsResponse ToUserWordsResponse(this UserWords userWords)
        {
            return new UserWordsResponse()
            {
                UserWordId = userWords.UserWordId,
                Word = userWords.Word,
                WordTranslation = userWords.WordTranslation,
                LastTimeEntered = userWords.LastTimeEntered,
                CorrectEnteredCount = userWords.CorrectEnteredCount,
                IncorrectEnteredCount = userWords.IncorrectEnteredCount,
                Priority = (userWords.LastTimeEntered is not null) ? ((double)userWords.CorrectEnteredCount / (userWords.IncorrectEnteredCount +
                userWords.CorrectEnteredCount) * (1 - Math.Exp(-(double)(DateTime.Now - userWords.LastTimeEntered).Value.Hours / 3))) : 0,
                UserId = userWords.UserId
            };
        }
    }
}

但我觉得这不是最佳实践，想把计算逻辑移到UserWordsService.cs里的GetPriority()方法中，然后在扩展方法里调用它。但我不知道怎么实现才对——是要在ToUserWordsResponse()扩展方法里实例化UserWordsService吗？还是有更好的方案？

我现在写了下面的实现，想问问这是否符合最佳实践：

首先在UserWordsService中添加GetPriority方法：

using EnjOffer.Core.Domain.Entities;
using EnjOffer.Core.DTO;
using EnjOffer.Core.Helpers;
using EnjOffer.Core.ServiceContracts;

namespace EnjOffer.Core.Services
{
    public class UserWordsService : IUserWordsService
    {
        private readonly List<UserWords> _userWords;

        public UserWordsService()
        {
            _userWords = new List<UserWords>();
        }

        public double GetPriority(DateTime? lastTimeEntered, int correctlyEntered, int incorrectlyEntererd)
        {
            return (lastTimeEntered is not null) ? ((double)correctlyEntered / (incorrectlyEntererd +
                correctlyEntered) * (1 - Math.Exp(-(double)(DateTime.Now - lastTimeEntered).Value.Hours / 3))) : 0;
        }
    }
}

然后在扩展方法里实例化UserWordsService并调用方法：

public static class UserWordsResponseExtensions
{
    public static UserWordsResponse ToUserWordsResponse(this UserWords userWords)
    {
        UserWordsService userWordsService = new UserWordsService();
        double priority = userWordsService.GetPriority(userWords.LastTimeEntered, userWords.CorrectEnteredCount, userWords.IncorrectEnteredCount);

        return new UserWordsResponse()
        {
            UserWordId = userWords.UserWordId,
            Word = userWords.Word,
            WordTranslation = userWords.WordTranslation,
            LastTimeEntered = userWords.LastTimeEntered,
            CorrectEnteredCount = userWords.CorrectEnteredCount,
            IncorrectEnteredCount = userWords.IncorrectEnteredCount,
            Priority = priority,
            UserId = userWords.UserId
        };
    }
}

你当前的实现不算最佳实践，核心问题在于扩展方法里直接实例化UserWordsService，会带来以下问题：

• 耦合性高：扩展方法与UserWordsService强绑定，后续如果UserWordsService的构造函数需要添加依赖（比如数据库上下文），扩展方法里的代码会直接报错。
• 测试难度大：如果要模拟不同的时间、计数场景测试优先级逻辑，直接实例化服务会让测试变得繁琐，无法轻松替换依赖。

针对你的场景，这里有几个更合理的优化方案：

方案1：将优先级计算提取为静态工具类/方法 #

当前的GetPriority是纯计算逻辑，完全不依赖UserWordsService的内部状态（比如_userWords列表根本没用到），可以把它独立成一个静态工具类：

public static class PriorityCalculator
{
    public static double Calculate(DateTime? lastTimeEntered, int correctlyEntered, int incorrectlyEntered)
    {
        if (lastTimeEntered == null)
            return 0;
            
        var totalAttempts = correctlyEntered + incorrectlyEntered;
        if (totalAttempts == 0)
            return 0; // 避免除以0的异常
            
        var accuracy = (double)correctlyEntered / totalAttempts;
        var hoursSinceLastReview = (DateTime.Now - lastTimeEntered.Value).TotalHours;
        var decayFactor = 1 - Math.Exp(-hoursSinceLastReview / 3);
        
        return accuracy * decayFactor;
    }
}

然后在扩展方法里直接调用这个静态方法：

public static UserWordsResponse ToUserWordsResponse(this UserWords userWords)
{
    return new UserWordsResponse()
    {
        UserWordId = userWords.UserWordId,
        Word = userWords.Word,
        WordTranslation = userWords.WordTranslation,
        LastTimeEntered = userWords.LastTimeEntered,
        CorrectEnteredCount = userWords.CorrectEnteredCount,
        IncorrectEnteredCount = userWords.IncorrectEnteredCount,
        Priority = PriorityCalculator.Calculate(userWords.LastTimeEntered, userWords.CorrectEnteredCount, userWords.IncorrectEnteredCount),
        UserId = userWords.UserId
    };
}

这个方案简单直接，逻辑独立，既方便维护也容易编写单元测试。

方案2：在Service层完成DTO转换（推荐） #

扩展方法适合简单的属性映射，但如果转换逻辑需要依赖服务或复杂计算，更好的做法是在UserWordsService内部完成DTO转换，利用ASP.NET Core的依赖注入避免手动实例化：

在UserWordsService中添加转换方法：

public UserWordsResponse ToUserWordsResponse(UserWords userWords)
{
    return new UserWordsResponse()
    {
        UserWordId = userWords.UserWordId,
        Word = userWords.Word,
        WordTranslation = userWords.WordTranslation,
        LastTimeEntered = userWords.LastTimeEntered,
        CorrectEnteredCount = userWords.CorrectEnteredCount,
        IncorrectEnteredCount = userWords.IncorrectEnteredCount,
        Priority = GetPriority(userWords.LastTimeEntered, userWords.CorrectEnteredCount, userWords.IncorrectEnteredCount),
        UserId = userWords.UserId
    };
}

然后在控制器等需要转换的地方，通过依赖注入使用IUserWordsService：

public class WordsController : Controller
{
    private readonly IUserWordsService _userWordsService;
    
    public WordsController(IUserWordsService userWordsService)
    {
        _userWordsService = userWordsService;
    }
    
    public IActionResult Detail(Guid userWordId)
    {
        var userWord = _userWordsService.GetUserWordById(userWordId);
        var response = _userWordsService.ToUserWordsResponse(userWord);
        return Ok(response);
    }
}

这个方案符合ASP.NET Core的设计思想，代码解耦，测试时可以轻松MockIUserWordsService验证转换逻辑。

方案3：给扩展方法传入计算委托（灵活场景适用） #

如果一定要保留扩展方法，又不想耦合到具体服务，可以给扩展方法传入优先级计算的委托：

public static UserWordsResponse ToUserWordsResponse(this UserWords userWords, Func<DateTime?, int, int, double> priorityCalculator)
{
    return new UserWordsResponse()
    {
        UserWordId = userWords.UserWordId,
        Word = userWords.Word,
        WordTranslation = userWords.WordTranslation,
        LastTimeEntered = userWords.LastTimeEntered,
        CorrectEnteredCount = userWords.CorrectEnteredCount,
        IncorrectEnteredCount = userWords.IncorrectEnteredCount,
        Priority = priorityCalculator(userWords.LastTimeEntered, userWords.CorrectEnteredCount, userWords.IncorrectEnteredCount),
        UserId = userWords.UserId
    };
}

调用时传入IUserWordsService的方法引用：

var response = userWord.ToUserWordsResponse(_userWordsService.GetPriority);

这个方案灵活性很高，允许动态切换优先级计算规则，但需要在调用处传入委托，适合需要动态调整逻辑的场景。

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