จับข้อยกเว้นหลายรายการพร้อมกันหรือไม่

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 ...
)

ORIGINAL:

ฉันรู้ว่าฉันมาช้าไปงานปาร์ตี้ที่นี่ แต่ควันศักดิ์สิทธิ์ ...

การตัดตรงไปที่การไล่ล่าการทำซ้ำคำตอบก่อนหน้านี้ แต่ถ้าคุณต้องการดำเนินการร่วมกันสำหรับประเภทข้อยกเว้นหลายประเภทและทำให้ทุกอย่างเรียบร้อยและเป็นระเบียบภายในขอบเขตของวิธีการหนึ่งทำไมไม่ใช้แลมบ์ดา ฟังก์ชันการปิด / / อินไลน์เพื่อทำสิ่งต่อไปนี้? ฉันหมายความว่ามีโอกาสค่อนข้างดีที่คุณจะรู้ว่าคุณเพียงแค่ต้องการทำให้การปิดเป็นวิธีแยกต่างหากที่คุณสามารถใช้ประโยชน์ได้ทั่วทุกที่ แต่มันจะเป็นเรื่องง่ายสุด ๆ โดยไม่ต้องเปลี่ยนส่วนที่เหลือของโครงสร้าง ขวา?

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 block

หากคุณถามฉันตัวอย่างที่สอง (พร้อมกับifและisคำหลัก) มีทั้งที่อ่านได้น้อยลงและมีข้อผิดพลาดเกิดขึ้นได้ง่ายกว่าในระหว่างขั้นตอนการบำรุงรักษาของโครงการของคุณ

ขั้นตอนการบำรุงรักษาสำหรับผู้ที่อาจจะค่อนข้างใหม่ในการเขียนโปรแกรมจะประกอบด้วย 98.7% หรือมากกว่าของอายุการใช้งานโดยรวมของโครงการของคุณและ schmuck ที่ไม่ดีในการบำรุงรักษาเกือบจะแน่นอนเป็นคนอื่นที่ไม่ใช่คุณ และมีโอกาสที่ดีมากที่พวกเขาจะใช้เวลา 50% ในการสาปแช่งชื่อของคุณ

และแน่นอน FxCop เปลือกที่คุณและดังนั้นคุณต้องยังเพิ่มแอตทริบิวต์รหัสของคุณที่ได้อย่างแม่นยำ zip จะทำอย่างไรกับโปรแกรมการทำงานและเป็นเพียงมีจะบอก FxCop ที่จะไม่สนใจปัญหาที่ใน 99.9% ของกรณีมันเป็นโดยสิ้นเชิง แก้ไขในการตั้งค่าสถานะ และขออภัยฉันอาจเข้าใจผิด แต่แอตทริบิวต์ "เพิกเฉย" นั้นไม่ได้รวบรวมไว้ในแอปของคุณจริงหรือ

การวางการifทดสอบทั้งหมดในบรรทัดเดียวจะทำให้อ่านง่ายขึ้นหรือไม่ ฉันไม่คิดอย่างนั้น ฉันหมายความว่าฉันมีโปรแกรมเมอร์คนอื่นเถียงอีกครั้งเมื่อนานมาแล้วว่าการวางโค้ดเพิ่มเติมในบรรทัดเดียวจะทำให้ "ทำงานได้เร็วขึ้น" แต่แน่นอนว่าเขาเป็นคนบ้าคลั่ง พยายามอธิบายให้เขา (ด้วยหน้าตรง - ซึ่งท้าทาย) วิธีล่ามหรือคอมไพเลอร์จะแยกบรรทัดยาวนั้นออกเป็นคำสั่งหนึ่งคำสั่งต่อบรรทัดแยกกันโดยสิ้นเชิงเหมือนกับผลลัพธ์ถ้าเขาไปข้างหน้าและ เพิ่งทำให้โค้ดอ่านได้แทนที่จะพยายามคอมไพเลอร์ที่ฉลาด - ไม่มีผลอะไรกับเขาเลย แต่ฉันเชือนแช

สิ่งนี้จะอ่านได้น้อยลงเท่าใดเมื่อคุณเพิ่มประเภทข้อยกเว้นอีกสามประเภทเดือนหรือสองเดือนนับจากนี้ (คำตอบ: มันอ่านน้อยลงมาก )

หนึ่งในประเด็นสำคัญจริง ๆ ก็คือจุดส่วนใหญ่ของการจัดรูปแบบซอร์สโค้ดแบบข้อความที่เราทุกคนกำลังดูอยู่ทุกวันคือการทำให้มันชัดเจนจริงๆกับมนุษย์คนอื่น ๆ สิ่งที่เกิดขึ้นจริงเมื่อรหัสทำงาน เพราะคอมไพเลอร์เปลี่ยนซอร์สโค้ดให้เป็นอะไรที่ต่างออกไปโดยสิ้นเชิงและไม่สนใจสไตล์การจัดรูปแบบโค้ดของคุณน้อยลง ดังนั้น all-on-one-line ก็ดูดเหมือนกัน

แค่พูด...

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

ตามที่คนอื่น ๆ ได้ชี้ให้เห็นคุณสามารถมีifคำสั่งในบล็อก catch ของคุณเพื่อกำหนดสิ่งที่เกิดขึ้น 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 ต่อไปคุณสามารถติดตั้งแพ็คเกจ nuget ต่อไปนี้:

ติดตั้งแพ็คเกจ 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 Guid.Emptyไป

ตั้งแต่C # 7คุณสามารถหลีกเลี่ยงการแนะนำตัวแปรในบรรทัดแยก:

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

คุณยังสามารถสร้างวิธีการแยกวิเคราะห์ tuples ที่ส่งคืนซึ่งไม่พร้อมใช้งานใน. 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สามารถปรับปรุงได้ในขณะที่ยังคงความสามารถในการอ่านของ switch statement:

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จะบ่นเกี่ยวกับความจริงที่ว่ามันเป็นประเภทยกเว้นทั่วไป

นอกจากนี้ดูเหมือนว่าตัวดำเนินการ "เป็น" อาจลดประสิทธิภาพลงเล็กน้อย

CA1800: อย่าส่งข้อความโดยไม่จำเป็นว่าให้ "พิจารณาการทดสอบผลลัพธ์ของตัวดำเนินการ" เป็น "แทน" แต่ถ้าคุณทำเช่นนั้นคุณจะต้องเขียนโค้ดมากกว่าที่คุณจะแยกแต่ละข้อยกเว้น

อย่างไรก็ตามนี่คือสิ่งที่ฉันจะทำ:

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
}

คำตอบของโจเซฟไดเกิลเป็นคำตอบที่ดี แต่ฉันพบว่าโครงสร้างต่อไปนี้มีความเป็นระเบียบและมีข้อผิดพลาดน้อยกว่า

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: ดูhttps://stackoverflow.com/a/22864936/1718702สำหรับ C # 6 มันสะอาดและตอนนี้เป็นมาตรฐานในภาษา

เหมาะสำหรับผู้ที่ต้องการทางออกที่หรูหรากว่าเพื่อจับครั้งเดียวและกรองข้อยกเว้นฉันใช้วิธีการขยายดังที่แสดงด้านล่าง

ฉันมีส่วนขยายนี้ในห้องสมุดของฉันซึ่งเดิมเขียนขึ้นเพื่อจุดประสงค์อื่น ๆ แต่มันก็ทำงานได้อย่างสมบูรณ์แบบสำหรับการtypeตรวจสอบข้อยกเว้น ยิ่งไปกว่านั้นมันดูสะอาดกว่า||คำพูดมากมาย นอกจากนี้ยังแตกต่างจากคำตอบที่ยอมรับฉันชอบการจัดการข้อยกเว้นที่ชัดเจนดังนั้นจึงex is ...มีพฤติกรรมที่ไม่พึงประสงค์เนื่องจากคลาสที่ได้รับมานั้นสามารถกำหนดให้กับประเภทพาเรนต์ได้)

การใช้

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

IsAnyOf.cs Extension (ดูตัวอย่างการจัดการข้อผิดพลาดแบบเต็มสำหรับการพึ่งพา)

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' และวิธีเดียวที่จะทำให้งานนี้ได้โดยการจับ 'ยกเว้น' วัตถุ

ณ จุดนี้เราสามารถเพิ่มฟังก์ชั่นแยกต่างหากที่จัดการข้อยกเว้นประเภทต่าง ๆ โดยใช้ความละเอียดเกินพิกัดหรือเพื่อจัดการข้อยกเว้น ทั้งสองมีข้อเสีย ในการเริ่มต้นนี่คือวิธีทำด้วยฟังก์ชั่นตัวช่วย:

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.");

อีกวิธีคือจับวัตถุยกเว้นและจัดการตามนั้น การแปลที่แท้จริงมากที่สุดสำหรับสิ่งนี้ตามบริบทข้างต้นคือ:

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 # ทุกคนต้องเผชิญในที่สุด

ให้ฉันแบ่งคำถามของคุณออกเป็น 2 คำถาม ครั้งแรก

ฉันสามารถตรวจจับข้อยกเว้นหลายรายการพร้อมกันได้หรือไม่?

ในระยะสั้นไม่มี

ซึ่งนำไปสู่คำถามต่อไป

ฉันจะหลีกเลี่ยงการเขียนรหัสซ้ำได้อย่างไรเนื่องจากฉันไม่สามารถตรวจพบข้อยกเว้นหลายประเภทในบล็อก 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

หากการสร้างค่า fall-back มีราคาแพงและการรีเซ็ตค่านั้นถูกกว่ามากฉันจะย้ายรหัสรีเซ็ตไปยังฟังก์ชันของตัวเอง:

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" เป็นข้อยกเว้นมันจะนำหน้าคำสั่ง 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 นี้:

ลำดับชั้นข้อยกเว้น

อาจพยายามทำให้รหัสของคุณง่ายขึ้นเช่นวางรหัสทั่วไปในวิธีการเช่นเดียวกับที่คุณทำในส่วนอื่น ๆ ของรหัสที่ไม่ได้อยู่ในประโยคจับ?

เช่น:

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

// ...

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

ฉันจะทำอย่างไรการพยายามหาสิ่งเรียบง่ายเป็นลวดลายที่สวยงาม

โปรดทราบว่าฉันพบวิธีที่จะทำ แต่ดูเหมือนว่าเนื้อหาสำหรับThe Daily WTF :

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

เป็นมูลค่าการกล่าวขวัญที่นี่ คุณสามารถตอบสนองต่อชุดค่าผสมหลายชุด (ข้อผิดพลาดข้อยกเว้นและ exception.message)

ฉันวิ่งเข้าไปในสถานการณ์กรณีใช้งานเมื่อพยายามที่จะโยนวัตถุควบคุมใน datagrid โดยมีเนื้อหาเป็น 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;
            });

สำหรับสิ่งนี้คุณต้องสร้างการโอเวอร์โหลดแบบ "Catch" หลายวิธีคล้ายกับ 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));
    }

และอื่น ๆ ตามที่คุณต้องการ แต่คุณต้องทำครั้งเดียวและคุณสามารถใช้มันในทุกโครงการของคุณ (หรือถ้าคุณสร้างแพ็คเกจ nuget เราก็สามารถใช้มันได้เช่นกัน)

และการติดตั้ง 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;
        }
    }

ปล. ฉันไม่ได้ทำการตรวจสอบค่าความเรียบง่ายของโค้ดลองพิจารณาเพิ่มการตรวจสอบความถูกต้องของพารามิเตอร์

ps2 ถ้าคุณต้องการส่งคืนค่าจาก catch คุณจำเป็นต้องใช้วิธีการ Catch เดียวกัน แต่ใช้ return และ Func แทน Action ในพารามิเตอร์

เพียงโทรลองและจับสองครั้ง

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