Reliable ASP.NET Core Health Checks for Databases and APIs

As a .NET developer building resilient applications, you understand the critical need to ensure your services are truly healthy, not just “up.” When your ASP.NET Core application depends on external resources like databases, Redis caches, or third-party APIs, a simple network ping is insufficient. You need to verify these dependencies are not only reachable but also responsive and functional. Manually crafting and maintaining these checks can quickly become a significant burden as your application’s external footprint grows.

Leveraging AI, specifically Claude Code, can dramatically accelerate the development of robust health checks. By understanding C# and the nuances of ASP.NET Core’s health check middleware, Claude Code can suggest and generate implementations for common dependency checks. This empowers you to focus on your core application logic rather than boilerplate monitoring code, leading to faster development cycles and more reliable applications.

Consider the scenario of ensuring your ASP.NET Core app can reliably connect to its SQL Server database, ping a Redis instance, and successfully execute a crucial external REST API call. Instead of painstakingly writing each check from scratch, you can prompt Claude Code with specific requirements. For instance, requesting Claude Code to “Generate an ASP.NET Core health check for a SQL Server database using SqlConnection and a basic HTTP liveness check for an external API” will yield C# code utilizing the Microsoft.Extensions.Diagnostics.HealthChecks package and relevant libraries, integrating seamlessly into your existing health check pipeline.

Here’s a sample of what Claude Code might generate for a SQL Server health check, assuming you have the necessary NuGet packages installed (Microsoft.Extensions.Diagnostics.HealthChecks and System.Data.SqlClient):

using Microsoft.Extensions.Diagnostics.HealthChecks;
using System.Data.SqlClient;
using System.Threading;
using System.Threading.Tasks;

public class SqlServerHealthCheck : IHealthCheck
{
    private readonly string _connectionString;

    public SqlServerHealthCheck(string connectionString)
    {
        _connectionString = connectionString;
    }

    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
    {
        using (var connection = new SqlConnection(_connectionString))
        {
            try
            {
                await connection.OpenAsync(cancellationToken);
                // Optionally, execute a simple query to further verify database responsiveness
                using (var command = connection.CreateCommand())
                {
                    command.CommandText = "SELECT 1";
                    await command.ExecuteScalarAsync(cancellationToken);
                }
                return HealthCheckResult.Healthy("SQL Server is available and responsive.");
            }
            catch (SqlException ex)
            {
                // Log the exception for detailed troubleshooting
                return new HealthCheckResult(context.Registration.FailureStatus, "SQL Server connection failed.", ex);
            }
            catch (Exception ex)
            {
                // Catch any other unexpected exceptions during the check
                return new HealthCheckResult(context.Registration.FailureStatus, "An unexpected error occurred during SQL Server health check.", ex);
            }
        }
    }
}

A critical gotcha to be aware of is that while Claude Code can generate the core logic, you must remember to register and configure the health check endpoint within your ASP.NET Core application’s Program.cs (or Startup.cs for older .NET versions) and inject necessary configurations like connection strings. Furthermore, for external API checks, failing to implement sensible timeouts can lead to prolonged health check durations, potentially impacting the overall responsiveness of your application during these checks. This approach works because ASP.NET Core’s health check middleware executes registered IHealthCheck implementations, allowing for granular checks of individual dependencies and reporting their status centrally.