如何限制UnitOfWork类的依赖注入范围？避免非Service类注入

要实现限制IUnitOfWork只能注入到继承BaseService的类中，可通过以下几种方式实现，从编译期到运行时逐步强化架构约束：

1. 编译期强制检查（推荐）：自定义Roslyn分析器 #

通过编写Roslyn分析器，在编译阶段扫描所有注入IUnitOfWork的类，若未继承BaseService则直接抛出错误或警告，从源头阻止偏离架构的行为。

核心实现逻辑 #

创建Roslyn分析器项目，注册构造函数符号分析逻辑：

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Diagnostics;
using System.Linq;

[DiagnosticAnalyzer(LanguageNames.CSharp)]
public class UnitOfWorkInjectionAnalyzer : DiagnosticAnalyzer
{
    private const string DiagnosticId = "UOW001";
    private static readonly LocalizableString Title = "Invalid IUnitOfWork Injection";
    private static readonly LocalizableString MessageFormat = "IUnitOfWork can only be injected into classes inheriting from BaseService. Found in: {0}";
    private static readonly LocalizableString Description = "IUnitOfWork should only be used within service classes that inherit BaseService.";
    private const string Category = "Architecture";

    private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, Category, DiagnosticSeverity.Error, isEnabledByDefault: true, description: Description);

    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);

    public override void Initialize(AnalysisContext context)
    {
        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
        context.EnableConcurrentExecution();
        context.RegisterSymbolAction(AnalyzeConstructor, SymbolKind.Method);
    }

    private void AnalyzeConstructor(SymbolAnalysisContext context)
    {
        var ctorSymbol = (IMethodSymbol)context.Symbol;
        if (!ctorSymbol.IsConstructor) return;

        var declaringType = ctorSymbol.ContainingType;
        var compilation = context.Compilation;

        // 获取BaseService和IUnitOfWork的类型符号
        var baseServiceType = compilation.GetTypeByMetadataName("YourNamespace.BaseService");
        var unitOfWorkType = compilation.GetTypeByMetadataName("YourNamespace.IUnitOfWork");

        if (baseServiceType == null || unitOfWorkType == null) return;

        // 检查当前类是否继承自BaseService
        if (declaringType.DerivesFrom(baseServiceType)) return;

        // 检查构造函数是否包含IUnitOfWork参数
        if (ctorSymbol.Parameters.Any(p => p.Type.Equals(unitOfWorkType, SymbolEqualityComparer.Default)))
        {
            context.ReportDiagnostic(Diagnostic.Create(Rule, ctorSymbol.Locations[0], declaringType.Name));
        }
    }
}

将分析器打包为NuGet包，团队成员引用后，编译时只要有非BaseService子类注入IUnitOfWork，就会触发编译错误，强制遵循架构规范。

2. 运行时检查：在UnitOfWork中验证调用方 #

如果暂时无法实现Roslyn分析器，可在UnitOfWork的构造函数中通过调用栈检查注入方类型，不符合则抛出异常，让违规行为在运行时立刻暴露：

using System.Diagnostics;

public class UnitOfWork : IUnitOfWork
{
    public UnitOfWork()
    {
        var stackTrace = new StackTrace();
        foreach (var frame in stackTrace.GetFrames())
        {
            var method = frame.GetMethod();
            if (method?.IsConstructor == true)
            {
                var declaringType = method.DeclaringType;
                if (declaringType != null && !typeof(BaseService).IsAssignableFrom(declaringType))
                {
                    throw new InvalidOperationException($"IUnitOfWork仅允许注入到继承BaseService的类中，当前类：{declaringType.FullName}");
                }
                break;
            }
        }
    }

    // IUnitOfWork接口实现方法...
}

这种方式虽然不能在编译期发现问题，但能快速阻止违规代码运行，让开发者明确感知到架构约束。

3. DI层面辅助限制：自定义注册逻辑 #

在依赖注入容器注册时，可配合上述方法强化约束，例如不直接对外暴露IUnitOfWork的注册，而是通过BaseService的专属注册逻辑提供：

// ASP.NET Core DI示例
services.AddScoped<IUnitOfWork, UnitOfWork>();

// 统一注册所有BaseService子类
services.Scan(scan => scan
    .FromAssembliesOf(typeof(BaseService))
    .AddClasses(classes => classes.InheritedFrom<BaseService>())
    .AsSelf()
    .WithScopedLifetime());

这种方式单独使用无法完全阻止违规注入，但能引导开发者通过规范路径使用IUnitOfWork，结合前面的编译期或运行时检查，形成完整的约束体系。

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