Question

我有两个变量（基本上四个=>每个变换的旧/当前变量）。所有这些都可以是＆＃34; ABCDXFG＆＃34;或＆＃34;：ABCDXFG＆＃34; （基本上是级别名称）和＆＃34; hub＆＃34;。

如果级别名称不相等，我有一个if else语句返回true，但我需要hub的例外（现在它真的很长）加上另外4个级别!!!

if (current.LevelSecond != old.LevelSecond && 
    current.LevelSecond != old.LevelFirst && 
    current.LevelFirst != "HUB" && 
    old.LevelFirst != "HUB" && 
    current.LevelSecond != "HUB" && 
    old.LevelSecond != "HUB")
        return true;

else if (current.LevelFirst == "HUB" || 
         old.LevelFirst == "HUB" || 
         current.LevelSecond == "HUB" || 
         old.LevelSecond == "HUB")
            return false;

这看起来非常恶心，因为我没有经验，所以我不知道如何尽可能提高效率。如果我添加这4个级别，语句的长度将会翻两倍......

请帮忙！：（

Answer 1

一种可能性是将此检测功能的一部分推送到您的类中，这应该简化您当前正在编写的代码，如果在其他地方重复使用，可能会减少其他代码：

class Item
{
    public const string Hub = "HUB";
    public string LevelFirst { get; set; }
    public string LevelSecond { get; set; }

    public bool HasCommonLevelWith(Item other)
    {
        if (other == null || ContainsAHub() || other.ContainsAHub())
        {
            return false;
        }

        return
            LevelFirst.Equals(other.LevelFirst, StringComparison.OrdinalIgnoreCase) ||
            LevelSecond.Equals(other.LevelSecond, StringComparison.OrdinalIgnoreCase);
    }

    public bool ContainsAHub()
    {
        return LevelFirst.Equals(Hub, StringComparison.OrdinalIgnoreCase) ||
               LevelSecond.Equals(Hub, StringComparison.OrdinalIgnoreCase);
    }
}

然后你之前写的代码看起来像：

return current.HasCommonLevelWith(old);

Answer 2

您可以使用以下方法：使用简单数据结构的集合来保存旧和当前级别值：

class Level
{
    public string Current { get; set; }
    public string Old { get; set; }
}

class Program
{

    static bool CompareLevels(ICollection<Level> levels)
    {
        foreach (var item in levels)
        {
            // Either of any level is HUB => false
            if ((item.Current == "HUB") || (item.Old == "HUB"))
                return false;

            // Any Old level == any Current level => false
            if (levels.Any(level => level.Old == item.Current))
                return false;
        }

        // All levels met the criteria (no exceptions/failures)
        return true;
    }


    // A simple console program to exercise the above function:

    static void Main(string[] args)
    {
        // Should return false if any Old or Current levels are HUB
        var levels = new List<Level>
        {
            new Level { Current = "HUB", Old = "ABCDEF" },
            new Level { Current = "DEFGHI", Old = "HUB" }
        };
        Console.WriteLine(CompareLevels(levels));

        // Should return true if all Old levels != any Current level and none are "HUB"
        levels = new List<Level>
        {
            new Level { Current = "ABC123", Old = "ABCDEF" },
            new Level { Current = "DEFGHI", Old = "DEF456" }
        };
        Console.WriteLine(CompareLevels(levels));

        // Should return false if any Old level == any Current level
        levels = new List<Level>
        {
            new Level { Current = "ABC123", Old = "ABCDEF" },
            new Level { Current = "DEFGHI", Old = "ABC123" }
        };
        Console.WriteLine(CompareLevels(levels));

        Console.ReadLine();
    }
}

级别集合的迭代将在第一个失败条件下终止，因此不会浪费地遍历整个集合。完全枚举集合的唯一条件是没有失败时。

这可能不是最有效的，但是对于您指示涉及的级别数量，此处的优化将会非常小。它还要求您初始化一个集合以保存要比较的级别。

然而，它确实具有适应任何数量的水平的优势。和（imho）使比较标准非常清晰易懂。

注意：在C＃中使用==比较字符串值没有问题，除了需要考虑文化和案例变体等时{.1}}字符串将比较所涉及的字符串的值。

如何在C＃中有效地比较两组字符串？

2 个答案: