C#-interface使用

接口 = 抽象"角色/能力"的工具
隔离变化 = 使用接口之后自然带来的收益

public interface ILogger
{
    void Log(string message);
}

public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}

// 正确
public void Log(string message) { }

// 错误：隐式实现不能是 private/protected
private void Log(string message) { }

// 通过类实例调用
var logger = new ConsoleLogger();
logger.Log("hello");

// 通过接口引用调用
ILogger iLogger = new ConsoleLogger();
iLogger.Log("world");

// UserRepository 实现 IUserRepository
public class UserRepository : IUserRepository { }

// EmailSender 实现 IMessageSender
public class EmailSender : IMessageSender { }

// FileLogger 实现 ILogger
public class FileLogger : ILogger { }

public interface ILogger
{
    void Log(string message);
}

public class ConsoleLogger : ILogger
{
    // 显式实现：不写访问修饰符，加上接口名前缀
    void ILogger.Log(string message)
    {
        Console.WriteLine(message);
    }
}

// 错误写法
public void ILogger.Log(string message) { } // 编译错误

var logger = new ConsoleLogger();
logger.Log("hello");         // 编译错误，不可见

// 必须转型为接口后才能调用
ILogger iLogger = logger;
iLogger.Log("hello");        // 正确

((ILogger)logger).Log("hello"); // 也正确

public interface IInternalAudit
{
    void Audit();
}

public class OrderService : IInternalAudit
{
    // 主职责：公开暴露
    public void CreateOrder()
    {
        Console.WriteLine("Create order");
    }

    // 辅助契约：隐藏在类 API 之外
    void IInternalAudit.Audit()
    {
        Console.WriteLine("Audit order service");
    }
}

var service = new OrderService();
service.CreateOrder();      // 可见
// service.Audit();         // 不可见

((IInternalAudit)service).Audit(); // 可见

public interface IReader
{
    void Open();
}

public interface IWriter
{
    void Open();
}

public class FileDevice : IReader, IWriter
{
    void IReader.Open()
    {
        Console.WriteLine("Open for reading");
    }

    void IWriter.Open()
    {
        Console.WriteLine("Open for writing");
    }
}

var device = new FileDevice();
((IReader)device).Open(); // Open for reading
((IWriter)device).Open(); // Open for writing

public class MyCollection<T> : IEnumerable<T>, IEnumerable
{
    // 主 API：泛型版本，公开暴露
    public IEnumerator<T> GetEnumerator()
    {
        throw new NotImplementedException();
    }

    // 兼容旧接口：显式实现，不污染现代 API
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public class DataExporter : IDisposable
{
    private readonly FileStream _stream;
    private bool _disposed;

    public DataExporter(string filePath)
    {
        _stream = new FileStream(filePath, FileMode.Create);
    }

    // 主 API，清晰暴露
    public async Task ExportAsync(IEnumerable<Order> orders)
    {
        if (_disposed)
            throw new ObjectDisposedException(nameof(DataExporter));

        foreach (var order in orders)
        {
            var bytes = Encoding.UTF8.GetBytes(order.ToString() + "\n");
            await _stream.WriteAsync(bytes);
        }
    }

    // 显式实现，不污染主 API
    void IDisposable.Dispose()
    {
        if (_disposed) return;
        _stream.Dispose();
        _disposed = true;
    }
}

// using 语句能正确触发显式实现的 Dispose()
using var exporter = new DataExporter("output.txt");
await exporter.ExportAsync(orders);
// 块结束时自动调用 IDisposable.Dispose()

public interface IMessage
{
    string GetText();
}

public class Notice : IMessage
{
    // 隐式实现
    public string GetText() => "public text";

    // 显式实现
    string IMessage.GetText() => "interface text";
}

var notice = new Notice();
Console.WriteLine(notice.GetText());          // public text

IMessage msg = notice;
Console.WriteLine(msg.GetText());             // interface text

隐式实现："这是我的公开能力。"
显式实现："这是我在扮演某个接口角色时才有的能力。"

接口：描述"能做什么"  → 角色 / 能力 / 契约
抽象类：描述"是什么，并且已经有一部分共性实现"  → 基类 / 模板 / 骨架

// 一个类扮演多个角色
public class FileCache : ICache, IDisposable, IAsyncDisposable
{
}

public interface ISerializer
{
    string Serialize<T>(T obj);
}

// 三种实现完全不同，接口非常合适
public class JsonSerializer : ISerializer { }
public class XmlSerializer : ISerializer { }
public class YamlSerializer : ISerializer { }

public abstract class FileImporter
{
    // 共享流程（模板方法）
    public void Import(string path)
    {
        ValidatePath(path);
        var content = File.ReadAllText(path);
        Parse(content);
        Save();
    }

    // 共性实现
    protected virtual void ValidatePath(string path)
    {
        if (string.IsNullOrWhiteSpace(path))
            throw new ArgumentException(nameof(path));
    }

    // 子类各自实现
    protected abstract void Parse(string content);
    protected abstract void Save();
}

public abstract class WorkerBase
{
    // 共享字段和构造函数
    protected readonly ILogger _logger;

    protected WorkerBase(ILogger logger)
    {
        _logger = logger;
    }
}

// 对外：依赖接口（稳定契约）
public interface IMessageSender
{
    Task SendAsync(string message);
}

// 对内：抽象类沉淀共性（模板流程 + 共享状态）
public abstract class MessageSenderBase : IMessageSender
{
    protected readonly ILogger _logger;

    protected MessageSenderBase(ILogger logger)
    {
        _logger = logger;
    }

    public async Task SendAsync(string message)
    {
        Validate(message);
        await SendCoreAsync(message);
        _logger.LogInformation("message sent");
    }

    protected virtual void Validate(string message)
    {
        if (string.IsNullOrWhiteSpace(message))
            throw new ArgumentException(nameof(message));
    }

    protected abstract Task SendCoreAsync(string message);
}

// 具体实现：只填差异部分
public class EmailSender : MessageSenderBase
{
    public EmailSender(ILogger<EmailSender> logger) : base(logger) { }

    protected override Task SendCoreAsync(string message)
    {
        Console.WriteLine($"Email: {message}");
        return Task.CompletedTask;
    }
}

// 如果 TaxCalculator 没有多种实现、不是边界、不需要多态
// 直接用具体类即可
public class TaxCalculator
{
    public decimal Calculate(Order order) { ... }
}

// 不必要的接口定义
public interface ITaxCalculator
{
    decimal Calculate(Order order);
}

// 没有意义
public interface IUserDto
{
    string Name { get; set; }
}

// 直接用数据类
public class UserDto
{
    public string Name { get; set; }
}

// 如果没有多种哈希策略切换、没有测试替身需求
// 直接用具体类
public class Md5Hasher
{
    public string Hash(string input) { ... }
}

// 只在程序集内部使用，变化可能性低
internal class OrderNumberGenerator
{
    public string Generate() { ... }
}

// 典型反模式：一比一机械配对，没有抽象价值
public interface IOrderService { ... }
public class OrderService : IOrderService { ... }

public interface IUserManager { ... }
public class UserManager : IUserManager { ... }

public interface IProductHelper { ... }
public class ProductHelper : IProductHelper { ... }

能不能发消息？能不能写日志？能不能取缓存？
→ 适合接口

仓储 / 外部 API / 支付网关 / 消息队列 / 文件存储 / 缓存 / 时钟
→ 适合接口

// 有实际多实现价值的接口
public interface ICacheProvider { }
// RedisCacheProvider
// MemoryCacheProvider

public interface INotificationSender { }
// SmsNotificationSender
// EmailNotificationSender
// WechatNotificationSender

// 策略模式：运行时选择不同策略
public interface IDiscountStrategy
{
    decimal Calculate(Order order);
}

现在不用接口也没问题？没有外部依赖边界？不太可能扩展？
→ 先用具体类，等需求出现再提炼（渐进式抽象）

// 仓储层（系统边界）
public interface IOrderRepository
{
    Task<Order?> GetByIdAsync(Guid id);
    Task SaveAsync(Order order);
}

// 外部服务（可替换实现）
public interface IPaymentGateway
{
    Task PayAsync(decimal amount);
}

// 策略（多态扩展）
public interface IPricingStrategy
{
    decimal Calculate(Order order);
}

// 小而稳定的环境依赖
public interface IClock
{
    DateTime UtcNow { get; }
}

接口定义在哪个层 → 由哪个层负责，或由组合根统一管理

┌───────────────────────────────┐
│         API / Web 层          │  ← 入口、Controller、Middleware
├───────────────────────────────┤
│         Application 层        │  ← 用例、Service、DTO
├───────────────────────────────┤
│          Domain 层            │  ← 实体、领域服务、接口定义
├───────────────────────────────┤
│       Infrastructure 层       │  ← 仓储实现、第三方服务实现
└───────────────────────────────┘

Domain 层定义：
  IOrderRepository  ← 契约，属于内层

Infrastructure 层实现：
  EfOrderRepository : IOrderRepository  ← 实现，属于外层

// Infrastructure/DependencyInjection.cs
public static class InfrastructureServiceCollectionExtensions
{
    public static IServiceCollection AddInfrastructure(
        this IServiceCollection services,
        IConfiguration configuration)
    {
        services.AddDbContext<AppDbContext>(options =>
            options.UseSqlServer(configuration.GetConnectionString("Default")));

        services.AddScoped<IOrderRepository, EfOrderRepository>();
        services.AddScoped<IUserRepository, EfUserRepository>();
        services.AddScoped<IEmailSender, SmtpEmailSender>();
        services.AddScoped<IPaymentGateway, AlipayGateway>();

        return services;
    }
}

// Application/DependencyInjection.cs
public static class ApplicationServiceCollectionExtensions
{
    public static IServiceCollection AddApplication(
        this IServiceCollection services)
    {
        services.AddMediatR(cfg =>
            cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()));

        services.AddAutoMapper(Assembly.GetExecutingAssembly());

        return services;
    }
}

var builder = WebApplication.CreateBuilder(args);

builder.Services
    .AddApplication()
    .AddInfrastructure(builder.Configuration);

builder.Services.AddControllers();

var app = builder.Build();
app.Run();

Singleton    整个进程生命周期内使用同一个实例
Scoped       同一次请求内使用同一个实例
Transient    每次注入都创建一个新实例

// 危险：Scoped 服务被 Singleton 捕获，变成事实上的 Singleton
public class MySingletonService
{
    private readonly IOrderRepository _repo; // Scoped，危险！

    public MySingletonService(IOrderRepository repo)
    {
        _repo = repo;
    }
}

// 正确：手动创建 Scope
public class MySingletonService
{
    private readonly IServiceScopeFactory _scopeFactory;

    public MySingletonService(IServiceScopeFactory scopeFactory)
    {
        _scopeFactory = scopeFactory;
    }

    public async Task DoWorkAsync()
    {
        using var scope = _scopeFactory.CreateScope();
        var repo = scope.ServiceProvider
            .GetRequiredService<IOrderRepository>();
        await repo.GetByIdAsync(Guid.NewGuid());
    }
}

// Domain 层 - 定义接口
public interface IOrderRepository
{
    Task<Order?> GetByIdAsync(Guid id);
    Task<IReadOnlyList<Order>> GetByUserIdAsync(Guid userId);
    Task SaveAsync(Order order);
    Task DeleteAsync(Guid id);
}

// Infrastructure 层 - 实现
public class EfOrderRepository : IOrderRepository
{
    private readonly AppDbContext _context;

    public EfOrderRepository(AppDbContext context)
    {
        _context = context;
    }

    public async Task<Order?> GetByIdAsync(Guid id)
        => await _context.Orders.FindAsync(id);

    public async Task<IReadOnlyList<Order>> GetByUserIdAsync(Guid userId)
        => await _context.Orders
            .Where(o => o.UserId == userId)
            .ToListAsync();

    public async Task SaveAsync(Order order)
    {
        _context.Orders.Update(order);
        await _context.SaveChangesAsync();
    }

    public async Task DeleteAsync(Guid id)
    {
        var order = await GetByIdAsync(id);
        if (order is not null)
        {
            _context.Orders.Remove(order);
            await _context.SaveChangesAsync();
        }
    }
}

// 注册
services.AddScoped<IOrderRepository, EfOrderRepository>();

// 接口定义
public interface INotificationSender
{
    Task SendAsync(string recipient, string message);
    NotificationChannel Channel { get; }
}

public enum NotificationChannel { Email, Sms, Wechat }

// 多种实现
public class EmailNotificationSender : INotificationSender
{
    public NotificationChannel Channel => NotificationChannel.Email;

    public async Task SendAsync(string recipient, string message)
    {
        Console.WriteLine($"[Email] To: {recipient}, Message: {message}");
        await Task.CompletedTask;
    }
}

public class SmsNotificationSender : INotificationSender
{
    public NotificationChannel Channel => NotificationChannel.Sms;

    public async Task SendAsync(string recipient, string message)
    {
        Console.WriteLine($"[SMS] To: {recipient}, Message: {message}");
        await Task.CompletedTask;
    }
}

public interface INotificationSenderFactory
{
    INotificationSender GetSender(NotificationChannel channel);
}

public class NotificationSenderFactory : INotificationSenderFactory
{
    private readonly IEnumerable<INotificationSender> _senders;

    public NotificationSenderFactory(IEnumerable<INotificationSender> senders)
    {
        _senders = senders;
    }

    public INotificationSender GetSender(NotificationChannel channel)
    {
        return _senders.FirstOrDefault(s => s.Channel == channel)
            ?? throw new InvalidOperationException(
                $"No sender registered for channel: {channel}");
    }
}

// 注册
services.AddScoped<INotificationSender, EmailNotificationSender>();
services.AddScoped<INotificationSender, SmsNotificationSender>();
services.AddScoped<INotificationSender, WechatNotificationSender>();
services.AddScoped<INotificationSenderFactory, NotificationSenderFactory>();

// 直接用具体类，不套接口
public class OrderPriceCalculator
{
    public decimal Calculate(Order order)
    {
        var basePrice = order.Items.Sum(i => i.Price * i.Quantity);
        var discount = GetDiscount(order);
        var tax = GetTax(basePrice - discount);
        return basePrice - discount + tax;
    }

    private decimal GetDiscount(Order order)
        => order.IsVip
            ? order.Items.Sum(i => i.Price * i.Quantity) * 0.1m
            : 0;

    private decimal GetTax(decimal amount)
        => amount * 0.13m;
}

// 当出现以下情况时再提炼：
// 1. 需要支持多种计算策略（普通/VIP/活动价）
// 2. 需要在测试中 Mock 价格结果
// 3. 被跨模块共享，需要稳定契约
public interface IPriceCalculator
{
    decimal Calculate(Order order);
}

public interface IReadable
{
    void Open();
    string Read();
}

public interface IWritable
{
    void Open();
    void Write(string data);
}

public class DataService : IReadable, IWritable
{
    private bool _readMode;
    private bool _writeMode;

    // 显式实现，区分两个 Open 的不同语义
    void IReadable.Open()
    {
        _readMode = true;
        Console.WriteLine("Opened for reading");
    }

    void IWritable.Open()
    {
        _writeMode = true;
        Console.WriteLine("Opened for writing");
    }

    public string Read()
    {
        if (!_readMode)
            throw new InvalidOperationException("Not opened for reading");
        return "data";
    }

    public void Write(string data)
    {
        if (!_writeMode)
            throw new InvalidOperationException("Not opened for writing");
        Console.WriteLine($"Writing: {data}");
    }
}

var service = new DataService();
((IReadable)service).Open();  // Opened for reading
((IWritable)service).Open();  // Opened for writing

// Domain 层 - 定义接口契约
public interface IPaymentGateway
{
    Task<PaymentResult> PayAsync(PaymentRequest request);
}

// Infrastructure 层 - 多个实现
public class AlipayGateway : IPaymentGateway
{
    public async Task<PaymentResult> PayAsync(PaymentRequest request)
    {
        // 调用支付宝 API
        return new PaymentResult { Success = true };
    }
}

public class WechatPayGateway : IPaymentGateway
{
    public async Task<PaymentResult> PayAsync(PaymentRequest request)
    {
        // 调用微信支付 API
        return new PaymentResult { Success = true };
    }
}

// Application 层 - 只依赖接口，不关心实现
public class OrderService
{
    private readonly IOrderRepository _orderRepo;
    private readonly IPaymentGateway _paymentGateway;
    private readonly INotificationSenderFactory _senderFactory;

    public OrderService(
        IOrderRepository orderRepo,
        IPaymentGateway paymentGateway,
        INotificationSenderFactory senderFactory)
    {
        _orderRepo = orderRepo;
        _paymentGateway = paymentGateway;
        _senderFactory = senderFactory;
    }

    public async Task CreateOrderAsync(CreateOrderRequest request)
    {
        var order = new Order(request.UserId, request.Items);

        var paymentResult = await _paymentGateway.PayAsync(
            new PaymentRequest { Amount = order.TotalAmount });

        if (!paymentResult.Success)
            throw new PaymentFailedException();

        await _orderRepo.SaveAsync(order);

        var sender = _senderFactory.GetSender(NotificationChannel.Email);
        await sender.SendAsync(request.UserEmail, "订单创建成功");
    }
}

// 胖接口：违反接口隔离原则
public interface IUserService
{
    void Create();
    void Delete();
    void Update();
    void Login();
    void Logout();
    void SendEmail();
    void ExportExcel();
}

// 按角色拆分
public interface IUserRepository   { void Create(); void Delete(); void Update(); }
public interface IAuthService      { void Login(); void Logout(); }
public interface IEmailSender      { void SendEmail(); }
public interface IReportExporter   { void ExportExcel(); }

// 好的命名（角色/能力）
public interface IMessageSender { }
public interface IOrderRepository { }
public interface ICacheProvider { }
public interface IClock { }

// 一般的命名（不够清晰）
public interface IUserService { }
public interface ICommonHelper { }
public interface IManager { }

正确理解：高层模块依赖稳定抽象，而不是依赖易变细节
错误理解：项目里每个类都必须有一个 IXXX

需要定义接口吗？
│
├── 是系统边界？（数据库、外部 API、文件系统、消息队列）
│   └── 是 → 定义接口
│
├── 有多个实现，或可预见替换？
│   └── 是 → 定义接口
│
├── 需要多态 / 策略 / 插件机制？
│   └── 是 → 定义接口
│
├── 纯内部实现，无边界，无替换，无多态？
│   └── 先用具体类，等需求出现再提炼（渐进式抽象）
│
└── 只是为了看起来规范 / 方便 Mock？
    └── 不要

用隐式实现还是显式实现？
│
├── 这个方法是类的主要能力 / 主职责？
│   └── 隐式实现
│
├── 只是为了履行辅助契约，不想污染主 API？
│   └── 显式实现
│
├── 多个接口同名但语义不同？
│   └── 必须显式实现
│
└── 兼容旧接口 / 辅助接口（如非泛型 IEnumerable）？
    └── 显式实现

注册在哪里？
│
├── 仓储、数据库、外部服务实现
│   └── Infrastructure 层注册
│
├── 应用层协调类（MediatR、AutoMapper 等）
│   └── Application 层注册
│
├── Web 相关（Controller、Middleware）
│   └── Web 层注册
│
└── Program.cs 只做组合
    └── 调用各层的注册扩展方法，保持简洁

接口 vs 抽象类？
│
├── 表达"角色/能力"，可能多个角色叠加？
│   └── 接口
│
├── 有共享实现、共享状态、模板流程，是"对象家族"？
│   └── 抽象类
│
└── 两者都需要？
    └── 接口 + 抽象类组合使用
        └── 接口对外暴露契约
            抽象类对内沉淀共性

生命周期？
│
├── 依赖 DbContext，或需要在同一请求内共享？
│   └── Scoped
│
├── 全局共享状态，整个进程只需一个？
│   └── Singleton
│       └── 注意：不能直接依赖 Scoped，用 IServiceScopeFactory
│
└── 无状态，轻量级，每次用新的？
    └── Transient