Bir kerede birden fazla istisna yakalamak?


Al─▒nan cevaba git


Basit├že yakalamak cesareti vard─▒r System.Exception . Bunun yerine, yaln─▒zca "bilinen" istisnalar yakalanmal─▒d─▒r.

┼×imdi, bu bazen gereksiz tekrarlayan kodlara neden olur, ├Ârne─čin:

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

Merak ediyorum: Her iki istisnay─▒ yakalaman─▒n ve aramay─▒ yaln─▒zca bir WebId = Guid.Empty kez araman─▒n bir yolu var m─▒ ?

Verilen ├Ârnek sadece bir oldu─ču gibi, olduk├ža basittir GUID . Ancak bir nesneyi birden ├žok kez de─či┼čtirdi─činiz kodu hayal edin ve manip├╝lasyonlardan biri beklenen ┼čekilde ba┼čar─▒s─▒z olursa, "s─▒f─▒rlamak" istersiniz object . Ancak, beklenmeyen bir istisna varsa, yine de bunu daha y├╝kse─če f─▒rlatmak istiyorum.


1987









Cevap say─▒s─▒n─▒ say: 28






System.Exception T├╝rleri yakala ve a├ž

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

    throw;
}
 

1985







EDIT: C # 6.0'dan itibaren istisna filtrelerinin art─▒k m├╝kemmel bir yol oldu─čunu s├Âyleyen di─čerleriyle ayn─▒ fikirdeyim: catch (Exception ex) when (ex is ... || ex is ... )

Bunun d─▒┼č─▒nda, bir sat─▒rl─▒k d├╝zenden hala nefret ediyorum ve kodu ki┼čisel olarak a┼ča─č─▒daki gibi d├╝zenleyece─čim. Bunun estetik oldu─ču kadar i┼člevsel oldu─čunu d├╝┼č├╝n├╝yorum, ├ž├╝nk├╝ anlama becerisini geli┼čtirdi─čine inan─▒yorum. Baz─▒lar─▒ kat─▒lm─▒yorum:

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

OR─░J─░NAL:

Partiye biraz ge├ž kald─▒─č─▒m─▒ biliyorum ama kutsal duman ...

Do─čruca kovalamaca kesmek, bu t├╝r bir kopya daha ├Ânceki bir cevab─▒ ├žo─čalt─▒r, ancak birka├ž istisna t├╝r├╝ i├žin ortak bir i┼člem yapmak ve her ┼čeyi bir y├Ântem kapsam─▒nda d├╝zenli ve d├╝zenli tutmak istiyorsan─▒z, neden sadece lambda kullanm─▒yorsunuz? / closure / inline i┼člevi a┼ča─č─▒daki gibi bir ┼čey yapacak m─▒? Demek istedi─čim, ┼čans─▒n─▒z─▒ tamamen kapatman─▒z─▒n, sadece bu kapatmay─▒ her yerde kullanabilece─činiz ayr─▒ bir y├Ântem yapmak istedi─činizi fark edersiniz. Ancak, kodun geri kalan─▒n─▒ yap─▒sal olarak de─či┼čtirmeden bunu yapmak ├žok kolay olacak. Sa─č?

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

Yard─▒m edemiyorum ama merak ediyorum ( uyar─▒: biraz ironi / alayc─▒ ileride) neden d├╝nyadaki t├╝m bu ├žabay─▒ temelde a┼ča─č─▒dakilerin yerine koymaya ├žal─▒┼č─▒yorum:

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

... bu sonraki kod kokusunun ├ž─▒lg─▒nca bir ├že┼čitlemesiyle, sadece birka├ž tu┼ča basm─▒┼č gibi yapt─▒─č─▒n─▒z─▒ iddia etmek i├žin bir ├Ârnek.

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

├ç├╝nk├╝ kesinlikle otomatik olarak daha okunakl─▒ de─čil.

Verilmi┼č, /* write to a log, whatever... */ return; ilk ├Ârnekten ├╝├ž ayn─▒ ├Ârne─či b─▒rakt─▒m .

Ama bu benim a├ž─▒mdan bir ┼čey. Hepiniz i┼člev / y├Ântem duydunuz, de─čil mi? Ciddi anlamda. Ortak bir ErrorHandler i┼člev yaz─▒n ve her yakalama blo─čundan buna benzer.

Bana sorarsan─▒z, ikinci ├Ârnek ( if ve is anahtar kelimelerle birlikte) hem projenizin bak─▒m a┼čamas─▒nda hem de daha az okunabilir ve ayn─▒ anda ├žok daha fazla hataya a├ž─▒k.

Programlamada nispeten yeni olabilecek herhangi biri i├žin bak─▒m a┼čamas─▒, projenizin genel ├Âmr├╝n├╝n% 98,7'sini veya daha fazlas─▒n─▒ i├žerecek ve bak─▒m─▒ yapan zavall─▒ adam neredeyse kesinlikle sizden ba┼čka biri olacak. Ve zamanlar─▒n─▒n% 50'sini ismine k├╝frederek i┼če harcayacaklar─▒ ├žok iyi bir ┼čans var.

Ve tabii FxCop sana ve zorunda kabuklar─▒ da kesin olarak ├žal─▒┼čan program ile yapmak zip gelmi┼čtir Kodunuza bir ├Âznitelik eklemek ve vakalar─▒n 99.9% olarak tamamen oldu─čuna bir sorunu g├Ârmezden FxCop anlatmak i├žin sadece orada i┼čaretlemede d├╝zelt Ve ├╝zg├╝n├╝m, yan─▒lm─▒┼č olabilirim, ancak bu "yoksay" niteli─či asl─▒nda uygulaman─▒za eklenmemi┼č mi?

if Testin tamam─▒n─▒ bir sat─▒ra koymak, daha okunakl─▒ hale getirebilir mi? Sanm─▒yorum Demek istedi─čim, ├žok uzun zaman ├Ânce, bir sat─▒ra daha fazla kod koyman─▒n "daha h─▒zl─▒ ├žal─▒┼čmas─▒n─▒" sa─člayaca─č─▒n─▒ ┼čiddetle tart─▒┼č─▒yordum. Ama elbette ├ž─▒ld─▒rm─▒┼č somun gibiydi. Terc├╝man veya derleyicinin, bu uzun ├žizgiyi, sat─▒r ba┼č─▒na tek bir talimat ba┼č─▒na ayr─▒ ayr─▒ ifadelere ay─▒rd─▒─č─▒n─▒ - esas olarak ilerlemi┼č olsayd─▒ sonu├žla ├Âzde┼čle┼čtirilece─čini (d├╝z bir y├╝zle - ki bu zorlu) a├ž─▒klamaya ├žal─▒┼čmak ve sadece derleyiciyi zekice ├ž├Âzmeye ├žal─▒┼čmak yerine kodu okunabilir hale getirdi - onun ├╝zerinde hi├žbir etkisi olmad─▒. Ama ben dal─▒yorum.

Bundan bir veya iki ay sonra ├╝├ž istisna t├╝r├╝ ekledi─činizde, bu ne kadar az okunabilir oluyor? (Cevap: Bir olur ├žok az okunabilir).

Ger├žekten de en ├Ânemli noktalardan biri, her g├╝n ara┼čt─▒─č─▒m─▒z metin kaynak kodunu bi├žimlendirme noktas─▒n─▒n ├žo─čunun, kod ├žal─▒┼čt─▒r─▒ld─▒─č─▒nda ger├žekte olanlar─▒ ger├žekten, ger├žekten, ger├žekten a├ž─▒k├ža ortaya koymakt─▒r. ├ç├╝nk├╝ derleyici kaynak kodunu tamamen farkl─▒ bir ┼čeye d├Ân├╝┼čt├╝r├╝r ve kod bi├žimlendirme stilinize daha az ├Ânem vermez. Yani hepsi bir arada hat da tamamen berbat.

Sadece s├Âyl├╝yorum...

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

508







Di─čerlerinin de belirtti─či gibi, if neler olup bitti─čini belirlemek i├žin catch blo─čunuzun i├žinde bir ifade olabilir . C # 6 ├ľzel Durum Filtrelerini destekler, b├Âylece a┼ča─č─▒dakiler i┼če yarayacakt─▒r:

 try { ÔÇŽ }
catch (Exception e) when (MyFilter(e))
{
    ÔÇŽ
}
 

MyFilter Y├Ântemi, daha sonra b├Âyle bir ┼čey olabilir:

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

Alternatif olarak, t├╝m bunlar sat─▒r i├ži yap─▒labilir (when ifadesinin sa─č taraf─▒ sadece bir boole ifadesi olmal─▒d─▒r).

 try { ÔÇŽ }
catch (Exception e) when (e is ArgumentNullException || e is FormatException)
{
    ÔÇŽ
}
 

Bu kullanarak farkl─▒d─▒r if i├žinden deyimi catch , blo─čun istisna filtreleri kullanarak olmayacakt─▒r y─▒─č─▒n─▒n─▒ gev┼čeyin.

Bunu kontrol etmek i├žin Visual Studio 2015'i indirebilirsiniz .

Visual Studio 2013'├╝ kullanmaya devam etmek istiyorsan─▒z, a┼ča─č─▒daki nuget paketini y├╝kleyebilirsiniz:

Paket Kur Microsoft.Net.Compilers

Yazma s─▒ras─▒nda, bu C # 6 i├žin destek i├žerecektir.

Bu pakete at─▒fta bulunmak, projenin, sistemde kurulu herhangi bir versiyonun aksine, pakette bulunan C # ve Visual Basic derleyicilerinin belirli versiyonlar─▒n─▒ kullanarak in┼ča edilmesine neden olacakt─▒r.


327


2014-04-04





C # dilinde de─čil, bunu yapmak i├žin bir istisna filtresine ihtiya├ž duyaca─č─▒n─▒z ve C # MSIL'in bu ├Âzelli─čini g├Âstermedi─či i├žin. VB.NET bu yetene─če sahiptir, ├Ârne─čin;

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

Yapabilecekleriniz, hata kodunuzu kaps├╝llemek i├žin ads─▒z bir i┼člev kullanmak ve daha sonra bu ├Âzel catch bloklar─▒nda onu ├ža─č─▒rmakt─▒r:

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

185







Eksiklik ad─▒na, .NET 4.0'dan beri kod ┼ču ┼čekilde yeniden yaz─▒labilir:

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

TryParse hi├žbir zaman istisna alamaz ve bi├žim yanl─▒┼čsa WebId'yi ayarlayarak yanl─▒┼č d├Ând├╝r├╝r Guid.Empty .


C # 7'den beri , bir de─či┼čkeni ayr─▒ bir sat─▒ra sokmaktan ka├ž─▒nabilirsiniz:

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

Ayr─▒ca, .NET Framework'te hen├╝z kullan─▒ma sunulmam─▒┼č olan ve 4.6 s├╝r├╝m├╝nden itibaren kullan─▒lmayan d├Ânen dosya ayr─▒┼čt─▒rma y├Ântemleri de olu┼čturabilirsiniz:

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

Ve onlar─▒ ┼ču ┼čekilde kullan─▒n:

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

Bu yarars─▒z cevab─▒n bir sonraki faydas─▒z g├╝ncellemesi, C # 12'de parametrelerin yap─▒dan kald─▒r─▒lmas─▒yla ger├žekle┼čtirildi─činde gelir. :)


130







─░stisna filtreleri ┼čimdi c # 6+ ile kullan─▒labilir. Yapabilirsin

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

C # 7.0+ 'de, bunu ┼čablon e┼čle┼čtirme ile de birle┼čtirebilirsiniz.

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

79







Uygulaman─▒z─▒ C # 6'ya y├╝kseltebiliyorsan─▒z, ┼čansl─▒s─▒n─▒z. Yeni C # s├╝r├╝m├╝ ─░stisna filtreleri uygulad─▒. B├Âylece ┼čunu yazabilirsiniz:

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

Baz─▒ insanlar bu kodun ayn─▒ oldu─čunu d├╝┼č├╝n├╝yor

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

Ama de─čil. Asl─▒nda bu C # 6'daki ├Ânceki s├╝r├╝mlerde ├Âyk├╝nmesi m├╝mk├╝n olmayan tek yeni ├Âzellik. ─░lk ├Ânce, bir yeniden atmak, mandal─▒n atlanmas─▒ndan daha fazla ek y├╝k anlam─▒na gelir. ─░kincisi, anlamsal olarak e┼čde─čer de─čildir. Yeni ├Âzellik, kodunuzda hata ay─▒klama yaparken y─▒─č─▒n─▒ korur. Bu ├Âzellik olmadan ├žarpma d├Âk├╝m├╝ daha az kullan─▒┼čl─▒, hatta i┼če yaramaz.

Bu konuda CodePlex'te bir tart─▒┼čma bak─▒n . Ve fark─▒ g├Âsteren bir ├Ârnek .


72







Bir kullanmak istemiyorsan─▒z if i├žinde a├ž─▒klama catch g├Âr├╝┼č cihaz─▒, i├žinde C# 6.0 kullanabilece─činiz Exception Filters s├Âzdizimi zaten ├Ânizleme s├╝r├╝mlerinde CLR taraf─▒ndan desteklenen ancak varolan edildi VB.NET / MSIL :

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

Bu kod yakalayacak Exception bir olunca sadece InvalidDataException ya ArgumentNullException .

Asl─▒nda, bu when f─▒kran─▒n i├žine temel olarak herhangi bir ┼čart─▒ koyabilirsiniz :

 static int a = 8;

...

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

Kapsam─▒ if i├žindeki bir ifadenin aksine catch , Exception Filters f─▒rlatma yapamayaca─č─▒n─▒n Exceptions ve yapt─▒klar─▒nda veya ko┼čul olmad─▒─č─▒nda bir true sonraki catch ko┼čulun de─čerlendirilece─čini unutmay─▒n:

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

Çıktı: Genel yakalama.

Bir taneden fazla oldu─čunda true Exception Filter - ilk kabul edilir:

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

Çıktı: Yakala.

─░├žinde g├Ârd├╝─č├╝n├╝z gibi MSIL koduna ├ževrilmez if tablolarda, bunlarla Filters ve Exceptions i┼čaretli alanlar─▒n i├žinden atmak olamaz Filter 1 ve Filter 2 ancak atma filtre Exception yerine ba┼čar─▒s─▒z olur, ayn─▒ zamanda son kar┼č─▒la┼čt─▒rma de─čeri ├Ânce y─▒─č─▒n─▒na itilir endfilter komuta Filtrenin ba┼čar─▒s─▒n─▒ / ba┼čar─▒s─▒zl─▒─č─▒n─▒ belirleyecektir ( Catch 1 XOR Catch 2 buna g├Âre ├žal─▒┼čacakt─▒r):


─░stisna Filtreleri MSIL

Ayr─▒ca, spesifik olarak Guid yer al─▒r Guid.TryParse y├Ântem.


31







C # 7 ile , bir anahtar ifadenin okunabilirli─čini korurken Michael Stum'un yan─▒t─▒ geli┼čtirilebilir:

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

21







Kabul edilen cevap kabul edilebilir gibi g├Âr├╝n├╝yor, ancak CodeAnalysis / FxCop genel bir istisna t├╝r├╝ yakalad─▒─č─▒ndan ┼čikayet ediyor.

Ayr─▒ca, "is" operat├Âr├╝ performans─▒ biraz d├╝┼č├╝rebilir gibi g├Âr├╝n├╝yor.

CA1800: Gereksiz yere "sak─▒n" yerine "i┼čle├ž olarak" sonucunu test etmeyi d├╝┼č├╝n "diyor, ancak bunu yaparsan─▒z, her istisnay─▒ ayr─▒ ayr─▒ yakalad─▒─č─▒n─▒zdan daha fazla kod yazacaks─▒n─▒z.

Her neyse, i┼čte yapaca─č─▒m ┼čey:

 bool exThrown = false;

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

if (exThrown)
{
    // Something else
}
 

18


2010-07-30





C # 6'da ├Ânerilen yakla┼č─▒m ─░stisna Filtreleri kullanmakt─▒r, i┼čte bir ├Ârnek:

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

18


2015-10-04





Bu Matt'in cevab─▒n─▒n bir ├že┼čididir (bunun biraz daha temiz oldu─čunu d├╝┼č├╝n├╝yorum) ... bir y├Ântem kullan─▒n:

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

    WebId = Guid.Empty;
}
 

Ba┼čka istisnalar da at─▒lacak ve kod WebId = Guid.Empty; etkilenmeyecek. Di─čer istisnalar─▒n program─▒n─▒z─▒ ├ž├Âkertmesini istemiyorsan─▒z, di─čer iki al─▒c─▒dan sonra ┼čunu eklemeniz yeterlidir:

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

17







Joseph Daigle'nin Cevab─▒ iyi bir ├ž├Âz├╝m, ancak a┼ča─č─▒daki yap─▒n─▒n biraz daha d├╝zenli ve daha az hataya meyilli oldu─čunu g├Ârd├╝m.

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

    // Handle exception
}
 

─░fadeyi tersine ├ževirmenin birka├ž avantaj─▒ vard─▒r:

  • Bir iade ifadesi gerekli de─čildir
  • Kod i├ž i├že ge├žmemi┼č
  • Joseph'in ├ž├Âz├╝m├╝nde ifadeden ayr─▒lan ÔÇťatmaÔÇŁ veya ÔÇťgeri d├Ân├╝┼čÔÇŁ ifadelerini unutma riski yoktur.

Tek bir hatta bile s─▒k─▒┼čt─▒r─▒labilir (├žok ho┼č olmasa da)

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

    // Handle exception
}
 

D├╝zenleme: istisna filtreleme C # 6.0 s├Âzdizimini biraz daha temiz hale ve bir ile gelir olacak di─čer faydalar─▒ say─▒s─▒nda herhangi Ge├žerli ├ž├Âz├╝m ├╝zerinde. (en ├Ânemlisi y─▒─č─▒n─▒ zarar g├Ârmeden b─▒rakmak)

─░┼čte ayn─▒ sorunun C # 6.0 s├Âzdizimini kullanarak nas─▒l g├Âr├╝nd├╝─č├╝n├╝ ┼č├Âyle g├Âsterir:

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

17







@Micheal

Kodunuzun biraz g├Âzden ge├žirilmi┼č hali:

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

Dize kar┼č─▒la┼čt─▒rmalar─▒ ├žirkin ve yava┼čt─▒r.


16







Peki ya

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

13







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

12







Dikkatli ve Uyar─▒lm─▒┼č: Yine ba┼čka bir t├╝r, fonksiyonel stil.

Ba─člant─▒da yer alan soru do─črudan sorunuzu yan─▒tlam─▒yor, ancak bunun gibi g├Âr├╝nmesini sa─člamak i├žin ├Ânemsiz:

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

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

(Temel olarak, Catch kendisine geri d├Ânen ba┼čka bir bo┼č a┼č─▒r─▒ y├╝k sa─člay─▒n )

Bunun en b├╝y├╝k sorusu neden . Maliyetin buradaki kazan├žtan daha a─č─▒r oldu─čunu sanm─▒yorum :)


11







G├╝ncelleme 2015-12-15: C # 6 i├žin https://stackoverflow.com/a/22864936/1718702 adresine bak─▒n . Bu dil daha temiz ve ┼čimdi standart.

Bir kez yakalamak ve istisnalar─▒ filtrelemek i├žin daha zarif bir ├ž├Âz├╝m isteyen insanlara y├Ânelik , a┼ča─č─▒da g├Âsterildi─či gibi bir uzatma y├Ântemi kullan─▒yorum.

Bu uzant─▒y─▒ k├╝t├╝phanemde daha ├Ânce ba┼čka ama├žlar i├žin yazm─▒┼čt─▒m, ancak type istisnalar─▒ kontrol etmek i├žin m├╝kemmel bir ┼čekilde ├žal─▒┼čt─▒ . Ayr─▒ca, imho, bir s├╝r├╝ || ifadeden daha temiz g├Âr├╝n├╝yor . Ayr─▒ca, kabul edilen cevab─▒n aksine, a├ž─▒k istisna muamelesini tercih ederim, bu y├╝zden ex is ... dezavantajl─▒ s─▒n─▒flar orada ebeveyn t├╝rlerine atanabildi─činden, istenmeyen davran─▒┼ča sahipti.

kullan─▒m

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

IsAnyOf.cs Uzant─▒s─▒ (Bkz. Dependancies i├žin Tam Hata ─░┼čleme ├ľrne─či)

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

Tam Hata ─░┼čleme ├ľrne─či (Yeni Konsol uygulamas─▒na kopyala-yap─▒┼čt─▒r)

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

─░ki ├ľrnek Birim Birim Testleri

T├╝rler i├žin e┼čle┼čtirme davran─▒┼č─▒ Exception kesindir (├Âr. Bir ├žocuk, ├╝st t├╝rlerinden hi├žbiriyle e┼čle┼čmiyor).

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

9







Bu cevaplar sadece y├╝zeye dokundu─čunu hissetti─čim i├žin, biraz daha derine inmeye ├žal─▒┼čt─▒m.

Yani yapmak istedi─čimiz ┼čey derlenmeyen bir ┼čey, der ki:

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

Bunu istememizin nedeni, istisna i┼čleyicisinin daha sonra ihtiya├ž duydu─čumuz ┼čeyleri i┼člemde yakalamas─▒n─▒ istemememizdir. Tabii ki, bir ─░stisna yakalayabilir ve 'e─čer' ile ne yapaca─č─▒m─▒z─▒ kontrol edebiliriz, ama d├╝r├╝st olal─▒m, bunu ger├žekten istemiyoruz. (FxCop, hata ay─▒klay─▒c─▒ sorunlar─▒, ├žirkinlik)

├ľyleyse neden bu kod derlenmeyecek - ve onu nas─▒l yapacak ┼čekilde hackleyelim?

E─čer koda bakarsak, yapmak istedi─čimiz ┼čey aramay─▒ iletmek. Bununla birlikte, MS Partition II'ye g├Âre, IL istisna eylemci bloklar─▒ bu ┼čekilde ├žal─▒┼čmaz, bu durumda 'istisna' nesnesinin farkl─▒ tiplere sahip olabilece─či anlam─▒na gelir, ├ž├╝nk├╝ bu mant─▒kl─▒d─▒r.

Ya da koduna yazmak i├žin, derleyiciden b├Âyle bir ┼čey yapmas─▒n─▒ istiyoruz (tamam─▒yla do─čru de─čil, ama san─▒r─▒m en yak─▒n ┼čey bu):

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

Bunun derlenmemesinin nedeni a├ž─▒kt─▒r: '$ exception' nesnesinin t├╝r├╝ ve de─čeri ne olurdu (burada 'e' de─či┼čkenlerinde saklan─▒r)? Derleyicinin bunu ele almas─▒n─▒ istedi─čimiz yol, her iki istisnan─▒n ortak taban t├╝r├╝n├╝n '─░stisna' oldu─čunu belirtmek, bunu bir de─či┼čkenin her iki istisnay─▒ i├žermesi i├žin kullanmak ve ard─▒ndan yakalanan yaln─▒zca iki istisnay─▒ ele almakt─▒r. Bunun ILÔÇÖde uygulanma ┼čekli, VB.NetÔÇÖte mevcut olan ÔÇťfiltreÔÇŁ dir.

C # 'da ├žal─▒┼čmas─▒n─▒ sa─člamak i├žin, do─čru' ─░stisna 'taban tipine sahip ge├žici bir de─či┼čkene ihtiyac─▒m─▒z var. Kod ak─▒┼č─▒n─▒ kontrol etmek i├žin baz─▒ dallar ekleyebiliriz. ─░┼čte gidiyor:

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

Bunun bariz dezavantajlar─▒, d├╝zg├╝n ┼čekilde tekrar atamayaca─č─▒m─▒z ve -d├╝r├╝st olmak gerekirse, olduk├ža ├žirkin bir ├ž├Âz├╝m. ├çirkinlik dal─▒ ortadan kald─▒rarak biraz giderilebilir, bu da ├ž├Âz├╝m├╝ biraz daha iyi yapar:

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

Bu sadece 'yeniden atma' b─▒rak─▒yor. Bunun ├žal─▒┼čmas─▒ i├žin, 'catch' blo─ču i├žindeki i┼člemi ger├žekle┼čtirebilmemiz gerekir - ve bu i┼či yapman─▒n tek yolu, bir 'Exception' nesnesi yakalamakt─▒r.

Bu noktada, a┼č─▒r─▒ y├╝k ├ž├Âz├╝n├╝rl├╝─č├╝ kullanarak farkl─▒ ─░stisna t├╝rlerini i┼čleyen veya ─░stisna'y─▒ ele almak i├žin ayr─▒ bir i┼člev ekleyebiliriz. Her ikisi de dezavantajlara sahiptir. Ba┼člamak i├žin, i┼čte yard─▒mc─▒ i┼čleviyle yapman─▒n yolu:

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

Di─čer ├ž├Âz├╝m, Exception nesnesini yakalamak ve buna g├Âre kullanmakt─▒r. Bunun i├žin en fazla ├ževiri, yukar─▒daki i├žeri─če dayanarak ┼č├Âyledir:

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

Sonu├ž olarak:

  • Yeniden atmak istemezsek, do─čru istisnalar─▒ yakalamay─▒ ve ge├žici olarak saklamay─▒ d├╝┼č├╝nebiliriz.
  • ─░┼čleyici basitse ve kodu tekrar kullanmak istiyorsak, en iyi ├ž├Âz├╝m muhtemelen bir yard─▒mc─▒ i┼člev sunmakt─▒r.
  • Yeniden atmak istiyorsak, kodu FxCop ve hata ay─▒klay─▒c─▒n─▒z─▒n yakalanmam─▒┼č istisnalar─▒n─▒ k─▒racak bir '─░stisna' yakalama i┼čleyicisine koymaktan ba┼čka se├žene─čimiz yok.

7







Bu, her C # geli┼čtiricisinin sonunda kar┼č─▒la┼čt─▒─č─▒ klasik bir sorundur.

Sorunu 2 soruya b├Âlmeme izin ver. ─░lk,

Ayn─▒ anda birden fazla istisna yakalayabilir miyim?

K─▒sacas─▒ hay─▒r.

Bundan sonraki soruya yol a├žar,

Ayn─▒ catch () blo─čunda birden fazla istisna t├╝r├╝n├╝ yakalayamad─▒─č─▒m i├žin yinelenen kod yazmaktan nas─▒l ka├ž─▒nabilirim?

Geri d├Ân├╝┼č de─čerinin in┼ča edilmesinin ucuz oldu─ču ├Âzel ├Ârne─činize g├Âre, ┼ču ad─▒mlar─▒ izlemeyi seviyorum:

  1. WebId'yi geri d├Ân├╝┼č de─čerine s─▒f─▒rlay─▒n.
  2. Ge├žici bir de─či┼čkende yeni bir K─▒lavuz olu┼čturun.
  3. WebId'yi tamamen olu┼čturulan ge├žici de─či┼čkene ayarlay─▒n. Bunu try {} blo─čunun son ifadesi yap─▒n.

Yani kod ┼č├Âyle g├Âz├╝k├╝yor:

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

Herhangi bir istisna at─▒l─▒rsa, WebId hi├žbir zaman yar─▒ olu┼čturulan de─čere ayarlanmaz ve Guid.Empty olarak kal─▒r.

Geri d├Ân├╝┼č de─čerinin olu┼čturulmas─▒ pahal─▒ysa ve bir de─čeri s─▒f─▒rlamak ├žok daha ucuzsa, s─▒f─▒rlama kodunu kendi i┼člevine ta┼č─▒rd─▒m:

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

7







Yani her istisna anahtar─▒nda ├žok say─▒da kod mu tekrarl─▒yorsunuz? Bir y├Ântemi ├ž─▒karmak gibi g├Âr├╝n├╝yor tanr─▒ fikri olurdu, de─čil mi?

Demek kodunuz buna ba─čl─▒:

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

Neden kimsenin bu kod ├žo─čaltmay─▒ fark etmedi─čini merak ediyorum.

C # 6'dan ba┼čkalar─▒ taraf─▒ndan daha ├Ânce belirtildi─či gibi istisna filtrelerine de sahipsiniz . B├Âylece yukar─▒daki kodu bu ┼čekilde de─či┼čtirebilirsiniz:

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

6







Bu zaten uzun olan konuya k─▒sa cevab─▒m─▒ eklemek istedim. S├Âz edilmemi┼č olan bir ┼čey, catch ifadelerinin ├Âncelik s─▒ras─▒d─▒r, daha ├Âzel olarak, yakalamaya ├žal─▒┼čt─▒─č─▒n─▒z her istisna t├╝r├╝n├╝n kapsam─▒n─▒ bilmeniz gerekir.

├ľrne─čin, ─░stisna olarak bir "t├╝m├╝-t├╝m├╝" istisnas─▒ kullan─▒rsan─▒z, di─čer t├╝m ifadelerin ├Ân├╝ne ge├žecek ve a├ž─▒k bir ┼čekilde derleyici hatalar─▒ alacaks─▒n─▒z ancak s─▒ray─▒ tersine ├ževirirseniz, yakalama ifadelerinizi zincirleyebilir (bence bir anti-kal─▒ptan bence) ) catch-all ─░stisnalar tipini en alta koyabilirsiniz ve bu, denemeniz i├žin daha ├Ânce istemedi─činiz t├╝m istisnalar─▒ yakalayacakt─▒r.

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

─░nsanlar─▒n bu MSDN belgesini incelemelerini ┼čiddetle tavsiye ederim:

─░stisna Hiyerar┼čisi


4







Belki kodunuzu, bir kod i├žinde, herhangi bir catch c├╝mlesi i├žinde olmayan di─čer herhangi bir b├Âl├╝mde yapt─▒─č─▒n─▒z gibi, bir metoda koymak gibi basit tutmaya ├žal─▒┼čabilirsiniz.

├ľrne─čin:

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

// ...

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

Nas─▒l yapard─▒m basit bulmaya ├žal─▒┼č─▒rken g├╝zel desen


3







Bunu yapman─▒n bir yolunu buldu─čumu unutmay─▒n, ancak bu The Daily WTF i├žin daha ├žok materyal gibi g├Âr├╝n├╝yor :

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

1







Burada bahsetmeye de─čer. Birden ├žok kombinasyona cevap verebilirsiniz (─░stisna hatas─▒ ve istisna. Mesaj─▒).

TextBox, TextBlock veya CheckBox gibi bir i├žerik i├žeren bir datagrid'de kontrol nesnesini yay─▒nlamaya ├žal─▒┼č─▒rken senaryo senaryosuna girdim. Bu durumda, geri g├Ânderilen ─░stisna ayn─▒yd─▒, ancak mesaj farkl─▒yd─▒.

 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
} 
 

1







En k─▒sa cevap (bir daha i┼člevsel stil ) ├Ânermek istiyorum :

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

Bunun i├žin, System.Action'a benzer birka├ž "Catch" y├Ântemi a┼č─▒r─▒ y├╝klemesi olu┼čturman─▒z gerekir:

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

ve istedi─činiz kadar. Ancak bunu bir kez yapman─▒z gerekir ve t├╝m projelerinizde kullanabilirsiniz (ya da bir nuget paketi olu┼čturduysan─▒z, biz de kullanabiliriz).

Ve CatchMany uygulamas─▒:

     [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 Kod basitli─či i├žin bo┼č denetimler almad─▒m, parametre do─črulamalar─▒ eklemeyi d├╝┼č├╝n├╝n.

ps2 E─čer al─▒c─▒dan bir de─čer d├Ând├╝rmek istiyorsan─▒z, ayn─▒ Catch y├Ântemlerini yapmak gerekir, ancak parametrelerde Action yerine return ve Func komutlar─▒ gerekir.


0







Sadece deneyin ve iki kez yakalay─▒n.

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

Sadece bu kadar basit!


-15







C # 6.0'da, ─░stisna Filtreleri istisna i┼čleme i├žin iyile┼čtirmelerdir

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

-23



─░lgili yay─▒nlar


Bir sat─▒rda birden fazla istisna yakalay─▒n (blok hari├ž)

Stilleri ayn─▒ anda birden fazla s─▒n─▒fa nas─▒l uygulayabilirim?

Bir yakalama blo─čunda birden fazla istisna t├╝r├╝n├╝ yakalamak

Birden ├žok modeli ayn─▒ anda sed ile nas─▒l de─či┼čtirebilirim?

Ayn─▒ anda birden fazla paket y├╝kleyin

SQL Server'da bir kerede birden fazla s├╝tun nas─▒l ALTER

Ayn─▒ anda birden fazla de─či┼čkene ayn─▒ de─čeri atama

Ayn─▒ anda birden fazla kareyi ├Âny├╝kleme karuseli

Linux'ta Bash'te ayn─▒ anda birden fazla dosya nas─▒l silinir?

MKMapView'├╝n bir kerede birden fazla a├ž─▒klama g├Âsterecek ┼čekilde konumland─▒r─▒lmas─▒

Etiketle ilgili di─čer sorular [c#]


MVP ve MVC nedir ve fark nedir?

Etkinlik, ba┼člang─▒├žta eklenen pencereyi s─▒zd─▒r─▒yor

Alt─▒gen rengini (veya rgb ve kar─▒┼č─▒m renklerini) programatik olarak a├ž─▒kla┼čt─▒r

PHP ile MySQL veri tarihinden ba┼čka bir formata d├Ân├╝┼čt├╝rme

Vim 80 s├╝tun d├╝zeni endi┼čeleri

ASP.NET'te bir kullan─▒c─▒n─▒n istemci IP adresi nas─▒l al─▒n─▒r?

nodejs vs nub 12.04 ├╝zerindeki d├╝─č├╝m

JavaScript - T├╝m virg├╝lleri bir dizgede de─či┼čtirin [duplicate]

Bir makefile 'cd' komutunu nas─▒l yazar─▒m?

Bir anahtar─▒n s├Âzl├╝kte olup olmad─▒─č─▒n─▒ nas─▒l kontrol edebilirim? [├žift]