Task Parallel Library (TPL) in C#

Understanding Task Parallel Library (TPL) in C#

The **Task Parallel Library (TPL)** in C# provides a **higher-level abstraction** for managing parallel execution. It is more efficient and flexible than manually creating **threads**, allowing tasks to be scheduled and executed efficiently using the **Task class**.

Key Features of Task Parallel Library

• Automatically manages **thread pooling**.
• Supports **cancellation and continuation**.
• Scales efficiently using **multi-core processors**.
• Provides **async and await** integration for non-blocking execution.

Creating and Running Tasks

The **Task.Run()** method is used to create and execute a task asynchronously.

Example: Creating and Running a Task

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Task task = Task.Run(() =>
        {
            Console.WriteLine($"Task {Task.CurrentId} is running.");
        });

        task.Wait(); // Wait for task to complete
        Console.WriteLine("Task completed.");
    }
}

// Output:
// Task 1 is running.
// Task completed.
        

The **Task.Run()** method schedules a task to run asynchronously on a **thread pool thread**.

Running Multiple Tasks in Parallel

The **Task.WhenAll()** method waits for multiple tasks to complete before proceeding.

Example: Running Multiple Tasks Using Task.WhenAll()

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Task task1 = Task.Run(() => Console.WriteLine("Task 1 running"));
        Task task2 = Task.Run(() => Console.WriteLine("Task 2 running"));

        await Task.WhenAll(task1, task2);
        Console.WriteLine("All tasks completed.");
    }
}

// Output:
// Task 1 running
// Task 2 running
// All tasks completed.
        

**Task.WhenAll()** ensures that all tasks complete before executing the next statement.

Using Task Continuations

The **ContinueWith()** method allows chaining tasks, ensuring that a follow-up task executes after the first one completes.

Example: Task Continuation Using ContinueWith()

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Task task = Task.Run(() => Console.WriteLine("Task 1 running"))
                        .ContinueWith(t => Console.WriteLine("Task 2 running"));

        task.Wait();
    }
}

// Output:
// Task 1 running
// Task 2 running
        

The **ContinueWith()** method ensures that **Task 2 runs only after Task 1 completes**.

Cancelling a Running Task

You can use a **CancellationToken** to cancel a running task.

Example: Cancelling a Task Using CancellationToken

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        CancellationTokenSource cts = new CancellationTokenSource();

        Task task = Task.Run(() =>
        {
            for (int i = 1; i <= 5; i++)
            {
                if (cts.Token.IsCancellationRequested)
                {
                    Console.WriteLine("Task cancelled.");
                    return;
                }
                Console.WriteLine($"Task running {i}");
                Thread.Sleep(1000);
            }
        }, cts.Token);

        Thread.Sleep(2000);
        cts.Cancel(); // Cancel the task
        task.Wait();
    }
}

// Output:
// Task running 1
// Task running 2
// Task cancelled.
        

The **CancellationTokenSource** allows gracefully stopping a task before it completes execution.

Best Practices for Using Task Parallel Library

• Use **Task.Run()** for CPU-bound operations, avoiding manual thread creation.
• Use **Task.WhenAll()** to efficiently execute multiple tasks concurrently.
• Use **CancellationTokenSource** to stop long-running tasks gracefully.
• Avoid using **Task.Wait() or Task.Result** in UI applications, as it can block the UI.