Let’s discuss about Async vs Sync in .NET

Introduction

In the world of web development, invoking endpoints is a common task when building applications. In the .NET Core framework, developers have the flexibility to choose between synchronous (sync) and asynchronous (async) approaches for invoking these endpoints. Understanding the difference between these two paradigms is crucial for optimizing application performance and responsiveness. In this article, I’ll get into the concepts of async and sync endpoint invocations, explore their advantages, and provide real-life examples to illustrate their practical applications.

Synchronous Endpoint Invocations

Synchronous endpoint invocations follow the traditional request-response pattern. When a synchronous call is made, the application waits for the request to be processed and a response to be returned before proceeding to the next line of code. This means that the application remains blocked until the operation is completed, which can lead to potential performance issues, especially in scenarios with high concurrency.

Example:

public string GetUserData(int userId)
{
    // Make a synchronous call to retrieve user data
    var userData = UserService.GetUserById(userId);
    // Perform other operations with the user data
    // ...
    return userData;
}

In this example, the GetUserData method makes a synchronous call to the GetUserById method, which retrieves user data from the UserService. If the GetUserById operation takes a significant amount of time to complete, the entire application will be held up, making it less responsive to other user requests.

Asynchronous Endpoint Invocations

Asynchronous endpoint invocations, on the other hand, leverage asynchronous programming to enable concurrent execution of tasks without blocking the main application thread. When an asynchronous call is made, the application continues executing the subsequent code while awaiting the response. This approach is particularly useful when dealing with long-running tasks, such as network requests or database queries, as it allows the application to remain responsive during these operations.

Example

public async Task<string> GetUserDataAsync(int userId)
{
    // Make an asynchronous call to retrieve user data
    var userData = await UserService.GetUserByIdAsync(userId);
    // Perform other operations with the user data
    // ...
    return userData;
}

In this example, the GetUserDataAsync method is marked as async, and it awaits the GetUserByIdAsync method, which is an asynchronous version of the previous synchronous call. While waiting for the response, the application thread is free to handle other tasks, enhancing overall performance and responsiveness.

Some Real-Life Examples

Web API Requests: When a web application makes API calls to external services, using asynchronous endpoint invocations is recommended. This prevents the application from becoming unresponsive while waiting for the API responses, allowing it to handle incoming requests more efficiently.

public async Task<string> GetWeatherAsync(string city)
{
	var response = await httpClient.GetAsync($"weather/{city}");
	response.EnsureSuccessStatusCode();
	var weatherData = await response.Content.ReadAsStringAsync();
	return weatherData;
}

Database Operations: When performing complex database queries or large data retrievals, using asynchronous endpoint invocations can significantly improve the application’s scalability. As the application awaits the database response, other users’ requests can be processed concurrently.

public async Task<int> UpdateUserAsync(int userId, string newEmail)
{
	using (var connection = new SqlConnection(connectionString))
	{
		await connection.OpenAsync();
		using (var command = new SqlCommand("UPDATE Users SET Email = @NewEmail WHERE Id = @UserId", connection))
		{
			command.Parameters.AddWithValue("@NewEmail", newEmail);
			command.Parameters.AddWithValue("@UserId", userId);
			return await command.ExecuteNonQueryAsync();
		}
	}
}

File Uploads and Downloads: When handling file uploads or downloads in a web application, using asynchronous endpoint invocations is highly beneficial. Uploading or downloading large files can be time-consuming, and synchronous calls may lead to a sluggish user experience, especially in scenarios with multiple users simultaneously performing file operations. By employing asynchronous programming, the application can continue serving other user requests efficiently while handling file transfers in the background.

public async Task<ActionResult> UploadFileAsync(IFormFile file)
{
    // Asynchronously save the file to the server
    await FileService.SaveFileAsync(file);
    // Respond to the client with success message
    return Ok("File uploaded successfully!");
}

Email Sending: When sending emails from a web application, using asynchronous endpoint invocations can be advantageous. Email sending involves communication with external email servers, which can sometimes have variable response times. By making the email sending process asynchronous, the application can promptly respond to user requests while sending emails in the background, preventing potential delays in serving other essential functionalities.

public async Task<IActionResult> SendEmailAsync(string recipient, string subject, string body)
{
    // Asynchronously send the email
    await EmailService.SendEmailAsync(recipient, subject, body);
    // Respond to the client with success message
    return Ok("Email sent successfully!");
}

Real-time Data Processing: In scenarios where real-time data processing is required, synchronous endpoint invocations may not be the best fit. For example, in a financial application that tracks stock prices, processing data synchronously could result in delays, potentially leading to inaccurate information for traders and investors. By adopting asynchronous programming, the application can update stock prices in real-time without hindering other critical functionalities.

public async Task<IActionResult> TrackStockPriceAsync(string stockSymbol)
{
    // Asynchronously fetch the latest stock price from an external API
    var stockPrice = await StockService.GetStockPriceAsync(stockSymbol);
    // Update the stock price in real-time on the application's dashboard
    RealTimeUpdateService.UpdateStockPrice(stockSymbol, stockPrice);
    // Respond to the client with the current stock price
    return Ok($"Current price of {stockSymbol}: {stockPrice}");
}

Conclusion

In conclusion, the choice between asynchronous and synchronous endpoint invocations in the .NET Core framework depends on the specific requirements of your application. While synchronous calls may be suitable for simpler operations, leveraging asynchronous programming can greatly enhance the responsiveness and scalability of your application, especially when dealing with time-consuming tasks like web API requests or database operations. By understanding and effectively implementing these approaches, you can optimize your .NET applications for improved performance and better user experiences.