core

Optimizing Web Performance with Output Caching Middleware in C#

Pandiyan MuruganLeave a comment

Introduction

In the fast-paced world of web development, optimizing website performance is paramount. Users expect websites to load quickly and responsively. One powerful technique for achieving this goal is output caching. Output caching stores the output of a web page or a portion of it, so it can be reused for subsequent requests, reducing the need for redundant processing. In this blog post, we’ll explore how to implement Output Caching Middleware in C# to enhance the performance of your web applications.

Understanding Output Caching

Output caching involves storing the HTML output generated by a web page or a portion of it, such as a user control or a custom view, in memory. When subsequent requests are made for the same content, the cached output is returned directly, bypassing the need for re-rendering the page or executing the underlying logic. This significantly reduces server load and improves response times.

Implementing Output Caching Middleware in C#

Implementing output caching in C# involves creating custom middleware. Middleware in ASP.NET Core provides a way to handle requests and responses globally as they flow through the pipeline.

Step 1: Create Output Caching Middleware

First, create a class for your middleware. This class should implement IMiddleware interface and handle caching logic.

public class OutputCachingMiddleware : IMiddleware
{
    private readonly MemoryCache _cache;

    public OutputCachingMiddleware()
    {
        _cache = new MemoryCache(new MemoryCacheOptions());
    }

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        var cacheKey = context.Request.Path.ToString();

        if (_cache.TryGetValue(cacheKey, out string cachedResponse))
        {
            // If cached response is found, return it
            await context.Response.WriteAsync(cachedResponse);
        }
        else
        {
            // If not cached, proceed to the next middleware and cache the response
            var originalBodyStream = context.Response.Body;
            using (var responseBody = new MemoryStream())
            {
                context.Response.Body = responseBody;

                await next(context);

                responseBody.Seek(0, SeekOrigin.Begin);
                cachedResponse = new StreamReader(responseBody).ReadToEnd();
                _cache.Set(cacheKey, cachedResponse, TimeSpan.FromMinutes(10)); // Cache for 10 minutes
                responseBody.Seek(0, SeekOrigin.Begin);

                await responseBody.CopyToAsync(originalBodyStream);
            }
        }
    }
}

Step 2: Register Middleware in Startup.cs

In your Startup.cs file, add the following code to register your custom middleware in the Configure method.

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    // Other middleware registrations
    
    app.UseMiddleware<OutputCachingMiddleware>();
    
    // More middleware registrations
}

Conclusion

Output caching middleware is a powerful tool in your web development arsenal, significantly improving the performance and responsiveness of your web applications. By implementing this technique, you can reduce server load, decrease response times, and enhance user experience. Remember to carefully consider cache duration and the content you cache to strike a balance between performance and serving up-to-date content to your users. Happy coding!

Installing and Using Swagger in C# 11 with Code Samples

Pandiyan MuruganLeave a comment

Swagger is a tool that allows developers to document and test their API endpoints. It is a popular choice for building APIs in a variety of programming languages, including C#. In this blog post, we will walk through the process of installing and using Swagger in a C# 11 project.

Step 1: Install the necessary packages

To get started, you will need to install the following packages to your C# project:

  • Swashbuckle.AspNetCore: This package is the main package that integrates Swagger with your ASP.NET Core project.
  • Microsoft.AspNetCore.Swagger: This package provides the necessary tools for generating and displaying the Swagger documentation.

To install these packages, you can use the following command in the Package Manager Console:

PM> Install-Package Swashbuckle.AspNetCore -Version 5.7.1
PM> Install-Package Microsoft.AspNetCore.Swagger -Version 5.0.0

Step 2: Configure Swagger in Startup.cs

Once you have the necessary packages installed, you can configure Swagger in your project’s Startup.cs file. In the ConfigureServices method, add the following code to add Swagger services to your project:

services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });
});

Then, in the Configure method, add the following code to enable Swagger UI:

app.UseSwagger();
app.UseSwaggerUI(c =>
{
    c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
});

Step 3: Add documentation to your API

You can now add documentation to your API by adding XML comments to your code. For example:

/// <summary>/// Get the value of x
/// </summary>/// <param name="x">The x value</param>/// <returns>The x value</returns>
[HttpGet("{x}")]
public int Get(int x)
{
    return x;
}

Step 4: Run and Test the API

You can now run your API and test it using Swagger UI by visiting the following URL:

<http://localhost>:<port>/swagger

Note that the “port” should be replaced with the actual port that your API is running on.

Please note the above steps are for general guidance and implementation may vary depending on the use case, for example the specific version of package, or different framework etc.

Step 5: Customizing the Swagger UI

The default Swagger UI that is generated when you add Swagger to your project can be customized to fit your needs. Some of the ways that you can customize the UI include:

  • Changing the layout and styling: You can use CSS to change the appearance of the Swagger UI. You can also use the Swagger UI custom layout feature to change the layout of the UI.
  • Adding custom pages: You can add custom pages to the Swagger UI to provide additional information about your API, such as examples and tutorials.
  • Customizing the authentication process: You can customize the authentication process so that users are prompted to enter their credentials when accessing your API.

Step 6: Additional Swagger Features

Swagger also has other features that can help you work with your API, including:

  • Validation: You can use the Swagger validator to validate the requests and responses of your API.
  • Code generation: You can use the Swagger code generator to generate client code for your API in a variety of programming languages, including C#.
  • Middleware: You can use the Swagger middleware to add additional functionality to your API, such as logging and security.

In this post, we have covered the basics of installing and using Swagger in a C# 11 project. By following the steps outlined in this post, you can quickly and easily add Swagger to your project and start documenting and testing your API. With the rich functionality that it offers, you can further customize the UI and find other useful functionalities to improve the developer experience and make the API more understandable.

Step 7: Advanced Usage

Once you have set up Swagger in your project, you can start exploring the advanced usage of it.

  • Advanced configuration options: You can configure the Swagger settings to suit your needs, such as disabling the authorization dialog, hiding the API version or enabling JWT.
services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });
    c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
    {
        Description = "JWT Authorization header using the Bearer scheme. Example: \\"Authorization: Bearer {token}\\"",
        Name = "Authorization",
        In = ParameterLocation.Header,
        Type = SecuritySchemeType.ApiKey,
        Scheme = "Bearer"
    });
    c.AddSecurityRequirement(new OpenApiSecurityRequirement
    {
        {
            new OpenApiSecurityScheme
            {
                Reference = new OpenApiReference { Type = ReferenceType.SecurityScheme, Id = "Bearer" }
            },
            new string[] {}
        }
    });
});
  • Grouping endpoints by tags: You can group your endpoints by using tags in the XML comments. This way you can make it easier for users to navigate through your API.
/// <summary>/// Get the value of x
/// </summary>/// <param name="x">The x value</param>/// <returns>The x value</returns>/// <tag>Values</tag>
[HttpGet("{x}")]
public int Get(int x)
{
    return x;
}
  • Custom operations: You can create custom operations by using the IOperationFilter and ISchemaFilter interfaces. These interfaces allow you to add custom functionality to the Swagger UI, such as adding extra fields or changing the behavior of the UI.

Step 8: Use Swagger for ASP.Net Core 3.1

If you are using ASP.NET Core 3.1, you will need to install the appropriate packages and configure them slightly differently.

  • First, you need to install the following NuGet package:
Microsoft.OpenApi
  • Then, in the Startup.cs file, you need to configure the services and the app in the ConfigureServices and Configure methods:
// ConfigureServices method
services.AddControllers();
services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });
});

// Configure method
app.UseSwagger();
app.UseSwaggerUI(c =>
{
    c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
});
app.UseRouting();
app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
});
  • Finally, you need to add the XML comments to your controllers and actions, and you can run the application and access the Swagger UI at the /swagger endpoint.

Step 9: Use the advanced features

Swagger provides a wide range of advanced features that can help you work with your API, some of them are:

  • Versioning: You can version your API by specifying different versions of the Swagger documentation, this will enable users to access different versions of the API.
services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });
    c.SwaggerDoc("v2", new OpenApiInfo { Title = "My API", Version = "v2" });
});
  • Deprecation: You can deprecate an endpoint by adding [Obsolete] attribute, which will notify the users that this endpoint is no longer available in the latest version.
[Obsolete]
[HttpGet("{x}")]
public int Get(int x)
{
    return x;
}
  • OperationId: You can provide a unique operationId for each endpoint, this will provide a specific identifier for the endpoint.
[HttpGet("{x}")]
[Operation(OperationId = "GetX")]
public int Get(int x)
{
    return x;
}
  • Examples: You can provide examples of the expected request and response for each endpoint, this will help the users understand how to use the endpoint correctly.
[HttpGet("{x}")]
[ProducesResponseType(typeof(int), 200)]
[ProducesResponseType(typeof(string), 400)]
[ProducesResponseType(typeof(void), 500)]
[SwaggerResponseExample(200, typeof(int), "{x:10}")]
[SwaggerRequestExample(typeof(int), "{x:10}")]
public int Get(int x)
{
    return x;
}

These are just a few examples of the advanced features that Swagger provides, there are many more features available that you can use to enhance the developer experience and make your API more understandable.

Step 10: Implementing security

Securing your API is an important aspect to ensure the confidentiality and integrity of the data. Swagger provides a feature that enables you to define and implement security for your API.

  • Security Definitions: You can define the type of security that your API supports, for example, OAuth2 or Basic Authentication.
services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });
    c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
    {
        Description = "JWT Authorization header using the Bearer scheme. Example: \\"Authorization: Bearer {token}\\"",
        Name = "Authorization",
        In = ParameterLocation.Header,
        Type = SecuritySchemeType.ApiKey,
        Scheme = "Bearer"
    });
});
  • Security Requirements: You can specify the security requirements for your API, for example, which endpoints require authentication and which do not.
services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });
    c.AddSecurityRequirement(new OpenApiSecurityRequirement
    {
        {
            new OpenApiSecurityScheme
            {
                Reference = new OpenApiReference { Type = ReferenceType.SecurityScheme, Id = "Bearer" }
            },
            new string[] {}
        }
    });
});

It’s important to note that, the above example uses JWT Bearer authentication, but you can use other types of authentication schemes such as OAuth2, Basic or others. Additionally, security is a complex topic that requires a thorough understanding of the different types of threats and best practices for securing your application. You should consult the appropriate security documentation and guidelines for your specific use case.

In this step, you have learned how to define and implement security for your API using Swagger. By defining security definitions and requirements, you can ensure the confidentiality and integrity of your API and enhance the developer experience by clearly communicating the security requirements of your API.

In conclusion, Swagger is a powerful tool for documenting and testing APIs in C#. With the ability to customize the UI, add custom pages, and advanced configuration options, Swagger provides a great developer experience. It is worth taking the time to learn how to use the different features that Swagger offers so that you can take full advantage of it in your projects.