компактное выражение C # для нескольких последовательных не вложенных разрывных if

Question

В настоящее время у меня есть

if A {
    //code
    return;
}
if B {
    //code
    return;
}
...

Есть ли простой способ выразить это для большого числа условий?

Цель в этом случае - проверка того, что может потерпеть неудачу в разныхспособы, которые требуют разной обработки.
Затем я ожидаю, что этот блок кода будет вызван снова позже, когда любое условие, которое только что было разрешено, не будет выполнено, и оно будет проходить через тесты, пока не выполнит другое условие и не будет отклонено вновый и захватывающий способ.

Я действительно просто надеялся на что-то на уровне оператора switch (с точки зрения простоты и простоты использования), но я думаю, что этого не существует ...

Answer 1

Возможно, но действительно сложно руководить вами, не зная больше о типах условий, которые у вас есть, и о том, что делает код в каждом из них ... если есть сходства, вы, вероятно, можете найти способы абстрагировать их вместо повторенияих (используя операторы 'switch', делегаты и т. д.).Если эти вещи абсолютно не связаны, это не станет лучше, чем вы показали - за исключением того, что вы поменяете последнее 'if' на 'else if', а затем поместите один 'return' в самом конце.

Answer 2

Если ваши условия проверяют одно и то же значение на равенство с другими значениями, вы можете использовать оператор switch . Обратите внимание, что в C #, в отличие от C ++ или Java, вы можете использовать строку в качестве значения переключателя.

Вы можете использовать оператор ?: , но только если ваш «код» может быть выражен как одно выражение, и все они возвращают один и тот же тип. Так, например,

var user = conditionA ? expressionA :
           conditionB ? expressionB :
           conditionC ? expressionC;

Вероятно, это помогло бы большинству, хотя, если бы вы сказали, какова ваша настоящая проблема. Возможно, более чистый подход был бы возможен с помощью полиморфизма, поиска в массиве / словаре и т. Д.

Answer 3

Вы можете использовать класс, который наследует абстрактный базовый класс ConditionalAction, который может выглядеть следующим образом:

public abstract class ConditionalAction
{
    public abstract bool Condition();
    public abstract void Action();
}

Пример класса, который наследует ConditionalAction:

public class SampleConditionalAction : ConditionalAction
{
    public override bool Condition()
    {
        // Condition
    }
    public override void Action()
    {
        // Code
    }
}

Пример реализации:

List<ConditionalAction> conditionalActions = new List<ConditionalAction>();
conditionalActions.Add(new SampleConditionalAction());
// Add more ConditionalActions...

foreach(ConditionalAction conditionalAction in conditionalActions)
{
    if (conditionalAction.Condition())
        conditionalAction.Action();
}

Главное место, где вы застряли бы с этим подходом, - это если вам нужна информация для ваших условий или ваших действий, но вы можете встроить ее, передав параметры вашим конструкторам вашихConditionalActions.

Answer 4

Это зависит от условий, кода и дизайна компонента.

Например, если это класс конфигурации, в котором хранится множество настроек, у меня не возникнет проблем с вышеуказанным.И наоборот, если это определяет или контролирует пути выполнения в вашем приложении, то это может указывать на недостаток дизайна.Многие условные выражения или операторы switch могут быть реорганизованы, например, с использованием наследования или внедрения зависимостей.

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

Answer 5

Вы можете создать Dictionary<Func<bool>, Action>.Ключи будут условиями (каждое из них bool Method()), а значения будут частями кода для выполнения.

Затем вы можете легко перебирать ключи, которые соответствуют кодификации, и выполнять их значения:

foreach (pair in dictionary.Where(pair => pair.Key()))
{
    pair.Value();
}