C#-interface使用

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

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

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

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

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");
    }
}

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");
    }
}

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;
    }
}

public interface IMessage
{
    string GetText();
}

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

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

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 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 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; }
}

// 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;
    }
}

// 正确：手动创建 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;
}

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}");
    }
}

// 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(); }

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

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

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

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

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