¿Cómo determinar si se está manejando una excepción .NET?

Question

Estamos investigando un patrón de codificación en C# en el que nos gustaría usar una cláusula "using" con una clase especial, cuyo método Dispose() hace cosas diferentes dependiendo de si el cuerpo "using" se salió normalmente o con una excepción .

Según entiendo, CLR realiza un seguimiento de la excepción actual que se maneja hasta que se ha consumido por un controlador "catch". Sin embargo, no está del todo claro si esta información está expuesta de alguna manera para que el código acceda. ¿Sabes si es, y si es así, cómo acceder?

Por ejemplo:

using (var x = new MyObject()) 
{ 
    x.DoSomething(); 
    x.DoMoreThings(); 
} 

class MyObject : IDisposable 
{ 
    public void Dispose() 
    { 
     if (ExceptionIsBeingHandled) 
      Rollback(); 
     else 
      Commit(); 
    } 
} 

Esto se ve casi como System.Transactions.TransactionScope, excepto que el éxito/fracaso no está determinada por una llamada a x.Complete(), sino más bien en función de si el cuerpo using se terminó normalmente.

Answer 1

http://www.codewrecks.com/blog/index.php/2008/07/25/detecting-if-finally-block-is-executing-for-an-manhandled-exception/ describe un "truco" para detectar si su código se ejecuta en modo de manejo de excepciones o no. Utiliza Marshal.GetExceptionPointers para ver si una excepción es "activa".

Pero hay que tener en cuenta:

Observaciones

GetExceptionPointers se expone para el apoyo del compilador de control estructurado de excepciones (SEH) solamente. NotaNota:

Este método usa SecurityAction.LinkDemand para evitar que se llame desde un código que no es de confianza; solo la persona que llama de inmediato debe tener el permiso SecurityPermissionAttribute.UnmanagedCode. Si su código puede ser llamado desde un código parcialmente confiable, no pase la entrada del usuario a los métodos de clase Marshal sin validación. Para conocer las limitaciones importantes sobre el uso del miembro LinkDemand, consulte Demanda contra LinkDemand.

Answer 2

Una declaración de uso es simplemente azúcar sintáctica para un bloque try try. Se puede obtener lo que desea escribiendo el intento finalmente a cabo en su totalidad y luego añadir una instrucción catch para manejar su caso especial:

try 
{ 
    IDisposable x = new MyThing(); 
} 
catch (Exception exception) // Use a more specific exception if possible. 
{ 
    x.ErrorOccurred = true; // You could even pass a reference to the exception if you wish. 
    throw; 
} 
finally 
{ 
    x.Dispose(); 
} 

Dentro MYTHing puede hacerlo si lo desea, por ejemplo:

class MyThing : IDisposable 
{ 
    public bool ErrorOccurred() { get; set; } 

    public void Dispose() 
    { 
     if (ErrorOccurred) { 
      RollBack(); 
     } else { 
      Commit(); 
     } 
    } 
} 

Nota: También me pregunto por qué quieres hacer esto. Tiene algún olor a código. El método Dispose está destinado a limpiar recursos no administrados, no a manejar excepciones. Probablemente sea mejor que escriba el código de manejo de excepciones en el bloque de captura, no en el desecho, y si necesita compartir el código, realice algunas funciones de ayuda útiles a las que puede llamar desde ambos lugares.

Aquí hay una manera mejor de hacer lo que quiere:

using (IDisposable x = new MyThing()) 
{ 
    x.Foo(); 
    x.Bar(); 
    x.CommitChanges(); 
} 

class MyThing : IDisposable 
{ 
    public bool IsCommitted { get; private set; } 

    public void CommitChanges() 
    { 
     // Do stuff needed to commit. 
     IsCommitted = true; 
    } 

    public void Dispose() 
    { 
     if (!IsCommitted) 
      RollBack(); 
    } 
} 

Answer 3

Esta información no está disponible para usted.

Usaría un patrón similar al utilizado por la clase DbTransaction: es decir, su clase IDisposable debería implementar un método similar a DbTransaction.Commit(). Su método Dispose puede entonces realizar una lógica diferente dependiendo de si se invocó o no a Commit (en el caso de DbTransaction, la transacción se retrotraerá si no se cometió explícitamente).

Los usuarios de la clase usarían entonces el siguiente patrón, similar a una típica DbTransaction:

using(MyDisposableClass instance = ...) 
{ 
    ... do whatever ... 

    instance.Commit(); 
} // Dispose logic depends on whether or not Commit was called. 

EDITAR veo que haya editado su pregunta para mostrar que está consciente de este patrón (su ejemplo usa TransactionScope). Sin embargo, creo que es la única solución realista.

Answer 4

Esto no parece ser una mala idea; simplemente no parece ser ideal en C# /. NET.

En C++ hay una función que permite que el código detecte si se está llamando debido a una excepción. Esto es de la mayor importancia en destructores RAII; es una cuestión trivial para el destructor elegir cometer o abortar dependiendo de si el flujo de control es normal o excepcional. Creo que este es un enfoque bastante natural de tomar, pero la falta de soporte integrado (y la naturaleza moralmente dudosa de la solución alternativa, se siente bastante dependiente de la implementación para mí) probablemente significa que se debe tomar un enfoque más convencional.

Answer 5

No fue una respuesta a la pregunta, sino solo una nota de que nunca terminé usando el código "aceptado" en código real, por lo que aún no se ha probado "en la naturaleza". En vez fuimos para algo como esto:

DoThings(x => 
{ 
    x.DoSomething(); 
    x.DoMoreThings(); 
}); 

donde

public void DoThings(Action<MyObject> action) 
{ 
    bool success = false; 
    try 
    { 
     action(new MyObject()); 
     Commit(); 
     success = true; 
    } 
    finally 
    { 
     if (!success) 
      Rollback(); 
    } 
} 

El punto clave es que es tan compacto como el "uso" ejemplo en la pregunta, y no utiliza ningún hacks.

Entre los inconvenientes se encuentra una penalización de rendimiento (completamente despreciable en nuestro caso), y F10 entrando en DoThings cuando realmente quiero que vaya directamente al x.DoSomething(). Ambos muy menores.