Riesci a rilevare più di un tipo di eccezione con ogni blocco?

Question

This question is close to what I want to do, ma non proprio lì.

C'è un modo per semplificare il seguente codice?

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

Sembra uno spreco, e se poi voglio cambiare il modo segnalo un errore indietro per l'utente, o forse voglio registrare questi errori, o qualsiasi altra cosa, quindi ho avuto modo di cambiare 5 diversi prendere blocchi. Mi sto sfuggendo qualcosa, o è palesemente contro il riutilizzo del codice?

Sto solo cercando di essere (troppo) pigro?

Answer 1

È possibile utilizzare:

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

Si può fare

ex.GetType()

vedere 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

Se le eccezioni condividere una superclasse comune, allora si può solo prendere la superclasse .

Answer 4

si può prendere un'eccezione classe di base (tutte le eccezioni derivano da SystemException):

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

Ma poi si può finire per la cattura di eccezioni che non si desidera per la cattura.

Answer 5

Sì, si sta cercando di essere pigro, ma la pigrizia è una delle the virtues of a programmer, così va bene.

Per quanto riguarda la tua domanda: non c'è modo io sono a conoscenza, ma ci sono alcune soluzioni alternative disponibili:

• dare al Eccezioni un antenato comune. Penso che questo non sarà possibile nel tuo caso, dal momento che sembra essere costruito.
• Cattura l'eccezione più generica che puoi.
• Spostare il codice di gestione nella propria funzione e chiamarlo da ogni blocco di cattura.

Answer 6

Questo è fastidioso, e altre risposte hanno suggerito buoni soluzioni (io userei @ Lotfi).

Tuttavia questo comportamento è un requisito data la sicurezza del tipo di C#.

Immagino che si potrebbe fare questo:

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

Ora che tipo è ex? Tutti hanno .Message perché ereditano System.Exception, ma provano ad accedere ad una delle loro altre proprietà e si ha un problema.

Answer 7

E 'anche importante notare che quando si cattura più di un tipo di eccezione dovrebbero essere ordinati per la maggior parte specifici al più generale.L'eccezione troverà il primo nella lista che corrisponde e genera quell'errore, nessuno degli altri errori verrà lanciato.

Answer 8

Si potrebbe usare delegati, questo farà ciò che si vuole:

EDIT: semplificato un po '

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

vostro particolare try/catch sarebbe:

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 Comprendere alcune di queste eccezioni potrebbe non essere prevedibile, ma se possibile provare a implementare la propria logica "preventiva". Le eccezioni sono costose, anche se in questo caso probabilmente non è un affare.

Ad esempio, utilizzare Directory.GetAccessControl (...) anziché affidarsi a una UnauthorizedAccessException da lanciare.

Answer 10

Solo per completezza amor:

In VB, è possibile utilizzare condizionale la gestione delle eccezioni:

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

Tale blocco Catch otterrebbe inseriti solo per le eccezioni indicate - a differenza di C#.

Forse una versione futura di C# offrirà una funzionalità simile (dopo tutto, c'è un'istruzione IL specifica per quel codice).

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

Answer 11

Partenza il The Exception Handling Application Block da EntLib. Articolano una metodologia di gestione delle eccezioni basata su criteri e configurazione molto buona che evita blocchi logici condizionali di grandi dimensioni.