한 번에 여러 예외를 잡으시겠습니까?

단순히 잡는 것은 바람직하지 않습니다 System.Exception. 대신 "알려진"예외 만 포착해야합니다.

이제는 때때로 불필요한 반복 코드로 이어집니다. 예를 들면 다음과 같습니다.

try
{
    WebId = new Guid(queryString["web"]);
}
catch (FormatException)
{
    WebId = Guid.Empty;
}
catch (OverflowException)
{
    WebId = Guid.Empty;
}

궁금합니다 : 두 예외를 모두 잡아서 WebId = Guid.Empty한 번만 전화를 걸 수있는 방법이 있습니까?

주어진 예제는 단지이므로 간단합니다 GUID. 그러나 객체를 여러 번 수정하는 코드를 상상하고 조작 중 하나가 예상대로 실패하면을 "재설정"하려고합니다 object. 그러나 예기치 않은 예외가있는 경우 여전히 더 높이 던지고 싶습니다.

캐치 System.Exception및 유형 켜기

catch (Exception ex)            
{                
    if (ex is FormatException || ex is OverflowException)
    {
        WebId = Guid.Empty;
        return;
    }

    throw;
}

편집 : C # 6.0에서 예외 필터는 이제 완벽하게 갈 수있는 방법이라고 말하는 사람들과 동의합니다.catch (Exception ex) when (ex is ... || ex is ... )

내가 여전히 한 줄짜리 레이아웃을 싫어하고 개인적으로 다음과 같이 코드를 배치한다는 것을 제외하고. 나는 이것이 그것이 이해력을 향상 시킨다고 생각하기 때문에 그것이 미학적 인 것처럼 기능적이라고 생각한다. 일부는 동의하지 않을 수 있습니다.

catch (Exception ex) when (
    ex is ...
    || ex is ...
    || ex is ...
)

기발한:

나는 여기서 파티에 조금 늦었지만 성스러운 연기는 ...

추격을 바로 잡기 위해이 종류의 이전 답변을 복제하지만 실제로 몇 가지 예외 유형에 대해 공통 작업을 수행하고 한 방법의 범위 내에서 모든 것을 깔끔하고 깔끔하게 유지하려면 람다를 사용하지 않는 이유는 무엇입니까? 다음과 같은 작업을 수행하는 / closure / inline 함수? 내 말은, 당신은 당신이 그 폐쇄를 당신이 모든 곳에서 활용할 수있는 별도의 방법으로 만들고 싶다는 것을 깨닫게 될 가능성이 꽤 있다는 것을 의미합니다. 그러나 실제로 나머지 코드를 구조적으로 변경하지 않고 그렇게하는 것이 매우 쉽습니다. 권리?

private void TestMethod ()
{
    Action<Exception> errorHandler = ( ex ) => {
        // write to a log, whatever...
    };

    try
    {
        // try some stuff
    }
    catch ( FormatException  ex ) { errorHandler ( ex ); }
    catch ( OverflowException ex ) { errorHandler ( ex ); }
    catch ( ArgumentNullException ex ) { errorHandler ( ex ); }
}

나는 지구상에서 기본적으로 다음을 대체하기 위해이 모든 노력을 기울이는 이유를 궁금해 할 수는 없습니다 ( 경고 : 약간의 아이러니 / 풍자).

try
{
    // try some stuff
}
catch( FormatException ex ){}
catch( OverflowException ex ){}
catch( ArgumentNullException ex ){}

...이 다음 코드 냄새의 미친 변형으로, 예를 들어, 몇 번의 키 입력을 저장하고 있다고 가정합니다.

// sorta sucks, let's be honest...
try
{
    // try some stuff
}
catch( Exception ex )
{
    if (ex is FormatException ||
        ex is OverflowException ||
        ex is ArgumentNullException)
    {
        // write to a log, whatever...
        return;
    }
    throw;
}

확실히 자동으로 더 읽기 쉽지 않기 때문입니다.

물론, /* write to a log, whatever... */ return;첫 번째 예 에서 세 개의 동일한 인스턴스를 남겼습니다 .

그러나 그것은 내 요점입니다. 여러분은 기능 / 방법에 대해 들어 보았습니다. 진심으로. 공통 ErrorHandler함수를 작성하고 각 catch 블록에서 호출하십시오.

나에게 묻는다면 두 번째 예제 ( if및 is키워드 포함)는 프로젝트의 유지 보수 단계에서 읽기가 쉽지 않으며 오류가 발생하기 쉽습니다.

유지 보수 단계는 프로그래밍에 익숙하지 않은 사용자를 위해 프로젝트 전체 수명의 98.7 % 이상을 차지할 것이며 유지 보수를 수행하는 불량 Schmuck은 거의 다른 사람이 될 것입니다. 그리고 그들이 당신의 이름을 저주하는 일에 그들의 시간의 50 %를 소비 할 가능성이 매우 높습니다.

그리고 물론의 FxCop 당신의 당신이 할 필요가 있으므로 껍질 도 정확하게 실행중인 프로그램을 할 압축 한 코드에 속성을 추가 한 경우 99.9 %에 완전히이라고 문제를 무시의 FxCop 말씀 만이 신고가 정확합니다. 그리고, 죄송합니다, 착각 할 수도 있지만, 그 "무시"속성이 실제로 앱에 컴파일되지 않습니까?

전체 if테스트를 한 줄에 배치하면 더 읽기 쉬워 집니까? 나는 그렇게 생각하지 않습니다. 한 번에 한 줄에 더 많은 코드를 넣으면 "더 빠르게"실행될 것이라고 한 번도 다른 프로그래머가 격렬하게 주장했음을 의미합니다. 그러나 물론 그는 굶주린 견과였다. 통역사 또는 컴파일러가 어떻게 긴 줄을 별개의 한 줄에 한 줄로 나누는 방법을 그에게 설명하려고 노력했지만 본질적으로 결과가 동일한 경우 컴파일러를 능숙하게 만들지 않고 코드를 읽을 수있게 만들었습니다. 그러나 나는 산만하다.

한 달에서 두 달 사이에 예외 유형을 세 개 더 추가 할 때 읽기가 훨씬 어렵 습니까? (답 : 읽기 가 훨씬 어렵습니다).

실제로 중요한 점 중 하나는 우리가 매일보고있는 텍스트 소스 코드를 형식화하는 대부분의 포인트가 코드 실행시 실제로 발생하는 일을 다른 사람에게 실제로 분명하게 만드는 것입니다. 컴파일러는 소스 코드를 완전히 다른 것으로 변환하고 코드 서식 스타일에 대해서는 신경 쓰지 않기 때문입니다. 따라서 올인원 라인도 완전히 짜증납니다.

그냥 ...

// super sucks...
catch( Exception ex )
{
    if ( ex is FormatException || ex is OverflowException || ex is ArgumentNullException )
    {
        // write to a log, whatever...
        return;
    }
    throw;
}

다른 사람들이 지적했듯이 ifcatch 블록 내에 명령문을 사용하여 진행 상황을 결정할 수 있습니다. C # 6은 예외 필터를 지원하므로 다음이 작동합니다.

try { … }
catch (Exception e) when (MyFilter(e))
{
    …
}

그러면 MyFilter메소드는 다음과 같이 보일 수 있습니다.

private bool MyFilter(Exception e)
{
  return e is ArgumentNullException || e is FormatException;
}

또는 이것은 모두 인라인으로 수행 될 수 있습니다 (when 문의 오른쪽은 부울 표현식이어야합니다).

try { … }
catch (Exception e) when (e is ArgumentNullException || e is FormatException)
{
    …
}

이것은 블록 if내에서 명령문 을 사용하는 것과 다릅니다. catch예외 필터 를 사용 하면 스택이 풀리지 않습니다 .

Visual Studio 2015 를 다운로드 하여 확인할 수 있습니다 .

Visual Studio 2013을 계속 사용하려면 다음과 같은 너겟 패키지를 설치할 수 있습니다.

설치 패키지 Microsoft.Net.Compilers

작성 당시에는 C # 6에 대한 지원이 포함됩니다.

이 패키지를 참조하면 시스템에 설치된 모든 버전과 달리 패키지에 포함 된 특정 버전의 C # 및 Visual Basic 컴파일러를 사용하여 프로젝트가 빌드됩니다.

불행히도 C #에는 그렇지 않습니다. 예외 필터가 필요하고 C #은 MSIL의 해당 기능을 노출하지 않기 때문입니다. VB.NET은이 기능을 가지고 있습니다.

Catch ex As Exception When TypeOf ex Is FormatException OrElse TypeOf ex Is OverflowException

당신이 할 수있는 일은 익명 함수를 사용하여 오류가 발생한 코드를 캡슐화 한 다음 특정 catch 블록에서 호출하는 것입니다.

Action onError = () => WebId = Guid.Empty;
try
{
    // something
}
catch (FormatException)
{
    onError();
}
catch (OverflowException)
{
    onError();
}

완전성을 위해 .NET 4.0 이후 코드는 다음과 같이 다시 작성할 수 있습니다.

Guid.TryParse(queryString["web"], out WebId);

TryParse 는 예외가 발생하지 않으며 형식이 잘못된 경우 WebId를로 설정하여 false를 반환합니다 Guid.Empty.

C # 7 부터는 별도의 행에 변수를 도입하지 않아도됩니다.

Guid.TryParse(queryString["web"], out Guid webId);

.NET Framework에서는 아직 버전 4.6에서는 사용할 수없는 반환 튜플을 구문 분석하는 메서드를 만들 수도 있습니다.

(bool success, Guid result) TryParseGuid(string input) =>
    (Guid.TryParse(input, out Guid result), result);

그리고 이것을 다음과 같이 사용하십시오 :

WebId = TryParseGuid(queryString["web"]).result;
// or
var tuple = TryParseGuid(queryString["web"]);
WebId = tuple.success ? tuple.result : DefaultWebId;

이 쓸모없는 답변에 대한 다음 쓸모없는 업데이트는 C # 12에서 매개 변수의 해체가 구현 될 때 발생합니다.

예외 필터는 이제 C # 6+에서 사용할 수 있습니다. 넌 할 수있어

try
{
       WebId = new Guid(queryString["web"]);
}
catch (Exception ex) when(ex is FormatException || ex is OverflowException)
{
     WebId = Guid.Empty;
}

C # 7.0 이상에서는이를 패턴 일치와 결합 할 수도 있습니다

try
{
   await Task.WaitAll(tasks);
}
catch (Exception ex) when( ex is AggregateException ae &&
                           ae.InnerExceptions.Count > tasks.Count/2)
{
   //More than half of the tasks failed maybe..? 
}

응용 프로그램을 C # 6으로 업그레이드 할 수 있다면 운이 좋습니다. 새로운 C # 버전은 예외 필터를 구현했습니다. 그래서 당신은 이것을 쓸 수 있습니다 :

catch (Exception ex) when (ex is FormatException || ex is OverflowException) {
    WebId = Guid.Empty;
}

어떤 사람들은이 코드가

catch (Exception ex) {                
    if (ex is FormatException || ex is OverflowException) {
        WebId = Guid.Empty;
    }
    throw;
}

그러나 그렇지 않습니다. 실제로 이것은 C # 6의 유일한 새로운 기능으로 이전 버전에서는 에뮬레이션 할 수 없습니다. 우선, 다시 던지기는 캐치를 건너 뛰는 것보다 더 많은 오버 헤드를 의미합니다. 둘째, 의미 상 동등하지 않습니다. 새로운 기능은 코드를 디버깅 할 때 스택을 그대로 유지합니다. 이 기능이 없으면 크래시 덤프는 덜 유용하거나 쓸모가 없습니다.

CodePlex에 대한 논의를 참조하십시오 . 그리고 차이점을 보여주는 예 입니다.

당신이 사용하지 않을 경우 if내에서 문을 catch범위, 에에게 C# 6.0당신이 사용할 수있는 Exception Filters구문 이미 미리보기 버전의 CLR에 의해 지원 만 존재했다 VB.NET/ MSIL:

try
{
    WebId = new Guid(queryString["web"]);
}
catch (Exception exception) when (exception is FormatException || ex is OverflowException)
{
    WebId = Guid.Empty;
}

이 코드는 또는 일 Exception때만 잡습니다 .InvalidDataExceptionArgumentNullException

사실, 그 안에 기본적으로 어떤 조건이든 넣을 수 있습니다 when 절 :

static int a = 8;

...

catch (Exception exception) when (exception is InvalidDataException && a == 8)
{
    Console.WriteLine("Catch");
}

범위 if안에 있는 명령문 과 달리 catch, 다음 Exception Filters을 던질 수없고 Exceptions, 언제, 또는 조건이 아닌 true경우에는 다음을 수행합니다.catch 조건이 대신 평가됩니다.

static int a = 7;

static int b = 0;

...

try
{
    throw new InvalidDataException();
}
catch (Exception exception) when (exception is InvalidDataException && a / b == 2)
{
    Console.WriteLine("Catch");
}
catch (Exception exception) when (exception is InvalidDataException || exception is ArgumentException)
{
    Console.WriteLine("General catch");
}

출력 : 일반 캐치.

하나 이상이 있으면 true Exception Filter첫 번째 것이 허용됩니다.

static int a = 8;

static int b = 4;

...

try
{
    throw new InvalidDataException();
}
catch (Exception exception) when (exception is InvalidDataException && a / b == 2)
{
    Console.WriteLine("Catch");
}
catch (Exception exception) when (exception is InvalidDataException || exception is ArgumentException)
{
    Console.WriteLine("General catch");
}

출력 : 캐치.

당신이 볼 수 있듯이 MSIL코드로 번역되지 않은 if문장 만합니다 Filters, 그리고 Exceptions표시된 영역 내에서 던질 수 없다 Filter 1하고 Filter 2있지만,이 던지는 필터 Exception대신 실패도 마지막 비교 값은 전에 스택에 푸시 endfilter명령 필터의 성공 / 실패를 결정합니다 ( Catch 1 XOR Catch 2 이 그에 따라 실행 됨).

또한 구체적 Guid으로 Guid.TryParse방법이 있습니다.

C # 7 을 사용하면 스위치 명령문의 가독성을 유지하면서 Michael Stum의 답변을 향상시킬 수 있습니다.

catch (Exception ex)
{
    switch (ex)
    {
        case FormatException _:
        case OverflowException _:
            WebId = Guid.Empty;
            break;
        default:
            throw;
    }
}

그리고 스위치 식으로 C # 8을 사용하면 다음과 같습니다.

catch (Exception ex)
{
    WebId = ex switch
    {
        _ when ex is FormatException || ex is OverflowException => Guid.Empty,
        _ => throw ex
    };
}

CodeAnalysis / FxCop을 제외하고는 허용되는 답변으로 보입니다. 이 일반적인 예외 유형을 포착하고 있다는 사실에 대해 불만을 제기 있습니다.

또한 "is"연산자는 성능을 약간 저하시킬 수 있습니다.

CA1800 : 불필요하게 캐스트하지 마십시오 " 'as'연산자의 결과 테스트 대신 그러나 그렇게하면 각 예외를 개별적으로 잡는 것보다 더 많은 코드를 작성하게된다.

어쨌든, 여기 내가 할 일이 있습니다 :

bool exThrown = false;

try
{
    // Something
}
catch (FormatException) {
    exThrown = true;
}
catch (OverflowException) {
    exThrown = true;
}

if (exThrown)
{
    // Something else
}

C # 6에서 권장되는 방법은 예외 필터를 사용하는 것입니다. 예는 다음과 같습니다.

 try
 {
      throw new OverflowException();
 }
 catch(Exception e ) when ((e is DivideByZeroException) || (e is OverflowException))
 {
       // this will execute iff e is DividedByZeroEx or OverflowEx
       Console.WriteLine("E");
 }

이것은 Matt의 답변의 변형입니다 (이것이 조금 더 깨끗하다고 ​​생각합니다) ... 방법을 사용하십시오.

public void TryCatch(...)
{
    try
    {
       // something
       return;
    }
    catch (FormatException) {}
    catch (OverflowException) {}

    WebId = Guid.Empty;
}

다른 예외는 발생하고 코드 WebId = Guid.Empty;는 적중되지 않습니다. 다른 예외로 인해 프로그램이 중단되는 것을 원하지 않으면 다른 두 가지 캐치 후에 이것을 추가하십시오.

...
catch (Exception)
{
     // something, if anything
     return; // only need this if you follow the example I gave and put it all in a method
}

Joseph Daigle의 답변 은 좋은 해결책이지만 다음 구조는 약간 깔끔하고 오류가 적은 경향이 있음을 알았습니다.

catch(Exception ex)
{   
    if (!(ex is SomeException || ex is OtherException)) throw;

    // Handle exception
}

식을 반전 시키면 몇 가지 장점이 있습니다.

• 반환 진술은 필요하지 않습니다
• 코드가 중첩되지 않았습니다
• 요셉의 해결책에서 표현과 분리되어있는 '투구'또는 '반환'진술을 잊어 버릴 위험이 없습니다.

심지어 한 줄로 압축 할 수도 있습니다 (매우 예쁘지는 않지만)

catch(Exception ex) { if (!(ex is SomeException || ex is OtherException)) throw;

    // Handle exception
}

편집 : C # 6.0 의 예외 필터링 은 구문을 조금 더 깔끔하게 만들고 현재 솔루션에 비해 여러 가지 다른 이점 을 제공합니다. (주로 스택을 손상시키지 않은 채로 둡니다)

다음은 C # 6.0 구문을 사용하여 동일한 문제가 어떻게 보이는지 보여줍니다.

catch(Exception ex) when (ex is SomeException || ex is OtherException)
{
    // Handle exception
}

@Micheal

약간 수정 된 코드 버전 :

catch (Exception ex)
{
   Type exType = ex.GetType();
   if (exType == typeof(System.FormatException) || 
       exType == typeof(System.OverflowException)
   {
       WebId = Guid.Empty;
   } else {
      throw;
   }
}

문자열 비교는 추악하고 느립니다.

어때요?

try
{
    WebId = Guid.Empty;
    WebId = new Guid(queryString["web"]);
}
catch (FormatException)
{
}
catch (OverflowException)
{
}

catch (Exception ex)
{
    if (!(
        ex is FormatException ||
        ex is OverflowException))
    {
        throw;
    }
    Console.WriteLine("Hello");
}

주의와 경고 : 또 다른 종류의 기능적 스타일.

링크에있는 내용이 귀하의 질문에 직접 대답하지는 않지만 다음과 같이 확장하기는 쉽지 않습니다.

static void Main() 
{ 
    Action body = () => { ...your code... };

    body.Catch<InvalidOperationException>() 
        .Catch<BadCodeException>() 
        .Catch<AnotherException>(ex => { ...handler... })(); 
}

(기본적으로 Catch자체 빈 반환 과부하를 제공 합니다)

이것에 대한 더 큰 질문은 이유 입니다. 나는 비용이 이익보다 크다고 생각하지 않는다. :)

2015-12-15 업데이트 : C # 6에 대해서는 https://stackoverflow.com/a/22864936/1718702 를 참조 하십시오 . 언어가 더 깨끗하고 표준입니다.

한 번만 포착하고 예외를 필터링 하는 보다 우아한 솔루션 을 원하는 사람들 을 위해 아래에 설명 된 확장 방법을 사용합니다.

나는 이미 다른 목적으로 작성된 내 라이브러리 에이 확장을 가지고 있었지만 type예외 를 확인하는 데 완벽하게 작동했습니다 . 게다가, imho, 그것은 많은 ||진술 보다 깨끗해 보입니다 . 또한 허용되는 답변과 달리 명시 적 예외 처리를 선호하므로 ex is ...파생 클래스가 부모 유형에 할당 될 수 있으므로 바람직하지 않은 동작이있었습니다).

용법

if (ex.GetType().IsAnyOf(
    typeof(FormatException),
    typeof(ArgumentException)))
{
    // Handle
}
else
    throw;

IsAnyOf.cs 확장 (종속성에 대한 전체 오류 처리 예 참조)

namespace Common.FluentValidation
{
    public static partial class Validate
    {
        /// <summary>
        /// Validates the passed in parameter matches at least one of the passed in comparisons.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="p_parameter">Parameter to validate.</param>
        /// <param name="p_comparisons">Values to compare against.</param>
        /// <returns>True if a match is found.</returns>
        /// <exception cref="ArgumentNullException"></exception>
        public static bool IsAnyOf<T>(this T p_parameter, params T[] p_comparisons)
        {
            // Validate
            p_parameter
                .CannotBeNull("p_parameter");
            p_comparisons
                .CannotBeNullOrEmpty("p_comparisons");

            // Test for any match
            foreach (var item in p_comparisons)
                if (p_parameter.Equals(item))
                    return true;

            // Return no matches found
            return false;
        }
    }
}

전체 오류 처리 예 (새 콘솔 앱에 복사하여 붙여 넣기)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Common.FluentValidation;

namespace IsAnyOfExceptionHandlerSample
{
    class Program
    {
        static void Main(string[] args)
        {
            // High Level Error Handler (Log and Crash App)
            try
            {
                Foo();
            }
            catch (OutOfMemoryException ex)
            {
                Console.WriteLine("FATAL ERROR! System Crashing. " + ex.Message);
                Console.ReadKey();
            }
        }

        static void Foo()
        {
            // Init
            List<Action<string>> TestActions = new List<Action<string>>()
            {
                (key) => { throw new FormatException(); },
                (key) => { throw new ArgumentException(); },
                (key) => { throw new KeyNotFoundException();},
                (key) => { throw new OutOfMemoryException(); },
            };

            // Run
            foreach (var FooAction in TestActions)
            {
                // Mid-Level Error Handler (Appends Data for Log)
                try
                {
                    // Init
                    var SomeKeyPassedToFoo = "FooParam";

                    // Low-Level Handler (Handle/Log and Keep going)
                    try
                    {
                        FooAction(SomeKeyPassedToFoo);
                    }
                    catch (Exception ex)
                    {
                        if (ex.GetType().IsAnyOf(
                            typeof(FormatException),
                            typeof(ArgumentException)))
                        {
                            // Handle
                            Console.WriteLine("ex was {0}", ex.GetType().Name);
                            Console.ReadKey();
                        }
                        else
                        {
                            // Add some Debug info
                            ex.Data.Add("SomeKeyPassedToFoo", SomeKeyPassedToFoo.ToString());
                            throw;
                        }
                    }
                }
                catch (KeyNotFoundException ex)
                {
                    // Handle differently
                    Console.WriteLine(ex.Message);

                    int Count = 0;
                    if (!Validate.IsAnyNull(ex, ex.Data, ex.Data.Keys))
                        foreach (var Key in ex.Data.Keys)
                            Console.WriteLine(
                                "[{0}][\"{1}\" = {2}]",
                                Count, Key, ex.Data[Key]);

                    Console.ReadKey();
                }
            }
        }
    }
}

namespace Common.FluentValidation
{
    public static partial class Validate
    {
        /// <summary>
        /// Validates the passed in parameter matches at least one of the passed in comparisons.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="p_parameter">Parameter to validate.</param>
        /// <param name="p_comparisons">Values to compare against.</param>
        /// <returns>True if a match is found.</returns>
        /// <exception cref="ArgumentNullException"></exception>
        public static bool IsAnyOf<T>(this T p_parameter, params T[] p_comparisons)
        {
            // Validate
            p_parameter
                .CannotBeNull("p_parameter");
            p_comparisons
                .CannotBeNullOrEmpty("p_comparisons");

            // Test for any match
            foreach (var item in p_comparisons)
                if (p_parameter.Equals(item))
                    return true;

            // Return no matches found
            return false;
        }

        /// <summary>
        /// Validates if any passed in parameter is equal to null.
        /// </summary>
        /// <param name="p_parameters">Parameters to test for Null.</param>
        /// <returns>True if one or more parameters are null.</returns>
        public static bool IsAnyNull(params object[] p_parameters)
        {
            p_parameters
                .CannotBeNullOrEmpty("p_parameters");

            foreach (var item in p_parameters)
                if (item == null)
                    return true;

            return false;
        }
    }
}

namespace Common.FluentValidation
{
    public static partial class Validate
    {
        /// <summary>
        /// Validates the passed in parameter is not null, throwing a detailed exception message if the test fails.
        /// </summary>
        /// <param name="p_parameter">Parameter to validate.</param>
        /// <param name="p_name">Name of tested parameter to assist with debugging.</param>
        /// <exception cref="ArgumentNullException"></exception>
        public static void CannotBeNull(this object p_parameter, string p_name)
        {
            if (p_parameter == null)
                throw
                    new
                        ArgumentNullException(
                        string.Format("Parameter \"{0}\" cannot be null.",
                        p_name), default(Exception));
        }
    }
}

namespace Common.FluentValidation
{
    public static partial class Validate
    {
        /// <summary>
        /// Validates the passed in parameter is not null or an empty collection, throwing a detailed exception message if the test fails.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="p_parameter">Parameter to validate.</param>
        /// <param name="p_name">Name of tested parameter to assist with debugging.</param>
        /// <exception cref="ArgumentNullException"></exception>
        /// <exception cref="ArgumentOutOfRangeException"></exception>
        public static void CannotBeNullOrEmpty<T>(this ICollection<T> p_parameter, string p_name)
        {
            if (p_parameter == null)
                throw new ArgumentNullException("Collection cannot be null.\r\nParameter_Name: " + p_name, default(Exception));

            if (p_parameter.Count <= 0)
                throw new ArgumentOutOfRangeException("Collection cannot be empty.\r\nParameter_Name: " + p_name, default(Exception));
        }

        /// <summary>
        /// Validates the passed in parameter is not null or empty, throwing a detailed exception message if the test fails.
        /// </summary>
        /// <param name="p_parameter">Parameter to validate.</param>
        /// <param name="p_name">Name of tested parameter to assist with debugging.</param>
        /// <exception cref="ArgumentException"></exception>
        public static void CannotBeNullOrEmpty(this string p_parameter, string p_name)
        {
            if (string.IsNullOrEmpty(p_parameter))
                throw new ArgumentException("String cannot be null or empty.\r\nParameter_Name: " + p_name, default(Exception));
        }
    }
}

두 개의 샘플 NUnit 단위 테스트

Exception유형에 대한 일치 동작 은 정확합니다 (예 : 자식은 부모 유형과 일치하지 않습니다).

using System;
using System.Collections.Generic;
using Common.FluentValidation;
using NUnit.Framework;

namespace UnitTests.Common.Fluent_Validations
{
    [TestFixture]
    public class IsAnyOf_Tests
    {
        [Test, ExpectedException(typeof(ArgumentNullException))]
        public void IsAnyOf_ArgumentNullException_ShouldNotMatch_ArgumentException_Test()
        {
            Action TestMethod = () => { throw new ArgumentNullException(); };

            try
            {
                TestMethod();
            }
            catch (Exception ex)
            {
                if (ex.GetType().IsAnyOf(
                    typeof(ArgumentException), /*Note: ArgumentNullException derrived from ArgumentException*/
                    typeof(FormatException),
                    typeof(KeyNotFoundException)))
                {
                    // Handle expected Exceptions
                    return;
                }

                //else throw original
                throw;
            }
        }

        [Test, ExpectedException(typeof(OutOfMemoryException))]
        public void IsAnyOf_OutOfMemoryException_ShouldMatch_OutOfMemoryException_Test()
        {
            Action TestMethod = () => { throw new OutOfMemoryException(); };

            try
            {
                TestMethod();
            }
            catch (Exception ex)
            {
                if (ex.GetType().IsAnyOf(
                    typeof(OutOfMemoryException),
                    typeof(StackOverflowException)))
                    throw;

                /*else... Handle other exception types, typically by logging to file*/
            }
        }
    }
}

이 답변이 표면에 닿는 것처럼 느껴지므로 조금 더 깊이 파고 들었습니다.

그래서 우리가 정말로하고 싶은 것은 컴파일되지 않는 것입니다.

// Won't compile... damn
public static void Main()
{
    try
    {
        throw new ArgumentOutOfRangeException();
    }
    catch (ArgumentOutOfRangeException)
    catch (IndexOutOfRangeException) 
    {
        // ... handle
    }

우리가 원하는 이유는 예외 처리기가 프로세스에서 나중에 필요한 것을 포착하지 않기 때문입니다. 물론, 우리는 예외를 잡아서해야 할 일을 '만약'으로 확인할 수 있지만, 솔직히 말하면 실제로는 원하지 않습니다. (FxCop, 디버거 문제, 못생긴)

그렇다면 왜이 코드가 컴파일되지 않습니까? 어떻게 그렇게 해킹 할 수 있습니까?

코드를 살펴보면 실제로 전화를 걸어야합니다. 그러나 MS Partition II에 따르면 IL 예외 처리기 블록은 이와 같이 작동하지 않습니다.이 경우 '예외'개체가 다른 유형을 가질 수 있기 때문에 의미가 있습니다.

또는 코드로 작성하려면 컴파일러에게 다음과 같은 작업을 수행하도록 요청하십시오 (전적으로 정확하지는 않지만 가장 가까운 것으로 생각됩니다).

// Won't compile... damn
try
{
    throw new ArgumentOutOfRangeException();
}
catch (ArgumentOutOfRangeException e) {
    goto theOtherHandler;
}
catch (IndexOutOfRangeException e) {
theOtherHandler:
    Console.WriteLine("Handle!");
}

이것이 컴파일되지 않는 이유는 분명합니다. '$ exception'객체가 갖는 유형과 값 (여기서 'e'변수에 저장되어 있음)은 무엇입니까? 컴파일러가 이것을 처리하도록하는 방법은 두 예외의 공통 기본 유형이 '예외'라는 점에 유의하고 변수에 두 예외를 모두 포함시킨 다음 포착 된 두 예외 만 처리하는 것입니다. 이것이 IL에서 구현되는 방식은 VB.Net에서 사용할 수있는 '필터'입니다.

C #에서 작동하려면 올바른 '예외'기본 유형의 임시 변수가 필요합니다. 코드 흐름을 제어하기 위해 분기를 추가 할 수 있습니다. 간다 :

    Exception ex;
    try
    {
        throw new ArgumentException(); // for demo purposes; won't be caught.
        goto noCatch;
    }
    catch (ArgumentOutOfRangeException e) {
        ex = e;
    }
    catch (IndexOutOfRangeException e) {
        ex = e;
    }

    Console.WriteLine("Handle the exception 'ex' here :-)");
    // throw ex ?

noCatch:
    Console.WriteLine("We're done with the exception handling.");

이것에 대한 명백한 단점은 우리가 올바르게 다시 던질 수 없다는 것입니다. 솔직히 말해서 그것이 그것이 못생긴 해결책이라는 것입니다. 분기 제거를 수행하여 추악함을 약간 수정하여 솔루션을 약간 향상시킬 수 있습니다.

Exception ex = null;
try
{
    throw new ArgumentException();
}
catch (ArgumentOutOfRangeException e)
{
    ex = e;
}
catch (IndexOutOfRangeException e)
{
    ex = e;
}
if (ex != null)
{
    Console.WriteLine("Handle the exception here :-)");
}

그것은 단지 '다시 던지기'만 남습니다. 이것이 작동하려면 'catch'블록 내부에서 처리를 수행 할 수 있어야합니다.이 작업을 수행하는 유일한 방법은 'Exception'개체를 잡는 것입니다.

이 시점에서 우리는 과부하 해결을 사용하여 다른 유형의 예외를 처리하거나 예외를 처리하는 별도의 함수를 추가 할 수 있습니다. 둘 다 단점이 있습니다. 시작하려면 다음은 도우미 기능으로 수행하는 방법입니다.

private static bool Handle(Exception e)
{
    Console.WriteLine("Handle the exception here :-)");
    return true; // false will re-throw;
}

public static void Main()
{
    try
    {
        throw new OutOfMemoryException();
    }
    catch (ArgumentException e)
    {
        if (!Handle(e)) { throw; }
    }
    catch (IndexOutOfRangeException e)
    {
        if (!Handle(e)) { throw; }
    }

    Console.WriteLine("We're done with the exception handling.");

그리고 다른 해결책은 Exception 객체를 잡아서 적절히 처리하는 것입니다. 위의 맥락에 따라 가장 문자 그대로의 번역은 다음과 같습니다.

try
{
    throw new ArgumentException();
}
catch (Exception e)
{
    Exception ex = (Exception)(e as ArgumentException) ?? (e as IndexOutOfRangeException);
    if (ex != null)
    {
        Console.WriteLine("Handle the exception here :-)");
        // throw ?
    }
    else 
    {
        throw;
    }
}

결론 :

• 다시 던지기를 원하지 않으면 올바른 예외를 잡아 임시로 저장하는 것을 고려할 수 있습니다.
• 핸들러가 단순하고 코드를 재사용하려는 경우 가장 좋은 해결책은 아마도 도우미 함수를 도입하는 것입니다.
• 다시 던지기를 원한다면 FxCop과 디버거의 포착되지 않은 예외를 중단시키는 '예외'캐치 핸들러에 코드를 넣는 것 외에는 선택의 여지가 없습니다.

이것은 모든 C # 개발자가 결국 직면하는 고전적인 문제입니다.

질문을 두 가지 질문으로 나누겠습니다. 첫번째,

한 번에 여러 예외를 잡을 수 있습니까?

요컨대

다음 질문으로 이어지는

동일한 catch () 블록에서 여러 예외 유형을 잡을 수 없으므로 중복 코드를 작성하지 않으려면 어떻게합니까?

폴백 값이 구성하기에 저렴한 특정 샘플을 고려할 때 다음 단계를 따르고 싶습니다.

1. 대체 값으로 WebId를 초기화하십시오.
2. 임시 변수에 새 Guid를 구성하십시오.
3. WebId를 완전히 구성된 임시 변수로 설정하십시오. 이것을 try {} 블록의 최종 문장으로 만드십시오.

따라서 코드는 다음과 같습니다.

try
{
    WebId = Guid.Empty;
    Guid newGuid = new Guid(queryString["web"]);
    // More initialization code goes here like 
    // newGuid.x = y;
    WebId = newGuid;
}
catch (FormatException) {}
catch (OverflowException) {}

예외가 발생하면 WebId는 반으로 구성된 값으로 설정되지 않으며 Guid.Empty로 유지됩니다.

폴백 값을 구성하는 것이 비싸고 값을 재설정하는 것이 훨씬 저렴하다면 재설정 코드를 자체 기능으로 옮길 것입니다.

try
{
    WebId = new Guid(queryString["web"]);
    // More initialization code goes here.
}
catch (FormatException) {
    Reset(WebId);
}
catch (OverflowException) {
    Reset(WebId);
}

모든 예외 스위치 내에서 많은 코드를 반복하고 있습니까? 방법을 추출하는 것과 같은 소리는 신의 생각일까요?

따라서 코드는 다음과 같습니다.

MyClass instance;
try { instance = ... }
catch(Exception1 e) { Reset(instance); }
catch(Exception2 e) { Reset(instance); }
catch(Exception) { throw; }

void Reset(MyClass instance) { /* reset the state of the instance */ }

아무도 왜 그 코드 중복을 알아 차리지 못했는지 궁금합니다.

C # 6부터는 이미 다른 사람들이 언급 한 예외 필터 가 있습니다. 따라서 위 코드를 다음과 같이 수정할 수 있습니다.

try { ... }
catch(Exception e) when(e is Exception1 || e is Exception2)
{ 
    Reset(instance); 
}

이 긴 스레드에 짧은 대답을 추가하고 싶었습니다. 언급되지 않은 것은 catch 문의 우선 순위이며,보다 구체적으로 파악하려는 각 예외 유형의 범위를 알고 있어야합니다.

예를 들어 "catch-all"예외를 Exception 으로 사용하면 다른 모든 catch 문보다 우선하고 분명히 컴파일러 오류가 발생하지만 순서를 반대로 바꾸면 catch 문을 연결할 수 있습니다. ) catch-all Exception 유형을 맨 아래에 놓을 수 있으며 try..catch 블록에서 상위를 수용하지 않은 예외를 캡처합니다.

            try
            {
                // do some work here
            }
            catch (WebException ex)
            {
                // catch a web excpetion
            }
            catch (ArgumentException ex)
            {
                // do some stuff
            }
            catch (Exception ex)
            {
                // you should really surface your errors but this is for example only
                throw new Exception("An error occurred: " + ex.Message);
            }

이 MSDN 문서를 검토하는 것이 좋습니다.

예외 계층

catch 절에없는 코드의 다른 부분에서와 같이 메소드에 공통 코드를 넣는 것과 같이 코드를 단순하게 유지하려고 시도하십시오.

예 :

try
{
    // ...
}
catch (FormatException)
{
    DoSomething();
}
catch (OverflowException)
{
    DoSomething();
}

// ...

private void DoSomething()
{
    // ...
}

내가 어떻게 할 것인가, 단순함 을 찾으려고 노력하는 것은 아름다운 패턴입니다.

한 가지 방법을 찾았지만 Daily WTF의 자료와 비슷합니다 .

catch (Exception ex)
{
    switch (ex.GetType().Name)
    {
        case "System.FormatException":
        case "System.OverflowException":
            WebId = Guid.Empty;
            break;
        default:
            throw;
    }
}

여기서 언급 할 가치가 있습니다. 여러 조합 (예외 오류 및 예외. 메시지)에 응답 할 수 있습니다.

TextBox, TextBlock 또는 CheckBox와 같은 내용으로 데이터 그리드에서 컨트롤 개체를 캐스팅하려고 할 때 유스 케이스 시나리오가 발생했습니다. 이 경우 반환 된 Exception은 동일하지만 메시지가 다양합니다.

try
{
 //do something
}
catch (Exception ex) when (ex.Message.Equals("the_error_message1_here"))
{
//do whatever you like
} 
catch (Exception ex) when (ex.Message.Equals("the_error_message2_here"))
{
//do whatever you like
} 

가장 짧은 답변을 제안하고 싶습니다 (하나 이상의 기능적 스타일 ).

        Catch<FormatException, OverflowException>(() =>
            {
                WebId = new Guid(queryString["web"]);
            },
            exception =>
            {
                WebId = Guid.Empty;
            });

이를 위해 System.Action과 유사한 몇 가지 "캐치"메서드 오버로드를 만들어야합니다.

    [DebuggerNonUserCode]
    public static void Catch<TException1, TException2>(Action tryBlock,
        Action<Exception> catchBlock)
    {
        CatchMany(tryBlock, catchBlock, typeof(TException1), typeof(TException2));
    }

    [DebuggerNonUserCode]
    public static void Catch<TException1, TException2, TException3>(Action tryBlock,
        Action<Exception> catchBlock)
    {
        CatchMany(tryBlock, catchBlock, typeof(TException1), typeof(TException2), typeof(TException3));
    }

당신이 원하는대로 등등. 그러나 한 번만 수행하면 모든 프로젝트에서 사용할 수 있습니다 (또는 너겟 패키지를 만들면 사용할 수도 있습니다).

그리고 CatchMany 구현 :

    [DebuggerNonUserCode]
    public static void CatchMany(Action tryBlock, Action<Exception> catchBlock,
        params Type[] exceptionTypes)
    {
        try
        {
            tryBlock();
        }
        catch (Exception exception)
        {
            if (exceptionTypes.Contains(exception.GetType())) catchBlock(exception);
            else throw;
        }
    }

추신 : 코드 단순성을 위해 null 검사를하지 않았으므로 매개 변수 유효성 검사를 추가하십시오.

ps2 catch에서 값을 반환하려면 동일한 Catch 메서드를 수행해야하지만 매개 변수의 Action 대신 return 및 Func를 사용해야합니다.

시도하고 두 번 잡으십시오.

try
{
    WebId = new Guid(queryString["web"]);
}
catch (FormatException)
{
    WebId = Guid.Empty;
}
try
{
    WebId = new Guid(queryString["web"]);
}
catch (OverflowException)
{
    WebId = Guid.Empty;
}

그 단순한 것입니다!

C # 6.0에서 예외 필터는 예외 처리를 개선 한 것입니다.

try
{
    DoSomeHttpRequest();
}
catch (System.Web.HttpException e)
{
    switch (e.GetHttpCode())
    {
        case 400:
            WriteLine("Bad Request");
        case 500:
            WriteLine("Internal Server Error");
        default:
            WriteLine("Generic Error");
    }
}