AggregateException GetType gibt falschen Wert zurück nachdem das Objekt serialisiert wurde

Hey Forum

Ich habe eine Frage zu der AggregateException.

In meiner Client Software fange ich eine AggregateException ab und sende das Objekt an einen Web Service. Sobald ich das Objekt auf der Serverseite nach dem Typ prüfe bekomme ich anstatt dem AggregateException Type den Exception Type.

Hat jemand eine Idee wieso es sich so verhält?

Data

public class LogErrorDto
{
    public Exception Exception { get; set; }
    public string Client { get; set; }
}

Client

try 
{
    throw new AggregateException();
} 
catch (Exception exce) {
    Assert.IsTrue(exce.GetType() == typeof(AggregateException)) // <-- is true

    using (var client = new HttpClient())
    {
        var response = client.PostAsync(
            "http://MyWebService/api/Log/PostError",
            new ObjectContent(typeof(LogErrorDto), exce, new JsonMediaTypeFormatter()));
        response.Wait();
    }
}

Controller

public class LogController : ApiController
{
    [HttpPost]
    public void PostError([FromBody]LogErrorDto error)
    {
        LogService.LogException(error.Exception, error.Client);
    }
}

Service

public class LogService
{
    public static void LogException(Exception exception, string client)
    {
        var value = (AggregateException)exception;
        //throws Cannot cast 'exception' (which has an actual type of 'System.Exception') to 'System.AggregateException'    System.AggregateException
    }
}

Weil Du Dich in einem asynchronen Context befindest und dieser beim Fehlerfall AggregateExceptions zurück gibt.
An die eigentliche Exception kommt man dann via InnerException.

Wenn Du async korrekt aufrufen würdst (also mit async await) würde es keine AggregateExceptions geben.
Du aber nimmst nur den Task entgegen, blockierst mit Wait() weshalb es zu dieser Situation kommt.

Oder verstehe ich Deine Sitation falsch?

Danke für die Info am Rande mein Problem ist in der tat ein anders.

Mein Problem ist nicht das die AggregateException geworfen wird sondern das sie auf dem Server nicht mehr als solche erkannt wird.
Mein Ziel ist es ein Exception Logger Service zu bauen.
Nun will ich wenn eine AggregateException geworfen wird alle InnerExceptions loggen.
Zu diesem Zweck muss ich die AggregateException die auf dem Client geworfen wurde zuerst Serialisieren, an den Server senden, Deserialiseren und schlussendlich in eine Datei oder eine DB schreiben.

Bevor ich die Exception auf dem Client serialisiere kann ich das Objekt vom Typ Exception in den Typ AggregateException casten und auf die Property InnerExceptions zugreifen.

Sobald dasselbe mit dem Objekt auf dem Server machen will wird das Objekt nicht mehr als AggregateException erkannt.

Meiner Meinung nach muss das was mit der Serisalisation zu tun haben.

Assert.IsInstanceOfType ist vermutlich die Lösung, die Du suchst.

public class LogService
{
    public static void LogException(Exception exception, string client)
    {
        // Assert.IsTrue(exception.GetType() == typeof(AggregateException)); // <-- fails
        Assert.IsInstanceOfType(exception, typeof(AggregateException));
    }
}

Sorry die Asserts habe ich eigentlich nur zum veranschaulichen.

Anstelle des Asserts das fehlschlägt habe ich ein cast der Eine Exception wirft.
Ich habe den Inital Post angepasst.

public static void LogException(Exception exception, string client)
{
    var value = (AggregateException)exception;
    //throws Cannot cast 'exception' (which has an actual type of 'System.Exception') to 'System.AggregateException'	System.AggregateException

}

Ach jetz..

Exceptions direkt übertragen sollte man lassen. Geht i.d.R. in die Hose.
Du solltest das schon vor dem Senden in eine eigene Klasse mappen, diese serialisieren und übertragen.

Ach super danke für die Info.
Ich werde mir eine DataTransferObject Klasse für den Exception Typ schreiben.

Für mich ist das Thema abgeschlossen