Question

是否有较短版本的IF语句来执行此操作？

if (el.type == ElementType.Type1 || el.type == ElementType.Type2)

Answer 1

您可以使用扩展方法，但这真的会更好吗？

将此内容放在静态类中：

public static bool IsOneOf(this ElementType self, params ElementType[] options)
{
    return options.Contains(self);
}

然后你可以这样做：

if (el.type.IsOneOf(ElementType.Type1, ElementType.Type2)) {

但是，这将比if语句慢 lot ，因为有一个隐式数组初始化后跟一个数组遍历，而不是（最多）两个比较和分支。 / p>

Answer 2

考虑将ElementType定义为

enum ElementType
{
Type1,
Type2,
Type3
}

在这种特殊情况下，您可以写if(el.type<ElementType3) 默认情况下，Type1等于0，Type2等于1，等等

Answer 3

如果你只有2个值，我强烈建议你使用你发布的代码，因为它可能是最具可读性，优雅和快速的代码（恕我直言）。

但如果您有更多这样的案例并且更复杂，您可以考虑使用switch语句：

switch (el.type)
{
    case ElementType.Type1:
    case ElementType.Type2:
    case ElementType.Type3:
        //code here
        break;
    case ElementType.Type4:
    case ElementType.Type5:
        //code here
        break;
    case ElementType.Type6:
        //code here
        break;
}

在if statements中翻译的

将是：

if (el.type == ElementType.Type1 ||
    el.type == ElementType.Type2 ||
    el.type == ElementType.Type3 )
{
    // code here
}else if(el.type == ElementType.Type4 ||
         el.type == ElementType.Type5)
{
    // code here
}else if(el.type == ElementType.Type6)
{
    // code here
}

它们与我完全相同，但switch似乎更具可读性/更清晰，你需要输入更少（即代码长度更短）：）

Answer 4

你可以试试这个：

if(new [] { ElementType.Type1, ElementType.Type2 }.Contains(el.type))

（事实证明，这需要更多的人物）

Answer 5

我猜你是指IN（）子句还是其他一些？不是......好吧，有点......你可以这样做：

if ((new [] { ElementType.Type1, ElementType.Type2}).Contains(el.type)) {...}

但这不会像你现在所做的那样接近高效（或简短）。你也可以

if (el.type == ElementType.Type1 | el.type == ElementType.Type2)

但这不做短路评估，所以你很少想使用那个运算符。我的建议是坚持你所拥有的。

Answer 6

简短的回答是否定的。没有C＃语言构造可以让您组合对象比较。但正如许多人之前提到的那样，创建一个类型的集合可能是创建更短的if语句的最佳选择。然而，这在性能方面做出了相当大的牺牲。我会坚持使用OR声明。

Answer 7

没有更好的方法来优化您的代码。正如其他用户所示，您可以优化if else。

但是我特别想到的一种if语句是

if（X> [Y || Z || A]）

但那不存在，并且不像当前的那样干净（X> Y || X＆gt; Z || X＆gt; A）

（这更像是对Cody Gray的回应）

Answer 8

简而言之：没有任何合理性（在代码可读性和性能优化方面合理）。我也不建议使用三元运算符进行这种比较。

实际if可以缩短为5个字符;）

bool b = (el.type == ElementType.Type1) | (el.type == ElementType.Type2);

if(b){...}

Answer 9

如果这是您的代码中常见的逻辑比较，那么我只会编写一个方法来处理它。

private bool isType1OrType2(ElementType type)
{
    return type == ElementType.Type1 || type == ElementType.Type2;
}

然后你可以做

if(isType1OrType2(el.type))

您也可以将此作为扩展方法，如此

public static bool isType1OrType2(this ElementType type)
{
    return type == ElementType.Type1 || type == ElementType.Type2;
}

所以代码会读得更好

if(el.type.isType1OrType2())

但是你必须有一个静态类，但你可以决定它是否值得。我个人不会写一个方法来收集要比较的类型集合，除非你发现你正在将类型与许多不同的组合进行比较。如果这是你进行这种比较的唯一地方，我甚至根本不打扰更改代码。

Answer 10

我认为没有办法优化你的陈述

Answer 11

不要这样做，除非你有一个有限状态的自动机，否则它是愚蠢和令人困惑的。

enum MyEnum
{
    A,
    B,
    C

}
private readonly Dictionary<MyEnum, Action> _handlers = new Dictionary<MyEnum, Action>
                                                        {
    {MyEnum.A,()=>Console.Out.WriteLine("Foo")},
    {MyEnum.B,()=>Console.Out.WriteLine("Bar")},
    };

public static void ActOn(MyEnum e)
{
    Action handler = null;
    if (_handlers.TryGetValue(e, out handler) && handler != null)
    {
        handler();
    }
}

Answer 12

另一种方法是做一些按位比较，但实际上不值得再次。

    private void ActWithCast(MyEnum e)
    {
        const int interest = (int)MyEnum.A | (int)MyEnum.B;
        if (0 != ((int)e & interest))
        {
            Console.Out.WriteLine("Blam");
        }
    }

Answer 13

如果ElementType是枚举，则有一种更短的方法：

[Flags]
public enum ElementType
{
    Type1 = 1,
    Type2 = 2,
    Type3 = 4,
}
...
tElementType.HasFlag(ElementType.Type1 | ElementType.Type2);

您不需要[Flags]属性来使用HasFlag，但每个属性的值都需要遵循该模式。

C＃ - IF语句的较短版本

13 个答案: