Czy można złapać więcej niż jeden typ wyjątku dla każdego bloku?

Question

This question is close to what I want to do, ale nie do końca.

Czy istnieje sposób na uproszczenie następującego kodu?

private bool ValidDirectory(string directory) 
{ 
    if (!Directory.Exists(directory)) 
    { 
     if (MessageBox.Show(directory + " does not exist. Do you wish to create it?", this.Text) 
      == DialogResult.OK) 
     { 
      try 
      { 
       Directory.CreateDirectory(directory); 
       return true; 
      } 
      catch (IOException ex) 
      { 
       lblBpsError.Text = ex.Message; 
      } 
      catch (UnauthorizedAccessException ex) 
      { 
       lblBpsError.Text = ex.Message; 
      } 
      catch (PathTooLongException ex) 
      { 
       lblBpsError.Text = ex.Message; 
      } 
      catch (DirectoryNotFoundException ex) 
      { 
       lblBpsError.Text = ex.Message; 
      } 
      catch (NotSupportedException ex) 
      { 
       lblBpsError.Text = ex.Message; 
      } 
     } 
    } 

    return false; 
} 

Wydaje się odpady, a jeśli później chcą zmienić sposób mogę zgłosić błąd z powrotem do użytkownika, czy może chcę zalogować się tych błędów, czy cokolwiek, to muszę zmienić 5 różnych łapać bloki. Czy czegoś brakuje, czy też jest to rażąco przeciwko ponownemu użyciu kodu?

Czy staram się być (zbyt) leniwy?

Answer 1

Można użyć:

catch (SystemException ex) 
{ 
    if( (ex is IOException) 
     || (ex is UnauthorizedAccessException) 
// These are redundant 
// || (ex is PathTooLongException) 
// || (ex is DirectoryNotFoundException) 
     || (ex is NotSupportedException) 
    ) 
     lblBpsError.Text = ex.Message; 
    else 
     throw; 
} 

Answer 2

Można zrobić

ex.GetType()

widzieć http://msdn.microsoft.com/en-us/library/system.exception.gettype.aspx

EDIT

try    
{     
    Directory.CreateDirectory(directory); 
    return true;   
}    
catch (Exception ex)    
{ switch(ex.GetType()) 
     case ..... 
     case .......... 
    blBpsError.Text = ex.Message;    
} 

Answer 3

Jeśli wyjątki mają wspólny superklasę następnie można po prostu złapać superklasę .

Answer 4

Można złapać wyjątek klasy bazowej (wszystkie wyjątki wynikają z SystemException):

try 
{ 
    Directory.CreateDirectory(directory); 
    return true; 
} 
catch (SystemException ex) 
{ 
    lblBpsError.Text = ex.Message; 
} 

Ale wtedy może skończyć się łapanie wyjątków nie chcesz złapać.

Answer 5

Tak, starasz się być leniwy, ale lenistwo jest jednym z the virtues of a programmer, więc to jest dobre.

chodzi o twoje pytanie: nie ma sposobu Jestem świadomy, ale istnieją pewne obejścia dostępne:

• dać wyjątki wspólnego przodka. Myślę, że nie będzie to możliwe w twoim przypadku, ponieważ wydają się być wbudowane.
• Złap najbardziej ogólny wyjątek, jaki możesz.
• Przenieś kod obsługi do swojej własnej funkcji i wywołaj go z każdego bloku catch.

Answer 6

Jest to denerwujące, a inne odpowiedzi sugerują dobre obejścia (użyłbym @ Lotfi's).

Jednak takie zachowanie jest wymagane z uwagi na bezpieczeństwo typu C#.

Załóżmy, że może to zrobić:

try 
{ 
    Directory.CreateDirectory(directory); 
    return true; 
} 
catch (IOException, 
    UnauthorizedAccessException, 
    PathTooLongException, 
    DirectoryNotFoundException, 
    NotSupportedException ex) 
{ 
    lblBpsError.Text = ex.Message; 
} 

Teraz, jakiego rodzaju jest ex? Wszystkie mają .Message, ponieważ dziedziczą System.Exception, ale spróbuj uzyskać dostęp do dowolnej z ich innych właściwości i masz problem.

Answer 7

Należy również zauważyć, że przy wychwytywaniu więcej niż jednego rodzaju wyjątku powinny być one uporządkowane według większości ogólnych.Wyjątek znajdzie pierwszą na liście, która pasuje i rzuci ten błąd, żaden z pozostałych błędów nie zostanie zgłoszony.

Answer 8

Można użyć delegatów, zrobi to, co chcesz:

EDIT: uproszczone nieco

static void Main(string[] args) 
{ 
    TryCatch(() => { throw new NullReferenceException(); }, 
     new [] { typeof(AbandonedMutexException), typeof(ArgumentException), typeof(NullReferenceException) }, 
     ex => Console.WriteLine(ex.Message)); 

} 

public static void TryCatch(Action action, Type[] exceptions, Action<Exception> catchBlock) 
{ 
    try 
    { 
     action(); 
    } 
    catch (Exception ex) 
    { 
     if(exceptions.Any(p => ex.GetType() == p)) 
     { 
      catchBlock(ex); 
     } 
     else 
     { 
      throw; 
     } 
    } 
} 

Twój szczególności try/catch byłoby:

bool ret; 
TryCatch(
    () => 
     { 
      Directory.CreateDirectory(directory); 
      ret = true; 
     }, 
    new[] 
     { 
      typeof (IOException), typeof (UnauthorizedAccessException), typeof (PathTooLongException), 
      typeof (DirectoryNotFoundException), typeof (NotSupportedException) 
     }, 
    ex => lblBpsError.Text = ex.Message 
); 

return ret; 

Answer 9

I zrozum, że niektóre z tych wyjątków mogą nie być możliwe do przewidzenia, ale jeśli to możliwe, spróbuj wdrożyć własną logikę "wyprzedzającą". Wyjątki są drogie, ale w tym przypadku prawdopodobnie nie są złamaniem umowy.

Na przykład użyj Directory.GetAccessControl (...) zamiast polegać na wyrzucaniu wyjątku UnauthorizedAccessException.

Answer 10

Tylko dla kompletności, albowiem

w VB, można użyć warunkową obsługę wyjątków:

Try 
    … 
Catch ex As Exception When TypeOf ex Is MyException OrElse _ 
          TypeOf ex Is AnotherExecption 
    … 
End Try 

Taki Catch blok dostanie się jedynie do określonych wyjątków - w przeciwieństwie do C#.

Być może przyszła wersja C# będzie oferować podobną funkcję (w końcu istnieje specjalna instrukcja IL dla tego kodu).

MSDN: How to: Filter Errors in a Catch Block in Visual Basic

Answer 11

Zapoznaj się z The Exception Handling Application Block z EntLib. Opisują one bardzo dobrą metodologię obsługi wyjątków opartą na zasadach i konfiguracji, która pozwala uniknąć dużych bloków logicznych warunkowych.