Question

例如，我有这样的界面......

public interface IInterface1
{
    bool CheckSomething(Object a, Object b);
}

CheckSomething（）方法可能有1000个不同的实现，它们需要使用不同的参数调用不同的私有方法（在抽象基础实现上），具体取决于特定的实现。

public abstract BaseClass1 : IInterface1
{
    public abstract CheckSomething(Object a, Object b);

    protected bool CheckA()
    {
        //Do work etc.
    }

    protected bool CheckB()
    {
        //Do work etc.
    }

    protected bool CheckC()
    {
        //Do work etc.
    }
}

//One of 1000 implementations
public class ImplementedClass1 : BaseClass1
{
    public bool CheckSomething(Object a, Object b);
    {
        return base.CheckA() && base.CheckC();
    }
}

//Two of 1000 implementations
public class ImplementedClass2 : BaseClass1
{
    public bool CheckSomething(Object a, Object b);
    {
        return base.CheckB() && !base.CheckC();
    }
}

我看过使用工厂模式，但是在一个类中有1000多个具体实现，更不用说一个相当疯狂的案例陈述似乎不太合理。

在不必创建1000多个具体类的情况下，实现此接口1000多次的最有效方法是什么？

此问题的更具体版本：

我有一个外部定义的界面：

public interface ICarChecker
{
    bool IsMatch(Car carA, Car carB);
}

Car类中有许多属性需要进行比较（有时以不同的方式对同一属性进行比较），具体取决于传递给IsMatch方法的汽车类型。

public class Car
{
    public string Name { get; set; }
    public string Colour { get; set; }
    public string Model { get; set; }
}

假设我们有3个车名（假设可能有1000多个），“Saloon”，“两厢车”，“房产”......如果传入的类型是“Saloon”，我们会说只想比较颜色。但是，如果传入的类型是“Hatchback”，我们想要比较模型上的颜色和精确的字符串匹配。如果它是“Estate”，我们想要比较Color和Model，但是在尝试比较它之前在Model上执行一些字符串操作（假设只是反转参数的字符串）。

我的第一个想法是创建某种CarCheckerFactory，例如。：

public class CarCheckerFactory
{
    public ICarChecker GetCarChecker(string name)
    {
        switch (name)
            case "Saloon":
               return new SaloonCarChecker();
            case ...
    }
}

public class HatchbackCarChecker : ICarChecker
{
    IColourChecker ColourChecker = new ColourChecker();
    IModelChecker ModelChecker = new ModelChecker();

    public bool IsMatch(Car carA, Car carB);
    {
        return this.ColourChecker.IsMatch(carA, carB) && this.ModelChecker.IsMatch(carA, carB);
    }
}

public class EstateCarChecker : ICarChecker
{
    IColourChecker ColourChecker = new ColourChecker();
    IModelChecker ModelChecker = new ReverseModelChecker();

    public bool IsMatch(Car carA, Car carB);
    {
        return this.ColourChecker.IsMatch(carA, carB) && this.ModelChecker.IsMatch(carA, carB);
    }
}

但这当然需要创建每种类型的具体实现来定义正确的属性“Checker”定义，因此不适合1000多种变体。

所以问题是如何以不需要1000多个具体实现的方式设计这个解决方案？

这是一个编码练习，而不是真实世界的场景，因此需求定义相对模糊。

Answer 1

创建1000个具体类几乎肯定不是正确的解决方案。为什么需要类来表示这些不同的模式？为什么要使用实现检查器的类的实例，或者只使用Func<object, object, bool>。将问题分开。

假设您有一个ICheckable接口CheckA()，CheckB()，Func<ICheckable, ICheckable, bool>，...用于要检查的对象。

您可以将所有不同的检查表示为public static readonly Func<ICheckable, ICheckable, bool> Class1Checker = (a, b) => a.CheckA() && b.CheckB(); public static readonly Func<ICheckable, ICheckable, bool> Class2Checker = (a, b) => a.CheckB() && b.CheckC();的实例：

object

很难给出一个更精确的答案，因为这个问题有点不清楚，但希望你理解使用实例而不是1000个具体类的概念。

我还会质疑为什么使用{{1}}而不是使用泛型来找到解决方案。

实现具有1000多个具体实现的接口的最合适的设计模式是什么？

1 个答案: