Senkron Programlama

Senkron programlama, işlemlerin sırayla ve bloklayarak yürütüldüğü programlama yaklaşımıdır. İşlem, tamamlanana kadar diğer işlemlerin beklemesi gerekmektedir. İşlem tamamlandığında bir sonraki işlem yürütülür.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Senkron işlem 1 başladı.");
        SenkronIslem1();
        Console.WriteLine("Senkron işlem 1 tamamlandı.");

        Console.WriteLine("Senkron işlem 2 başladı.");
        SenkronIslem2();
        Console.WriteLine("Senkron işlem 2 tamamlandı.");

        Console.WriteLine("Program sonlandı.");
    }

    static void SenkronIslem1()
    {
        // Birinci senkron işlem
        Console.WriteLine("Senkron işlem 1 çalışıyor...");
        // İşlem süresi ve mantığı
        Console.WriteLine("Senkron işlem 1 tamamlandı.");
    }

    static void SenkronIslem2()
    {
        // İkinci senkron işlem
        Console.WriteLine("Senkron işlem 2 çalışıyor...");
        // İşlem süresi ve mantığı
        Console.WriteLine("Senkron işlem 2 tamamlandı.");
    }
}

Bu örnekte, senkron bir programlama yaklaşımıyla işlemler sırayla ve bloklayarak yürütülüyor. İlk olarak "Senkron işlem 1" tamamlanıyor ve ardından "Senkron işlem 2" tamamlanıyor. İşlemler birbirini beklemektedir.

Asenkron Programlama

Asenkron programlama, programdaki işlemlerin eşzamansız olarak gerçekleştirildiği bir programlama yaklaşımıdır. Bu yaklaşım, özellikle uzun süren veya giriş/çıkış işlemleri gibi beklemeye dayalı işlemlerde performansı artırmak ve kullanıcı arayüzünün yanıt vermesini sağlamak için kullanılır.

Asenkron programlama, C# dilinde "async" ve "await" anahtar kelimeleriyle desteklenir. "async" anahtar kelimesi, bir metodu asenkron bir metot olarak işaretler. "await" anahtar kelimesi ise bir asenkron metodu çağırırken o metotun tamamlanmasını bekler ve ilgili sonucu elde etmek için kullanılır.

Asenkron programlama, aşağıdaki avantajları sağlar:

1. Daha iyi performans: Uzun süren işlemler veya giriş/çıkış işlemleri gibi beklemeye dayalı işlemlerde, işlemi beklerken CPU kaynaklarının başka işlemler için kullanılmasını sağlar. Böylece programın daha hızlı çalışmasını ve daha iyi performans göstermesini sağlar.

2. Daha duyarlı kullanıcı arayüzü: Asenkron programlama, kullanıcı arayüzünün donmamasını ve yanıt vermesini sağlar. Uzun süren işlemleri asenkron olarak yürüterek kullanıcıya anında geribildirim sağlanabilir.

3. Kaynakların etkin kullanımı: Birden fazla işlem veya istek arasında kaynakların daha etkin kullanılmasını sağlar. İşlemler arasında bekleme sürelerinde diğer işlemler gerçekleştirilebilir.

Asenkron programlama, programdaki işlemlerin eşzamansız olarak gerçekleştirildiği bir programlama yaklaşımıdır. Bu yaklaşım, özellikle uzun süren veya giriş/çıkış işlemleri gibi beklemeye dayalı işlemlerde performansı artırmak ve kullanıcı arayüzünün yanıt vermesini sağlamak için kullanılır.

Asenkron programlama, aşağıdaki gibi senaryolarda kullanılır:

• Uzun süren veritabanı sorguları veya dosya okuma/yazma gibi giriş/çıkış işlemleri
• Ağ istekleri ve servis çağrıları
• Uzun süren hesaplamalar veya işlemler

Aşağıda, C# dilinde asenkron programlamayı gösteren bir örnek bulunmaktadır:

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Console.WriteLine("İşlem başladı.");
        await LongRunningTask();
        Console.WriteLine("İşlem tamamlandı.");
    }

    static async Task LongRunningTask()
    {
        Console.WriteLine("Uzun süren işlem başladı...");
        await Task.Delay(3000); // 3 saniye bekleme
        Console.WriteLine("Uzun süren işlem tamamlandı.");
    }
}

Bu örnekte, "Main" metodu "async" olarak işaretlenir ve "await" anahtar kelimesiyle "LongRunningTask" metodu çağırılır. "LongRunningTask" metodu da "async" olarak işaretlenmiştir ve içerisinde "await Task.Delay(3000)" kullanılarak 3 saniye beklenir. Böylece "LongRunningTask" metodu tamamlandığında, "Main" metodu devam eder ve işlem tamamlanır.

Asenkron programlama, C# dilinde genellikle Task ve Task<T> türleri ile kullanılır. Bu türler, asenkron operasyonları temsil eden nesnelerdir ve asenkron işlemlerin yönetimi ve sonuçlarının elde edilmesi için kullanılırlar.

Asenkron programlama, modern C# uygulamalarında önemli bir rol oynar ve performansı artırmak, kullanıcı deneyimini iyileştirmek ve kaynakları etkin kullanmak için yaygın olarak kullanılır.

Thread

C# dilinde "thread", bir iş parçacığı olarak adlandırılan ve bağımsız olarak çalışabilen bir işlem birimidir. Bir thread, programdaki işlemlerin eşzamanlı olarak gerçekleştirilmesini sağlar. Her C# programı en az bir thread ile başlar, bu da ana thread olarak adlandırılır.

İş parçacıkları (thread'ler) aynı program içinde birbirinden bağımsız olarak çalışabilir ve aynı anda farklı işleri yapabilirler. Thread'ler, eşzamanlılık sağlamak ve iş yükünü paylaşmak için kullanılır. Birden çok thread kullanarak, aynı anda birden fazla görevi gerçekleştirmek, paralel işlem yapmak ve programın performansını artırmak mümkündür.

C# dilinde thread'leri yönetmek ve kontrol etmek için .NET Framework tarafından sunulan System.Threading isim alanı içindeki sınıflar ve yöntemler kullanılır.

C# dilinde thread'lerle ilgili temel kavramlar şunlardır:

• Thread sınıfı: Yeni bir thread oluşturmak ve yönetmek için kullanılan sınıftır. Bu sınıf, Start yöntemiyle yeni bir thread'i başlatmayı sağlar.

• ThreadStart delegesi: Thread'in çalıştıracağı metodu temsil eden bir delegedir. Thread sınıfının kurucusuna bu delegenin bir örneği geçirilerek thread başlatılabilir.

• ParameterizedThreadStart delegesi: Parametre alan bir metodu temsil eden bir delegedir. Thread'e parametre geçirmek için kullanılır.

• Thread.Sleep yöntemi: Belirli bir süre boyunca thread'in çalışmasını durdurur. Bu yöntem, thread'in belirli bir süre beklemesini ve diğer thread'lerin çalışmasına izin vermesini sağlar.

• Thread.Join yöntemi: Bir thread'in tamamlanmasını beklemek için kullanılır. Ana thread, Join yöntemini kullanarak belirli bir thread'in tamamlanmasını bekleyebilir.

• ThreadAbortException istisnası: Bir thread'in çalışması sırasında Abort yöntemi çağrıldığında oluşan bir istisnadır. Bu istisna, bir thread'in çalışmasını durdurmak için kullanılabilir.

Thread'lerin doğru bir şekilde yönetilmesi önemlidir. Senkronizasyon ve veri bütünlüğü gibi konulara dikkat etmek, birden çok thread arasında kaynak paylaşımı ve eşzamanlılık problemlerinin önlenmesi için gereklidir.

1) Thread Başlatma:

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // Yeni bir thread başlatma
        Thread thread = new Thread(WorkerMethod);
        thread.Start();

        // Ana thread'in çalışması devam eder
        Console.WriteLine("Ana thread çalışıyor...");

        // Diğer thread'in tamamlanmasını beklemek için bekleme
        thread.Join();

        Console.WriteLine("Program sonlandı.");
    }

    static void WorkerMethod()
    {
        Console.WriteLine("Worker thread başladı.");
        Thread.Sleep(2000); // 2 saniye bekleme
        Console.WriteLine("Worker thread tamamlandı.");
    }
}

Bu örnekte, Thread sınıfı kullanılarak yeni bir thread oluşturulur ve Start yöntemiyle başlatılır. Ana thread ise çalışmasına devam eder. WorkerMethod adında bir metot, yeni thread üzerinde çalıştırılır ve belirli bir süre uyutulur (Thread.Sleep). Sonuç olarak, ana thread yeni thread'in tamamlanmasını bekler (Join) ve program sonlanır.

2) Parametreli Thread Başlatma:

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // Parametreli thread başlatma
        Thread thread = new Thread(WorkerMethod);
        thread.Start("Merhaba, dünya!");

        // Ana thread'in çalışması devam eder
        Console.WriteLine("Ana thread çalışıyor...");

        // Diğer thread'in tamamlanmasını beklemek için bekleme
        thread.Join();

        Console.WriteLine("Program sonlandı.");
    }

    static void WorkerMethod(object message)
    {
        Console.WriteLine("Worker thread başladı: " + message);
        Thread.Sleep(2000); // 2 saniye bekleme
        Console.WriteLine("Worker thread tamamlandı.");
    }
}

Bu örnekte, WorkerMethod metodu bir parametre (message) alır ve Thread sınıfıyla başlatılan thread üzerinde çalıştırılır. Parametreli thread başlatma, thread'e belirli bir parametrenin aktarılmasını sağlar.

3) Thread Durdurma:

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // Thread'i durdurma
        Thread thread = new Thread(WorkerMethod);
        thread.Start();

        // Ana thread'in çalışması devam eder
        Console.WriteLine("Ana thread çalışıyor...");

        // 2 saniye bekledikten sonra thread'i durdurma
        Thread.Sleep(2000);
        thread.Abort();

        Console.WriteLine("Program sonlandı.");
    }

    static void WorkerMethod()
    {
        try
        {
            Console.WriteLine("Worker thread başladı.");
            while (true)
            {
                Console.WriteLine("Worker thread çalışıyor...");
                Thread.Sleep(500); // 0.5 saniye bekleme
            }
        }
        catch (ThreadAbortException)
        {
            Console.WriteLine("Worker thread durduruldu.");
        }
    }
}

Bu örnekte, WorkerMethod metodu sonsuz bir döngüde çalışırken abort edilerek thread durdurulur.

TASK

C# dilinde asenkron programlama yapısı, Task ve Task<T> sınıfları kullanılarak desteklenir. Bu yapı, uzun süren işlemleri etkin bir şekilde yönetmek, iş parçacıklarını verimli bir şekilde kullanmak ve kullanıcı arayüzünün yanıt vermesini sağlamak için önemlidir.

Task, .NET Framework 4.0 ile birlikte tanıtılan bir sınıftır ve Task<T> ise generic bir versiyonudur. Task, asenkron bir işi temsil eder ve işin başlatılması, sonucunun elde edilmesi veya hataların işlenmesi gibi işlemleri yönetmek için kullanılır.

Aşağıda, C# dilinde asenkron programlama yapısını kullanarak Task'ların nasıl kullanıldığını açıklayan bir örnek bulunmaktadır:

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Console.WriteLine("Program başladı.");

        // Asenkron bir metodu çağırma ve sonucunu beklemek için Task kullanma
        Task<string> task1 = AsenkronMetod();
        string result1 = await task1;
        Console.WriteLine("AsenkronMetod sonucu: " + result1);

        // Birden fazla asenkron metodu eşzamanlı olarak çağırma ve sonuçlarını beklemek için Task kullanma
        Task<string> task2 = AsenkronMetod1();
        Task<int> task3 = AsenkronMetod2();
        Task<bool> task4 = AsenkronMetod3();

        await Task.WhenAll(task2, task3, task4);

        string result2 = task2.Result;
        int result3 = task3.Result;
        bool result4 = task4.Result;

        Console.WriteLine("AsenkronMetod1 sonucu: " + result2);
        Console.WriteLine("AsenkronMetod2 sonucu: " + result3);
        Console.WriteLine("AsenkronMetod3 sonucu: " + result4);

        Console.WriteLine("Program sonlandı.");
    }

    static async Task<string> AsenkronMetod()
    {
        await Task.Delay(2000); // 2 saniye bekletme
        return "Merhaba, dünya!";
    }

    static async Task<string> AsenkronMetod1()
    {
        await Task.Delay(3000); // 3 saniye bekletme
        return "Selam!";
    }

    static async Task<int> AsenkronMetod2()
    {
        await Task.Delay(1500); // 1.5 saniye bekletme
        return 42;
    }

    static async Task<bool> AsenkronMetod3()
    {
        await Task.Delay(1000); // 1 saniye bekletme
        return true;
    }
}

Bu örnekte, Main metodu asenkron olarak işaretlenir (async Task Main()). AsenkronMetod adında bir asenkron metot çağırılır ve sonucu beklemek için await anahtar kelimesi kullanılır. Bu şekilde, asenkron metotların sonucu döndüğünde devam edilecek şekilde programın akışı kontrol edilir.

Ayrıca, birden fazla asenkron metot eşzamanlı olarak çağrılabilir ve sonuçları beklemek için Task.WhenAll yöntemi kullanılabilir. Bu yöntem, birden fazla Task nesnesini parametre olarak alır ve bu Task'ların tamamlanmasını bekler.

Asenkron programlama yapısı, uzun süren işlemleri etkin bir şekilde yönetmek, paralel işlemler gerçekleştirmek ve daha iyi bir kullanıcı deneyimi sağlamak için önemlidir. Task'lar, bu yapıyı destekleyen C# dilindeki önemli bir öğedir.

Thread ve Task arasındaki farklar

C# dilinde Thread ve Task, çoklu iş parçacığı programlamasını desteklemek için kullanılan iki farklı yaklaşımdır. İşte Thread ve Task arasındaki farklar:

1. Başlatma ve Yönetim:

• Thread: Thread sınıfı, System.Threading isim alanında bulunur. Yeni bir thread oluşturmak için Thread sınıfının bir örneği oluşturulur ve Start yöntemiyle başlatılır. Thread'ler, daha düşük seviyeli bir yapıya sahiptir ve daha fazla kontrol ve yönetim gerektirir.

• Task: Task, System.Threading.Tasks isim alanında bulunan bir sınıftır ve .NET Framework 4.0'tan itibaren tanıtılmıştır. Task, daha yüksek seviyeli bir soyutlamadır ve Task sınıfının veya Task.Run yönteminin kullanılmasıyla oluşturulabilir. Task'lar, daha yüksek seviyeli bir arayüz sağlar ve thread yönetimini .NET Runtime'a bırakır. .NET Runtime, Task'ları otomatik olarak thread havuzundan uygun sayıda iş parçacığıyla eşleştirir.

2. Geri Dönüş Değeri:

• Thread: Thread'ler geri dönüş değeri döndürmez. Bunun nedeni, Thread sınıfının bir metodu temsil etmesi ve geri dönüş değeri ile ilişkilendirilmemesidir.

• Task: Task, geri dönüş değeri döndürebilen bir yapıya sahiptir. Task<T> türü kullanılarak oluşturulan Task nesneleri, belirli bir türde bir sonuç döndürebilir.

3. Senkronizasyon:

• Thread: Thread'ler, senkronizasyon mekanizmalarını (lock, mutex, semaphore vb.) doğrudan kullanarak senkronize edilmelidir. Bu, thread'ler arasında senkronizasyon ve veri bütünlüğünün sağlanması için ekstra çaba gerektirir.

• Task: Task'lar, async/await sözdizimiyle birlikte kullanılarak kolayca senkronize edilebilir. async/await sözdizimi, senkron ve asenkron kodu bir arada kullanmayı sağlar ve senkronizasyon mekanizmalarının otomatik olarak işlenmesini sağlar.

4. Hata Yönetimi:

• Thread: Thread'lerde hata yönetimi ve hata paylaşımı zordur. Bir thread hata üretirse, bu hata diğer thread'lerle paylaşılamaz ve yönetimi zorlaşır.

• Task: Task'lar, hata yönetimi ve hata paylaşımı için daha iyi bir yapıya sahiptir. Task'lar, bir hata durumunda bu hatayı yakalamanıza ve uygun şekilde işlem yapmanıza olanak tanır. Ayrıca, Task'lar arasında hata paylaşımı kolaylıkla gerçekleştir

TASK VE VALUETASK ARASINDAKİ FARK

C# dilinde Task ve ValueTask, asenkron programlama için kullanılan iki farklı yapıdır. İşte Task ve ValueTask arasındaki farklar:

1. Genel Kullanım:

• Task: Task, System.Threading.Tasks isim alanında bulunan bir sınıftır. Task, bir asenkron işi temsil eder ve genellikle asenkron metotların dönüş değeri olarak kullanılır. Task, bir işin tamamlanmasını bekleyebilir, sonucunu taşıyabilir veya bir hata üretebilir.

• ValueTask: ValueTask, System.Threading.Tasks isim alanında bulunan bir yapıdır. ValueTask, asenkron bir işi temsil eder ve Task'a benzer şekilde kullanılabilir. Ancak, ValueTask daha hafif bir yapıya sahiptir ve bazı durumlarda performans avantajı sağlayabilir.

2. Bellek Kullanımı:

• Task: Task, bir referans türüdür ve heap üzerinde bir nesne olarak oluşturulur. Bu nedenle, Task nesneleri bellekte daha fazla yer kaplar ve gereksiz yere bellek tüketebilir.

• ValueTask: ValueTask, bir değer türüdür ve stack üzerinde depolanır. Bu, ValueTask nesnelerinin daha hafif olduğu ve bellek tüketiminin daha düşük olduğu anlamına gelir. Özellikle, bir işin sık sık tamamlandığı veya yeniden kullanıldığı durumlarda ValueTask kullanmak performans avantajı sağlayabilir.

3. Performans:

• Task: Task, genellikle IO-beklemeli veya CPU yoğun işlemleri temsil etmek için kullanılır. Task, async/await sözdizimi ile birlikte kullanıldığında, işlemin tamamlanmasını beklerken iş parçacığının serbest bırakılmasını sağlar. Ancak, Task bazen gereksiz yere iş parçacığı oluşturabilir ve yönetebilir, bu da performans açısından maliyetli olabilir.

• ValueTask: ValueTask, hafif bir yapısı olduğu için bazı durumlarda performans avantajı sağlar. Özellikle, işin hızlı bir şekilde tamamlandığı veya işin genellikle senkron olarak gerçekleştiği durumlarda ValueTask tercih edilebilir. ValueTask, gerektiğinde Task'a dönüştürülebilir, bu da daha esnek bir kullanım sağlar.

Genel olarak, Task, daha genel ama ağır bir yapıdır ve çoğu durumda kullanılabilirken, ValueTask daha hafif bir yapıdır ve performans avantajı sağlar. ValueTask'ı kullanmak için, işin hızlı bir şekilde tamamlandığı veya performansın önemli olduğu durumları değerlendirmek önemlidir.

ValueTask Örneği:

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        // ValueTask çağırma
        ValueTask<int> valueTask = GetValue();

        // Ana iş parçacığından bazı işlemler
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine("Ana iş parçacığı çalışıyor...");
            Task.Delay(1000).Wait(); // 1 saniye bekleme
        }

        // ValueTask'in tamamlanmasını bekleyin ve değerini alın
        int result = valueTask.GetAwaiter().GetResult();

        Console.WriteLine("Sonuç: " + result);
        Console.WriteLine("Program sonlandı.");
    }

    static async ValueTask<int> GetValue()
    {
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine("ValueTask çalışıyor...");
            await Task.Delay(1000); // 1 saniye bekleme
        }

        return 42;
    }
}

Bu örnekte, GetValue metodunu çağırdık ve geri dönüş değeri olarak ValueTask<int> kullandık. Ana iş parçacığı, "Ana iş parçacığı çalışıyor..." yazısını her saniyede bir ekrana yazdırırken, ValueTask çalışması da "ValueTask çalışıyor..." yazısını her saniyede bir ekrana yazdıracaktır. Son olarak, GetAwaiter().GetResult() yöntemini kullanarak ValueTask'in tamamlanmasını bekleyip değerini alıyoruz.

Bu örneklerde, Thread, Task ve ValueTask kullanarak çoklu iş parçacıklarında eşzamanlı çalışmayı ve paralel işlemleri gerçekleştirebilirsiniz. Dikkat etmeniz gereken noktalardan biri, çoklu iş parçacığı kullanırken senkronizasyon ve kritik bölge sorunlarına dikkat etmek ve uygun senkronizasyon mekanizmalarını kullanmaktır.

PARALEL PROGRAMLAMA

Paralel programlama, işlemlerin aynı anda ve gerçekten paralel olarak yürütüldüğü bir programlama yaklaşımıdır. İşlemler birbirinden bağımsız olarak çalışır ve işlemcinin çoklu çekirdeklerini kullanarak performans artışı sağlar.

C# dilinde paralel programlama, birden fazla işin aynı anda yürütülmesini sağlayan bir programlama yaklaşımıdır. Bu, çok çekirdekli işlemcilerin gücünden yararlanarak işleri daha hızlı ve verimli bir şekilde gerçekleştirmeyi mümkün kılar. C# dilinde paralel programlama için aşağıdaki yapılar ve yöntemler bulunmaktadır:

Parallel sınıfı: System.Threading.Tasks isim alanında yer alan Parallel sınıfı, paralel programlamayı desteklemek için kullanılan önemli bir yapıdır. Bu sınıf, birden fazla iş parçacığının (thread) paralel olarak çalışmasını yönetir ve işleri otomatik olarak dağıtır.

Örnek olarak, bir dizi üzerinde paralel bir döngü çalıştırmak için Parallel.ForEach yöntemini kullanabilirsiniz:

int[] numbers = { 1, 2, 3, 4, 5 };

Parallel.ForEach(numbers, number =>
{
    Console.WriteLine(number);
});

Bu kodda, numbers dizisindeki her bir eleman için ayrı bir iş parçacığı oluşturulur ve bu iş parçacıkları aynı anda çalışır.

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Console.WriteLine("Paralel işlem 1 başladı.");
        Parallel.Invoke(ParalelIslem1, ParalelIslem2);
        Console.WriteLine("Paralel işlem 1 ve 2 tamamlandı.");

        Console.WriteLine("Program sonlandı.");
    }

    static void ParalelIslem1()
    {
        // Birinci paralel işlem
        Console.WriteLine("Paralel işlem 1 çalışıyor...");
        // İşlem süresi ve mantığı
        Console.WriteLine("Paralel işlem 1 tamamlandı.");
    }

    static void ParalelIslem2()
    {
        // İkinci paralel işlem
        Console.WriteLine("Paralel işlem 2 çalışıyor...");
        // İşlem süresi ve mantığı
        Console.WriteLine("Paralel işlem 2 tamamlandı.");
    }
}

Bu örnekte, paralel programlama yaklaşımıyla işlemler aynı anda ve gerçekten paralel olarak yürütülüyor. Parallel.Invoke metodu kullanılarak işlemler aynı anda başlatılıyor ve sonucun tamamlanması bekleniyor. İşlemler bağımsız olarak çalışıyor ve işlemcinin çoklu çekirdeklerini kullanarak performans artışı sağlanıyor.

C# LINQ (Language-Integrated Query) kullanarak paralel programlama örneklerini aşağıda bulabilirsin:

1. Paralel LINQ Sorgusu: Paralel LINQ, veriler üzerinde paralel olarak sorguların çalıştırılmasını sağlayan bir özelliktir. AsParallel() yöntemi kullanılarak LINQ sorgusu paralel olarak yürütülebilir.

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] numbers = Enumerable.Range(1, 1000000).ToArray();

        // Paralel LINQ sorgusu
        var evenNumbers = numbers.AsParallel()
                                 .Where(n => n % 2 == 0)
                                 .ToArray();

        Console.WriteLine("Çift sayılar: " + evenNumbers.Length);
        Console.WriteLine("Program sonlandı.");
    }
}

Bu örnekte, Enumerable.Range() yöntemi ile 1'den 1.000.000'e kadar olan sayı dizisi oluşturuluyor. AsParallel() yöntemi kullanılarak LINQ sorgusu paralel olarak yürütülüyor ve çift sayıları filtreleyerek evenNumbers dizisine atanıyor. Sonuç olarak, kaç çift sayı olduğu ekrana yazdırılıyor.

2. Paralel LINQ Sorgusu ile Agregasyon: Paralel LINQ, agregasyon işlemleri için de kullanılabilir. AsParallel() ve Aggregate() yöntemleri kullanılarak veriler üzerinde paralel agregasyon gerçekleştirilebilir.

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] numbers = Enumerable.Range(1, 1000000).ToArray();

        // Paralel LINQ sorgusu ile toplam bulma
        var sum = numbers.AsParallel()
                         .Aggregate(0, (subtotal, number) => subtotal + number);

        Console.WriteLine("Toplam: " + sum);
        Console.WriteLine("Program sonlandı.");
    }
}

Bu örneklerde senkron, asenkron ve paralel programlama yaklaşımlarını gösterdik. Senkron programlama, işlemlerin sırayla ve bloklayarak yürütüldüğü durumlar için kullanılırken, asenkron programlama beklemek yerine işlemleri devam ettirebilir. Paralel programlama ise bağımsız işlemleri aynı anda ve gerçekten paralel olarak yürütebilir. Hangi yaklaşımın kullanılacağı, ihtiyaçlara ve uygulamanın gereksinimlerine bağlıdır.