C # - более короткая версия заявления IF

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, так как существует неявная инициализация массива, за которой следует обход массива, в отличие от (самое большее) двух сравнений и ветвей.

Answer 2

Если у вас есть только 2 значения, я настоятельно рекомендую использовать размещенный вами код, потому что он, вероятно, является наиболее читабельным, элегантным и быстрым из возможных (IMHO).

Но если у вас больше подобных дел и они более сложные, вы можете подумать, что вы используете выражение 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 3

Учтите, что ElementType определен как

enum ElementType
{
Type1,
Type2,
Type3
}

В этом конкретном случае вы можете написать if(el.type<ElementType3) По умолчанию Type1 равен 0, Type2 равен 1 и т. Д.

Answer 4

Если ElementType является перечислением, есть более короткий способ сделать это:

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

Вам не нужен атрибут [Flags], чтобы использовать HasFlag, но значения каждого из них действительно должныследуйте этой схеме.

Answer 5

Другой подход - сделать побитовое сравнение, но на самом деле оно того не стоит.

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

Answer 6

Не делайте этого, это глупо и сбивает с толку, если у вас нет конечного автомата.

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 7

я не думаю, что есть способ оптимизировать ваше утверждение

Answer 8

Если это обычное логическое сравнение в вашем коде, которое часто появляется, я бы просто написал метод для его обработки.

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 9

Короче говоря: ничего разумного (разумного с точки зрения читабельности кода и оптимизации производительности).Я бы не рекомендовал троичный оператор для такого сравнения.

Фактическое значение if можно сократить до 5 символов;)

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

if(b){...}

Answer 10

Нет лучшего способа оптимизировать ваш код. Как показали другие пользователи, вы можете оптимизировать if else.

Но тип выражения if, о котором я думал, особенно в вашем случае, будет

если (X> [Y || Z || A])

Но этого не существует, и оно не такое чистое, как текущее, если (X> Y || X> Z || X> A)

(Это скорее ответ Коди Грей)