C # yığın izini kaybetmeden InnerException yeniden nasıl?

Düşünme yoluyla bir istisnaya neden olabilecek bir yöntem arıyorum. Sargı yansıması etrafa sarılmadan istisnayı arayana nasıl iletebilirim?
InnerException'ı yeniden yüklüyorum, ancak bu yığın izini yok eder.
Örnek kod:

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

In .NET 4.5 şimdi olduğu ExceptionDispatchInfosınıf.

Bu, bir istisna yakalamanızı ve yığın izini değiştirmeden yeniden atmanızı sağlar:

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

Bu sadece istisnalar dışında çalışır AggregateException.

Eşzamansız dil özelliklerini senkronize dil özellikleri gibi daha fazla hale getirmek için awaitiç istisnaları AggregateExceptionörneklerden açan C # dil özelliği nedeniyle tanıtıldı .

Bir yansıma olmaksızın yeniden atma önce yığın izleme korumak mümkün:

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
}

Bu InternalPreserveStackTrace, önbelleğe alınan delege aracılığıyla yapılan çağrılara kıyasla çok sayıda döngüyü boşa harcar , ancak yalnızca kamu işlevselliğine güvenme avantajına sahiptir. Yığın izleme koruma işlevleri için birkaç yaygın kullanım şekli şunlardır:

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

En iyi bahsinizin bunu catch bloğunuza koymak olduğunu düşünüyorum:

throw;

Ve daha sonra innerexception'ı çıkarın.

Kimse ile ExceptionDispatchInfo.Capture( ex ).Throw()ova arasındaki farkı açıklamadı throw, işte burada.

Yakalanan bir istisnayı yeniden anlatmanın tam yolu kullanmaktır ExceptionDispatchInfo.Capture( ex ).Throw()(yalnızca .Net 4.5'ten edinilebilir).

Aşağıda bunu test etmek için gerekli durumlar vardır:

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

Durum 1 ve durum 2, CallingMethodyöntemin kaynak kodu satır numarasının satırın satır numarası olduğu bir yığın izlemesi verecektir throw new Exception( "TEST" ).

Ancak, 3. durum size CallingMethodyöntemin kaynak kodu satır numarasının throwçağrının hat numarası olduğu bir yığın izlemesi verecektir . Bu, throw new Exception( "TEST" )çizgi diğer işlemlerle çevriliyse, istisnanın hangi satır numarasına atıldığına dair hiçbir fikriniz olmadığı anlamına gelir .

Durum 4, durum 2 ile benzerdir, çünkü orijinal istisnanın satır numarası korunur, ancak orijinal istisnanın türünü değiştirdiği için gerçek bir tekrarlama değildir.

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

Atmadan önce istisnadaki uzantı yöntemini çağırın, orijinal yığın izini koruyacaktır.

Daha da fazla yansıma ...

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

Özel alanlar API'nın bir parçası olmadığından bunun herhangi bir zamanda kırılabileceğini unutmayın. Mono bugzilla hakkında daha fazla tartışmaya bakın .

İlk olarak: TargetInvocationException'ı kaybetmeyin - bir şeyleri hata ayıklamak istediğinizde değerli bilgilerdir.
İkincisi: Kendi istisna türünüzde TIE'yi InnerException olarak sarın ve ihtiyacınız olan şeylere bağlanan bir OriginalException özelliği koyun (ve tüm çağrı kitlesini koruyun).
Üçüncüsü: TIE'nin yönteminizden dışarı çıkmasına izin verin.

Çocuklar, harikasınız .. Yakında bir büyücü olacağım.

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

    }

İstisna serileştirme / serileştirmeyi kullanan başka bir örnek kod. Gerçek istisna türünün serileştirilebilir olmasını gerektirmez. Ayrıca sadece genel / korumalı yöntemler kullanır.

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

Paul Turners cevabına dayanarak bir uzatma yöntemi yaptım

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

return exist ulaştı asla ama avantajı kullanabilir miyim yani throw ex.Capture()derleyici bir zam olmayacak şekilde bir tek astar olarak not all code paths return a valuehatayı.

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