c# - 什么是最适合实现具有 1000 多个具体实现的接口(interface)的设计模式？

Question

关闭。这个问题需要details or clarity .它目前不接受答案。












想改进这个问题？通过 editing this post 添加详细信息并澄清问题.

7年前关闭。




Improve this question




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

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

CheckSomething() 方法可能有 1000 种不同的实现，它们需要根据特定实现使用不同的参数调用不同的私有(private)方法(在抽象基础实现上)。

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 多个具体类的情况下实现此接口(interface) 1000 多次的最有效方法是什么？

这个问题的更具体的版本:

我有一个外部定义的接口(interface):

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

根据传递给 IsMatch 方法的汽车类型，需要比较 Car 类上的许多属性(有时对于同一属性以不同的方式进行比较)。

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

假设我们有 3 个汽车名称(假设可能有 1000+)，“轿车”，“掀背车”，“庄园”......如果传入的类型是“轿车”，我们会说只想比较颜色。但是，如果传入的类型是“Hatchback”，我们想要比较颜色和模型上的精确字符串匹配。如果它是“Estate”，我们想要比较颜色和模型，但在尝试比较之前对模型执行一些字符串操作(假设只是反转参数的字符串)。

我的第一个想法是创建某种 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);
    }
}

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

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

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

Answer 1

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

假设您有一个接口(interface) 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();

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

我还想问你为什么使用 object而不是使用泛型找到解决方案。