switch 문의 여러 사례

case value:반복해서 진술하지 않고 여러 사례 진술을 겪을 수있는 방법이 있습니까?

나는 이것이 효과가 있다는 것을 안다.

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 Statement 에서 가져온 것입니다 .

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의 열거 가능 범위

SWITCH 문은 "=="연산자를 사용한다고 말했듯이 "contains"및 IF 문과 함께 사용할 수 있습니다.

예를 들면 다음과 같습니다.

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 에서는 case 매개 변수가 동일하다는 사실을 캡슐화 하기 쉬운 Partial Application 이 없지만 약간의 도우미 메서드 (bit verbose, tho)를 만듭니다.

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

다음은 새로운 함수형 반 입문이 이전 명령형 문보다 IMHO가 더 강력하고 우아하다는 예입니다.

완벽한 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이 모두 동일한 논리를 실행하는 경우 해당 논리를 루틴으로 랩핑하고 각 사례에 대해 호출하십시오. 나는 이것이 실제로 사례 진술을 제거하지는 않는다는 것을 알고 있지만, 좋은 스타일을 구현하고 유지 보수를 최소한으로 유지합니다 .....

[편집] 원래 질문과 일치하도록 대체 구현 추가 ... [/ 편집]

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 #에서 스위치의 알려진 덜 알려진 측면 중 하나 는 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 case 또는 goto default 문을 사용해야합니다.

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();
        }
    }

문자열의 문자가 16 진수인지 확인하고 싶을 수도 있습니다. 엉뚱하고 다소 큰 switch 문을 사용할 수 있습니다.

또는 정규식을 사용하여 문자를 테스트하거나 IndexOf 함수를 사용하여 알려진 16 진 문자 문자열에서 문자를 검색 할 수 있습니다.

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

1에서 24 사이의 값에 따라 3 가지 다른 작업 중 하나를 수행한다고 가정하겠습니다. IF 문 집합을 사용하는 것이 좋습니다. 그리고 그것이 너무 복잡해지면 (또는 1에서 90 사이의 값에 따라 5 개의 다른 동작과 같이 숫자가 더 커짐) 열거 형을 사용하여 동작을 정의하고 열거 형의 배열 맵을 만듭니다. 그런 다음이 값을 사용하여 배열 맵에 색인을 작성하고 원하는 조치의 열거를 가져옵니다. 그런 다음 작은 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 # 스위치 케이스에서 범위를 확인할 수도 있습니다. 스위치 케이스 : 하나의 숫자 대신 범위를 사용할 수 있습니까? 또는 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();
    }