berzahx 1
berzahx
aslan6474 1
aslan6474
Reklam vermek için turkmmo@gmail.com

C# Programlamada Async ve Await: Task Yapısı ve Kritik Hatalar

  • Konuyu başlatan Konuyu başlatan Agora Metin2
  • Başlangıç tarihi Başlangıç tarihi
  • Cevaplar Cevaplar 0
  • Görüntüleme Görüntüleme 13
image247fbc2075bc98a7.jpg


Yazılım dünyasındaki yavaşlıkların temelinde genellikle beklemek yatar; bir sunucudan yanıt gelmesini, veritabanının sorguyu bitirmesini veya bir dosyanın diskten okunmasını beklersiniz. async ve await mekanizması, bu bekleme sürelerinde işlemci çekirdeğini (thread) meşgul etmeden kodun duraklamasını ve iş bitince devam etmesini sağlar. Bu sayede kodunuz karmaşıklaşmaz, tıpkı standart kodlar gibi yukarıdan aşağıya akıcı bir şekilde okunmaya devam eder.

İlk asenkron metodun oluşturulması

Asenkron bir fonksiyon ya geriye bir değer döndürmeyen Task objesi ya da T tipinde sonuç üreten bir Task<T> döndürür. Fonksiyonun içindeki await ifadesi, bir işin bitmesini bekler ve elde edilen sonucu size teslim eder.

C#:
using System;
using System.Threading.Tasks;

class Program
{
    static async Task<decimal> GetPriceAsync(string product)
    {
        await Task.Delay(200);          // stands in for a network call
        return product == "tea" ? 2.50m : 4.00m;
    }

    static async Task RunAsync()
    {
        decimal tea = await GetPriceAsync("tea");
        decimal cake = await GetPriceAsync("cake");
        Console.WriteLine("Tea " + tea + ", cake " + cake + ", total " + (tea + cake));
    }

    static void Main()
    {
        RunAsync().GetAwaiter().GetResult();
    }
}

Sonuç:

Kod:
Tea 2.50, cake 4.00, total 6.50

Yukarıdaki örnekte GetPriceAsync metodu 2.50m değerini döndürdüğünde, derleyici bu değeri otomatik olarak bir Task<decimal> içine yerleştirir. await ise bu kutuyu açarak değeri dışarı çıkarır. Task.Delay komutu, bildiğimiz Thread.Sleep metodunun asenkron versiyonudur; belirtilen süre dolana kadar bekler ancak bu esnada sistemi kilitlemez.

C# 7.1 sürümüyle beraber Main metodu da asenkron yapılabiliyor. Güncel .NET standartlarında uygulama yapısı şöyledir:

C#:
static async Task Main()
{
    decimal tea = await GetPriceAsync("tea");
    Console.WriteLine(tea);
}

Buradaki örnek kodlarda, asenkron RunAsync metodu standart bir Main içerisinden .GetAwaiter().GetResult() kullanılarak çağrılmaktadır; aslında derleyici asenkron bir giriş noktası oluştururken arka planda tam olarak bunu yapar. Konsol uygulamalarında bu yöntem sorun çıkarmaz ancak birazdan değineceğimiz "deadlock" (kilitlenme) konusu nedeniyle arayüz (UI) uygulamalarında risklidir.

Await kullanıldığında arka planda ne döner?

Asenkron bir metot, henüz tamamlanmamış bir görevin (task) üzerindeki ilk await satırına gelene dek normal kod gibi senkron çalışır. Bu satıra ulaştığında, kendisini çağıran yere bir Task nesnesi fırlatır ve geri kalan işlemlerin tamamlanması için bir "devam görevi" (continuation) oluşturur.

C#:
using System;
using System.Threading.Tasks;

class Program
{
    static async Task DownloadAsync()
    {
        Console.WriteLine("  Download: starting");
        await Task.Delay(300);
        Console.WriteLine("  Download: finished");
    }

    static async Task RunAsync()
    {
        Console.WriteLine("Calling DownloadAsync");
        Task download = DownloadAsync();          // runs until its first await
        Console.WriteLine("DownloadAsync returned a task; doing other work");
        await download;                           // now wait for it
        Console.WriteLine("Download awaited");
    }

    static void Main()
    {
        RunAsync().GetAwaiter().GetResult();
    }
}

Sonuç:

Kod:
Calling DownloadAsync
  Download: starting
DownloadAsync returned a task; doing other work
  Download: finished
Download awaited

"Download: starting" metni, DownloadAsync henüz görevini bitirmeden ekrana yazılır; çünkü ilk beklemeye kadar olan kısım ana thread üzerinde icra edilir. Metot bitmemiş bir görev döndürdükten sonra ana akış devam eder. "Download: finished" yazısı ise sadece gecikme süresi dolduğunda ekranda belirir. Kısacası asenkron bir metodu çağırmak onu tetikler, await kullanmak ise sonucunu beklememizi sağlar.

Unutulmamalıdır ki async tek başına yeni bir thread yaratmaz. Metot askıdayken onu bekleyen boşta bir thread yoktur. Web sunucularının kısıtlı kaynakla binlerce veritabanı isteğini yönetebilmesinin sırrı budur. Eğer gerçekten işlemciyi yoran (CPU-bound) bir işi başka bir thread'e paslamak isterseniz Task.Run kullanmalısınız.

Task.WhenAll ile paralel operasyonlar

Eğer birden fazla await işlemini alt alta yazarsanız, her işlem bir öncekinin bitmesini bekler ve süreç uzar. Birbirinden bağımsız işleri hızlandırmak için hepsini aynı anda başlatıp Task.WhenAll ile beraber bekleyebilirsiniz:

C#:
using System;
using System.Diagnostics;
using System.Threading.Tasks;

class Program
{
    static async Task<int> FetchStockAsync(string item, int ms)
    {
        await Task.Delay(ms);   // simulated request
        return item.Length * 10;
    }

    static async Task RunAsync()
    {
        var sw = Stopwatch.StartNew();
        int a = await FetchStockAsync("apples", 300);
        int b = await FetchStockAsync("pears", 300);
        int c = await FetchStockAsync("plums", 300);
        Console.WriteLine("Sequential: " + (a + b + c) + " units in ~" + sw.ElapsedMilliseconds / 100 * 100 + " ms");

        sw.Restart();
        Task<int> ta = FetchStockAsync("apples", 300);   // all three start now
        Task<int> tb = FetchStockAsync("pears", 300);
        Task<int> tc = FetchStockAsync("plums", 300);
        int[] results = await Task.WhenAll(ta, tb, tc);
        Console.WriteLine("Concurrent: " + (results[0] + results[1] + results[2]) + " units in ~" + sw.ElapsedMilliseconds / 100 * 100 + " ms");
    }

    static void Main()
    {
        RunAsync().GetAwaiter().GetResult();
    }
}

Örnek sonuç:

Kod:
Sequential: 160 units in ~900 ms
Concurrent: 160 units in ~300 ms

Sıralı yöntemde süre tüm beklemelerin toplamı kadarken, paralel yöntemde süre sadece en uzun süren görev kadardır. Task.WhenAll, görevlerin bitiş sırası ne olursa olsun sonuçları size verdiğiniz ilk sırada teslim eder. Liste yapılarında, örneğin "tüm ID'ler için veri çek" gibi senaryolarda await Task.WhenAll(ids.Select(id => FetchAsync(id))) kalıbı sıklıkla tercih edilir.

Task.WhenAny ise görevlerden herhangi biri biter bitmez tetiklenir; özellikle zaman aşımı (timeout) durumlarında veya "ilk yanıtı veren gelsin" mantığında oldukça kullanışlıdır.

Asenkron yapılarda hata yönetimi

Asenkron bir metot içinde hata (exception) oluştuğunda, bu hata dönen task nesnesinin içine paketlenir. Hata ancak görev await edildiğinde gün yüzüne çıkar. Bu yüzden standart try/catch bloklarını await satırının etrafında güvenle kullanabilirsiniz:

C#:
using System;
using System.Threading.Tasks;

class Program
{
    static async Task<string> LoadProfileAsync(int userId)
    {
        await Task.Delay(50);
        if (userId <= 0) throw new ArgumentOutOfRangeException(nameof(userId));
        return "profile " + userId;
    }

    static async Task RunAsync()
    {
        Task<string> task = LoadProfileAsync(-1);   // no exception yet
        Console.WriteLine("Task created, completed yet: " + task.IsCompleted);

        try
        {
            await task;                              // rethrown here
        }
        catch (ArgumentOutOfRangeException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name + " for " + e.ParamName);
        }

        Task<string> ok = LoadProfileAsync(7);
        Task<string> bad = LoadProfileAsync(0);
        Task<string[]> all = Task.WhenAll(ok, bad);
        try
        {
            await all;
        }
        catch (ArgumentOutOfRangeException)
        {
            Console.WriteLine("WhenAll rethrew the first failure");
            Console.WriteLine("All failures: " + all.Exception.InnerExceptions.Count);
            Console.WriteLine("The other task still succeeded: " + ok.Result);
        }
    }

    static void Main()
    {
        RunAsync().GetAwaiter().GetResult();
    }
}

Sonuç:

Kod:
Task created, completed yet: False
Caught ArgumentOutOfRangeException for userId
WhenAll rethrew the first failure
All failures: 1
The other task still succeeded: profile 7

Dikkat ederseniz LoadProfileAsync(-1) çağrıldığı an değil, await edildiği an hata fırlatmıştır. Eğer bir task'ı asla await etmezseniz, içindeki hatayı asla göremezsiniz; bu yüzden başlattığınız görevleri mutlaka takip etmelisiniz. WhenAll kullanımında await ilk hatayı fırlatırken, görevin Exception özelliği (AggregateException türünde) tüm hataları bünyesinde saklar.

async void kullanımı: Sadece olay yakalayıcılar için

Metotlar async void şeklinde tanımlanabilir ancak bunu olay yakalayıcılar (event handlers) haricinde asla kullanmamalısınız:

C#:
// Bad: the caller cannot await it or catch its exceptions.
static async void SaveAsync(Order order)
{
    await db.InsertAsync(order);   // if this throws, the process may crash
}

// Good: return Task, so callers can await and handle errors.
static async Task SaveAsync(Order order)
{
    await db.InsertAsync(order);
}

// Acceptable: an event handler must return void.
private async void SaveButton_Click(object sender, EventArgs e)
{
    try { await SaveAsync(currentOrder); }
    catch (Exception ex) { ShowError(ex); }
}

async void ile çağrılan bir metodun takip edilebilecek bir task'ı yoktur. Hata oluştuğunda, çağıran tarafın try/catch bloğu bunu yakalayamaz ve uygulama doğrudan çökebilir. Eğer asenkron bir metodu await etmeden çağırırsanız derleyici sizi CS4014 uyarısıyla ikaz eder; bu durumda metodun akıbeti belirsiz kalır.

.Result ve .Wait() kaynaklı kilitlenmeler (Deadlock)

Asenkron bir görevi .Result veya .Wait() ile zorla bekletmek, programın donmasına yol açan en büyük hatadır. Özellikle UI tabanlı (WPF, WinForms, eski ASP.NET) uygulamalarda şu senaryo gerçekleşir:

1. Arayüz thread'i .Result ile bir görevi beklemeye başlar ve kendini kilitler.
2. Görev içindeki await işlemi biter. Sistem, kaldığı yerden devam etmek için arayüz thread'ini geri ister.
3. Ancak arayüz thread'i birinci adımda kilitlendiği için cevap veremez. Sonuç olarak uygulama tamamen donar.

ASP.NET Core veya konsol uygulamalarında bu tip bir "context" olmadığı için sorun çıkmayabilir ancak bu durum kodun hatalı olduğu gerçeğini değiştirmez. Çözüm yolları:

• Kodun her aşamasında await kullanarak zinciri bozmayın.
• Kütüphane geliştiriyorsanız, arayüz thread'ine geri dönme zorunluluğunu kaldırmak için await SomethingAsync().ConfigureAwait(false); ifadesini kullanın. Bu, performansı artırır ve kilitlenme riskini azaltır ancak her seviyede uygulanması gerekir.

Modern ASP.NET Core uygulamalarında artık senkronizasyon bağlamı bulunmadığı için ConfigureAwait(false) kullanımı zorunlu değildir.

Sıkça yapılan yanlışlar

• Birbirinden bağımsız işleri sırayla await etmek. Bunun yerine hepsini başlatıp Task.WhenAll kullanın.
• async void kullanmak. Event handler'lar dışındaki her yerde Task döndürün.
• UI kodlarında .Result veya .Wait() kullanmak. Bunlar deadlock nedenidir; sadece await kullanın.
• await yazmayı unutmak. Bu durumda hatalar ve sonuçlar sessizce kaybolur.
• Dosya okuma veya internetten veri çekme gibi hazır asenkron metotları Task.Run içine koymak. Bu metotlar zaten sistemi kilitlemez; Task.Run sadece gereksiz kaynak tüketir.
• async kelimesinin her şeyi yeni bir thread'de yapacağını sanmak. Bu yapı "thread yaratmak" değil, "thread'i serbest bırakmak" üzerinedir. İşlemci gücü gerektiren işlerde Task.Run tercih edilmelidir.
 

Şu an konuyu görüntüleyenler (Toplam : 0, Üye: 0, Misafir: 0)

Geri
Üst