Ignorar excepción en C #

¿Hay una mejor manera de ignorar una excepción en C # que colocarla en un bloque de captura de prueba y no hacer nada en la captura? Encuentro que esta syntax 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?

No creo que haya un truco para evitar la excepción, pero puedes usar el siguiente fragmento de código:

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

El uso del método se ve así:

 IgnoreExceptions(() => foo()); 

Otra solución es usar AOP (Progtwigció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.

Puedes 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 podrás decorar tus métodos de esta manera:

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

Una forma es aprovechar la Progtwigción Orientada a Aspectos (AOP). Eche un vistazo a PostSharp . Este 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.

EDITAR:

Ah, sí, la sugerencia de Dror también es buena. 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).

No conozco ningún mecanismo que te permita hacer esto.

En general, también se considera una práctica muy mala ignorar las 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 stack hasta el final.

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

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

 ///  /// Extension methods for  objects. ///  public static class ActionExtensions { ///  /// Executes the  and ignores any exceptions. ///  ///  /// This should be used in very rare cases. ///  /// The action to execute. public static void IgnoreExceptions(this Action action) { try { action(); } catch { } } ///  /// Extends an existing  so that it will ignore exceptions when executed. ///  /// The action to extend. /// A new Action that will ignore exceptions when executed. public static Action AddIgnoreExceptions(this Action action) { return () => action.IgnoreExceptions(); } } 

Y la unidad prueba:

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

No. Si se lanza una excepción, generalmente es un error crítico que ha sucedido. No quieres ignorarlo.

En su lugar, debe volver a escribir su código para verificar los errores y solo si realmente falla, se emite una excepción.

Por ejemplo, utilizando 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.

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 # 1a es, “si no manejaste la Excepción, vuelve a lanzarla”.

Si solo intenta evitar que la aplicación se bloquee, existen mecanismos más apropiados para usar en la mayoría de las circunstancias. .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.

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

Usar:

  Ignore(() => foo());