¿Puede atrapar más de un tipo de excepción con cada bloque?

Question

This question is close to what I want to do, pero no del todo allí.

¿Hay alguna manera de simplificar el siguiente código?

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

Parece un desperdicio, y si más adelante desea cambiar la forma puedo informar de un error de nuevo al usuario, o tal vez quiero registrar estos errores, o lo que sea, entonces tengo que cambiar 5 diferentes atrapar bloques. ¿Me estoy perdiendo algo, o esto es descaradamente contra la reutilización del código?

¿Solo trato de ser (demasiado) vago?

Answer 1

que puede utilizar:

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

Usted puede hacer

ex.GetType()

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

EDITAR

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

Answer 3

Si las excepciones comparten una superclase comunes a continuación, puedes coger la superclase .

Answer 4

se puede coger una excepción de clase base (todas las excepciones se derivan de SystemException):

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

Pero entonces usted puede terminar la captura de excepciones que no desea atrapar.

Answer 5

Sí, usted está tratando de ser perezoso, pero la pereza es uno de the virtues of a programmer, y eso es bueno.

cuanto a su pregunta: No hay manera que soy consciente de, pero hay algunas soluciones disponibles:

• dar los Excepciones un ancestro común. Creo que esto no será posible en tu caso, ya que parecen estar integrados.
• Captura la excepción más genérica que puedas.
• Mueva el código de manejo a su propia función y llámelo desde cada bloque catch.

Answer 6

Esto es molesto, y otras respuestas han sugerido buenas soluciones (usaría @ Lotfi's).

Sin embargo, este comportamiento es un requisito dado el tipo de seguridad de C#.

supongo que se podría hacer esto:

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

Ahora qué tipo es ex? Todos tienen .Message porque heredan System.Exception, pero intenta acceder a cualquiera de sus otras propiedades y tienes un problema.

Answer 7

También es importante tener en cuenta que cuando se capturan más de un tipo de excepción, la mayoría debe especificarla a la más general.La excepción encontrará la primera en la lista que coincida y arroje ese error; ninguno de los otros errores se arrojará.

Answer 8

Usted podría utilizar delegados, esto va a hacer lo que quiere:

EDIT: simplificado un poco

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

Su particular, try/catch sería:

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 entienda que algunas de estas excepciones pueden no ser previsibles pero, cuando sea posible, intente implementar su propia lógica "preventiva". Las excepciones son caras, aunque en este caso probablemente no sea un factor decisivo.

Por ejemplo, use Directory.GetAccessControl (...) en lugar de basarse en una excepción de acceso no autorizado para ser lanzada.

Answer 10

Justo De forma complementaria:

En VB, se puede usar condicional manejo de excepciones:

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

Tal bloque Catch sólo se ingresan las excepciones especificadas - a diferencia de C#.

Quizás una versión futura de C# ofrezca una característica similar (después de todo, hay una instrucción específica de IL para ese código).

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

Answer 11

Mira la The Exception Handling Application Block de EntLib. Articulan una metodología muy agradable de manejo de excepciones basada en políticas y configuraciones que evita grandes bloques lógicos condicionales.