Почему бы не форсировать явный провал, а не явный разрыв для операторов switch?

Обоснование операторов C# switch заключается в том, что поведение C заключается в том, что случаи проваливаются, если вы явно не выйдете с оператором, таким как break, return или goto. Это означает, что все, кто знаком с C (а это, вероятно, большинство программистов на C#), будут ожидать, что синтаксис C# switch будет означать примерно то же самое. Если бы разработчики C# сделали так, чтобы случаи не не выпадали, код работал бы в точности противоположно тому, что ожидают пользователи!

С другой стороны, обычным источником ошибок является то, что люди забывают оператор break в конце кейса и теряют контроль там, где этого не должно было быть. Менее распространенная проблема заключается в том, что люди переупорядочивают дела таким образом, что тот, который раньше был в конце (и не нуждался в break), больше не был в конце (и неожиданно провалился).

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

Операторы switch действительно сияют в том случае, когда происходят подобные вещи (для замены ifs)

switch (my_var) {
    case 1:
    case 2:
    case 3:
    case 4:
        do_something();
        break;
    case 5:
    case 6:
    case 7:
    case 8:
        do_something else();
        break;
}

Это сильно заменяет либо вложенные операторы if, либо гигантские операторы if с операторами and в них.

Другая основная причина заключается в том, что он как бы заимствован из C. Операторы case выглядят почти точно так же, как сборка, которая будет сгенерирована для них компилятором (в некоторых случаях). Не совсем уверен, почему они сначала выбрали этот дизайн, но я действительно не вижу проблемы, так как такое же количество «если» может также показаться загроможденным (хотя и не всегда).

С#, вероятно, воспринимает отсутствующий разрыв как ошибку (при этом распространенную), и, вероятно, это причина его пометки. Обычно он делает это только с последним, который попадает в оператор по умолчанию, а сам оператор по умолчанию должен иметь разрыв (потому что вы всегда можете поместить значение по умолчанию в начале). C# пытается быть строгим в этом смысле, чтобы избежать некоторых простых ошибок, которые могут быть вызваны тем, что вы просто забываете набирать break в конце каждого случая (или некоторого случая) и проваливаете выполнение.

Причина того, что C и C++ имеют неявный отказ, заключается в обратной совместимости с огромным количеством кода, который зависит от него, хотя и редко.

Причина, по которой C# не имеет неявного провала, заключается в том, что в большинстве случаев это ошибка. Причина, по которой C# не имеет неявного разрыва, заключается в том, что это было бы неожиданностью для программистов на C, C++ и Java. И это даже не будет генерировать предупреждение? Тихие неожиданные неудачи — это очень плохо.

Требовать, чтобы поведение было явным, — самый безопасный вариант, и C# выбрал именно этот путь. (и я бы хотел, чтобы C++ разработал явный синтаксис для провала, чтобы компиляторы могли предупреждать о неявном провале)