Richtige Behandlung von Ausnahmen in AsyncDispose

Beim Wechsel zu den neuen .NET Core 3 IAsynsDisposablebin ich auf das folgende Problem gestoßen.

Der Kern des Problems: Wenn DisposeAsynceine Ausnahme ausgelöst wird, werden durch diese Ausnahme alle innerhalb von await using-block ausgelösten Ausnahmen ausgeblendet.

class Program 
{
    static async Task Main()
    {
        try
        {
            await using (var d = new D())
            {
                throw new ArgumentException("I'm inside using");
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message); // prints I'm inside dispose
        }
    }
}

class D : IAsyncDisposable
{
    public async ValueTask DisposeAsync()
    {
        await Task.Delay(1);
        throw new Exception("I'm inside dispose");
    }
}

Was gefangen wird, ist die AsyncDisposeAusnahme, wenn es geworfen wird, und die Ausnahme von innen await usingnur, wenn AsyncDisposees nicht wirft.

Ich würde es jedoch andersherum vorziehen: await usingwenn möglich die Ausnahme vom Block zu bekommen und DisposeAsync-ausnahme nur, wenn der await usingBlock erfolgreich beendet wurde.

Begründung: Stellen Sie sich vor, meine Klasse Darbeitet mit einigen Netzwerkressourcen und abonniert einige Remote-Benachrichtigungen. Der darin enthaltene Code await usingkann etwas falsch machen und den Kommunikationskanal ausfallen lassen. Danach schlägt auch der Code in Dispose fehl, der versucht, die Kommunikation ordnungsgemäß zu schließen (z. B. das Abbestellen der Benachrichtigungen). Aber die erste Ausnahme gibt mir die wirklichen Informationen über das Problem, und die zweite ist nur ein sekundäres Problem.

In dem anderen Fall, in dem der Hauptteil durchlaufen wurde und die Entsorgung fehlgeschlagen ist, liegt das eigentliche Problem im Inneren DisposeAsync, sodass die Ausnahme von DisposeAsyncder relevanten ist. Dies bedeutet, dass es DisposeAsynckeine gute Idee sein sollte, alle darin enthaltenen Ausnahmen zu unterdrücken .

Ich weiß, dass es das gleiche Problem mit nicht asynchronen Fällen gibt: Ausnahme in finallyüberschreibt die Ausnahme in try, deshalb wird nicht empfohlen, sie einzufügen Dispose(). Bei Klassen mit Netzwerkzugriff sieht das Unterdrücken von Ausnahmen beim Schließen von Methoden jedoch überhaupt nicht gut aus.

Es ist möglich, das Problem mit dem folgenden Helfer zu umgehen:

static class AsyncTools
{
    public static async Task UsingAsync<T>(this T disposable, Func<T, Task> task)
            where T : IAsyncDisposable
    {
        bool trySucceeded = false;
        try
        {
            await task(disposable);
            trySucceeded = true;
        }
        finally
        {
            if (trySucceeded)
                await disposable.DisposeAsync();
            else // must suppress exceptions
                try { await disposable.DisposeAsync(); } catch { }
        }
    }
}

und benutze es gerne

await new D().UsingAsync(d =>
{
    throw new ArgumentException("I'm inside using");
});

Das ist irgendwie hässlich (und verbietet Dinge wie frühe Rückkehr innerhalb des using-Blocks).

Gibt es eine gute kanonische Lösung, await usingwenn möglich? Bei meiner Suche im Internet wurde dieses Problem nicht einmal diskutiert.

Es gibt Ausnahmen, die auftauchen sollen (die aktuelle Anforderung unterbrechen oder den Prozess beenden), und es gibt Ausnahmen, von denen Ihr Entwurf erwartet, dass sie manchmal auftreten und die Sie behandeln können (z. B. erneut versuchen und fortfahren).

Die Unterscheidung zwischen diesen beiden Typen liegt jedoch beim endgültigen Aufrufer des Codes - dies ist der springende Punkt bei Ausnahmen, um die Entscheidung dem Anrufer zu überlassen.

Manchmal legt der Anrufer größeren Wert darauf, dass die Ausnahme aus dem ursprünglichen Codeblock und manchmal die Ausnahme aus dem ursprünglichen Codeblock angezeigt wird Dispose. Es gibt keine allgemeine Regel für die Entscheidung, welche Priorität haben soll. Die CLR ist mindestens konsistent (wie Sie bemerkt haben) zwischen dem Synchronisierungs- und dem nicht asynchronen Verhalten.

Es ist vielleicht bedauerlich, dass wir jetzt AggregateExceptionmehrere Ausnahmen darstellen müssen. Es kann nicht nachgerüstet werden, um dies zu lösen. dh wenn eine Ausnahme bereits im Flug ist und eine andere ausgelöst wird, werden sie zu einer zusammengefasst AggregateException. Der catchMechanismus kann so geändert werden, dass beim Schreiben alle Mechanismen catch (MyException)abgefangen werden AggregateException, die eine Ausnahme vom Typ enthalten MyException. Es gibt jedoch verschiedene andere Komplikationen, die sich aus dieser Idee ergeben, und es ist wahrscheinlich zu riskant, etwas so Grundlegendes jetzt zu modifizieren.

Sie könnten Ihre verbessern UsingAsync, um die frühzeitige Rückgabe eines Wertes zu unterstützen:

public static async Task<R> UsingAsync<T, R>(this T disposable, Func<T, Task<R>> task)
        where T : IAsyncDisposable
{
    bool trySucceeded = false;
    R result;
    try
    {
        result = await task(disposable);
        trySucceeded = true;
    }
    finally
    {
        if (trySucceeded)
            await disposable.DisposeAsync();
        else // must suppress exceptions
            try { await disposable.DisposeAsync(); } catch { }
    }
    return result;
}

Vielleicht verstehen Sie bereits, warum dies passiert, aber es lohnt sich, dies zu formulieren. Dieses Verhalten ist nicht spezifisch für await using. Es würde auch mit einem einfachen usingBlock passieren . Während ich Dispose()hier sage , gilt das alles auch für DisposeAsync().

Ein usingBlock ist nur syntaktischer Zucker für einen try/ finallyBlock, wie im Abschnitt "Anmerkungen" der Dokumentation angegeben . Was Sie sehen , geschieht , weil der finallyBlock immer läuft, auch nach einer Ausnahme. Wenn also eine Ausnahme auftritt und kein catchBlock vorhanden ist , wird die Ausnahme angehalten, bis der finallyBlock ausgeführt wird, und dann wird die Ausnahme ausgelöst. Wenn jedoch eine Ausnahme auftritt finally, wird die alte Ausnahme nie angezeigt.

Sie können dies anhand dieses Beispiels sehen:

try {
    throw new Exception("Inside try");
} finally {
    throw new Exception("Inside finally");
}

Es spielt keine Rolle, ob Dispose()oder DisposeAsync()innerhalb der aufgerufen wird finally. Das Verhalten ist das gleiche.

Mein erster Gedanke ist: nicht einwerfen Dispose(). Aber nachdem ich einige von Microsofts eigenen Codes überprüft habe, denke ich, dass es davon abhängt.

Schauen Sie sich FileStreamzum Beispiel deren Implementierung an . Sowohl die synchrone Dispose()Methode als auch DisposeAsync()können tatsächlich Ausnahmen auslösen. Die synchrone Dispose()tut ignorieren einige Ausnahmen absichtlich, aber nicht alle.

Aber ich denke, es ist wichtig, die Natur Ihrer Klasse zu berücksichtigen. In a FileStreamwird beispielsweise Dispose()der Puffer in das Dateisystem geleert. Das ist eine sehr wichtige Aufgabe und Sie müssen wissen, ob dies fehlgeschlagen ist . Das kann man nicht einfach ignorieren.

Bei anderen Dispose()Objekttypen haben Sie beim Aufrufen jedoch wirklich keine Verwendung mehr für das Objekt. Anrufen Dispose()bedeutet wirklich nur "dieses Objekt ist für mich tot". Möglicherweise wird der zugewiesene Speicher bereinigt, aber ein Fehler hat keinerlei Auswirkungen auf den Betrieb Ihrer Anwendung. In diesem Fall können Sie die Ausnahme in Ihrem ignorieren Dispose().

Wenn Sie jedoch in jedem Fall zwischen einer Ausnahme innerhalb der usingoder einer Ausnahme, von der sie stammt Dispose(), unterscheiden möchten, benötigen Sie einen try/ catch-Block sowohl innerhalb als auch außerhalb Ihres usingBlocks:

try {
    await using (var d = new D())
    {
        try
        {
            throw new ArgumentException("I'm inside using");
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message); // prints I'm inside using
        }
    }
} catch (Exception e) {
    Console.WriteLine(e.Message); // prints I'm inside dispose
}

Oder du könntest es einfach nicht benutzen using. Formulieren Sie ein try/ catch/ finallyBlock selbst, wo Sie jede Ausnahme fangen in finally:

var d = new D();
try
{
    throw new ArgumentException("I'm inside try");
}
catch (Exception e)
{
    Console.WriteLine(e.Message); // prints I'm inside try
}
finally
{
    try
    {
        if (D != null) await D.DisposeAsync();
    }
    catch (Exception e)
    {
        Console.WriteLine(e.Message); // prints I'm inside dispose
    }
}

using ist effektiv Exception Handling Code (Syntax Zucker für try ... finally ... Dispose ()).

Wenn Ihr Code für die Ausnahmebehandlung Ausnahmen auslöst, wird etwas auf königliche Weise zerstört.

Was auch immer passiert ist, um dich dorthin zu bringen, spielt keine Rolle mehr. Fehlerhafter Ausnahmebehandlungscode verbirgt alle möglichen Ausnahmen auf die eine oder andere Weise. Der Ausnahmebehandlungscode muss festgelegt sein, der absolute Priorität hat. Ohne das erhalten Sie nie genug Debugging-Daten für das eigentliche Problem. Ich sehe es extrem oft falsch gemacht. Es ist ungefähr so ​​leicht, sich zu irren, wie mit nackten Zeigern umzugehen. So oft gibt es zwei Artikel zu dem von mir verlinkten Thema, die Ihnen bei allen zugrunde liegenden Designfehlern helfen könnten:

• Eine Klassifizierung der Ausnahmen und welche Sie fangen sollten
• Allgemeine bewährte Praktiken, die von der Klassifizierung nicht abgedeckt werden konnten

Abhängig von der Ausnahmeklassifizierung müssen Sie Folgendes tun, wenn Ihr Ausnahmebehandlungs- / Dipose-Code eine Ausnahme auslöst:

Für Fatal, Boneheaded und Vexing ist die Lösung dieselbe.

Exogene Ausnahmen müssen auch bei schwerwiegenden Kosten vermieden werden. Es gibt einen Grund, warum wir immer noch Protokolldateien verwenden, anstatt Datenbanken zu protokollieren, um Ausnahmen zu protokollieren. DB Opeartions sind nur eine Möglichkeit, auf exogene Probleme zu stoßen. Protokolldateien sind der einzige Fall, in dem es mir nichts ausmacht, wenn Sie das Dateihandle während der gesamten Laufzeit geöffnet lassen.

Wenn Sie eine Verbindung schließen müssen, sorgen Sie sich nicht zu sehr um das andere Ende. Behandeln Sie es wie UDP: "Ich werde die Informationen senden, aber es ist mir egal, ob die andere Seite es bekommt." Bei der Entsorgung geht es darum, Ressourcen auf der Client-Seite / Seite, an der Sie arbeiten, zu bereinigen.

Ich kann versuchen, sie zu benachrichtigen. Aber Sachen auf der Server / FS-Seite aufräumen? Dafür sind ihre Timeouts und ihre Ausnahmebehandlung verantwortlich.

Sie können versuchen, AggregateException zu verwenden und Ihren Code folgendermaßen zu ändern:

class Program 
{
    static async Task Main()
    {
        try
        {
            await using (var d = new D())
            {
                throw new ArgumentException("I'm inside using");
            }
        }
        catch (AggregateException ex)
        {
            ex.Handle(inner =>
            {
                if (inner is Exception)
                {
                    Console.WriteLine(e.Message);
                }
            });
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }
}

class D : IAsyncDisposable
{
    public async ValueTask DisposeAsync()
    {
        await Task.Delay(1);
        throw new Exception("I'm inside dispose");
    }
}

https://docs.microsoft.com/ru-ru/dotnet/api/system.aggregateexception?view=netframework-4.8

https://docs.microsoft.com/ru-ru/dotnet/standard/parallel-programming/exception-handling-task-parallel-library