Ignorar excepciones en C#

Question

¿Hay una mejor manera de hacer caso omiso de una excepción en C# de ponerlo en un bloque intento de captura y no hacer nada en la captura? Encuentro que esta sintaxis es engorrosa. Para un bloque de código, ¿no puedo simplemente "etiquetarlo" de tal manera que el tiempo de ejecución sepa qué excepciones descuidar?

Answer 1

No creo que hay un truco para evitar la excepción, pero se puede utilizar el siguiente fragmento de código:

public void IgnoreExceptions(Action act) 
{ 
    try 
    { 
     act.Invoke(); 
    } 
    catch { } 
} 

Utilizando el método se parece a:

IgnoreExceptions(() => foo()); 

Otra solución es utilizar AOP (Programación Orientada a Aspectos) - hay una herramienta llamada PostSharp que le permite crear un atributo que capturaría todas las excepciones en un ensamblaje/clase/método específico, que está más cerca de lo que está buscando.

Answer 2

No. Cuando se producen excepciones, viajan de vuelta hacia arriba en la pila de llamadas hasta que son manejadas por un bloque catch o todo el proceso finaliza.

Answer 3

Puede hacerlo con AOP. Postsharp, por ejemplo, le permitirá implementar fácilmente dicho atributo, que omitirá excepciones particulares en los métodos a los que haya aplicado dicho atributo. Sin AOP no veo una buena manera de hacerlo (si suponemos que hay una buena manera de hacer tales cosas;)).

Con PostSharp usted será capaz de decorar sus métodos de esta manera:

[IgnoreExceptions(typeof(NullReferenceException), typeof(StackOverflowException))] 
void MyMethod() { ... } 

Answer 4

Una forma es tomar advantge de programación orientada a aspectos (AOP). Eche un vistazo al PostSharp. Here es un ejemplo del uso de un atributo de excepción en un método, de modo que si ocurre una excepción, puede tratarlo sin un bloque try..catch.

EDIT:

Ah sí, la sugerencia de Dror es también un buen año. He visto ejemplos de eso en la Biblioteca Enterprise. Eso sería mejor si no desea tener un marco de terceros en su proyecto (es decir, PostSharp).

Answer 5

Yo no conozco a ningún mecanismo que permita que hagas esto.

En general, también se considera una muy mala práctica de ignorar excepciones. Las excepciones son (o siempre deben ser) planteadas por una buena razón; si nada más, al menos deberías registrarlos.

Si sabe que un cierto tipo de excepción no es crítico para su aplicación, puede evitar que se bloquee utilizando el evento Application.UnhandledException, buscando ese tipo de excepción. Tenga en cuenta que esto aún propagará la excepción a través de todos los cuadros de pila hasta el final.

Answer 6

No. Si se produce una excepción, por lo general es un error crítico que ha acaecer. No quieres ignorarlo.

su lugar debe reescribir su código para comprobar los errores y sólo si realmente falla, una excepción es fundido.

Por ejemplo, usando Int32.TryParse en lugar de Int32.Parse para comprobar si un objeto es un número entero válido. Recuerde que las excepciones son muy costosas cuando se lanzan y muchas versiones afectan seriamente el rendimiento de su aplicación.

Answer 7

Los bloques de captura vacíos son un olor a código muy apestoso.En resumen, no debería seguir una forma taquigráfica de escribirlos.

La regla n. ° 1 es: "no la atrape si no puede manejarla". La regla n. ° 1a es, "si no manejó la Excepción, vuelva a tirarla".

Si solo intenta evitar que la aplicación se bloquee, existen mecanismos más apropiados para usar en la mayoría de los casos. .NET incluye eventos UnhandledException en los niveles de Application, Dispatcher y AppDomain, así como eventos dedicados a notificarle de excepciones no controladas en hilos de fondo. En este nivel, si no puede verificar el estado de su aplicación, su mejor opción puede ser notificar al usuario que algo malo sucedió y finalizar la aplicación.

Answer 8

Quería contribuir con los métodos de extensión que creé en base a las respuestas anteriores. Espero que ayude a alguien.

/// <summary> 
/// Extension methods for <see cref="Action"/> objects. 
/// </summary> 
public static class ActionExtensions 
{ 
    /// <summary> 
    /// Executes the <paramref name="action"/> and ignores any exceptions. 
    /// </summary> 
    /// <remarks> 
    /// This should be used in very rare cases. 
    /// </remarks> 
    /// <param name="action">The action to execute.</param> 
    public static void IgnoreExceptions(this Action action) 
    { 
     try { action(); } 
     catch { } 
    } 

    /// <summary> 
    /// Extends an existing <see cref="Action"/> so that it will ignore exceptions when executed. 
    /// </summary> 
    /// <param name="action">The action to extend.</param> 
    /// <returns>A new Action that will ignore exceptions when executed.</returns> 
    public static Action AddIgnoreExceptions(this Action action) 
    { 
     return() => action.IgnoreExceptions(); 
    } 
} 

y la unidad de pruebas:

[TestClass] 
public class ActionExtensionsTests 
{ 
    [TestMethod] 
    public void IgnoreException() 
    { 
     Action justThrow =() => { throw new InvalidOperationException(); }; 
     justThrow.IgnoreExceptions(); 
    } 
    [TestMethod] 
    public void AddIgnoreException() 
    { 
     Action justThrow =() => { throw new InvalidOperationException(); }; 
     var newAction = justThrow.AddIgnoreExceptions(); 
     newAction(); 
    } 
} 

Answer 9

public static void Ignore<T>(Action a) where T : Exception 
    { 
     try 
     { 
      a(); 
     } 
     catch (T) 
     { 
     } 
    } 

de usar:

Ignore<InvalidOperationException>(() => foo());