Question

我试图根据开放原则重构一些代码，但在应用设计模式时，我似乎无法获得以下类。（我为下面列出的许多课程道歉 - 我尽可能地减少了它们，但剩下的就是向你展示我的设计了。）

该设置包含以下类：

public interface IPortFactory
{
    IPort CreatePort(int id, PortDetails details);
}

public class PtpPortFactory : IPortFactory
{
    public IPort CreatePort(int id, PortDetails details)
    {
        var ptpPortDetails = details as PtpPortDetails;
        if (ptpPortDetails == null)
        {
            throw new ArgumentException("Port details does not match ptp ports", "details");
        }

        return new PtpPort(id, FiberCapability.FromValue(ptpPortDetails.Capability));
    }
}

public interface IPort
{
    int Id { get; }
}

public interface IInternetPort : IPort
{
    bool OfCapability(FiberCapability capability);
}

public class PtpPort : IInternetPort
{
    private readonly FiberCapability _capability;

    public PtpPort(int id, FiberCapability capability)
    {
        _capability = capability;
        Id = id;
    }

    public int Id { get; private set; }

    public bool OfCapability(FiberCapability capability)
    {
        return capability.Equals(_capability);
    }
}

除了PtpPort之外，我还有PonPort，它还实现了IInternetPort，而CatvPort只是实现了IPort。

在此代码中，我认为有代码异味的迹象。在CreatePort PtpPortFactory中，美妙的做法就是接受PtpPortDetails（继承自PortDetails）而不必投出。但是，如果我这样做，我就无法创建PonPortFactory，这也会实现IPortFactory，因为这些端口需要PonPortDetails。或者问CatvPortFactory。

当我使用端口工厂时，会出现另一个代码异味：

PortType portType = command.PortType;
IPortFactory portFactory = portType.GetPortFactory();
var portsToSelectFrom = ports.Select(port => (IInternetPort) portFactory.CreatePort(port.Id, port.PortDetails)).ToList();

我真的不想从IPort到IInternetPort进行向下转播，只需让CreatePort返回IInternetPort。

理解上述内容所需的最后一点信息可能是以下类（基于Jimmy Bogards Enumeration类）：

public abstract class PortType : Enumeration<PortType, int>
{
    public static readonly PortType Ptp = new PtpPortType();
    public static readonly PortType Pon = new PonPortType();
    public static readonly PortType Catv = new CatvPortType();

    protected PortType(int value, string description)
        : base(value, description) { }

    public abstract IPortFactory GetPortFactory();

    private class CatvPortType : PortType
    {
        public CatvPortType() : base(2, "catv") { }

        public override IPortFactory GetPortFactory()
        {
            return new CatvPortFactory();
        }
    }

    private class PonPortType : PortType
    {
        public PonPortType() : base(1, "pon") { }

        public override IPortFactory GetPortFactory()
        {
            throw new NotImplementedException("Pon ports are not supported");
        }
    }

    private class PtpPortType : PortType
    {
        public PtpPortType() : base(0, "ptp") { }

        public override IPortFactory GetPortFactory()
        {
            return new PtpPortFactory();
        }
    }
}

我真的希望有人可以帮助我（我尝试引入泛型，但似乎总是遇到C＃的障碍，不支持返回类型的协方差）。

此外，我非常感谢任何其他提示和技巧，以帮助我编写更好的代码。

更新

由于评论请求，我在下面添加了更多代码。

public Port Handle(TakeInternetPortCommand command)
{
    var portLocatorService = new PortLocatorService();
    IList<Port> availablePorts = portLocatorService.FindAvailablePorts(command.Pop, command.PortType);

    PortType portType = command.PortType;
    IPortFactory portFactory = portType.GetPortFactory();
    var portsToSelectFrom = ports.Select(port => (IInternetPort) portFactory.CreatePort(port.Id, port.PortDetails)).ToList();

    IPort port = _algorithm.RunOn(portsToSelectFrom);
    Port chosenPort = availablePorts.First(p => p.Id == port.Id);
    chosenPort.Take(command.Spir);
    _portRepository.Add(chosenPort);
    return chosenPort;
}

不要因为突然间还有Port类型这一事实而感到困惑。这是另一个有界背景中的聚合（在DDD意义上）。算法需要将IInternetPort列表作为输入，因为它在内部使用方法OfCapability来选择端口。但是，当算法选择了正确的端口时，我们只对Id感兴趣，因此返回类型只是IPort。

Answer 1

以下是我如何理解您要解决的问题（业务问题，而不是设计问题）：

您有一个端口列表，您希望在列表中执行一些算法，从列表中选择一个端口（基于某些特定于该算法的标准）。

在这里，我将建议一种模拟方法。我将假设您有以下输入类：

public class PortInput
{
    public int Id { get; set; }

    public PortDetails PortDetails { get; set; }
}

这对应于您问题中Port部分的一部分。

在这里你有算法的接口：

public interface IPortSelectionAlgorithm
{
    int SelectPort(PortInput[] port_inputs);
}

请注意，此界面会模拟我们要解决的问题。即，给出一个端口列表 - ＆gt;我们需要选择一个

以下是此类算法接口的实现：

public class PortSelectionAlgorithm : IPortSelectionAlgorithm
{
    private readonly ICapabilityService<PortDetails> m_CapabilityService;

    public PortSelectionAlgorithm(ICapabilityService<PortDetails> capability_service)
    {
        m_CapabilityService = capability_service;
    }

    public int SelectPort(PortInput[] port_inputs)
    {
        //Here you can use m_CapabilityService to know if a specific port has specific capability

        ...
    }
}

此实现声明的是，它需要一些知道如何根据端口详细信息获取端口功能的服务。以下是此类服务合同的定义：

public interface ICapabilityService<TDetails> where TDetails : PortDetails
{
    bool OfCapability(TDetails port_details, FiberCapability capability);
}

对于每种端口类型，我们可以创建此类服务的实现，如下所示：

public class PtpPortCapabilityService: ICapabilityService<PtpPortDetails>
{
    public bool OfCapability(PtpPortDetails port_details, FiberCapability capability)
    {
        ...
    }
}

public class CatvPortCapabilityService : ICapabilityService<CatvPortDetails>
{
    public bool OfCapability(CatvPortDetails port_details, FiberCapability capability)
    {
        ...
    }
}

public class PonPortCapabilityService : ICapabilityService<PonPortDetails>
{
    public bool OfCapability(PonPortDetails port_details, FiberCapability capability)
    {
        //If such kind of port does not have any capability, simply return false
        ...
    }
}

然后，我们可以创建另一个使用这些单独服务的实现，以便能够告诉任何端口的功能：

public class PortCapabilityService : ICapabilityService<PortDetails>
{
    private readonly ICapabilityService<PtpPortDetails> m_PtpPortCapabilityService;
    private readonly ICapabilityService<CatvPortDetails> m_CatvPortCapabilityService;
    private readonly ICapabilityService<PonPortDetails> m_PonPortCapabilityService;

    public PortCapabilityService(ICapabilityService<PtpPortDetails> ptp_port_capability_service, ICapabilityService<CatvPortDetails> catv_port_capability_service, ICapabilityService<PonPortDetails> pon_port_capability_service)
    {
        m_PtpPortCapabilityService = ptp_port_capability_service;
        m_CatvPortCapabilityService = catv_port_capability_service;
        m_PonPortCapabilityService = pon_port_capability_service;
    }

    public bool OfCapability(PortDetails port_details, FiberCapability capability)
    {
        PtpPortDetails ptp_port_details = port_details as PtpPortDetails;

        if (ptp_port_details != null)
            return m_PtpPortCapabilityService.OfCapability(ptp_port_details, capability);

        CatvPortDetails catv_port_details = port_details as CatvPortDetails;

        if (catv_port_details != null)
            return m_CatvPortCapabilityService.OfCapability(catv_port_details, capability);

        PonPortDetails pon_port_details = port_details as PonPortDetails;

        if (pon_port_details != null)
            return m_PonPortCapabilityService.OfCapability(pon_port_details, capability);

        throw new Exception("Unknown port type");
    }
}

如您所见，除了算法类之外，没有类知道端口ID。确定功能的类不知道端口ID，因为没有它们就可以完成它们的工作。

另一件需要注意的事情是，每次运行算法时都不需要实例化新的功能服务。这与您的问题中描述的IInternetPort实现形成对比，每次您想要执行算法时都会创建一个新实例。我猜你这样做是因为每个实例都绑定了不同的ID。

这些类使用依赖注入。您应该将它们组合起来以便能够使用它们。您应该在Composition Root。

中执行此操作

以下是如何使用Pure DI进行此类合成的方法：

IPortSelectionAlgorithm algorithm =
    new PortSelectionAlgorithm(
        new PortCapabilityService(
            new PtpPortCapabilityService(),
            new CatvPortCapabilityService(),
            new PonPortCapabilityService()));

Answer 2

我认为有代码味道的迹象。在PtpPortFactory中的CreatePort中，美妙的做法是接受PtpPortDetails（继承自PortDetails）而不必进行强制转换。

不，它很好，因为依赖应该是在absctration而不是实现。所以在这种情况下传递PortDetails很好。

我看到的气味在这里：

public interface IPort
{
    int Id { get; }
}

public interface IInternetPort : IPort
{
    bool OfCapability(FiberCapability capability);
}

接口基本上用于定义行为。您在接口中使用属性看起来很可疑。

继承描述 is-a 关系。
实现接口描述 can-do 关系。

您在这里处理AbstractFactory模式。假设您可以使用抽象工厂BasePortFactory来执行IPortFactory声明的工作。所以你应该从工厂方法返回BasePortFactory。但在设计解决方案时，它又是一个重要选择。

类似于CreatePort方法应该根据is-a使用can-do的内容来公开基类或接口的返回类型。

<强>更新

此示例不适合您的方案，但这是为了描述我分享的想法：

public interface IInternetPort
{
    bool OfCapability(FiberCapability capability);
}

/// <summary>
/// This class can be a replacement of (IPort) interface. Each port is enabled for query via IInternetPort.
/// As a default behavior every port is not Internet enabled so OfCapability would return false.
/// Note: If you want you can still keep the IPort interface as Marker interface. 
/// /// </summary>
public abstract class Port : IInternetPort
{
    public int Id { get; private set; }

    public Port(int Id)
    {
        this.Id = Id;
    }

    public virtual bool OfCapability(FiberCapability capability)
    {
        // Default port is not internet capable
        return false; 
    }
}

/// <summary>
/// This class is-a <see cref="Port"/> and can provide capability checker.
/// Overiding the behavior of base for "OfCapability" would enable this port for internet.
/// </summary>
public class PtpPort : Port
{
    private readonly FiberCapability _capability;

    public PtpPort(int id, FiberCapability capability) : base(id)
    {
        _capability = capability;
    }

    public override bool OfCapability(FiberCapability capability)
    {
        return capability.Equals(_capability);
    }
}

/// <summary>
/// this test class doesn't need to implement or override OfCapability method
/// still it will be act like any other port.
/// | TestPort port = new TestPort(22);
/// | port.OfCapability(capability);
/// </summary>
public class TestPort : Port
{
    public TestPort(int id): base(id) { }
}

这里的工厂需要更改方法的签名以返回Port而不是IPort。

public interface IPortFactory
{
    Port CreatePort(int id, PortDetails details);
}

public class PtpPortFactory : IPortFactory
{
    public Port CreatePort(int id, PortDetails details)
    {
        var ptpPortDetails = details as PtpPortDetails;
        if (ptpPortDetails == null)
        {
            throw new ArgumentException("Port details does not match ptp ports", "details");
        }

        return new PtpPort(id, FiberCapability.FromValue(ptpPortDetails.Capability));
    }
}

现在这条线不需要任何外部演员。

var portsToSelectFrom = ports.Select(port => portFactory.CreatePort(port.Id, port.PortDetails)).ToList();

P.S。 - 应在code review或programmer上询问这类问题。

工厂模式，开放封闭原则，接口和泛型

更新

2 个答案: