Question

我已经阅读了规范模式的一些示例，但很难理解如何使用此模式实现。

我正在为客户开发一个庞大的程序。我需要从特定的银行导入XML文件，然后对每个文件进行验证。分类帐代码有不同的方法（subs，bo，rcc）。因此，当文件读取SUBS时，它应该发送到SUBS方法。

此处示例：

接口

BlackBank
BlueBank
雷德班克

分类帐代码：

SUBS
BO
RCC

结果：

BlackBank有SUBS，BO和RCC
BlueBank有SUBS
RedBank有BO和RCC

您能否提供一些示例代码或指出正确的方向？

Answer 1

如果没有上下文，这很难回答，所以我会尝试围绕我的信息做些事情，希望它会给你一个想法。

创建一个简单的规范界面，如此

interface ISpecification<T>
{
    IsSatisfiedBy(T obj);
}

假装你有'银行'的基本界面，看起来像

interface IBank
{
    LedgerCode LedgerCode { get; set; }
}

LedgerCodes的枚举

[Flags]
enum LedgerCodes
{
    SUBS, BO, RCC
}

您可以制作一个简单的分类帐代码规范来检查IBank的LedgerCodes（这是非常通用的，您需要根据您的需要进行定制）

class LedgerCodeSpec : ISpecification<IBank>
{
    private LedgerCode code;

    public LedgerCodeSpecification(LedgerCode code)
    {
        this.code = code
    }

    public override bool IsSatisfiedBy(IBank obj)
    {
        return obj.LedgerCode == code;
    }
}

在适当的情况下，您可以使用您的规范，在这里我使用它来提供简单的验证。另一种用途是'选择'，例如从存储库中获取数据

class Bank : IBank
{
    private ISpecification<IBank> spec;
    private LedgerCode code;

    public Bank(ISepcification<IBank> spec)
    {
        this.code = code;
        this.spec = spec;
    }

    public LedgerCode LedgerCode { get; set; }

    public bool IsValid 
    { 
        get
        {
            return spec.IsSatisfiedBy(this);
        }
    } 
}

最后一些代码可以快速测试/演示上面的

class Main
{
    public static void Main()
    {
        var spec = new LedgerCodeSpec(LedgerCodes.SUB)
        var blueBank = new Bank(spec);

        Console.WriteLine(blueBank.IsValid); // false

        blueBank.LedgerCode = LedgerCodes.RCC | LedgerCodes.SUB;

        Console.WriteLine(blueBank.IsValid); // false

        blueBank.LedgerCode = LedgerCodes.SUB;

        Console.WriteLine(blueBank.IsValid); // true
    }
}

网上有一些很好的例子，可以添加扩展方法，也可以覆盖运算符，以提供简洁易懂的自然可读规范，例如。

class MessageSpecification : Specification<string>
{
    public const int MIN_LENGTH = 5;
    public const int MAX_LENGTH = 60;

    public override bool IsSatisfiedBy(string s)
    {
        Specification<string> length = new LengthSpecification(MIN_LENGTH, MAX_LENGTH);
        Specification<string> isNull = new IsNullSpecification<string>();

        Specification<string> spec = length && !isNull;

        return spec.IsSatisfiedBy(s);
    }
}

我目前使用该模式的方式可能有些过分，但我喜欢删除，重用和通常使逻辑更加OO的想法。

编辑：在阅读了一些评论之后，您的问题似乎与一般的调度问题更相关，而不是规范模式。鉴于你的界面，你可以更简单地做。

class BankFacade
{
    public Send(IBlueBank bank)
    {
        // validate with specification
        // do stuff with IBlueBank
    }

    public Send(IRedBank bank)
    {
        // validate with specification
        // do stuff with IRedBank
    }

    //...
}

再多想一想，你可以按照

的方式做点什么

class Parser
{
    static class RedBankSpecification : ISpecification<XElement>
    {
        public override bool IsSatisfiedBy(XElement element)
        {
            return element.Value.equals("RED");
        }
    }

    public void Parse(XDocument doc)
    {
        var rspec = new RedBankSpecification();

        foreach(XElement e in doc)
        {
            if (r.IsSatisfiedBy(e))
            {
                IRedBank bank = new RedBank(e);
                bankFacade.Send(bank);
            }
        }

        //...
    }
}

然而你可能并不真的需要这种模式而且你不会试图将这个问题麻醉到其中

如何根据我的要求使用规范模式？

1 个答案: