switch语句中有多种情况

有没有办法case value:反复声明多个case语句？

我知道这可行：

switch (value)
{
   case 1:
   case 2:
   case 3:
      // Do some stuff
      break;
   case 4:
   case 5:
   case 6:
      // Do some different stuff
      break;
   default:
       // Default stuff
      break;
}

但我想做这样的事情：

switch (value)
{
   case 1,2,3:
      // Do something
      break;
   case 4,5,6:
      // Do something
      break;
   default:
      // Do the Default
      break;
}

我是从其他语言考虑使用这种语法吗？还是我错过了某些内容？

您提到的第二种方法在C ++和C＃中都没有语法。

您的第一种方法没有错。但是，如果范围很大，则只需使用一系列if语句。

我想这已经被回答了。但是，我认为您仍然可以通过以下方法以语法上更好的方式混合使用这两个选项：

switch (value)
{
    case 1: case 2: case 3:          
        // Do Something
        break;
    case 4: case 5: case 6: 
        // Do Something
        break;
    default:
        // Do Something
        break;
}

此语法来自Visual Basic Select ... Case语句：

Dim number As Integer = 8
Select Case number
    Case 1 To 5
        Debug.WriteLine("Between 1 and 5, inclusive")
        ' The following is the only Case clause that evaluates to True.
    Case 6, 7, 8
        Debug.WriteLine("Between 6 and 8, inclusive")
    Case Is < 1
        Debug.WriteLine("Equal to 9 or 10")
    Case Else
        Debug.WriteLine("Not between 1 and 10, inclusive")
End Select

您不能在C＃中使用此语法。相反，您必须使用第一个示例中的语法。

在C＃7（Visual Studio 2017 / .NET Framework 4.6.2默认提供）中，现在可以使用switch语句进行基于范围的切换，这将有助于解决OP的问题。

例：

int i = 5;

switch (i)
{
    case int n when (n >= 7):
        Console.WriteLine($"I am 7 or above: {n}");
        break;

    case int n when (n >= 4 && n <= 6 ):
        Console.WriteLine($"I am between 4 and 6: {n}");
        break;

    case int n when (n <= 3):
        Console.WriteLine($"I am 3 or less: {n}");
        break;
}

// Output: I am between 4 and 6: 5

笔记：

• 括号(和)在when条件中不是必需的，但在此示例中用于突出显示比较。
• var也可以代替int。例如：case var n when n >= 7:。

您可以省略换行符，该换行符为您提供：

case 1: case 2: case 3:
   break;

但我认为这种风格不好。

.NET Framework 3.5具有以下范围：

来自MSDN的Enumerable.Range

您可以将其与“ contains”和IF语句一起使用，因为就像有人说的那样，SWITCH语句使用“ ==”运算符。

这里是一个例子：

int c = 2;
if(Enumerable.Range(0,10).Contains(c))
    DoThing();
else if(Enumerable.Range(11,20).Contains(c))
    DoAnotherThing();

但是我认为我们可以有更多的乐趣：由于您不需要返回值，并且此操作不带参数，因此可以轻松使用操作！

public static void MySwitchWithEnumerable(int switchcase, int startNumber, int endNumber, Action action)
{
    if(Enumerable.Range(startNumber, endNumber).Contains(switchcase))
        action();
}

使用此新方法的旧示例：

MySwitchWithEnumerable(c, 0, 10, DoThing);
MySwitchWithEnumerable(c, 10, 20, DoAnotherThing);

由于传递的是动作而不是值，因此应该省略括号，这非常重要。如果您需要带有参数的函数，只需将类型更改Action为Action<ParameterType>。如果需要返回值，请使用Func<ParameterType, ReturnType>。

在C＃3.0中，没有简单的Partial Application来封装case参数相同的事实，但是您创建了一个小辅助方法（有点冗长，但是）。

public static void MySwitchWithEnumerable(int startNumber, int endNumber, Action action){ 
    MySwitchWithEnumerable(3, startNumber, endNumber, action); 
}

这是一个示例，说明新的函数式导入语句如何比旧的命令式语句更强大，更优雅。

这是完整的C＃7解决方案...

switch (value)
{
   case var s when new[] { 1,2,3 }.Contains(s):
      // Do something
      break;
   case var s when new[] { 4,5,6 }.Contains(s):
      // Do something
      break;
   default:
      // Do the default
      break;
}

它也适用于字符串...

switch (mystring)
{
   case var s when new[] { "Alpha","Beta","Gamma" }.Contains(s):
      // Do something
      break;
...
}

以下代码无法正常工作：

case 1 | 3 | 5:
// Not working do something

唯一的方法是：

case 1: case 2: case 3:
// Do something
break;

您要查找的代码在Visual Basic中有效，您可以在其中轻松放置范围... none该switch语句或if else块选项中比较方便，我建议在极端情况下使用Visual Basic制作.dll并重新导入到您的C＃项目。

注意：Visual Basic中的等效开关为Select Case。

另一种选择是使用例程。如果情况1-3都执行相同的逻辑，则将该逻辑包装在例程中，并为每种情况调用它。我知道这实际上并没有摆脱case语句，但是它确实实现了良好的风格并将维护降至最低。

[编辑]添加了替代实现以匹配原始问题... [/编辑]

switch (x)
{
   case 1:
      DoSomething();
      break;
   case 2:
      DoSomething();
      break;
   case 3:
      DoSomething();
      break;
   ...
}

private void DoSomething()
{
   ...
}

Alt键

switch (x)
{
   case 1:
   case 2:
   case 3:
      DoSomething();
      break;
   ...
}

private void DoSomething()
{
   ...
}

在C＃中，switch的一个鲜为人知的方面是它依赖于operator =，并且由于可以覆盖它，因此您可能会遇到以下情况：

string s = foo();

switch (s) {
  case "abc": /*...*/ break;
  case "def": /*...*/ break;
}

gcc实现了对C语言的扩展，以支持顺序范围：

switch (value)
{
   case 1...3:
      //Do Something
      break;
   case 4...6:
      //Do Something
      break;
   default:
      //Do the Default
      break;
}

编辑：刚刚注意到问题上的C＃标记，所以大概一个gcc答案无济于事。

在C＃7中，我们现在有了模式匹配，因此您可以执行以下操作：

switch (age)
{
  case 50:
    ageBlock = "the big five-oh";
    break;
  case var testAge when (new List<int>()
      { 80, 81, 82, 83, 84, 85, 86, 87, 88, 89 }).Contains(testAge):
    ageBlock = "octogenarian";
    break;
  case var testAge when ((testAge >= 90) & (testAge <= 99)):
    ageBlock = "nonagenarian";
    break;
  case var testAge when (testAge >= 100):
    ageBlock = "centenarian";
    break;
  default:
    ageBlock = "just old";
    break;
}

其实我也不喜欢GOTO命令，但是它在Microsoft官方资料中，并且所有允许的语法都在这里。

如果开关部分的语句列表的端点可访问，则发生编译时错误。这称为“不掉线”规则。这个例子

switch (i) {
case 0:
   CaseZero();
   break;
case 1:
   CaseOne();
   break;
default:
   CaseOthers();
   break;
}

之所以有效，是因为没有任何开关部分具有可到达的端点。与C和C ++不同，不允许执行切换部分以“掉入”到下一个切换部分，该示例

switch (i) {
case 0:
   CaseZero();
case 1:
   CaseZeroOrOne();
default:
   CaseAny();
}

导致编译时错误。当执行一个切换部分之后又执行另一个切换部分时，必须使用显式的goto情况或goto默认语句：

switch (i) {
case 0:
   CaseZero();
   goto case 1;
case 1:
   CaseZeroOrOne();
   goto default;
default:
   CaseAny();
   break;
}

开关部分允许使用多个标签。这个例子

switch (i) {
case 0:
   CaseZero();
   break;
case 1:
   CaseOne();
   break;
case 2:
default:
   CaseTwo();
   break;
}

我相信在这种特殊情况下，可以使用GOTO，这实际上是失败的唯一方法。

来源：http : //msdn.microsoft.com/en-us/library/aa664749%28v=vs.71%29.aspx

似乎已经进行了大量工作，以寻找使C＃最少使用的语法之一看起来更好或工作更好的方法。我个人认为switch语句很少值得使用。我强烈建议您分析要测试的数据以及所需的最终结果。

例如，假设您要在已知范围内快速测试值以查看它们是否为质数。您希望避免让代码进行浪费的计算，并且可以在要在线的范围内找到素数列表。您可以使用大量的switch语句将每个值与已知质数进行比较。

或者，您可以创建素数的数组映射并立即获得结果：

    bool[] Primes = new bool[] {
        false, false, true, true, false, true, false,    
        true, false, false, false, true, false, true,
        false,false,false,true,false,true,false};
    private void button1_Click(object sender, EventArgs e) {
        int Value = Convert.ToInt32(textBox1.Text);
        if ((Value >= 0) && (Value < Primes.Length)) {
            bool IsPrime = Primes[Value];
            textBox2.Text = IsPrime.ToString();
        }
    }

也许您想查看字符串中的字符是否为十六进制。您可以使用冗长的开关声明。

或者，您可以使用正则表达式测试char或使用IndexOf函数在已知的十六进制字母字符串中搜索char：

        private void textBox2_TextChanged(object sender, EventArgs e) {
        try {
            textBox1.Text = ("0123456789ABCDEFGabcdefg".IndexOf(textBox2.Text[0]) >= 0).ToString();
        } catch {
        }
    }

假设您要执行3个不同的操作之一，具体取决于一个介于1到24之间的值。我建议使用一组IF语句。并且如果这变得太复杂（或者数字较大，例如5个不同的操作，具体取决于1到90范围内的值），则使用枚举定义操作并创建枚举的数组映射。然后，该值将用于索引数组映射并获取所需动作的枚举。然后，使用一小组IF语句或非常简单的switch语句来处理结果枚举值。

另外，关于将一系列值转换为动作的数组映射的好处是，可以通过代码轻松地对其进行更改。使用硬连接的代码，您无法在运行时轻松更改行为，但使用数组映射则很容易。

只是为了添加到对话中，使用.NET 4.6.2，我还可以执行以下操作。我测试了代码，它确实为我工作。

您还可以执行多个“ OR”语句，如下所示：

            switch (value)
            {
                case string a when a.Contains("text1"):
                    // Do Something
                    break;
                case string b when b.Contains("text3") || b.Contains("text4") || b.Contains("text5"):
                    // Do Something else
                    break;
                default:
                    // Or do this by default
                    break;
            }

您还可以检查它是否与数组中的值匹配：

            string[] statuses = { "text3", "text4", "text5"};

            switch (value)
            {
                case string a when a.Contains("text1"):
                    // Do Something
                    break;
                case string b when statuses.Contains(value):                        
                    // Do Something else
                    break;
                default:
                    // Or do this by default
                    break;
            }

如果您有大量的字符串（或任何其他类型）都在做相同的事情，则建议将字符串列表与string.Contains属性结合使用。

因此，如果您有一个很大的switch语句，例如：

switch (stringValue)
{
    case "cat":
    case "dog":
    case "string3":
    ...
    case "+1000 more string": // Too many string to write a case for all!
        // Do something;
    case "a lonely case"
        // Do something else;
    .
    .
    .
}

您可能想要用如下if语句替换它：

// Define all the similar "case" string in a List
List<string> listString = new List<string>(){ "cat", "dog", "string3", "+1000 more string"};
// Use string.Contains to find what you are looking for
if (listString.Contains(stringValue))
{
    // Do something;
}
else
{
    // Then go back to a switch statement inside the else for the remaining cases if you really need to
}

这对于任何数量的字符串情况都可以很好地扩展。

我认为这在C＃7或更高版本中更好。

switch (value)
{
    case var s when new[] { 1,2 }.Contains(s):
    // Do something
     break;

    default:
    // Do the default
    break;
 }

您还可以在C＃切换案例中检查Range：切换案例：我可以使用范围而不是一个数字 吗？或者，如果您想了解C＃切换案例的基础，

为此，您将使用goto语句。如：

    switch(value){
    case 1:
        goto case 3;
    case 2:
        goto case 3;
    case 3:
        DoCase123();
    //This would work too, but I'm not sure if it's slower
    case 4:
        goto case 5;
    case 5:
        goto case 6;
    case 6:
        goto case 7;
    case 7:
        DoCase4567();
    }