C# Asenkron Programlama: Performans ve Duyarlılık İçin Anahtar

Günümüzün modern yazılım dünyasında kullanıcılar, uygulamalardan anında yanıt beklerler. Tıkır tıkır çalışan, uzun süreli işlemler yaparken bile donmayan, akıcı bir deneyim sunan yazılımlar artık bir lüks değil, bir beklentidir. Peki, geliştirdiğiniz C# uygulamalarında, bir veritabanı sorgusu, bir API çağrısı veya karmaşık bir hesaplama gibi zaman alan bir işlem yüzünden kullanıcı arayüzünün (UI) kilitlenmesi veya uygulamanızın yavaş tepki vermesi sorununu nasıl çözersiniz?

İşte tam da bu noktada asenkron programlama devreye giriyor. Geleneksel (senkron) programlama modelinde, bir işlem başlamadan önce diğer işlemlerin tamamlanmasını bekler. Bu durum, özellikle I/O (giriş/çıkış) yoğun işlemlerde veya uzun süren CPU operasyonlarında uygulamanın “donmasına” neden olabilir. Kullanıcılar için bu, sabır zorlayıcı bir deneyim anlamına gelir ve uygulamanızın performansına dair olumsuz bir algı oluşturur. C#’ta asenkron programlama, bu darboğazları aşmanın ve uygulamalarınızı çok daha duyarlı ve ölçeklenebilir hale getirmenin güçlü bir yoludur.

Asenkron programlama teknikleri sayesinde, uygulamanızın ana iş parçacığı (main thread) bloke olmadan uzun süreli işlemleri arka planda yürütebilirsiniz. Bu, kullanıcının uygulamanızla etkileşimde kalmasına, diğer işlevleri kullanmasına veya sadece bir işlemin bitmesini beklerken bir yükleme animasyonu görmesine olanak tanır. Özellikle masaüstü (WPF, Windows Forms), mobil (.NET MAUI, Xamarin) ve web (ASP.NET Core) uygulamalarında kullanıcı deneyimini doğrudan iyileştirirken, aynı zamanda sunucu tarafında yüksek eş zamanlılık ve kaynak verimliliği sağlar. Bu makalede, C#’taki asenkron programlamanın temelini oluşturan async ve await anahtar kelimelerinden başlayarak, ileri düzey kullanım senaryolarına, hata yönetimine ve performans ipuçlarına kadar geniş bir yelpazede bilgi edinecek, gerçek dünya örnekleriyle konuyu derinlemesine kavrayacaksınız.

C# asenkron programlama becerileri, modern yazılım geliştiricileri için vazgeçilmezdir. Bu makale, sizi bu güçlü paradigmanın temelleriyle tanıştıracak ve uygulamalarınızı bir üst seviyeye taşımanız için gerekli araçları sunacaktır. Hazırsanız, C#’ın asenkron dünyasına doğru bir yolculuğa çıkalım!

C# Asenkron Programlamanın Temel Kavramları ve async/await ile İlk Adımlar

Asenkron programlamanın kalbine inmeden önce, senkron ve asenkron yürütme modelleri arasındaki temel farkı anlamak kritik öneme sahiptir. Senkron modelde, her bir işlem sırayla tamamlanır. Bir metot çağrıldığında, o metot işini bitirene kadar kontrolü geri döndürmez ve sonraki kod satırı beklemek zorunda kalır. Örneğin, bir veritabanından büyük bir veri kümesi çeken senkron bir metot, bu veri kümesi tamamen alınana kadar uygulamanın tüm akışını durdurur. Bu durum, özellikle grafik kullanıcı arayüzüne (GUI) sahip uygulamalarda “donma” olarak algılanır.

Asenkron model ise, bir işlemin başlatılıp, o işlem tamamlanmadan kontrolün çağıran koda geri verilmesini sağlar. Bu sayede çağıran kod, uzun süreli işlemin bitmesini beklemek yerine diğer görevleri yapmaya devam edebilir. İşlem tamamlandığında, uygulamanın geri kalanına bildirim gönderilir ve istenirse sonuçlar işlenir. C#’ta bu, genellikle Task tabanlı Asenkron Desen (TAP) ile sağlanır. .NET Framework ve .NET Core, System.Threading.Tasks.Task sınıfı aracılığıyla bu soyutlamayı sunar. Task, asenkron bir operasyonun gelecekteki sonucunu temsil eden bir nesnedir.

C# 5.0 ile tanıtılan async ve await anahtar kelimeleri, asenkron programlamayı çok daha okunabilir ve yönetilebilir hale getirmiştir. Bu anahtar kelimeler, asenkron kod yazmayı senkron kod yazmaya benzer bir deneyime dönüştürerek geliştiricilerin işini büyük ölçüde kolaylaştırmıştır. async anahtar kelimesi bir metodun asenkron olduğunu ve içinde await kullanabileceğini belirtir. await ise, bir Task nesnesi üzerinde kullanılır ve o Task tamamlanana kadar metodun yürütülmesini askıya alır, ancak bu askıya alma işlemi ana iş parçacığını bloke etmez. Bunun yerine, kontrolü çağıran koda geri verir ve Task tamamlandığında metodun kaldığı yerden devam etmesini sağlar.

Şimdi basit bir asenkron metot örneğiyle konuyu pekiştirelim:

using System;
using System.Threading.Tasks;

public class AsyncDemo
{
    public static async Task UzunSurenIslemSimulasyonu()
    {
        Console.WriteLine("Uzun süreli işlem başlıyor...");
        await Task.Delay(3000); // 3 saniye bekle, ana thread'i bloke etmeden.
        Console.WriteLine("Uzun süreli işlem tamamlandı.");
    }

    public static async Task Main(string[] args)
    {
        Console.WriteLine("Main metot başladı.");
        Task islem = UzunSurenIslemSimulasyonu(); // Asenkron işlemi başlat

        Console.WriteLine("Main metot diğer işlerini yapıyor...");
        // Burada başka senkron işler yapılabilir, UI güncellenebilir.
        await Task.Delay(1000); // 1 saniye daha beklenti oluşturmak için

        await islem; // Asenkron işlemin bitmesini bekle
        Console.WriteLine("Main metot sona erdi.");
    }
}
    

Yukarıdaki örnekte Main metodu, UzunSurenIslemSimulasyonu metodunu await etmeden önce kendi işlerini yapmaya devam edebiliyor. Bu, uygulamanın duyarlılığını artıran temel mekanizmadır. Ayrıca, asenkron metotlar genellikle Task veya Task döndürürler. Task, belirli bir değer döndüren asenkron bir operasyonu temsil ederken, Task sadece bir operasyonun tamamlandığını belirtir ve bir değer döndürmez. async void de mümkündür, ancak hata yönetimi zorlukları nedeniyle genellikle yalnızca olay işleyicilerinde kullanılması önerilir.

Bir diğer önemli nokta ise ConfigureAwait(false) kullanımıdır. Özellikle kütüphane kodları yazarken, await Task.Delay(1000).ConfigureAwait(false); gibi bir ifade kullanmak, await sonrasında kodun orijinal eşzamanlama bağlamına (synchronization context) geri dönme zorunluluğunu ortadan kaldırır. Bu, özellikle GUI uygulamalarında performans artışı sağlayabilir ve potansiyel kilitlenmeleri (deadlock) önleyebilir, çünkü iş parçacığı havuzundan (thread pool) rastgele bir iş parçacığında devam edebilir. Ancak UI katmanında bu genellikle istenmez, çünkü UI elemanlarına erişmek için UI iş parçacığında olmak gerekir. Bu nedenle, ConfigureAwait(false) kullanımına nerede ve neden ihtiyaç duyulduğunu iyi anlamak önemlidir.

Asenkron Operasyonlarda Hata Yönetimi Nasıl Yapılır?

Asenkron programlama, performans ve duyarlılık sağlarken, hata yönetimi konusunda da bazı özel durumlar barındırır. Senkron kodda olduğu gibi, asenkron metotlarda da try-catch blokları kullanarak hataları yakalayabilirsiniz. Ancak, Task tabanlı asenkron operasyonlarda fırlatılan istisnalar doğrudan değil, Task nesnesinin içerisinde saklanır ve await edildiğinde tekrar fırlatılır. Bu sayede, tıpkı senkron kodda olduğu gibi await çağrısını bir try-catch bloğu içine alarak hataları kolayca yönetebilirsiniz.

using System;
using System.Threading.Tasks;

public class AsyncHataYonetimi
{
    public static async Task HataFirlatanAsenkronMetot()
    {
        await Task.Delay(1000);
        throw new InvalidOperationException("Asenkron bir hata oluştu!");
    }

    public static async Task Main(string[] args)
    {
        Console.WriteLine("Hata yönetimi örneği başladı.");
        try
        {
            await HataFirlatanAsenkronMetot();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine($"Beklenen hata yakalandı: {ex.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Beklenmeyen bir hata oluştu: {ex.Message}");
        }
        Console.WriteLine("Hata yönetimi örneği tamamlandı.");
    }
}
    

Birden fazla asenkron operasyonu Task.WhenAll ile aynı anda çalıştırıyorsanız ve bu operasyonlardan birden fazlası hata fırlatırsa, WhenAll çağrısı AggregateException tipinde bir istisna fırlatacaktır. Bu istisnanın içerisinde, fırlatılan tüm hataları barındıran bir InnerExceptions koleksiyonu bulunur. Bu koleksiyonu iterate ederek tüm hataları ayrı ayrı ele alabilir ve loglayabilirsiniz. Bu yaklaşım, karmaşık asenkron iş akışlarında kapsamlı hata raporlaması sağlamak için oldukça etkilidir. Hata yönetimini doğru bir şekilde uygulamak, uygulamanızın beklenmedik durumlara karşı daha dirençli olmasını ve kullanıcıya daha bilgilendirici geri bildirimler sunmasını sağlar. Unutmayın ki, ele alınmayan asenkron hatalar uygulamanın çökmesine yol açabilir veya tespit edilmesi zor, gizemli davranışlara neden olabilir.

Kullanıcı Arayüzü Duyarlılığı ve Ölçeklenebilir Uygulamalar İçin Asenkron Teknikler

Kullanıcı arayüzü (UI) duyarlılığı, modern uygulama geliştirmede temel bir gereksinimdir. Bir Windows Forms, WPF veya hatta mobil (.NET MAUI) uygulamasında, UI bileşenlerinin (düğmeler, metin kutuları, liste görünümleri) kullanıcı etkileşimlerine anında yanıt vermesi beklenir. Ancak, UI iş parçacığında (UI thread) uzun süreli bir işlem çalıştırdığınızda, bu iş parçacığı bloke olur ve UI donar. Kullanıcı ne bir düğmeye tıklayabilir ne de metin girişi yapabilir; uygulama tamamen yanıt vermeyi durdurur. İşte asenkron programlama, bu sorunu kökten çözmenin en etkili yoludur.

Asenkron bir metot await ile bir Task üzerinde beklemeye alındığında, UI iş parçacığı serbest bırakılır ve diğer UI olaylarını işlemeye devam edebilir. Task tamamlandığında, kontrol tekrar UI iş parçacığına döner ve metot kaldığı yerden devam eder. Bu dönüş, .NET çalışma zamanı tarafından sağlanan SynchronizationContext veya TaskScheduler gibi mekanizmalar aracılığıyla otomatik olarak yönetilir. Bu sayede, asenkron işlemin sonucuyla UI'yi güvenli bir şekilde güncelleyebilirsiniz. Örneğin, bir API'den veri çektikten sonra, await sonrası kod bloğu otomatik olarak UI iş parçacığında çalışmaya devam edeceğinden, direkt olarak bir TextBox'ın Text özelliğini veya bir ListView'in Items koleksiyonunu güncelleyebilirsiniz.

using System.Windows.Controls; // WPF için
using System.Threading.Tasks;

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    private async void BtnVeriCek_Click(object sender, RoutedEventArgs e)
    {
        BtnVeriCek.IsEnabled = false; // Düğmeyi devre dışı bırak
        txtDurum.Text = "Veriler çekiliyor..."; // Durum mesajı göster

        try
        {
            // Uzun süreli bir işlem simülasyonu (örneğin API çağrısı)
            string veri = await GetDataFromApiAsync(); 
            txtSonuc.Text = $"Çekilen Veri: {veri}"; // UI'yi güncelle
        }
        catch (Exception ex)
        {
            txtDurum.Text = $"Hata: {ex.Message}";
        }
        finally
        {
            BtnVeriCek.IsEnabled = true; // Düğmeyi tekrar etkinleştir
            txtDurum.Text = "İşlem tamamlandı.";
        }
    }

    private async Task GetDataFromApiAsync()
    {
        // Gerçek bir API çağrısı veya veritabanı işlemi
        await Task.Delay(4000); // 4 saniye süren bir ağ çağrısı simülasyonu
        return "API'den gelen önemli veriler.";
    }
}
    

Yukarıdaki WPF örneğinde, GetDataFromApiAsync metodu çağrıldığında await sayesinde UI iş parçacığı bloke olmaz. Kullanıcı düğmeye basmaya devam edebilir, pencereyi hareket ettirebilir veya diğer kontrollerle etkileşime geçebilir. İşlem bittiğinde, txtSonuc ve txtDurum kontrolleri güvenli bir şekilde güncellenir. Bu, kullanıcı için çok daha akıcı ve hoş bir deneyim sunar.

Asenkron programlama sadece kullanıcı arayüzleri için değil, aynı zamanda sunucu taraflı uygulamaların (örneğin ASP.NET Core API'leri) ölçeklenebilirliği için de hayati öneme sahiptir. Bir web sunucusunda, her gelen istek bir iş parçacığına atanır. Eğer bu iş parçacığı, bir veritabanı sorgusu veya harici bir servis çağrısı gibi G/Ç yoğun bir işlem nedeniyle beklemek zorunda kalırsa, o iş parçacığı da bloke olur. Bu, aynı anda işleyebileceğiniz istek sayısını sınırlar ve sunucunuzun kaynaklarını verimsiz kullanmasına yol açar. Asenkron G/Ç işlemleri, iş parçacığının beklerken serbest bırakılmasını sağlayarak, sunucunun çok daha fazla eşzamanlı isteği daha az kaynakla işlemesine olanak tanır. Modern web uygulamalarında, arayüzün farklı ekran boyutlarına uyum sağlaması için CSS media query'leri gibi teknikler kullanılırken, arka plandaki veri alışverişi ve işlem mantığının asenkron olması, uygulamanın genel duyarlılık ve performansını artırır.

İleri Düzey Asenkron Desenler: Paralel Yürütme ve İptal Mekanizmaları

Asenkron programlama, sadece tek bir işlemi bloke etmeden yürütmekle kalmaz, aynı zamanda birden fazla asenkron işlemi paralel olarak yönetmek için de güçlü desenler sunar. Bu, özellikle farklı kaynaklardan veri çeken veya birden fazla bağımsız görevi aynı anda başlatan uygulamalar için vazgeçilmezdir. C#’ta Task.WhenAll ve Task.WhenAny metotları, bu tür senaryolar için en sık kullanılan araçlardır.

Task.WhenAll metodu, bir dizi Task nesnesini argüman olarak alır ve bu Task'ların hepsi tamamlandığında kendisi de tamamlanan yeni bir Task döndürür. Bu, birden fazla bağımsız web servis çağrısını veya veritabanı sorgusunu aynı anda başlatıp, tüm sonuçları toplu olarak beklemek istediğinizde idealdir. Eğer Task dönen görevleriniz varsa, Task.WhenAll size tamamlanan tüm görevlerin sonuçlarını içeren bir koleksiyon döndürür. Bu sayede, birden fazla işlem için bekleme süresini toplam süre yerine en uzun süren işlemin süresine düşürebilirsiniz. Örneğin, bir ürün sayfasında ürün detayları, yorumlar ve benzer ürünler gibi farklı API'lerden veri çekiliyorsa, bunları WhenAll ile paralel olarak çekmek, sayfanın yüklenme süresini önemli ölçüde hızlandırabilir.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

public class ParalelIslemler
{
    public static async Task VeriCek1Async()
    {
        await Task.Delay(3000); // 3 saniye
        return "Veri 1";
    }

    public static async Task VeriCek2Async()
    {
        await Task.Delay(2000); // 2 saniye
        return "Veri 2";
    }

    public static async Task Main(string[] args)
    {
        Console.WriteLine("Paralel işlemler başlıyor...");

        // Her iki işlemi aynı anda başlat
        Task task1 = VeriCek1Async();
        Task task2 = VeriCek2Async();

        // Her ikisinin de bitmesini bekle
        string[] results = await Task.WhenAll(task1, task2); 

        Console.WriteLine($"Tüm veriler çekildi: {results[0]}, {results[1]}");
        Console.WriteLine("Paralel işlemler tamamlandı.");
    }
}
    

Diğer yandan, Task.WhenAny metodu, verilen Task koleksiyonundan herhangi biri tamamlandığında kendisi de tamamlanan bir Task döndürür. Bu, bir işlemi birden fazla kaynaktan başlattığınızda (örneğin, yedekli servis çağrıları) ve ilk yanıt vereni kullanmak istediğinizde kullanışlıdır. En hızlı olanı alıp diğerlerini iptal etmek (eğer mümkünse) kaynakları daha verimli kullanmanızı sağlar.

Asenkron işlemlerin yönetiminde bir diğer önemli konu ise iptal mekanizmalarıdır. Uzun süreli bir işlem başlamışken, kullanıcı fikrini değiştirebilir ve işlemi iptal etmek isteyebilir veya uygulamanın kendisi bir kaynak sıkıntısı nedeniyle işlemi sonlandırmak isteyebilir. CancellationTokenSource ve CancellationToken sınıfları, asenkron işlemleri düzgün bir şekilde iptal etmek için kullanılan standart yöntemlerdir. Bir CancellationTokenSource nesnesi oluşturulur ve Token özelliği ilgili asenkron metotlara veya Task.Delay gibi operasyonlara geçirilir. Kullanıcı iptali tetiklediğinde CancellationTokenSource.Cancel() metodu çağrılır ve CancellationToken üzerinden iptal isteği yayılır. Asenkron metotlar bu token'ı düzenli aralıklarla kontrol ederek iptal isteği olup olmadığını anlayabilir ve uygun bir şekilde OperationCanceledException fırlatarak veya temizlik yaparak sonlanabilirler.

Vaka Analizi: Büyük Ölçekli Bir Uygulamada Asenkron Dönüşümün Faydaları

Bir e-ticaret platformunun ürün listeleme sayfasını ele alalım. Bu sayfa, kullanıcılara ürün görselleri, fiyatları, stok bilgileri, müşteri yorumları ve önerilen diğer ürünler gibi birçok farklı bilgiyi tek bir ekranda sunar. Geleneksel (senkron) bir yaklaşımla geliştirildiğinde, bu sayfanın yüklenme süresi ciddi bir sorun haline gelebilir. Neden mi? Çünkü bu bilgiler genellikle farklı kaynaklardan (ürün veritabanı, stok servisi, yorumlar mikroservisi, öneri motoru) çekilir ve senkron bir yaklaşımla her bir veri çekme işlemi bir öncekinin bitmesini beklerdi.

Örneğin, ürün detaylarını çektiniz (200ms), sonra stok kontrolü yaptınız (150ms), ardından müşteri yorumlarını getirdiniz (300ms) ve son olarak benzer ürünleri öneri motorundan aldınız (400ms). Bu senaryoda sayfanın toplam yüklenme süresi yaklaşık 1050ms (1.05 saniye) olacaktır. Bu, günümüz standartlarında kabul edilemez derecede yavaş bir kullanıcı deneyimidir.

Peki, bu e-ticaret platformunu asenkron olarak nasıl dönüştürebiliriz? Tüm bu veri çekme işlemlerini async ve await kullanarak paralel hale getirebiliriz. Her bir veri çekme işlemini (örneğin, GetProductDetailsAsync(), CheckStockAsync(), GetCustomerReviewsAsync(), GetRecommendedProductsAsync()) bağımsız bir Task olarak başlatırız. Ardından, Task.WhenAll kullanarak bu görevlerin hepsinin tamamlanmasını bekleriz. Bu durumda, sayfanın yüklenme süresi, artık tüm işlemlerin toplam süresi değil, aralarındaki en uzun süren işlemin süresi kadar olacaktır. Yani yukarıdaki örnekte, 400ms süren öneri motoru çağrısı en uzun işlem olduğu için, sayfa yükleme süresi teorik olarak 400ms civarına düşecektir (network gecikmeleri ve işlem yükü hariç tutulduğunda).

Bu asenkron dönüşümün somut faydaları şunlardır:

• Daha Hızlı Sayfa Yükleme: Kullanıcılar ürün sayfasına saniyeler yerine milisaniyeler içinde ulaşır. Bu, özellikle mobil kullanıcılarda dönüşüm oranlarını doğrudan etkileyen bir faktördür.
• Gelişmiş Kullanıcı Deneyimi: Sayfa yüklenirken UI donmaz, kullanıcı etkileşimde kalabilir. Bu, markaya olan güveni artırır.
• Sunucu Kaynaklarının Verimli Kullanımı: Arka uçta, web sunucusu iş parçacıkları G/Ç işlemleri sırasında bloke olmaz. Bu, sunucunun aynı anda çok daha fazla kullanıcı isteğini işlemesine olanak tanır, böylece daha az sunucu kaynağıyla daha yüksek trafik yönetilebilir. Bu, maliyet tasarrufu ve daha iyi ölçeklenebilirlik anlamına gelir.
• Esneklik ve Bakım Kolaylığı: Asenkron kod, özellikle async/await ile yazıldığında, senkron koda benzer şekilde okunabilir ve bakımı kolaydır. Yeni veri kaynakları veya servisler eklendiğinde, mevcut asenkron yapıya entegrasyonu nispeten basittir.

Bu vaka analizi, asenkron programlamanın sadece teorik bir kavram olmadığını, aynı zamanda gerçek dünya uygulamalarında performansı, ölçeklenebilirliği ve kullanıcı deneyimini doğrudan etkileyen güçlü bir araç olduğunu göstermektedir. Modern yazılım geliştiricilerinin bu yeteneklere sahip olması, rekabetçi pazarda öne çıkmalarını sağlar.

Sonuç: C# Asenkron Programlama ile Uygulamalarınızı Geleceğe Taşıyın

Bu makalede C# asenkron programlamanın derinliklerine daldık ve neden modern yazılım geliştirmenin vazgeçilmez bir parçası olduğunu detaylıca inceledik. Uygulamaların kullanıcı arayüzlerinin duyarlılığını artırmasından, sunucu tarafındaki operasyonların ölçeklenebilirliğini sağlamasına kadar birçok alanda async ve await anahtar kelimelerinin gücünü keşfettik. Senkron ve asenkron yürütme arasındaki temel farkları anladık, Task tabanlı asenkron desenin nasıl çalıştığını gördük ve ConfigureAwait(false) gibi önemli optimizasyonları öğrendik.

Ayrıca, asenkron operasyonlarda hata yönetiminin inceliklerini, try-catch bloklarının ve AggregateException'ın nasıl kullanılacağını ele aldık. Task.WhenAll ve Task.WhenAny ile birden fazla asenkron işlemi paralel olarak yürütme yeteneğimizin yanı sıra, CancellationToken ile bu işlemleri düzgün bir şekilde iptal etme mekanizmalarını da irdeledik. Büyük ölçekli bir e-ticaret uygulamasının ürün listeleme sayfasının asenkron dönüşümünü bir vaka analizi olarak inceleyerek, asenkron programlamanın somut faydalarını ve gerçek dünya üzerindeki etkilerini gözlemledik.

C# asenkron programlama, sadece kodunuzu daha verimli hale getirmekle kalmaz, aynı zamanda kullanıcılarınıza daha akıcı, daha hızlı ve daha keyifli bir deneyim sunar. Geliştirdiğiniz uygulamaların geleceğe hazır olmasını sağlamak, artan beklentilere cevap vermek ve rekabette öne çıkmak için bu güçlü paradigmayı etkin bir şekilde kullanmak artık bir tercih değil, bir zorunluluktur. Bu makale ile edindiğiniz bilgiler, C# ile daha performanslı ve duyarlı uygulamalar geliştirme yolculuğunuzda size sağlam bir temel sunacaktır. Uygulamalarınızı asenkron hale getirerek, kullanıcı memnuniyetini artırabilir, sistem kaynaklarınızı optimize edebilir ve daha dayanıklı yazılımlar inşa edebilirsiniz.

Sıkça Sorulan Sorular

• S: async ve await kullanmak her zaman daha iyi performans sağlar mı?

  C: Her zaman değil. async ve await özellikle G/Ç yoğun (I/O-bound) operasyonlarda (ağ çağrıları, dosya işlemleri, veritabanı sorguları) performansı ve duyarlılığı önemli ölçüde artırır çünkü iş parçacığının beklerken boşa durmasını engeller. Ancak CPU yoğun (CPU-bound) işlemlerde (karmaşık matematiksel hesaplamalar) async ve await kullanmak tek başına performansı artırmaz, aksine iş parçacığı değiştirme maliyetleri nedeniyle hafif bir düşüşe neden olabilir. CPU yoğun işler için Task.Run kullanarak işlemi ayrı bir iş parçacığı havuzu iş parçacığında çalıştırmak daha uygun olabilir.

• S: async void ne zaman kullanılmalı, ne zaman kaçınılmalı?

  C: async void metotlar sadece olay işleyicileri (event handlers) için tasarlanmıştır. Bu bağlamda kullanıldığında UI'yi bloke etmeden asenkron işlemleri başlatabilirler. Ancak, async void metotlardan fırlatılan istisnalar doğrudan çağıran koda dönmez, bu da hata yönetimini zorlaştırır ve uygulamanın çökmesine neden olabilir. Bu nedenle, olay işleyicileri dışında, asenkron metotlarınızın Task veya Task döndürmesi şiddetle tavsiye edilir.

• S: Asenkron kodda deadlock (kilitlenme) nasıl önlenir?

  C: Deadlocklar genellikle asenkron metodun sonuçlarının senkron bir şekilde .Result veya .Wait() ile beklenmesi ve bu işlemin SynchronizationContext'e bağlı bir ortamda (GUI veya ASP.NET request context gibi) yapılmasıyla oluşur. En yaygın çözüm, kütüphane kodlarında veya UI thread'ine dönmek istemediğiniz durumlarda await çağrılarının sonuna .ConfigureAwait(false) eklemektir. Ayrıca, asenkron metotların sonuçlarını almak için her zaman await kullanmayı tercih etmek, deadlock riskini büyük ölçüde azaltır.

• S: Task.Delay ile Thread.Sleep arasındaki fark nedir?

  C: Temel fark, Task.Delay'in asenkron olması ve ana iş parçacığını bloke etmemesidir. Bir await Task.Delay(ms) çağrısı, metodu belirtilen süre boyunca askıya alır ve kontrolü çağıran koda geri verir, böylece uygulama duyarlı kalır. Thread.Sleep(ms) ise senkron bir işlemdir; çağrıldığı iş parçacığını belirtilen süre boyunca tamamen bloke eder ve bu süre boyunca o iş parçacığında hiçbir işlem yapılamaz. UI iş parçacığında Thread.Sleep kullanmak uygulamanın donmasına neden olur.