能否使用适配器设计模式简化接口列表？多接口适配技术咨询

当然可以！适配器模式绝对是解决这类接口不兼容问题的绝佳方案——它的核心就是把不同接口的“差异”给包装起来，让你能以统一的方式调用，再也不用在代码里写一堆判断区分两个接口了。

为什么它适合？ #

你的两个接口有着相同的方法名和返回类型，唯一的区别就是输入参数不同——这正好是适配器模式的典型应用场景：把一个接口转换成另一个接口的形式，让原本不兼容的接口可以无缝协同工作。

两种实现思路 #

思路1：定义统一的目标接口（推荐） #

如果想彻底统一调用方式，可以先定义一个新的通用接口，然后分别为两个原有接口写适配器类，把它们适配到这个新接口上。

步骤1：定义统一接口和请求参数类

首先我们需要一个能容纳两种请求参数的类，以及对应的统一接口：

// 封装所有可能的请求参数
public class TypifierRequest
{
    public AccessAddress AccessAddress { get; set; }
    public AddressKey TargetKey { get; set; }
    public string Name { get; set; }
}

// 统一的目标接口
public interface ITypifier
{
    IEnumerable<ProbabilityScore> CalculateProbabilities(TypifierRequest request);
}

步骤2：编写适配器类

接下来分别为两个原有接口写适配器，把它们的调用逻辑包装成ITypifier的形式：

// 适配IPropertyTypifier到ITypifier
public class PropertyTypifierAdapter : ITypifier
{
    private readonly IPropertyTypifier _innerTypifier;

    public PropertyTypifierAdapter(IPropertyTypifier innerTypifier)
    {
        _innerTypifier = innerTypifier;
    }

    public IEnumerable<ProbabilityScore> CalculateProbabilities(TypifierRequest request)
    {
        if (request.AccessAddress == null || request.TargetKey == null)
            throw new ArgumentException("Property typifier requires AccessAddress and TargetKey");
        
        return _innerTypifier.CalculateProbabilities(request.AccessAddress, request.TargetKey);
    }
}

// 适配INameTypifier到ITypifier
public class NameTypifierAdapter : ITypifier
{
    private readonly INameTypifier _innerTypifier;

    public NameTypifierAdapter(INameTypifier innerTypifier)
    {
        _innerTypifier = innerTypifier;
    }

    public IEnumerable<ProbabilityScore> CalculateProbabilities(TypifierRequest request)
    {
        if (string.IsNullOrEmpty(request.Name))
            throw new ArgumentException("Name typifier requires a Name");
        
        return _innerTypifier.CalculateProbabilities(request.Name);
    }
}

步骤3：统一调用

现在你就可以用ITypifier来统一调用两种实现了，不用再区分具体是哪个接口：

// 假设你已有两个接口的实现类
var propertyImpl = new YourPropertyTypifierImpl();
var nameImpl = new YourNameTypifierImpl();

// 包装成统一接口
ITypifier propertyAdapter = new PropertyTypifierAdapter(propertyImpl);
ITypifier nameAdapter = new NameTypifierAdapter(nameImpl);

// 调用时传入对应参数即可
var propertyResult = propertyAdapter.CalculateProbabilities(new TypifierRequest
{
    AccessAddress = new AccessAddress(),
    TargetKey = new AddressKey()
});

var nameResult = nameAdapter.CalculateProbabilities(new TypifierRequest
{
    Name = "Alice Smith"
});

思路2：适配到现有接口之一 #

如果你的代码里已经大量使用了其中一个接口（比如IPropertyTypifier），不想新增接口，也可以直接把另一个接口适配成这个现有接口的形式：

public class NameToPropertyTypifierAdapter : IPropertyTypifier
{
    private readonly INameTypifier _innerTypifier;

    public NameToPropertyTypifierAdapter(INameTypifier innerTypifier)
    {
        _innerTypifier = innerTypifier;
    }

    public IEnumerable<ProbabilityScore> CalculateProbabilities(AccessAddress accessAddress, AddressKey targetKey)
    {
        // 这里根据你的业务逻辑，从传入的参数中提取name，或者做其他转换
        // 比如假设AccessAddress里包含Name字段
        string name = accessAddress?.Name ?? throw new ArgumentException("Could not extract name from AccessAddress");
        return _innerTypifier.CalculateProbabilities(name);
    }
}

这样你就可以在所有原本用IPropertyTypifier的地方，直接传入这个适配器，无缝使用INameTypifier的实现。

适配器模式的好处 #

• 统一调用方式：调用方只需要关心统一的接口，不用处理不同接口的参数差异
• 解耦代码：后续如果新增类似的接口，只需要加一个新的适配器，不用修改现有调用逻辑
• 复用现有实现：完全保留你已有的两个接口的实现代码，不用重新开发逻辑

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