C# Interview Questions

The Task Parallel Library (TPL) is a set of public types and APIs in the System.Threading.Tasks namespace, introduced in .NET Framework 4.0. The TPL provides a powerful and flexible framework for parallel and asynchronous programming, making it easier to write concurrent code that can efficiently utilize multiple processors.

Key Concepts of TPL

1. Task Class:

   • The Task class represents an asynchronous operation. A Task can be started, awaited, and managed, providing a higher level of abstraction over traditional thread management.

2. Task<TResult> Class:

   • The Task<TResult> class represents an asynchronous operation that returns a result of type TResult. This is useful for performing computations that produce a value.

3. Parallel Class:

   • The Parallel class provides methods for parallel execution of loops (Parallel.For, Parallel.ForEach) and for executing a set of statements in parallel (Parallel.Invoke).

4. PLINQ (Parallel LINQ):

   • PLINQ extends LINQ with parallel processing capabilities, allowing you to perform LINQ queries in parallel using the AsParallel method.

Benefits of TPL

1. Simplified Parallelism:

   • TPL simplifies the creation and management of parallel tasks, making it easier to write concurrent code.

2. Scalability:

   • TPL automatically scales the degree of concurrency to utilize the available processors efficiently.

3. Error Handling:

   • TPL provides robust mechanisms for handling exceptions in parallel and asynchronous operations.

4. Task Composition:

   • TPL allows for easy composition of tasks, enabling complex workflows and continuations.

Basic Usage of TPL

Creating and Running Tasks

Example:

using System;
using System.Threading.Tasks;

public class Program
{
    public static void Main()
    {
        Task task = Task.Run(() => DoWork());
        task.Wait(); // Wait for the task to complete

        Task<int> taskWithResult = Task.Run(() => Compute());
        int result = taskWithResult.Result; // Wait for the task to complete and get the result
        Console.WriteLine($"Result: {result}");
    }

    public static void DoWork()
    {
        Console.WriteLine("Doing work...");
    }

    public static int Compute()
    {
        return 42;
    }
}

Using Parallel.For and Parallel.ForEach

Example:

using System;
using System.Threading.Tasks;

public class Program
{
    public static void Main()
    {
        // Parallel.For example
        Parallel.For(0, 10, i =>
        {
            Console.WriteLine($"Processing {i}");
        });

        // Parallel.ForEach example
        var items = new[] { "A", "B", "C", "D", "E" };
        Parallel.ForEach(items, item =>
        {
            Console.WriteLine($"Processing {item}");
        });
    }
}

Using Parallel.Invoke

Example:

using System;
using System.Threading.Tasks;

public class Program
{
    public static void Main()
    {
        Parallel.Invoke(
            () => DoTask1(),
            () => DoTask2(),
            () => DoTask3()
        );
    }

    public static void DoTask1()
    {
        Console.WriteLine("Task 1");
    }

    public static void DoTask2()
    {
        Console.WriteLine("Task 2");
    }

    public static void DoTask3()
    {
        Console.WriteLine("Task 3");
    }
}

Advanced Features

Continuations

Example:

using System;
using System.Threading.Tasks;

public class Program
{
    public static void Main()
    {
        Task task = Task.Run(() => DoWork())
                        .ContinueWith(t => DoMoreWork(t));

        task.Wait(); // Wait for all tasks to complete
    }

    public static void DoWork()
    {
        Console.WriteLine("Doing work...");
    }

    public static void DoMoreWork(Task t)
    {
        Console.WriteLine("Doing more work...");
    }
}

Handling Exceptions

Example:

using System;
using System.Threading.Tasks;

public class Program
{
    public static void Main()
    {
        try
        {
            Task task = Task.Run(() => ThrowException());
            task.Wait();
        }
        catch (AggregateException ex)
        {
            foreach (var innerException in ex.InnerExceptions)
            {
                Console.WriteLine(innerException.Message);
            }
        }
    }

    public static void ThrowException()
    {
        throw new InvalidOperationException("An error occurred.");
    }
}

PLINQ (Parallel LINQ)

Example:

using System;
using System.Linq;

public class Program
{
    public static void Main()
    {
        var numbers = Enumerable.Range(1, 100);
        var parallelQuery = numbers.AsParallel().Where(n => n % 2 == 0);

        foreach (var number in parallelQuery)
        {
            Console.WriteLine(number);
        }
    }
}

Summary

The Task Parallel Library (TPL) in C# provides a powerful and flexible framework for parallel and asynchronous programming. By using tasks, parallel loops, and PLINQ, developers can write efficient and scalable code that utilizes multiple processors effectively. TPL simplifies the management of concurrency, improves error handling, and enhances the overall performance of applications.