.NET中是否有内置方式标记类用于依赖注入？

问题背景 #

在.NET应用中，我们有大量依赖依赖注入（DI）的类：

public class MyClass {
    public MyClass(ILoggerFactory loggerFactory) ...
}

按照最佳实践，所有使用DI模式的类都应该注册到DI容器中。通常我们会在Program.cs或Startup.cs里手动注册：

builder.Services.AddTransient<MyClass>();

但当类的数量达到150个以上时，手动维护长长的注册列表就成了技术债务：

builder.Services
    .AddTransient<MyClass>()
    .AddTransient<MyClass2>()
    .AddTransient<MyClass3>()
    ...
    .AddTransient<MyClass150>();

现有临时解决方案 #

我实现了一个基于特性标记的自动注册方案：

1. 定义注册特性 #

[AttributeUsage(AttributeTargets.Class)]
public sealed class RegisterServiceAttribute : Attribute
{
    public ServiceLifetime Lifetime { get; }
    public Type? ServiceType { get; }

    public RegisterServiceAttribute(ServiceLifetime lifetime, Type? serviceType) => 
        (Lifetime, ServiceType) = (lifetime, serviceType);

    public RegisterServiceAttribute(ServiceLifetime lifetime) => 
        Lifetime = lifetime;
}

2. 扩展DI注册方法 #

namespace Microsoft.Extensions.DependencyInjection;

public static class RegisterServiceAttributeExtensions
{
    public static IServiceCollection AddServicesWithAttribute(this IServiceCollection services, Assembly assembly)
    {
        var typesRegisteredByAttribute =
            from t in assembly.GetTypes().AsParallel()
            where !t.IsAbstract
            let attributes = t.GetCustomAttributes(typeof(RegisterServiceAttribute), true)
            where attributes?.Length > 0
            select new { ImplementationType = t, Attribute = attributes.Cast<RegisterServiceAttribute>().First() };

        foreach (var regAttr in typesRegisteredByAttribute.ToArray())
            services.Add(new ServiceDescriptor(
                regAttr.Attribute.ServiceType ?? regAttr.ImplementationType,
                regAttr.ImplementationType,
                regAttr.Attribute.Lifetime));

        return services;
    }
}

3. 使用方式 #

在需要注册的类上标记特性：

[RegisterService(ServiceLifetime.Transient)]
public class MyClass {
}

然后在Program.cs中调用：

services.AddServicesWithAttribute(...get whatever assembly I expect them in);

现有方案的痛点 #

• 反射性能损耗：启动时需要遍历程序集所有类型来筛选标记特性的类，拖慢应用启动速度。
• 编译时无校验：如果特性中指定的服务类型（如IMyInterface）未被类实现，只会在运行时抛出错误，无法在编译阶段提前发现：

  // 错误示例：MyClass未实现IMyInterface，但特性指定了该服务类型
  [RegisterService(ServiceLifetime.Transient, typeof(IMyInterface))]
  public class MyClass {
  }
  

• 重复造轮子疑虑：怀疑.NET DI官方已有类似功能，或存在官方不内置该功能的合理原因。

解决方案与思路 #

一、官方推荐的约定式注册 #

.NET DI本身没有内置特性标记的注册方式，但可以通过约定式注册替代手动逐个注册，比全量反射更高效：

1. 基于标记接口约定

定义用于标记生命周期的空接口，让需要注册的类实现对应接口，再批量注册：

// 定义生命周期标记接口
public interface ITransientService { }
public interface IScopedService { }
public interface ISingletonService { }

// 扩展注册方法
public static IServiceCollection AddServicesByMarkerInterface(this IServiceCollection services, Assembly assembly)
{
    // 注册瞬时服务
    AddServicesOfLifetime(services, assembly, typeof(ITransientService), ServiceLifetime.Transient);
    // 注册作用域服务
    AddServicesOfLifetime(services, assembly, typeof(IScopedService), ServiceLifetime.Scoped);
    // 注册单例服务
    AddServicesOfLifetime(services, assembly, typeof(ISingletonService), ServiceLifetime.Singleton);
    return services;
}

private static void AddServicesOfLifetime(IServiceCollection services, Assembly assembly, Type markerInterface, ServiceLifetime lifetime)
{
    var targetTypes = assembly.GetTypes()
        .Where(t => !t.IsAbstract && markerInterface.IsAssignableFrom(t));
    
    foreach (var type in targetTypes)
    {
        // 注册自身
        services.Add(new ServiceDescriptor(type, type, lifetime));
        // 自动注册为其实现的业务接口（排除标记接口）
        var businessInterface = type.GetInterfaces().FirstOrDefault(i => i != markerInterface);
        if (businessInterface != null)
        {
            services.Add(new ServiceDescriptor(businessInterface, type, lifetime));
        }
    }
}

这种方式的遍历范围更小，且接口实现有编译时校验，不会出现类型不匹配的运行时错误。

2. 基于命名空间/类名约定

约定服务类的命名空间或命名规则，批量匹配注册：

public static IServiceCollection AddServicesByNamingConvention(this IServiceCollection services, Assembly assembly)
{
    var serviceTypes = assembly.GetTypes()
        .Where(t => !t.IsAbstract 
            && t.Namespace?.Contains(".Services") == true
            && t.Name.EndsWith("Service"));
    
    foreach (var type in serviceTypes)
    {
        services.AddTransient(type);
        // 自动注册为第一个实现的接口
        var interfaceType = type.GetInterfaces().FirstOrDefault();
        if (interfaceType != null)
        {
            services.AddTransient(interfaceType, type);
        }
    }
    return services;
}

二、优化现有特性方案（若坚持使用） #

1. 消除反射性能损耗

使用Source Generator在编译时自动生成注册代码，完全避免运行时反射：

• 编写Source Generator扫描所有标记RegisterServiceAttribute的类，自动生成包含所有注册逻辑的扩展方法，示例生成代码：

  // 自动生成的代码
  public static IServiceCollection AddAutoRegisteredServices(this IServiceCollection services)
  {
      services.AddTransient<MyClass>();
      services.AddTransient<IMyInterface, MyClass>();
      // ...其他标记类的注册代码
      return services;
  }
  

  启动时直接调用该生成方法，无反射开销。

2. 添加编译时校验

编写Roslyn自定义分析器，在编译阶段检查标记特性的类是否实现了指定的ServiceType：

• 分析器会在代码编写时实时校验，若类未实现特性指定的服务类型，直接抛出编译警告或错误，提前规避运行时问题。

三、官方未内置特性注册的原因 #

• 关注点分离：官方DI设计倾向于将注册逻辑集中在Program.cs/Startup.cs，让DI容器的整体结构更清晰，便于统一维护和调试。特性标记会将注册逻辑分散到各个类中，增加了理解整个依赖关系的成本。
• 复杂度平衡：内置特性注册需要处理大量边缘场景（如多特性冲突、生命周期覆盖、服务类型重复注册等），会显著增加DI容器的复杂度。官方更倾向于提供基础API，让开发者根据自身需求实现定制化的注册逻辑。
• 性能优先：运行时反射会带来启动性能损耗，尤其是大型应用中更为明显。官方更推荐编译时生成代码的方式（如Source Generator），而非内置反射式自动注册。

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