Boost Your Web App’s Speed: Performance Optimization Techniques

https://www.nilebits.com/blog/2023/10/boost-your-web-apps-speed-performance-optimization-techniques/

Today you cannot make it without a quick web application as digital attention span has never been shorter than now.?Slow loading websites can chase away users resulting in bad bounce rates, poor conversion rates and very poor user experience.?As such, web application performance optimization is now an essential competence for any web developer.?Let us explore various techniques meant to improve or increase the speed of your Web Application.

Optimize Database Queries

1. Efficient Query Writing

Efficient query writing is fundamental to optimizing database queries. When working with C# and Entity Framework or other ORMs, it’s essential to write concise and effective queries:

• Use Select to Retrieve Only Necessary Columns: “Steer clear of retrieving superfluous columns; opt to fetch solely the data essential for your specific application requirements. This approach can substantially diminish the volume of data exchanged between your application and the database.”
• Minimize Include Statements: When using Entity Framework, limit the use of the Include method to load related data. Overuse can lead to overly complex queries.
• Use LINQ to Entities Wisely: LINQ provides a convenient way to query databases, but it’s crucial to understand how LINQ translates into SQL queries. Use LINQ effectively to generate efficient SQL.

var results = dbContext.Orders.Where(o => o.CustomerId == customerId && !o.IsDeleted).ToList();        

2. Indexing

Database indexing plays a vital role in query optimization. Ensure that you create appropriate indexes on the database tables:

• Primary Keys: Ensure each table has a primary key. It’s usually automatically indexed and serves as a unique identifier for each row.
• Foreign Keys: Index columns used in foreign key relationships to improve JOIN performance.
• Column Indexing: Index columns frequently used in WHERE clauses and JOIN conditions. This can significantly speed up query execution.

[Table("Orders")]
public class Order
{
    [Key]
    public int OrderId { get; set; }

    [Index("IX_CustomerId")]
    public int CustomerId { get; set; }
    // ...
}        

3. Use Compiled Queries

In Entity Framework, you can benefit from compiled queries. These queries are precompiled and cached, reducing query execution time. Here’s an example of how to use compiled queries:

private static readonly Func<YourDbContext, int, IQueryable<Order>> _compiledQuery = 
    CompiledQuery.Compile((YourDbContext context, int customerId) =>
        from order in context.Orders
        where order.CustomerId == customerId
        select order);
var results = _compiledQuery(dbContext, customerId).ToList();        

4. Pagination

When dealing with large datasets, implement pagination to reduce the number of records retrieved from the database at once. Use methods like Skip and Take in LINQ to handle pagination efficiently:

var pageSize = 10;
var pageNumber = 1;

var results = dbContext.Orders
    .Where(o => o.CustomerId == customerId && !o.IsDeleted)
    .Skip((pageNumber - 1) * pageSize)
    .Take(pageSize)
    .ToList();        

5. Monitor and Analyze Query Performance

Use database profiling and monitoring tools to analyze query performance. Tools like Entity Framework Profiler or SQL Server Profiler can help you identify slow queries, execution plans, and areas for improvement.

6. Cache Data

Caching frequently accessed data can significantly reduce the load on your database. Consider using caching libraries like MemoryCache or Redis to store and retrieve data efficiently.

Leverage Caching for Speed

1. Use the MemoryCache Class

The MemoryCache class is offered by C# in the System.Runtime.namespace caching, which provides effective data caching. This is how to apply it:

using System.Runtime.Caching;
// Create or retrieve the cache
var cache = MemoryCache.Default;

// Set a key-value pair in the cache with an expiration time
var data = GetDataFromDatabase(); // Replace with your data retrieval logic
cache.Set("myKey", data, new CacheItemPolicy { AbsoluteExpiration = DateTime.Now.AddMinutes(10) });

// Retrieve data from the cache
var cachedData = cache["myKey"] as YourDataType;        

This code illustrates how to put data into the cache and get it again. The expiration policy in this example is set at 10 minutes, but you may change it as necessary.

2. Implement Caching Strategies

When implementing caching, consider the following strategies:

a. Cache What’s Frequently Accessed

Cache data that is frequently accessed or unlikely to change frequently. Examples include user profiles, configuration settings, or reference data.

b. Cache Data with a Time-to-Live (TTL)

Set an appropriate time-to-live (TTL) for cached data. Data that rarely changes can have a longer TTL, while more dynamic data should have a shorter TTL. This prevents your application from serving stale data.

c. Cache Data Conditionally

Cache data only when needed. Retrieve data from the cache if it exists; otherwise, fetch it from the source and then cache it. This prevents unnecessary cache updates and reduces cache churn.

3. Handle Cache Misses

In cases where the data is not found in the cache (cache miss), be prepared to retrieve the data from the source and then cache it for future access. Here’s a sample approach:

var cachedData = cache["myKey"] as YourDataType;

if (cachedData == null)
{
    // Data not found in the cache, retrieve and cache it
    cachedData = GetDataFromDatabase(); // Replace with your data retrieval logic
    cache.Set("myKey", cachedData, new CacheItemPolicy { AbsoluteExpiration = DateTime.Now.AddMinutes(10) });
}

// Use the cachedData        

4. Use Dependency-Based Caching

Dependency-based caching allows you to invalidate cached data when the underlying data changes. For example, if you cache user-specific data, you can set a cache dependency on the user’s record, and the cache will be automatically invalidated if the user’s data is updated.

CacheItemPolicy policy = new CacheItemPolicy();
policy.ChangeMonitors.Add(new SqlChangeMonitor(new SqlDependency(command)));

cache.Set("myKey", data, policy);        

5. Monitor Cache Usage

Keep an eye on your cache’s usage and performance. Tools like Application Insights or custom logging can help you monitor cache hits, misses, and cache performance.

Minimize HTTP Requests

1. Combine and Minify JavaScript and CSS Files

One of the best methods for decreasing HTTP requests is combining and minifying your JavaScript and CSS files.?You minimize the number of requests by the client’s browser by bundling multiple script or style files in one file.

You may define bundles of scripts and styles in ASP.NET using the BundleConfig class to be served to user in packed and minified form.

public class BundleConfig
{
    public static void RegisterBundles(BundleCollection bundles)
    {
        bundles.Add(new ScriptBundle("~/bundles/scripts").Include(
            "~/Scripts/jquery.min.js",
            "~/Scripts/bootstrap.min.js",
            "~/Scripts/custom-scripts.js"
        ));
        bundles.Add(new StyleBundle("~/bundles/styles").Include(
            "~/Content/bootstrap.min.css",
            "~/Content/site.css"
        ));
    }
}        

2. Use Image Sprites

Image sprites are a technique where multiple small images are combined into a single image. Instead of requesting each individual image separately, you load one image and use CSS to display the specific portion you need. This technique is particularly useful for icons and small graphics.

3. Implement Client-Side Caching

Use client side caching to minimize the number of requests by reoccurring visitors.?Browser can caching some of Resources like Image, StyleSheet, and Scripts, so these resources will be reused from local cache instead of repeat requests to the server.

With HTTP headers you have options for controlling server side cache on client response.?For instance, setting the Cache-Control header to tell duration a file can be stored within browsers.

Response.Cache.SetCacheability(HttpCacheability.Public);
Response.Cache.SetExpires(DateTime.Now.AddMinutes(30)); // Cache for 30 minutes        

4. Use Content Delivery Networks (CDNs)

Consider using Content Delivery Networks (CDNs) to serve commonly used libraries and frameworks like jQuery or Bootstrap. CDNs store these resources on servers located geographically closer to the user, reducing latency and improving loading times.

For example, you can link to jQuery from a CDN like this:

<script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>        

5. Lazy Load Images

The process of “lazy loading” holds wait on loading off-screen pictures until they are about to enter the viewport. The initial page load time may be greatly shortened as a result.

To achieve lazy loading in C#, you may utilize JavaScript libraries like the “LazyLoad” library:

<img data-src="image.jpg" class="lazyload" alt="Image">
<script src="lazyload.min.js"></script>        

6. Asynchronous Loading

Make use of asynchronous loading of resources like images, scripts, and styles to prevent blocking the main rendering process. Use the async and defer attributes for scripts to control how and when they load.

<script async src="your-script.js"></script>        

7. Prioritize Critical Resources

Identify the critical resources needed for the initial page rendering and prioritize their loading. This can be done by placing critical CSS inline and loading critical scripts early in the HTML.

Implement Asynchronous Programming

1. Define an Asynchronous Method

To implement asynchronous programming, start by defining a method with the async modifier. This indicates that the method will include asynchronous operations. For example:

public async Task DoAsyncOperation()
{
    // Asynchronous code will go here
}        

2. Use the await Keyword

Inside your asynchronous method, use the await keyword before a task that may potentially block or take time to complete. This allows your application to continue executing other code while waiting for the awaited task to finish. For instance, when making an HTTP request using HttpClient:

public async Task<string> FetchDataFromServerAsync()
{

    using (HttpClient client = new HttpClient())
    {
        HttpResponseMessage response = await client.GetAsync("https://example.com/api/data");

        if (response.IsSuccessStatusCode)
        {
            return await response.Content.ReadAsStringAsync();
        }

        return "Failed to fetch data";
    }
}        

The client in this case is referenced by the await keyword.Response and GetAsync().Content.To avoid stopping the main thread while waiting for the HTTP request to finish, use ReadAsStringAsync().

3. Return a Task or Task<TResult>

Asynchronous methods typically return a Task or Task<TResult>, where TResult is the type of the result. The Task represents an ongoing operation that can be awaited or monitored for completion.

In the above example, the method FetchDataFromServerAsync() returns a Task<string> to indicate that it returns a string result.

4. Error Handling

When exceptions can occur in asynchronous code, handle them gracefully. Use try-catch blocks to capture and handle exceptions. Make sure to propagate exceptions correctly to ensure that they are not silently swallowed.

public async Task DoAsyncOperation()
{
    try
    {
       // Asynchronous code with potential exceptions
       // ...
    }
   catch (Exception ex)
    {
        // Handle or log the exception
    }
}        

5. Execute Asynchronous Code

To execute an asynchronous method, you can await it in a higher-level asynchronous context. For example, within another asynchronous method or by using Task.Run for parallel execution.

public async Task RunAsyncOperations()
{
   await DoAsyncOperation(); // Calling an asynchronous method

   // Or run multiple asynchronous methods in parallel
    var task1 = DoAsyncOperation();
    var task2 = DoAnotherAsyncOperation();
    await Task.WhenAll(task1, task2);
}        

6. Avoid async void

Avoid defining asynchronous methods with a void return type unless it’s an event handler. Using async void can make it challenging to handle errors and exceptions properly.

7. Configure Awaiting Tasks

You can configure how asynchronous tasks run by using options such as ConfigureAwait. This allows you to specify the context in which the task continues running after an await. For example:

public async Task DoAsyncOperation()
{
    await SomeAsyncMethod().ConfigureAwait(false);

    // Continue running in a different context
}        

This can be useful in ASP.NET applications to avoid deadlocks in UI threads.

Optimize Images and Assets

1. Image Optimization

Images are often a significant portion of a web page’s size, and optimizing them can have a substantial impact on performance. Here are some image optimization techniques for your C# web application:

a. Use Image Compression Libraries

Leverage C# image compression libraries like ImageMagick, ImageSharp, or TinyPNG API to automatically reduce the file size of your images without compromising quality. These libraries allow you to apply lossless or lossy compression as needed.

b. Choose the Right Image Format

For each image on your website, pick the proper image format. For photos and other pictures with a lot of color, use JPEG; for images with transparency, use PNG; and for straightforward vector drawings, use SVG. A good format reduces file size.

c. Responsive Images

Implement responsive images using the srcset attribute in HTML. Provide multiple versions of the same image at various resolutions and screen sizes. Browsers can then choose the best-fitting image, improving performance for users on different devices.

<img src="small.jpg" alt="Small image" srcset="small.jpg 400w, medium.jpg 800w, large.jpg 1200w">        

2. Minify CSS and JavaScript

Minifying your CSS and JavaScript files can significantly reduce their size, leading to faster page loading. C# web applications often use bundling and minification libraries to accomplish this.

In ASP.NET, you can use the BundleConfig class to define bundles of scripts and styles, which are then minified and served as a single file, reducing the number of HTTP requests.

3. Utilize Content Delivery Networks (CDNs)

Leverage CDNs to serve commonly used libraries and assets. CDNs store resources like jQuery, Bootstrap, and font files on servers closer to the user, reducing latency and improving loading times. Use CDN links in your HTML:

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.min.js"></script>
<link rel="stylesheet" >        

4. Implement Lazy Loading

Lazy loading is a technique where resources are only loaded as they come into the viewport. This is particularly useful for images, videos, and other non-essential assets, reducing the initial page load time.

In HTML, use the loading="lazy" attribute to implement lazy loading:

<img src="image.jpg" alt="Image" loading="lazy">        

5. Use Gzip Compression

Implement Gzip compression on your web server to compress text-based assets like HTML, CSS, and JavaScript. This reduces the amount of data transferred between the server and the client, resulting in faster loading times.

6. Minimize HTTP Requests

Minimize the number of HTTP requests by bundling CSS and JavaScript files, reducing the number of assets used, and avoiding excessive use of external scripts and styles. Each request introduces latency, so keeping them to a minimum is crucial for performance optimization.

Monitor and Fine-Tune Regularly

It’s crucial to periodically check on and optimize your C# web application to guarantee peak performance, preserve dependability, and keep things going smoothly. This post will cover the value of monitoring as well as some crucial elements to pay attention to while optimizing your C# application.

The Importance of Monitoring

Continuous monitoring helps you identify issues, bottlenecks, and potential problems early, which can prevent service disruptions and improve the overall user experience. Monitoring is crucial for:

1. Performance Optimization: Monitoring allows you to identify slow database queries, high CPU or memory usage, or other performance bottlenecks that need optimization.
2. Reliability: Monitoring helps you detect errors, exceptions, and crashes, allowing you to address issues before they impact users.
3. Scalability: Monitoring helps you assess how well your application handles growing user loads, and when to scale resources.
4. Security: Detecting unusual or malicious activity through monitoring can help you prevent security breaches and vulnerabilities.

Key Aspects of Monitoring and Fine-Tuning

Here are key aspects to focus on when monitoring and fine-tuning your C# web application:

1. Performance Metrics

Regularly analyze performance metrics to identify and address bottlenecks. Key performance metrics include:

• Response Times: Monitor response times for web requests, database queries, and API calls.
• CPU and Memory Usage: Keep an eye on resource utilization to ensure your server can handle the load.
• Database Queries: Identify slow queries and optimize database performance.
• Network Latency: Measure the time it takes to transfer data to and from the server.

2. Logging

Implement comprehensive logging in your C# application. Use logging frameworks like Serilog or NLog to capture valuable information about application events, errors, and user interactions. Log and review application logs regularly to identify issues.

3. Error Handling

Monitor and address errors proactively. Set up error reporting and exception handling mechanisms to capture and report exceptions. Consider using error tracking services like Sentry or Application Insights.

4. Security Monitoring

Implement security monitoring to detect and respond to security threats. Monitor for suspicious activity, unauthorized access attempts, and other security-related events.

5. Scalability Testing

Regularly conduct scalability tests to assess how well your application handles increased load. These tests help you determine when to scale resources such as servers, databases, or application instances.

6. Continuous Integration and Deployment (CI/CD)

Implement CI/CD pipelines to automate the deployment process. Regularly test and deploy new application versions to ensure that changes don’t introduce performance issues or regressions.

7. Code Reviews

Conduct code reviews to identify code quality issues, performance bottlenecks, and potential vulnerabilities. Encourage best practices and adherence to coding standards in your development team.

8. Load Testing

Perform load testing to simulate high traffic scenarios and identify application weaknesses. Load tests help you understand how your application performs under stress.

9. Response Time Monitoring

Monitor response times from different geographic locations. This helps ensure a consistent user experience for global audiences.

10. User Experience Monitoring

Collect and analyze user experience data to gain insights into how users interact with your application. User experience monitoring tools like Google PageSpeed Insights or New Relic can help identify areas for improvement.

Regular Maintenance and Optimization

You should routinely maintain and enhance your C# application once you’ve found areas that need improvement through monitoring. This entails carrying out the required improvements, dealing with performance bottlenecks, and making sure your application stays trustworthy and safe.

Regular monitoring and fine-tuning are ongoing actions that need to be integrated into the design and operating lifetime of your application. You can deliver a greater user experience and preserve the dependability and efficiency of your C# web application by remaining proactive and attentive to its performance.

https://www.nilebits.com/blog/2023/10/boost-your-web-apps-speed-performance-optimization-techniques/