设计模式:基于输入参数选择任意功能,无需使用大型switch/if语句

这是我刚才谈到的OO方法,但根据您对我的评论,我不确定它是否满足您的需求。

第一个a Size 类,该类表示一个大小可能具有的所有属性(显然,这只是一个示例):

enum UnitOfMeasure
{
    Inches, Feet, Yards, Centimeters, Meters
}

class Size
{
    public int Length { get; set; }
    public int Width { get; set; }
    public int Height { get; set; }
    public int Depth { get; set; }
    public UnitOfMeasure Units { get; set; }
}

您可以创建一个转换类,该类对于转换可能很方便 200 inches 一个合适的字符串 16'8" :

static class Convert
{
    public static string ToFeetAndInches(int inches)
    {
        var feet = inches / 12;
        var remainingInches = inches % 12;

        var footStr = feet > 0 ? $"{feet}'" : "";
        var inchStr = remainingInches > 0 ? $"{remainingInches}\"" : "";

        return footStr + inchStr;
    }

    public static string ToMetersAndCentimeters(int centimeters)
    {
        var meters = centimeters / 10;
        var remainingCm = centimeters % 10;

        var meterStr = meters > 0 ? $"{meters}m " : "";
        var centimeterStr = remainingCm > 0 ? $"{remainingCm}cm" : "";

        return meterStr + centimeterStr;
    }
}

然后是一个“Kingdom”类,它以默认方式显示大小:

class Decor
{
    public Size Size { get; set; }

    public string GetSize()
    {
        switch (Size.Units)
        {
            case UnitOfMeasure.Inches:
                return string.Format("{0} x {1} x {2}",
                    Convert.ToFeetAndInches(Size.Width),
                    Convert.ToFeetAndInches(Size.Length),
                    Convert.ToFeetAndInches(Size.Height));
            case UnitOfMeasure.Feet:
                return $"{Size.Width}' x {Size.Length}' x {Size.Height}'";
            case UnitOfMeasure.Centimeters:
                return string.Format("{0} x {1} x {2}",
                    Convert.ToMetersAndCentimeters(Size.Width),
                    Convert.ToMetersAndCentimeters(Size.Length),
                    Convert.ToMetersAndCentimeters(Size.Height));
            case UnitOfMeasure.Meters:
                return $"{Size.Width}m x {Size.Length}m x {Size.Height}m";
        }

        return $"{Size.Width} x {Size.Length} x {Size.Height}";
    }
}

两个“家族”类,一个继承了王国版本的 GetSize 另一个是用自己的实现来隐藏它:

class Lamp : Decor
{
}

class Rug : Decor
{
    public new string GetSize()
    {
        var baseSize = base.GetSize();
        var lastX = baseSize.LastIndexOf("x");
        return baseSize.Substring(0, lastX - 1).Trim();  // Only show Width and Length
    }
}

然后是一个“物种”类 Family 实施:

class Chandelier : Lamp
{
    public new string GetSize()
    {
        var baseSize = base.GetSize();
        return baseSize.Split('x')[1].Trim();  // Only show the length
    }
}

这是一个如何以不同方式显示其大小的示例(即使使用相同的 大小 对象)看起来像:

static void Main()
{
    var genericSize = new Size
    {
        Width = 20,
        Height = 30,
        Length = 40,
        Units = UnitOfMeasure.Inches
    };

    var brassLamp = new Lamp { Size = genericSize };
    var glassChandelier = new Chandelier { Size = genericSize };
    var plushRug = new Rug { Size = genericSize };

    Console.WriteLine($"Brass lamp: {brassLamp.GetSize()}");
    Console.WriteLine($"Chandelier: {glassChandelier.GetSize()}");
    Console.WriteLine($"Plush Rug: {plushRug.GetSize()}");

    Console.WriteLine("\nDone!\nPress any key to exit...");
    Console.ReadKey();
}

输出

战略模式在这里很有用。为不同的计算方法创建策略,并根据给定的 王国 ,则, 家庭 和 种 。

首先创建一个接口来定义 GetSize 方法

public interface ISizeCalculator
{
    string GetSize(int width, int length, int height);
}

然后确定您需要的不同计算方法,并为每种方法创建单独的类。给这些类一些自解释的名称。

public class ASimpleCalculation : ISizeCalculator
{
    public string GetSize(int width, int length, int height)
    {
        return string.Format("{0} x {1} x {2}", width, length, height);
    }
}

public class AnotherCalculation : ISizeCalculator
{
    public string GetSize(int width, int length, int height)
    {
        return (width * length * height).ToString();
    }
}

...
...

然后根据给定的王国/家族/物种值指定适当的类实例。你不必为王国/家族/物种的每一个组合创造条件。创建默认计算,并仅为需要特殊计算的对象创建条件。

public class TestClass
{
    public void Test(string kingdom, string family, string species)
    {
        ISizeCalculator calculator = null;
        if (kingdom == "A")
        {
            calculator = new ASimpleCalculation();
        }
        else if (kingdom == "B" && family == "123")
        {
            calculator = new AnotherCalculation();
        }
        else if (new string[] { "X", "Y", "Z" }.Contains(species))
        {
            calculator = new ASimpleCalculation();
        }
        // add more criteria as per your requirements
        else
        {
            calculator = new DefaultCalculation();
        }
        string result = calculator.GetSize(1, 2, 3);
    }
}

我看不到使用 if else 这是本案的一个问题。其他替代方案可能会降低代码的可读性或导致性能问题。

首先,我同意你的观点,你正在某个地方走到尽头。

你说过

所有产品略有不同。例如,的大小 家具通常为

你举了很多例子 不同的算法 它们都做同样的事情,那就是计算大小。解决这类问题所需的只是使用 Size 方法或者可能是一种装饰图案,具体取决于您的实际需要。解决这种问题不需要分类学或层次关系。所以我觉得剩下的问题是事情偏离了轨道。

OO并不能解决所有问题。建议阅读: https://www.sicpers.info/2018/03/why-inheritance-never-made-any-sense/

总之,是否有一种将任意复杂类型连接到正确功能的设计模式?一个适配器,连接器,其他一些我可以抛出的OOP?

是的,但它需要将类型映射到功能,这似乎是您希望通过一些神奇的模式来避免的。没有,如果您要将某些特定功能添加到具体类型,那么您必须在某个地方说什么功能与什么类型匹配。。。你打算如何避免这种情况?

您完全放弃的另一个选项:

我不需要使用多态性/继承

就是让每个对象都知道如何做自己的事情。如果这不是一个选项,那么您必须使用某种映射基础架构。