0

我试图根据开闭原则重构一些代码,但在应用设计模式时,我似乎无法正确获得以下类。(对于下面列出的许多课程,我深表歉意——我已经尽可能地减少了它们,但其余的需要向您展示我的设计)。

该设置由以下类组成:

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

已经在这段代码中,我认为有代码气味的迹象。在CreatePortin 中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();

我真的很想不必从 to 做沮丧IPortIInternetPort而只是有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

4

2 回答 2

2

以下是我对您要解决的问题的理解(业务问题,而不是设计问题):

你有一个端口列表,你想在列表上执行一些算法,从列表中选择一个端口(基于特定于算法的一些标准)。

在这里,我将建议一种对此进行建模的方法。我将假设您有以下输入类:

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

    public PortDetails PortDetails { get; set; }
}

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

在这里你有算法的接口:

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

请注意,这个接口模拟了我们要解决的问题。即,给定一个端口列表->我们需要选择一个

这是此类算法接口的实现:

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()));
于 2015-09-18T15:37:31.387 回答
1

我认为有代码气味的迹象。在 PtpPortFactory 的 CreatePort 中,漂亮的事情是它接受 PtpPortDetails(继承自 PortDetails)而不是强制转换。

不,这很好,因为依赖项应该是抽象而不是实现。所以在这种情况下,传递 PortDetails 就可以了。

我看到的气味在这里:

public interface IPort
{
    int Id { get; }
}

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

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

  • 继承描述的是一种关系。
  • 实现一个接口描述了一种可以做的关系。

在这里,您正在处理 AbstractFactory 模式。比方说,您可以拥有BasePortFactory可以执行IPortFactory声明的抽象工厂。所以你应该BasePortFactory从工厂方法返回。但在设计解决方案时,这又是一种选择。

类似地,该CreatePort方法应该根据您是否要使用is-aovercan-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();

PS-这类问题应该问代码审查程序员

于 2015-09-14T17:58:55.720 回答