Tangkap beberapa pengecualian sekaligus?

Dianjurkan untuk hanya menangkap System.Exception. Sebaliknya, hanya pengecualian "diketahui" yang harus ditangkap.

Sekarang, ini terkadang mengarah pada kode berulang yang tidak perlu, misalnya:

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

Saya bertanya-tanya: Apakah ada cara untuk menangkap kedua pengecualian dan hanya menelepon satu WebId = Guid.Emptykali?

Contoh yang diberikan agak sederhana, karena hanya a GUID. Tetapi bayangkan kode di mana Anda memodifikasi objek beberapa kali, dan jika salah satu manipulasi gagal dengan cara yang diharapkan, Anda ingin "mengatur ulang" itu object. Namun, jika ada pengecualian yang tidak terduga, saya masih ingin membuang yang lebih tinggi.

Tangkap System.Exceptiondan aktifkan tipenya

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

    throw;
}

EDIT: Saya setuju dengan orang lain yang mengatakan bahwa, pada C # 6.0, filter pengecualian sekarang merupakan cara yang baik untuk digunakan:catch (Exception ex) when (ex is ... || ex is ... )

Kecuali bahwa saya masih agak benci tata letak garis panjang dan secara pribadi akan mengeluarkan kode seperti berikut. Saya pikir ini fungsional seperti estetika, karena saya percaya ini meningkatkan pemahaman. Beberapa mungkin tidak setuju:

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

ASLI:

Saya tahu saya sedikit terlambat ke pesta di sini, tetapi asap suci ...

Memotong langsung ke pengejaran, jenis ini menduplikasi jawaban sebelumnya, tetapi jika Anda benar-benar ingin melakukan tindakan umum untuk beberapa jenis pengecualian dan menjaga semuanya tetap rapi dan rapi dalam ruang lingkup satu metode, mengapa tidak hanya menggunakan lambda / closure / inline berfungsi untuk melakukan sesuatu seperti berikut ini? Maksud saya, peluangnya cukup bagus sehingga Anda akhirnya menyadari bahwa Anda hanya ingin membuat penutupan itu sebagai metode terpisah yang dapat Anda manfaatkan di semua tempat. Tetapi kemudian akan sangat mudah untuk melakukan itu tanpa benar-benar mengubah sisa kode secara struktural. Baik?

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

Saya tidak bisa menahan diri untuk bertanya-tanya ( peringatan: sedikit ironi / sarkasme di muka) mengapa harus melakukan semua upaya ini pada dasarnya hanya mengganti yang berikut ini:

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

... dengan beberapa variasi gila dari bau kode selanjutnya, maksud saya contoh, hanya untuk berpura-pura bahwa Anda menyimpan beberapa penekanan tombol.

// 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;
}

Karena itu tentu saja tidak secara otomatis lebih mudah dibaca.

Memang, saya meninggalkan tiga contoh identik dari /* write to a log, whatever... */ return;contoh pertama.

Tapi itu maksud saya. Kalian pernah mendengar fungsi / metode, kan? Serius. Tulis ErrorHandlerfungsi umum dan, seperti, panggil dari masing-masing blok tangkapan.

Jika Anda bertanya kepada saya, contoh kedua (dengan ifdan iskata kunci) keduanya kurang terbaca secara signifikan, dan secara bersamaan lebih rentan terhadap kesalahan selama fase pemeliharaan proyek Anda.

Fase pemeliharaan, bagi siapa saja yang mungkin relatif baru dalam pemrograman, akan mencapai 98,7% atau lebih dari keseluruhan masa hidup proyek Anda, dan orang bodoh yang melakukan pemeliharaan hampir pasti akan menjadi orang lain selain Anda. Dan ada kemungkinan yang sangat baik bahwa mereka akan menghabiskan 50% dari waktu mereka untuk pekerjaan mengutuk nama Anda.

Dan tentu saja FxCop menggonggong pada Anda dan Anda juga harus menambahkan atribut ke kode Anda yang memiliki persis zip terkait dengan program yang sedang berjalan, dan hanya ada di sana untuk memberitahu FxCop untuk mengabaikan masalah bahwa dalam 99,9% kasus itu benar-benar benar dalam menandai. Dan, maaf, saya mungkin salah, tetapi bukankah atribut "abaikan" itu benar-benar dikompilasi ke dalam aplikasi Anda?

Apakah menempatkan seluruh iftes pada satu baris membuatnya lebih mudah dibaca? Saya kira tidak. Maksud saya, saya punya programmer lain yang dengan keras berdebat sekali dulu bahwa menempatkan lebih banyak kode pada satu baris akan membuatnya "berjalan lebih cepat." Tapi tentu saja dia murka. Mencoba menjelaskan kepadanya (dengan wajah lurus - yang menantang) bagaimana penerjemah atau kompiler akan memecah garis panjang itu menjadi pernyataan satu-instruksi-per-garis yang terpisah - pada dasarnya identik dengan hasilnya jika ia terus maju dan hanya membuat kode dapat dibaca alih-alih mencoba mengompilasi kompiler - tidak berpengaruh padanya. Tapi saya ngelantur.

Berapa banyak kurang dibaca tidak mendapatkan ini ketika Anda menambahkan tiga jenis pengecualian lebih, satu atau dua bulan dari sekarang? (Jawaban: itu mendapat banyak kurang dibaca).

Salah satu poin utama, sungguh, adalah bahwa sebagian besar titik memformat kode sumber tekstual yang kita semua lihat setiap hari adalah untuk membuatnya benar-benar jelas bagi manusia lain apa yang sebenarnya terjadi ketika kode dijalankan. Karena kompiler mengubah kode sumber menjadi sesuatu yang sama sekali berbeda dan tidak peduli tentang gaya pemformatan kode Anda. Jadi all-on-one-line benar-benar menyebalkan juga.

Hanya mengatakan ...

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

Seperti yang telah ditunjukkan orang lain, Anda dapat memiliki ifpernyataan di dalam blok penangkap untuk menentukan apa yang sedang terjadi. C # 6 mendukung Filter Pengecualian, jadi yang berikut ini akan berfungsi:

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

The MyFilterMetode kemudian bisa terlihat seperti ini:

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

Atau, ini semua bisa dilakukan inline (sisi kanan pernyataan when hanya harus menjadi ekspresi boolean).

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

Ini berbeda dari menggunakan ifpernyataan dari dalam catchblok, menggunakan filter pengecualian tidak akan melepaskan tumpukan.

Anda dapat mengunduh Visual Studio 2015 untuk melihatnya.

Jika Anda ingin terus menggunakan Visual Studio 2013, Anda dapat menginstal paket nuget berikut:

Instal-Paket Microsoft.Net.Compiler

Pada saat penulisan, ini akan termasuk dukungan untuk C # 6.

Merujuk paket ini akan menyebabkan proyek dibangun menggunakan versi spesifik dari kompiler C # dan Visual Basic yang terdapat dalam paket, yang bertentangan dengan versi sistem yang diinstal.

Sayangnya tidak dalam C #, karena Anda memerlukan filter pengecualian untuk melakukannya dan C # tidak mengekspos fitur MSIL itu. VB.NET memang memiliki kemampuan ini, misalnya

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

Apa yang bisa Anda lakukan adalah menggunakan fungsi anonim untuk merangkum kode kesalahan Anda, dan kemudian menyebutnya di blok tangkapan khusus tersebut:

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

Demi kelengkapan, karena .NET 4.0 kode dapat ditulis ulang sebagai:

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

TryParse tidak pernah melempar pengecualian dan mengembalikan false jika formatnya salah, mengatur WebId menjadi Guid.Empty.

Karena C # 7 Anda dapat menghindari memperkenalkan variabel pada baris terpisah:

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

Anda juga dapat membuat metode untuk mem-parsing tupel yang kembali, yang belum tersedia di .NET Framework pada versi 4.6:

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

Dan gunakan seperti ini:

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

Pembaruan tidak berguna berikutnya untuk jawaban tidak berguna ini muncul ketika dekonstruksi parameter-out diimplementasikan dalam C # 12. :)

Filter pengecualian sekarang tersedia dalam c # 6+. Anda dapat melakukan

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

Di C # 7.0+, Anda dapat menggabungkan ini dengan pencocokan pola juga

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..? 
}

Jika Anda dapat meningkatkan aplikasi ke C # 6, Anda beruntung. Versi C # yang baru telah menerapkan filter Pengecualian. Jadi Anda bisa menulis ini:

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

Beberapa orang berpikir kode ini sama dengan

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

Tapi ternyata tidak. Sebenarnya ini adalah satu-satunya fitur baru di C # 6 yang tidak mungkin ditiru di versi sebelumnya. Pertama, lemparan ulang berarti lebih banyak overhead daripada melewatkan tangkapan. Kedua, itu tidak setara secara semantik. Fitur baru mempertahankan tumpukan utuh ketika Anda men-debug kode Anda. Tanpa fitur ini, dump crash kurang berguna atau bahkan tidak berguna.

Lihat diskusi tentang ini di CodePlex . Dan contoh menunjukkan perbedaannya .

Jika Anda tidak ingin menggunakan ifpernyataan dalam catchlingkup, di C# 6.0Anda dapat menggunakan Exception Filterssintaks yang sudah didukung oleh CLR dalam versi preview tetapi hanya ada di VB.NET/ MSIL:

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

Kode ini akan menangkap Exceptionhanya ketika itu InvalidDataExceptionatauArgumentNullException .

Sebenarnya, pada dasarnya Anda dapat meletakkan segala kondisi di dalam whenklausa itu:

static int a = 8;

...

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

Perhatikan bahwa sebagai lawan dari ifpernyataan di dalam catchruang lingkup, Exception Filterstidak bisa melempar Exceptions, dan ketika mereka melakukannya, atau ketika kondisinya tidak true, catchkondisi selanjutnya akan dievaluasi sebagai gantinya:

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

Output: Tangkapan umum.

Ketika ada lebih dari satu true Exception Filter- yang pertama akan diterima:

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

Output: Tangkap.

Dan seperti yang Anda lihat dalam MSILkode tidak diterjemahkan ke ifpernyataan, tetapi untuk Filters, dan Exceptionstidak dapat dilempar dari dalam area yang ditandai dengan Filter 1dan Filter 2tetapi filter yang melempar Exceptionakan gagal sebagai gantinya, juga nilai perbandingan terakhir didorong ke stack sebelum endfilterperintah akan menentukan keberhasilan / kegagalan filter ( Catch 1 XOR Catch 2 akan mengeksekusi sesuai):

Juga, secara khusus Guidmemiliki Guid.TryParsemetode.

Dengan C # 7 jawaban dari Michael Stum dapat ditingkatkan sambil menjaga keterbacaan pernyataan switch:

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

Dan dengan C # 8 sebagai ekspresi switch:

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

Jawaban yang diterima tampaknya dapat diterima, kecuali bahwa CodeAnalysis / FxCop akan mengeluh tentang fakta bahwa itu menangkap jenis pengecualian umum.

Juga, tampaknya operator "adalah" mungkin menurunkan kinerja sedikit.

CA1800: Jangan membuang yang tidak perlu kata yang untuk "pertimbangkan menguji hasil dari operator 'sebagai' sebagai gantinya," tetapi jika Anda melakukannya, Anda akan menulis lebih banyak kode daripada jika Anda menangkap setiap pengecualian secara terpisah.

Bagaimanapun, inilah yang akan saya lakukan:

bool exThrown = false;

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

if (exThrown)
{
    // Something else
}

di C # 6 pendekatan yang disarankan adalah menggunakan Filter Pengecualian, berikut ini sebuah contoh:

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

Ini adalah varian dari jawaban Matt (saya merasa ini sedikit lebih bersih) ... gunakan metode:

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

    WebId = Guid.Empty;
}

Pengecualian lain akan dilemparkan dan kode WebId = Guid.Empty;tidak akan terkena. Jika Anda tidak ingin pengecualian lain merusak program Anda, tambahkan saja ini SETELAH dua tangkapan lainnya:

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

Jawaban Joseph Daigle adalah solusi yang baik, tetapi saya menemukan struktur berikut menjadi sedikit lebih rapi dan lebih sedikit kesalahan.

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

    // Handle exception
}

Ada beberapa keuntungan dari membalikkan ekspresi:

• Pernyataan pengembalian tidak diperlukan
• Kode tidak bersarang
• Tidak ada risiko melupakan pernyataan 'melempar' atau 'kembali' yang dalam solusi Joseph dipisahkan dari ekspresi.

Ia bahkan dapat dipadatkan menjadi satu baris (meskipun tidak terlalu cantik)

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

    // Handle exception
}

Edit: The penyaringan pengecualian di C # 6.0 akan membuat sintaks sedikit lebih bersih dan dilengkapi dengan sejumlah manfaat lain atas setiap solusi saat ini. (terutama meninggalkan tumpukan tanpa terluka)

Berikut adalah bagaimana masalah yang sama akan terlihat menggunakan sintaks C # 6.0:

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

@Micheal

Versi kode Anda yang sedikit direvisi:

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

Perbandingan string jelek dan lambat.

Bagaimana tentang

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

Hati-hati dan Diperingatkan: Jenis fungsional fungsional yang lain.

Apa yang ada di tautan tidak menjawab pertanyaan Anda secara langsung, tetapi sepele untuk memperluasnya agar terlihat seperti:

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

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

(Pada dasarnya kosongkan yang lain Catch kelebihan yang mengembalikan sendiri)

Pertanyaan yang lebih besar adalah mengapa . Saya tidak berpikir biaya melebihi keuntungan di sini :)

Pembaruan 2015-12-15: Lihat https://stackoverflow.com/a/22864936/1718702 untuk C # 6. Ini lebih bersih dan sekarang standar dalam bahasa.

Diarahkan untuk orang yang menginginkan solusi yang lebih elegan untuk menangkap sekali dan memfilter pengecualian, saya menggunakan metode ekstensi seperti yang ditunjukkan di bawah ini.

Saya sudah memiliki ekstensi ini di perpustakaan saya, awalnya ditulis untuk tujuan lain, tetapi bekerja dengan sempurna untuk typememeriksa pengecualian. Plus, imho, itu terlihat lebih bersih daripada banyak ||pernyataan. Juga, tidak seperti jawaban yang diterima, saya lebih suka penanganan eksepsi eksplisit sehingga ex is ...memiliki perilaku yang tidak diinginkan karena kelas derivasi ditugaskan ke tipe induknya).

Pemakaian

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

Ekstensi IsAnyOf.cs (Lihat Contoh Penanganan Kesalahan Lengkap untuk Ketergantungan)

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

Contoh Penanganan Kesalahan Lengkap (Salin-Tempel ke aplikasi Konsol baru)

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

Dua Sampel Unit Tes NUnit

Perilaku mencocokkan untuk Exceptiontipe adalah tepat (mis. Seorang anak BUKAN pasangan yang cocok dengan tipe induknya).

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*/
            }
        }
    }
}

Karena saya merasa jawaban-jawaban ini hanya menyentuh permukaan, saya berusaha menggali lebih dalam.

Jadi yang ingin kita lakukan adalah sesuatu yang tidak dapat dikompilasi, katakan:

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

Alasan kami menginginkan ini adalah karena kami tidak ingin penangan pengecualian menangkap hal-hal yang kami butuhkan nanti dalam proses. Tentu, kita dapat menangkap Pengecualian dan memeriksa dengan 'jika' apa yang harus dilakukan, tapi jujur ​​saja, kita tidak benar-benar menginginkan itu. (FxCop, masalah debugger, keburukan)

Jadi mengapa kode ini tidak dapat dikompilasi - dan bagaimana kita bisa meretasnya sedemikian rupa sehingga akan terjadi?

Jika kita melihat kodenya, yang ingin kita lakukan adalah meneruskan panggilan. Namun, menurut MS Partition II, blok pengendali pengecualian IL tidak akan berfungsi seperti ini, yang dalam hal ini masuk akal karena itu akan menyiratkan bahwa objek 'pengecualian' dapat memiliki tipe yang berbeda.

Atau untuk menuliskannya dalam kode, kami meminta kompiler untuk melakukan sesuatu seperti ini (yah itu tidak sepenuhnya benar, tapi itu adalah hal yang paling dekat yang saya kira):

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

Alasan bahwa ini tidak akan dikompilasi cukup jelas: apa jenis dan nilai yang akan dimiliki objek '$ exception' (yang ada di sini disimpan dalam variabel 'e')? Cara kami ingin kompiler menangani ini adalah dengan mencatat bahwa tipe dasar umum dari kedua pengecualian adalah 'Pengecualian', menggunakannya untuk variabel yang berisi kedua pengecualian, dan kemudian hanya menangani dua pengecualian yang ditangkap. Cara ini diterapkan di IL adalah sebagai 'filter', yang tersedia di VB.Net.

Untuk membuatnya bekerja dalam C #, kita perlu variabel sementara dengan tipe dasar 'Pengecualian' yang benar. Untuk mengontrol aliran kode, kita dapat menambahkan beberapa cabang. Ini dia:

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

Kerugian yang jelas untuk ini adalah bahwa kita tidak dapat melempar ulang dengan benar, dan - yah jujur ​​saja - bahwa itu solusi yang jelek. Keburukan dapat diperbaiki sedikit dengan melakukan eliminasi cabang, yang membuat solusinya sedikit lebih baik:

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

Tinggal menyisakan 'lemparan ulang'. Agar ini berhasil, kita harus dapat melakukan penanganan di dalam blok 'tangkap' - dan satu-satunya cara untuk membuat pekerjaan ini adalah dengan menangkap objek 'Pengecualian'.

Pada titik ini, kita dapat menambahkan fungsi terpisah yang menangani berbagai jenis Pengecualian menggunakan resolusi kelebihan beban, atau untuk menangani Pengecualian. Keduanya memiliki kekurangan. Untuk memulai, inilah cara melakukannya dengan fungsi pembantu:

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

Dan solusi lainnya adalah menangkap objek Exception dan menanganinya sesuai. Terjemahan paling literal untuk ini, berdasarkan konteks di atas adalah ini:

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

Jadi untuk menyimpulkan:

• Jika kami tidak ingin melempar ulang, kami mungkin mempertimbangkan untuk menangkap pengecualian yang benar, dan menyimpannya untuk sementara waktu.
• Jika handler sederhana, dan kami ingin menggunakan kembali kode, solusi terbaik mungkin adalah memperkenalkan fungsi pembantu.
• Jika kita ingin melempar ulang, kita tidak punya pilihan selain memasukkan kode ke dalam catch handler 'Pengecualian', yang akan memecah FxCop dan pengecualian debugger yang tidak tertangkap.

Ini adalah masalah klasik yang dihadapi setiap pengembang C # pada akhirnya.

Biarkan saya membagi pertanyaan Anda menjadi 2 pertanyaan. Pertama,

Bisakah saya menangkap beberapa pengecualian sekaligus?

Singkatnya, tidak.

Yang mengarah pada pertanyaan selanjutnya,

Bagaimana cara saya menghindari menulis kode duplikat mengingat saya tidak bisa menangkap beberapa tipe pengecualian di blok catch () yang sama?

Mengingat sampel spesifik Anda, di mana nilai kembali lebih murah untuk dibangun, saya suka mengikuti langkah-langkah ini:

1. Inisialisasi WebId ke nilai mundur.
2. Bangun Guid baru dalam variabel sementara.
3. Setel WebId ke variabel sementara yang dibangun sepenuhnya. Jadikan ini pernyataan akhir dari blok coba {}.

Jadi kodenya terlihat seperti:

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) {}

Jika ada pengecualian yang dilemparkan, maka WebID tidak pernah diatur ke nilai setengah dibangun, dan tetap Guid.Empty.

Jika membangun kembali nilai itu mahal, dan mengatur ulang nilai jauh lebih murah, maka saya akan memindahkan kode reset ke fungsinya sendiri:

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

Jadi, Anda mengulang banyak kode dalam setiap pengecualian-switch? Kedengarannya seperti mengekstraksi metode akan menjadi ide dewa, bukan?

Jadi kode Anda sampai seperti ini:

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 */ }

Saya heran mengapa tidak ada yang memperhatikan duplikasi kode itu.

Dari C # 6 Anda selanjutnya memiliki filter pengecualian seperti yang telah disebutkan oleh orang lain. Jadi, Anda dapat mengubah kode di atas menjadi ini:

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

Ingin menambahkan jawaban singkat saya ke utas yang sudah lama ini. Sesuatu yang belum disebutkan adalah urutan prioritas pernyataan penangkapan, lebih khusus Anda perlu mengetahui ruang lingkup setiap jenis pengecualian yang Anda coba tangkap.

Sebagai contoh jika Anda menggunakan pengecualian "tangkap semua" sebagai Pengecualian, itu akan mendahului semua pernyataan tangkap lainnya dan Anda jelas akan mendapatkan kesalahan penyusun namun jika Anda membalik urutan, Anda dapat menyusun pernyataan tangkap Anda (sedikit anti-pola yang saya pikir ) Anda dapat meletakkan catch-all type Exception di bagian bawah dan ini akan menangkap setiap pengecualian yang tidak sesuai dengan yang lebih tinggi dalam percobaan Anda .. blok tangkapan:

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

Saya sangat merekomendasikan orang-orang meninjau dokumen MSDN ini:

Hirarki Pengecualian

Mungkin mencoba untuk menjaga kode Anda sederhana seperti menempatkan kode umum dalam suatu metode, seperti yang akan Anda lakukan di bagian lain dari kode yang tidak ada dalam klausa catch?

Misalnya:

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

// ...

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

Betapa saya akan melakukannya, berusaha menemukan yang sederhana adalah pola yang indah

Perhatikan bahwa saya memang menemukan satu cara untuk melakukannya, tetapi ini lebih mirip bahan untuk The Daily WTF :

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

Perlu disebutkan di sini. Anda dapat menanggapi beberapa kombinasi (Kesalahan pengecualian dan pengecualian. Pesan).

Saya mengalami skenario penggunaan kasus ketika mencoba untuk melemparkan objek kontrol dalam datagrid, dengan konten sebagai TextBox, TextBlock atau CheckBox. Dalam hal ini Pengecualian yang dikembalikan adalah sama, tetapi pesannya beragam.

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
} 

Saya ingin menyarankan jawaban terpendek (satu lagi gaya fungsional ):

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

Untuk ini, Anda perlu membuat beberapa metode "Catch" overload, mirip dengan 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));
    }

dan seterusnya sebanyak yang Anda inginkan. Tetapi Anda perlu melakukannya sekali dan Anda dapat menggunakannya di semua proyek Anda (atau, jika Anda membuat paket nuget, kami juga bisa menggunakannya).

Dan implementasi 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;
        }
    }

ps Saya belum menaruh cek nol untuk kesederhanaan kode, pertimbangkan untuk menambahkan validasi parameter.

ps2 Jika Anda ingin mengembalikan nilai dari tangkapan, perlu melakukan metode Penangkapan yang sama, tetapi dengan pengembalian dan Fungsi alih-alih Tindakan dalam parameter.

Panggil saja coba dan tangkap dua kali.

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

Sederhana saja !!

Dalam c # 6.0, Filter Pengecualian adalah peningkatan untuk penanganan pengecualian

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