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

本文关键字:实现 接口 设计模式 1000 什么 | 更新日期: 2023-09-27 18:28:55

例如,我有一个这样的接口。。。

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多个具体实现,更不用说一个相当疯狂的case语句了,似乎并不太明智。

在不必创建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; }
}

假设我们有三个汽车名称(假设可能有1000+),"Saloon","Hatchback","Estate"。。。如果传入的类型是"沙龙",我们会说只想比较颜色。然而,如果传入的类型是"Hatchback",我们需要比较Model上的颜色和字符串的精确匹配。如果是"Estate",我们会想比较Colour和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多个具体实现?

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

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

创建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();

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

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