彻底搞懂 .NET DI 的三种注册姿势：普通、泛型与工厂函数

 // 1. 日志接口与实现
 public interface ILoggerService
 {
     void Log(string message);
 }
 ​
 public class ConsoleLogger : ILoggerService
 {
     public void Log(string message) => Console.WriteLine($"[LOG]: {message}");
 }
 ​
 // 2. 用户服务接口与实现
 public interface IUserService
 {
     void CreateUser(string name);
 }
 ​
 public class UserService : IUserService
 {
     private readonly ILoggerService _logger;
 ​
     // 依赖注入：构造函数需要一个 ILoggerService
     public UserService(ILoggerService logger)
     {
         _logger = logger;
     }
 ​
     public void CreateUser(string name)
     {
         _logger.Log($"User {name} created!");
     }
 }

 var builder = WebApplication.CreateBuilder(args);
 ​
 // 【泛型注册】：将 ILoggerService 映射到 ConsoleLogger
 builder.Services.AddSingleton<ILoggerService, ConsoleLogger>();
 ​
 // 【泛型注册】：将 IUserService 映射到 UserService
 builder.Services.AddScoped<IUserService, UserService>();
 ​
 var app = builder.Build();
 ​
 // 在 Minimal API 中直接注入使用
 app.MapPost("/users", (string name, IUserService userService) =>
 {
     userService.CreateUser(name);
     return Results.Ok($"Created {name}");
 });
 ​
 app.Run();

 var builder = WebApplication.CreateBuilder(args);
 ​
 // 【普通注册】：传入 Type 对象
 builder.Services.AddSingleton(typeof(ILoggerService), typeof(ConsoleLogger));
 builder.Services.AddScoped(typeof(IUserService), typeof(UserService));
 ​
 var app = builder.Build();
 ​
 app.MapPost("/users", (string name, IUserService userService) =>
 {
     userService.CreateUser(name);
     return Results.Ok();
 });
 ​
 app.Run();

 // 开放泛型，T 是不确定的
 public interface IRepository<T> { ... }
 public class Repository<T> : IRepository<T> { ... }

 // 开放泛型注册：用 typeof(IRepository<>) 占位
 builder.Services.AddScoped(typeof(IRepository<>), typeof(Repository<>));

 var assembly = typeof(Program).Assembly;
 ​
 // 获取所有以 "Service" 结尾的类，并用普通注册自动注入
 var serviceTypes = assembly.GetTypes()
     .Where(t => t.Name.EndsWith("Service") && !t.IsInterface);
 ​
 foreach (var implType in serviceTypes)
 {
     var interfaceType = implType.GetInterfaces().FirstOrDefault();
     if (interfaceType != null)
     {
         // 只能使用普通注册，因为 implType 和 interfaceType 是运行时算出来的 Type 变量！
         builder.Services.AddScoped(interfaceType, implType);
     }
 }

 public class CustomLogger : ILoggerService
 {
     private readonly string _prefix;
     public CustomLogger(string prefix) => _prefix = prefix;
 ​
     public void Log(string message) => Console.WriteLine($"[{_prefix}]: {message}");
 }

 var builder = WebApplication.CreateBuilder(args);
 ​
 // 【工厂函数注册】：我自己写代码来 new 这个对象！
 builder.Services.AddSingleton<ILoggerService>(sp =>
 {
     // 1. 可以通过 sp 拿到配置服务
     var config = sp.GetRequiredService<IConfiguration>();
     var appName = config["AppName"] ?? "DefaultApp";
 ​
     // 2. 亲自 new 出 CustomLogger 并传参
     return new CustomLogger(prefix: appName);
 });
 ​
 // 如果 UserService 需要特殊处理，也可以用工厂函数：
 builder.Services.AddScoped<IUserService>(sp =>
 {
     // 从容器中解析出 Logger，再手工构造 UserService
     var logger = sp.GetRequiredService<ILoggerService>();
     return new UserService(logger);
 });
 ​
 var app = builder.Build();
 ​
 app.MapGet("/", (ILoggerService logger) =>
 {
     logger.Log("Hello Factory!");
     return Results.Ok();
 });
 ​
 app.Run();