Play Store Application link – Java to .NET in 9 Steps – App on Google Play

As a Java developer, you are likely familiar with asynchronous programming concepts and tools like Future, CompletableFuture, and the ExecutorService. In C#, the async and await keywords, along with the Task Parallel Library (TPL), provide powerful ways to handle asynchronous programming and concurrency. In this post, we’ll explore these concepts with real-world examples and draw comparisons to Java to help you understand and implement them in your C# applications.

1. Async and Await Keywords

The async and await keywords in C# make it easy to write asynchronous code that is easy to read and maintain.

Asynchronous Methods

In C#, you define an asynchronous method by using the async keyword in the method signature. Within this method, you can use the await keyword to pause the method execution until the awaited task completes.

Example Code:

public async Task<string> FetchDataAsync()
{
    using (var client = new HttpClient())
    {
        var response = await client.GetStringAsync("https://api.example.com/data");
        return response;
    }
}

This is similar to using CompletableFuture in Java:

public CompletableFuture<String> fetchDataAsync() {
    return CompletableFuture.supplyAsync(() -> {
        try {
            HttpURLConnection connection = (HttpURLConnection) new URL("https://api.example.com/data").openConnection();
            BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            return reader.lines().collect(Collectors.joining());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    });
}

Task Parallel Library (TPL)

The TPL provides a set of classes and methods for performing asynchronous programming and parallelism in C#. The Task class is the cornerstone of the TPL, similar to Future in Java.

Example Code:

public async Task ProcessDataAsync()
{
    var dataTask = FetchDataAsync();
    var data = await dataTask;

    Console.WriteLine(data);
}

This is akin to chaining CompletableFuture in Java:

public void processDataAsync() {
    fetchDataAsync().thenAccept(data -> {
        System.out.println(data);
    });
}

2. Handling Concurrency

Concurrency involves managing multiple tasks running at the same time. In C#, this can be handled using locks and synchronization, as well as parallel processing with Parallel LINQ (PLINQ).

Locks and Synchronization

To prevent race conditions and ensure thread safety, you can use locks in C#. This is similar to using synchronized blocks or ReentrantLock in Java.

Example Code:

private static readonly object _lock = new object();

public void IncrementCounter()
{
    lock (_lock)
    {
        // Critical section
        counter++;
    }
}

In Java, this would look like:

private final Object lock = new Object();

public void incrementCounter() {
    synchronized (lock) {
        // Critical section
        counter++;
    }
}

Parallel LINQ (PLINQ)

PLINQ allows you to perform parallel operations on collections, similar to Java’s parallel streams.

Example Code:

var numbers = Enumerable.Range(1, 100);
var parallelResult = numbers.AsParallel()
                            .Where(n => n % 2 == 0)
                            .ToArray();

Console.WriteLine(string.Join(", ", parallelResult));

In Java, this is similar to:

List<Integer> numbers = IntStream.rangeClosed(1, 100).boxed().collect(Collectors.toList());
List<Integer> parallelResult = numbers.parallelStream()
                                      .filter(n -> n % 2 == 0)
                                      .collect(Collectors.toList());

System.out.println(parallelResult);

Real-World Scenario Example: Fetching and Processing Data

Imagine you are building an application that needs to fetch data from a remote API and then process that data. Using asynchronous programming, you can ensure that your application remains responsive while the data is being fetched and processed.

C# Implementation:

public async Task FetchAndProcessDataAsync()
{
    var data = await FetchDataAsync();

    // Simulate data processing
    await Task.Run(() =>
    {
        Console.WriteLine("Processing data...");
        Thread.Sleep(2000); // Simulate a time-consuming task
        Console.WriteLine("Data processed.");
    });

    Console.WriteLine(data);
}

Java Implementation:

public void fetchAndProcessDataAsync() {
    fetchDataAsync().thenAccept(data -> {
        // Simulate data processing
        CompletableFuture.runAsync(() -> {
            System.out.println("Processing data...");
            try {
                Thread.sleep(2000); // Simulate a time-consuming task
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("Data processed.");
        }).thenRun(() -> System.out.println(data));
    });
}

Summary

Asynchronous programming and concurrency in C# using async and await, the Task Parallel Library, and PLINQ provide powerful tools for building responsive and efficient applications. By understanding these concepts and how they compare to Java, you can leverage your existing knowledge to quickly become proficient in C#. Happy coding!