AsyncDispose'teki istisnalarla başa çıkmanın uygun yolu

Yeni .NET Core 3'lere geçiş sırasında IAsynsDisposableaşağıdaki sorunla karşılaştım.

Sorunun özü: DisposeAsyncbir istisna atarsa, bu istisna await using-block içine atılan istisnaları gizler .

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

Yakalanan şey, AsyncDisposeatıldığında-istisna ve içeriden istisna await usingsadece AsyncDisposeatmazsa.

Ancak bunu başka bir şekilde tercih ederim: await usingmümkünse bloktan istisna almak ve DisposeAsync-sadece await usingblok başarıyla bittiğinde istisna .

Gerekçe: Sınıfımın Dbazı ağ kaynaklarıyla çalıştığını ve bazı bildirimlerin uzaktan abone olduğunu hayal edin . İçindeki kod await usingyanlış bir şey yapabilir ve iletişim kanalında başarısız olabilir, bundan sonra Dispose'deki iletişimi zarif bir şekilde kapatmaya çalışan kod (örneğin, bildirimlerden çıkma) da başarısız olur. Ama ilk istisna bana sorunla ilgili gerçek bilgileri veriyor, ikincisi ise sadece ikincil bir problem.

Diğer durumda, ana kısım bittiğinde ve bertaraf başarısız olduğunda, gerçek sorun içeridedir DisposeAsync, bu nedenle istisna DisposeAsyncilgili olanıdır. Bu, içerideki tüm istisnaları bastırmanın DisposeAsynciyi bir fikir olmaması gerektiği anlamına gelir .

Eşzamansız durumda da aynı sorun olduğunu biliyorum: istisna finallygeçersiz kılınır try, bu yüzden atmak tavsiye edilmez Dispose(). Ancak ağa erişen sınıflarla, kapatma yöntemlerindeki istisnaları bastırmak hiç de iyi görünmüyor.

Aşağıdaki yardımcıyla soruna geçici bir çözüm bulmak mümkündür:

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

ve onu gibi kullan

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

ki bu çirkin bir şeydir (ve kullanım bloğundaki erken dönüşler gibi şeylere izin vermez).

await usingMümkünse iyi, kanonik bir çözüm var mı ? İnternet'teki aramam bu sorunu tartışırken bile bulamadı.

Yüzeyleştirmek istediğiniz istisnalar vardır (mevcut isteği yarıda keser veya süreci aşağı çeker) ve tasarımınızın bazen gerçekleşmesini beklediği ve bunları kaldırabileceğiniz istisnalar vardır (örneğin, yeniden dene ve devam et).

Ancak bu iki tür arasında ayrım yapmak, kodun nihai arayanıdır - kararı arayana bırakmak için istisnaların hepsi budur.

Bazen arayan, orijinal kod bloğundan istisnayı ve bazen Dispose. Hangisinin öncelikli olacağına karar vermek için genel bir kural yoktur. CLR, senkronizasyon ile senkronize olmayan davranış arasında en azından (belirttiğiniz gibi) tutarlıdır.

Şimdi AggregateExceptionbirden fazla istisnayı temsil etmek zorunda olduğumuz belki de talihsiz bir durumdur, bunu çözmek için sonradan güçlendirilemez. yani uçuşta bir istisna varsa ve bir başkası fırlatılırsa, bir AggregateException. catchMekanizma yazarsanız o kadar modifiye edilebilir catch (MyException)o zaman herhangi yakalayacak AggregateExceptiontüründe bir istisna içerdiğini MyException. Yine de bu fikirden kaynaklanan çeşitli başka komplikasyonlar var ve muhtemelen bu kadar temel bir şeyi değiştirmek çok riskli.

Sen kalkındırmak olabilir UsingAsyncbir değerin erken dönüşü desteklemek için:

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

Belki de bunun neden olduğunu zaten biliyorsunuz, ancak yazılmaya değer. Bu davranış belirli değildir await using. Düz bir usingblokla da olur. Ben Dispose()burada söylerken , hepsi de geçerlidir DisposeAsync().

Bir usingblok, belgelerin açıklamalar bölümünde belirtildiği gibi, bir try/ finallyblok için sadece sözdizimsel şekerdir . Gördüğünüz şey , bir istisnadan sonra bile blok her zaman çalışıyor çünkü olur . Dolayısıyla, bir istisna oluşursa ve blok yoksa, istisna blok çalışana kadar beklemeye alınır ve sonra istisna atılır. Ancak bir istisna meydana gelirse , eski istisnayı asla göremezsiniz.finallycatchfinallyfinally

Bunu şu örnekle görebilirsiniz:

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

Fark etmez olsun Dispose()veya DisposeAsync()içeride denir finally. Davranış aynıdır.

İlk düşüncem: İçine atma Dispose(). Ancak Microsoft'un kendi kodlarını inceledikten sonra buna bağlı olduğunu düşünüyorum.

Örneğin, bunların uygulanmasına bir göz atın FileStream. Hem senkronize Dispose()yöntem hem DisposeAsync()de aslında istisnalar atabilir. Senkron Dispose(), kasıtlı olarak bazı istisnaları yok sayar, ancak hepsini değil.

Ama bence sınıfınızın doğasını dikkate almak önemlidir. Bir de FileStream, örneğin, Dispose()bir dosya sistemi tampon silinecektir. Bu çok önemli bir görev ve bunun başarısız olup olmadığını bilmeniz gerekiyor . Bunu görmezden gelemezsin.

Ancak, diğer nesne türlerinde, aradığınızda Dispose(), artık nesneyi gerçekten kullanamazsınız. Arayan Dispose()gerçekten sadece "bu nesne benim için öldü" demektir. Belki de ayrılan hafızayı temizler, ancak başarısızlık uygulamanızın çalışmasını hiçbir şekilde etkilemez. Bu durumda, içindeki istisnayı göz ardı etmeye karar verebilirsiniz Dispose().

Ancak her durumda, içindeki bir istisna usingveya gelen bir istisna arasında ayrım yapmak istiyorsanız Dispose(), bloğunuzun hem içinde hem de dışında bir try/ catchbloğuna ihtiyacınız vardır using:

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
}

Ya da sadece kullanamazsın using. Aşağıdaki durumlarda bir istisna yakaladığınız bir try/ catch/ finallybloğunu yazın 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
    }
}

kullanmak etkili bir şekilde İstisna İşleme Kodu (denemek için sözdizimi şekeri ... sonunda ... Dispose ()).

İstisna işleme kodunuz İstisnalar atıyorsa, bir şey kraliyet olarak yakalanır.

Seni oraya götürmek için başka ne olursa olsun, artık gerçekten materyal değil. Hatalı İstisna işleme kodu, olası tüm istisnaları bir şekilde gizler. Kural dışı durum işleme kodu, mutlak önceliğe sahip olan sabit olmalıdır. Bu olmadan, gerçek sorun için asla yeterli hata ayıklama verisi elde edemezsiniz. Çok sık yanlış yapıldığını görüyorum. Çıplak işaretçilerle uğraşmak kadar yanlış anlaşılması kolaydır. Sıklıkla, tematik olarak bağladığım, tasarımın altta yatan tasarım kavramlarına yardımcı olabilecek iki makale var:

• İstisnaların sınıflandırılması ve yakalamanız gereken
• Sınıflandırmanın kapsamadığı Genel İyi Uygulamalar

İstisna sınıflandırmasına bağlı olarak, İstisna İşleme / Dipoz kodunuz bir İstisna atarsa ​​yapmanız gerekenler şunlardır:

Ölümcül, Boneheaded ve Vexing için çözüm aynıdır.

Dışsal İstisnalardan ciddi maliyetle bile kaçınılmalıdır. Biz hala günlük kullandığımız bir sebep yoktur dosyaları log sonra yerine veritabanlarını istisnaları günlüğe - DB Opeartions Eksojen bir sorunla karşılaşmasını eğilimli sadece yoludur. Dosya tutamacı, tüm çalışma zamanı açık tutmak sakıncası bile ben bile günlük dosyaları.

Bir bağlantıyı kapatmanız gerekiyorsa, diğer uç hakkında fazla endişelenmeyin. UDP'nin yaptığı gibi ele alın: "Bilgileri göndereceğim, ancak diğer tarafın aldığını umursamıyorum." Elden çıkarma, üzerinde çalıştığınız istemci tarafındaki / taraftaki kaynakları temizlemekle ilgilidir.

Onları bilgilendirmeye çalışabilirim. Ama Sunucu / FS Tarafındaki şeyleri temizlemek mi? Yani ne onların zaman aşımları ve onların istisna işleme sorumludur.

AggregateException özelliğini kullanmayı deneyebilir ve kodunuzu aşağıdaki gibi değiştirebilirsiniz:

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