How to improve ASP.NET Core 6 Web API Performance

Welcome to the post; today, we will discuss How to improve ASP.NET Core 6 Web API Performance. We have summarised vital factors that can efficiently improve ASP.NET Core Web API performance. Let’s discuss the points.

1- Minimize allocations of large objects:

In ASP.NET Core apps, the default garbage collector removes the allocations and releases the memory automatically. So we developers do not have to worry about garbage collection, and how and when the memory is freed. But the issue is a garbage collector takes a lot of CPU time to clean unreferenced objects from memory, huge objects. Because large objects are stored in the Large Objects heap, it requires full garbage collection functionality to release the memory. So developers should minimize allocations of large objects and should consider caching large objects. Caching large objects can prevent large memory allocations.

2- Data Access Optimization:

The slowest part of ASP.NET Core Web APIs apps is interaction with data or remote services. Reading and writing records or data efficiently is the critical performance factor of any application, and it’s a sign of optimized performance.

• Always retrieve only necessary/required data and return necessary/required data.
• Always write data access API asynchronously.
• Minimize network round trips. Avoid several calls and retrieve required data in a single call.
• Always use no-tracking queries for the reading purpose in LINQKeep queries.

3- Keep Long-Running Tasks outside of HTTP requests:

Most requests of ASP.NET Core Web APIs are directly served by the controller calling simple service and returning an HTTP response. But some APIs contains Long-Running Task.

• As part of ordinary HTTP requests, do not wait for long-running tasks to complete.
• Always consider long-running tasks handling on background service.
• It is beneficial for CPU-intensive tasks to complete work out of the process.

4- Latest ASP.NET Core Release:

Always use the latest release of ASP.NET Core release because Microsoft improves the performance of the latest release than the older release. If you consider the performance, always try to use the latest ASP.NET Core Web API release.

5- Minimize Exceptions:

Throwing and catching exceptions should not be used in normal code flow; it should be rare. Because Throwing and catching exceptions makes the code slow relative to other coding flows.

• Always try to include logic to handle and detect the condition in the code that would cause an exception.
• Exceptions should be used for unexpected and unusual scenarios in code.
• Throwing and catching exceptions should not be used as a regular program flow.

6- Asynchronous Programming:

Always try to write APIs using async programming; async APIs can handle several concurrent HTTP requests. In contrast, we can not achieve this by synchronous APIs. Async Programming was introduced in C# 5 to achieve good performance and reliability try to write services/APIs end to end asynchronously.

public class DummyController: Controller
{
    [HttpGet("/xyz")]
    public async Task<ActionResult<Data>> Get()
    {
        var json = await new StreamReader(Request.Body).ReadToEndAsync();
        return JsonSerializer.Deserialize<Data>(json);
    }
}

7- High-Speed JSON Serializer:

Microsoft chose JSON.NET as a default JSON serialized in .NET, which is fast and quick to serialize data. Suppose you repeat JSON Serialization many times in your ASP.NET Core Web APIs. There are many other JSON Serializers faster than JSON.NET. So if the JSON Serializer is faster than others. We can use it to achieve high performance. I have listed some high-speed JSON Serializers below.

• Protobuf-Net Serializer
• JIL Serializer

8- Database Structure:

In any application, the database structure is the primary and critical factor in improving performance. If you are not creating a complex application, do not overcomplicate the database structure and keep it simple.

• Always use a Normalized Data structure.
• Relate all interrelated tables with the help of foreign keys and primary keys.
• Give proper indexing to the table. Searching data from the tables will be easy.

9- Client-side Validation:

Do not validate every little thing on the server. Try to validate more properties on the client-side to reduce API round trips. If any property is invalid, API will not be called, and if we validate every little thing on the server-side, it reduces API response time and affects the API performance. This thing can also enhance the user experience.

I have also written a guide on How to Boost Productivity as .NET Developer in Visual Studio. In this blog post, we have discussed amazing facts with our experience that can increase your productivity dramatically.

Measure the current performance of your Web API

Before you can improve the performance of your ASP.NET Core 6 Web API, you need to measure its current performance. This will give you a baseline to work from and allow you to see the impact of any changes you make. In this section, we’ll take a look at some tools you can use to measure your API’s performance.

One of the most popular tools for measuring API performance is Apache JMeter. It’s a free, open-source tool that allows you to test your API’s performance under load. It can simulate multiple users making requests to your API and measure how long it takes to respond to each request. This will give you an idea of how your API performs under real-world conditions.

Another tool you can use is Microsoft’s own Application Insights. This is a cloud-based tool that allows you to monitor the performance of your API in real-time. You can see how long it takes to respond to each request, as well as other useful metrics like the number of requests per second and the response time distribution.

When choosing a tool to measure your API’s performance, there are a few things to keep in mind. First, make sure the tool is compatible with ASP.NET Core 6. Second, consider the complexity of your API and the level of detail you need. Some tools may be better suited for simpler APIs, while others are designed for more complex applications.

Once you’ve chosen a tool, it’s time to measure your API’s performance. Start by setting up a test environment that closely mirrors your production environment. This will ensure that the results you get are accurate and representative of real-world usage.

Next, run the tool and simulate various types of requests. You may want to test different scenarios, such as high traffic volume or complex queries. This will give you a better understanding of how your API performs under different conditions.

Finally, analyze the results and look for areas where you can improve performance. This could include optimizing database queries, caching frequently accessed data, or reducing the number of API calls required to complete a task.

Optimize your API for Performance

Now that you’ve measured the current performance of your ASP.NET Core 6 Web API, it’s time to start optimizing it for better performance. In this section, we’ll look at some common strategies you can use to improve the speed and efficiency of your API.

1. Caching

One of the most effective ways to improve API performance is to implement caching. Caching involves storing frequently accessed data in memory so that it can be quickly retrieved without having to hit the database every time. This can significantly reduce the response time for API requests.

To add caching to your API, you can use the built-in caching features of ASP.NET Core 6. This allows you to store data in memory or on disk, and set expiration times for the cache to ensure that it stays up-to-date.

2. Gzip Compression

Another strategy for improving API performance is to use Gzip compression. Gzip is a file format used for file compression and decompression. By compressing API responses before sending them over the network, you can reduce the amount of data that needs to be transmitted, which can improve response times and reduce bandwidth usage.

To add Gzip compression to your API, you can use the built-in compression middleware provided by ASP.NET Core 6. This middleware will automatically compress API responses before sending them over the network.

3. Minimize Database Round Trips

Another way to improve API performance is to minimize the number of database round trips required to complete a task. Each round trip to the database adds latency to the API request, which can slow down the response time.

To minimize database round trips, you can use techniques like batching, caching, and lazy loading. Batching involves grouping multiple database requests together into a single request, which can reduce the number of round trips required. Caching involves storing frequently accessed data in memory, as mentioned earlier. And lazy loading involves loading data only when it’s actually needed, rather than loading all data up front.

By implementing these optimization strategies, you can significantly improve the performance of your ASP.NET Core 6 Web API. However, keep in mind that every API is unique, and what works well for one API may not work as well for another. Be sure to monitor the performance of your API regularly and make adjustments as needed.

Leverage Async and Await

Using asynchronous programming is another technique you can use to improve the performance of your ASP.NET Core 6 Web API. By leveraging the power of Async and Await, you can improve the responsiveness of your API and reduce the latency of your requests.

1. Explanation of Async and Await

Async and Await are two keywords in C# that enable asynchronous programming. Asynchronous programming allows the API to execute code without blocking the main thread, so it can continue processing requests while waiting for an I/O operation to complete.

2. Benefits of using Async and Await

Using Async and Await can bring many benefits to your API’s performance. It can help reduce the overall response time of your API, allowing it to handle more requests simultaneously. It can also help reduce CPU usage, as the API will be able to do more work with fewer resources.

3. Demonstration of how to use Async and Await in an API

To use Async and Await in your ASP.NET Core 6 Web API, you need to mark your methods with the “async” keyword and use the “await” keyword when calling asynchronous methods. This will allow the API to continue processing requests while waiting for the asynchronous operation to complete.

For example, consider a method that needs to query a database for some data. Instead of blocking the main thread while waiting for the database to respond, you can use Async and Await to make the request asynchronously. This will allow the API to continue processing requests while waiting for the database to respond.

[HttpGet]
public async Task>> GetProducts()
{
var products = await _context.Products.ToListAsync();
return Ok(products);
}

In this example, the “GetProducts” method is marked as “async”, and the call to “_context.Products.ToListAsync()” is marked with the “await” keyword. This allows the API to continue processing requests while waiting for the database to respond.

Use Load Balancing and Scaling Techniques

As your ASP.NET Core 6 Web API grows in popularity, you may find that it struggles to handle the increasing traffic. To ensure that your API can continue to handle requests without slowing down, you can use load balancing and scaling techniques. In this section, we’ll look at some common load balancing and scaling techniques that you can use to improve the performance of your API.

1. Explanation of Load Balancing and Scaling

Load balancing is the process of distributing incoming network traffic across multiple servers. By spreading the load across multiple servers, you can ensure that no single server becomes overwhelmed and that your API can continue to handle requests without slowing down.

Scaling involves adding more servers to your infrastructure to handle increasing traffic. Scaling can be done vertically by adding more resources to an existing server or horizontally by adding more servers to your infrastructure.

2. Demonstration of how to use Load Balancing and Scaling

To use load balancing and scaling in your ASP.NET Core 6 Web API, you can use tools like Kubernetes or Docker Swarm. These tools allow you to deploy your API to a cluster of servers and manage them as a single entity.

For load balancing, you can use a load balancer like NGINX or HAProxy to distribute incoming traffic across multiple servers. These load balancers can be configured to use various load balancing algorithms to distribute traffic evenly across your servers.

For scaling, you can use Kubernetes or Docker Swarm to manage a cluster of servers. When traffic increases, you can add more servers to the cluster to handle the increased load. Kubernetes and Docker Swarm can automatically distribute incoming traffic across the available servers, ensuring that the load is balanced.

It’s important to note that load balancing and scaling can be complex and require significant expertise to set up and manage. If you’re not comfortable with these techniques, consider using a managed hosting provider that offers load balancing and scaling services.