Як перезавантажити InnerException, не втрачаючи слід стека в C #?

Я закликаю через роздуми метод, який може спричинити виняток. Як я можу передавати виняток своєму абоненту без відображення обгортки?
Я перекидаю InnerException, але це руйнує слід стека.
Приклад коду:

public void test1()
{
    // Throw an exception for testing purposes
    throw new ArgumentException("test1");
}

void test2()
{
    try
    {
        MethodInfo mi = typeof(Program).GetMethod("test1");
        mi.Invoke(this, null);
    }
    catch (TargetInvocationException tiex)
    {
        // Throw the new exception
        throw tiex.InnerException;
    }
}

У .NET 4.5 тепер є ExceptionDispatchInfoклас.

Це дозволяє захопити виняток і повторно скинути його, не змінюючи трасування стека:

try
{
    task.Wait();
}
catch(AggregateException ex)
{
    ExceptionDispatchInfo.Capture(ex.InnerException).Throw();
}

Це працює за будь-яким винятком, а не тільки AggregateException.

Він був введений завдяки awaitфункції мови C #, яка розгортає внутрішні винятки з AggregateExceptionекземплярів, щоб зробити функції асинхронної мови більш схожими на функції синхронної мови.

Це є можливим збереження трасування стека перед тим Повторне викидання без відображення:

static void PreserveStackTrace (Exception e)
{
    var ctx = new StreamingContext  (StreamingContextStates.CrossAppDomain) ;
    var mgr = new ObjectManager     (null, ctx) ;
    var si  = new SerializationInfo (e.GetType (), new FormatterConverter ()) ;

    e.GetObjectData    (si, ctx)  ;
    mgr.RegisterObject (e, 1, si) ; // prepare for SetObjectData
    mgr.DoFixups       ()         ; // ObjectManager calls SetObjectData

    // voila, e is unmodified save for _remoteStackTraceString
}

Це витрачає багато циклів порівняно з дзвінками InternalPreserveStackTraceчерез кешований делегат, але має перевагу покладатися лише на публічну функціональність. Ось декілька загальних моделей використання функцій збереження трасування стека:

// usage (A): cross-thread invoke, messaging, custom task schedulers etc.
catch (Exception e)
{
    PreserveStackTrace (e) ;

    // store exception to be re-thrown later,
    // possibly in a different thread
    operationResult.Exception = e ;
}

// usage (B): after calling MethodInfo.Invoke() and the like
catch (TargetInvocationException tiex)
{
    PreserveStackTrace (tiex.InnerException) ;

    // unwrap TargetInvocationException, so that typed catch clauses 
    // in library/3rd-party code can work correctly;
    // new stack trace is appended to existing one
    throw tiex.InnerException ;
}

Я думаю, що найкраще було б просто поставити це у свій блок лову:

throw;

А потім витягнути іннерецепцію пізніше.

public static class ExceptionHelper
{
    private static Action<Exception> _preserveInternalException;

    static ExceptionHelper()
    {
        MethodInfo preserveStackTrace = typeof( Exception ).GetMethod( "InternalPreserveStackTrace", BindingFlags.Instance | BindingFlags.NonPublic );
        _preserveInternalException = (Action<Exception>)Delegate.CreateDelegate( typeof( Action<Exception> ), preserveStackTrace );            
    }

    public static void PreserveStackTrace( this Exception ex )
    {
        _preserveInternalException( ex );
    }
}

Викличте метод розширення за вашим винятком, перш ніж його кинути, він збереже початковий слід стека.

Ніхто не пояснив різницю між ExceptionDispatchInfo.Capture( ex ).Throw()та звичайною throw, так ось вона.

Повний спосіб повторного вигнання спійманого винятку - це використання ExceptionDispatchInfo.Capture( ex ).Throw()(доступне лише у .Net 4.5).

Нижче наведені випадки, необхідні для перевірки цього:

1.

void CallingMethod()
{
    //try
    {
        throw new Exception( "TEST" );
    }
    //catch
    {
    //    throw;
    }
}

2.

void CallingMethod()
{
    try
    {
        throw new Exception( "TEST" );
    }
    catch( Exception ex )
    {
        ExceptionDispatchInfo.Capture( ex ).Throw();
        throw; // So the compiler doesn't complain about methods which don't either return or throw.
    }
}

3.

void CallingMethod()
{
    try
    {
        throw new Exception( "TEST" );
    }
    catch
    {
        throw;
    }
}

4.

void CallingMethod()
{
    try
    {
        throw new Exception( "TEST" );
    }
    catch( Exception ex )
    {
        throw new Exception( "RETHROW", ex );
    }
}

Випадок 1 і випадок 2 дадуть вам стеження за стеком, де номер рядка вихідного коду для CallingMethodметоду є номером throw new Exception( "TEST" )рядка рядка.

Однак випадок 3 надасть вам стеження стека, де номер рядка вихідного коду для CallingMethodметоду є номером рядка throwвиклику. Це означає, що якщо throw new Exception( "TEST" )рядок оточений іншими операціями, ви не маєте уявлення, на якому номері рядка було виключено виняток.

Випадок 4 аналогічний випадку 2, оскільки номер рядка вихідного винятку зберігається, але не є реальним перезарядкою, оскільки він змінює тип вихідного винятку.

Ще більше роздумів ...

catch (TargetInvocationException tiex)
{
    // Get the _remoteStackTraceString of the Exception class
    FieldInfo remoteStackTraceString = typeof(Exception)
        .GetField("_remoteStackTraceString",
            BindingFlags.Instance | BindingFlags.NonPublic); // MS.Net

    if (remoteStackTraceString == null)
        remoteStackTraceString = typeof(Exception)
        .GetField("remote_stack_trace",
            BindingFlags.Instance | BindingFlags.NonPublic); // Mono

    // Set the InnerException._remoteStackTraceString
    // to the current InnerException.StackTrace
    remoteStackTraceString.SetValue(tiex.InnerException,
        tiex.InnerException.StackTrace + Environment.NewLine);

    // Throw the new exception
    throw tiex.InnerException;
}

Майте на увазі, що це може порушитися в будь-який час, оскільки приватні поля не є частиною API. Дивіться подальшу дискусію про Mono bugzilla .

По-перше: не втрачайте TargetInvocationException - це цінна інформація, коли ви захочете налагоджувати речі.
По-друге: Оберніть TIE як InnerException у своєму власному типі винятків і поставте властивість OriginalException, яке посилається на те, що вам потрібно (і зберігайте весь стійка виклику недоторканим).
По-третє: нехай TIE пузирить з вашого методу.

Хлопці, ви круті .. Я скоро буду некромантом.

    public void test1()
    {
        // Throw an exception for testing purposes
        throw new ArgumentException("test1");
    }

    void test2()
    {
            MethodInfo mi = typeof(Program).GetMethod("test1");
            ((Action)Delegate.CreateDelegate(typeof(Action), mi))();

    }

Інший зразок коду, який використовує серіалізацію / дезаріалізацію виключень. Він не вимагає, щоб фактичний тип винятку був серіалізованим. Також він використовує лише публічні / захищені методи.

    static void PreserveStackTrace(Exception e)
    {
        var ctx = new StreamingContext(StreamingContextStates.CrossAppDomain);
        var si = new SerializationInfo(typeof(Exception), new FormatterConverter());
        var ctor = typeof(Exception).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { typeof(SerializationInfo), typeof(StreamingContext) }, null);

        e.GetObjectData(si, ctx);
        ctor.Invoke(e, new object[] { si, ctx });
    }

На основі відповіді Пола Тернерса я створив метод розширення

    public static Exception Capture(this Exception ex)
    {
        ExceptionDispatchInfo.Capture(ex).Throw();
        return ex;
    }

return exIST ніколи не досяг , але перевага полягає в тому, що я можу використовувати в throw ex.Capture()якості одного лайнера , так що компілятор не видасть not all code paths return a valueпомилку.

    public static object InvokeEx(this MethodInfo method, object obj, object[] parameters)
    {
        {
            return method.Invoke(obj, parameters);
        }
        catch (TargetInvocationException ex) when (ex.InnerException != null)
        {
            throw ex.InnerException.Capture();
        }
    }