Correlation ID

https://github.com/stevejgordon/correlationid
Admin
Correlation ID is a lightweight .NET library that enables distributed applications to trace requests...
Tokens:38,124
Snippets:277
Trust Score:10
License:MIT
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Install CorrelationId package via Package Manager Console

Source: https://github.com/stevejgordon/correlationid/blob/main/README.md

Installs the CorrelationId package from NuGet using the Package Manager Console. This command downloads and installs CorrelationId and all required dependencies.

```powershell
Install-Package CorrelationId
```

--------------------------------

### Basic CorrelationContext construction

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-context.md

Basic construction example, typically for unit testing a consumer of ICorrelationContextAccessor. Uses CorrelationIdOptions.DefaultHeader as the header name.

```csharp
using CorrelationId;

var context = new CorrelationContext("ABC-123", CorrelationIdOptions.DefaultHeader);

Console.WriteLine(context.CorrelationId); // ABC-123
Console.WriteLine(context.Header);        // X-Correlation-ID
```

--------------------------------

### Custom provider implementation and registration

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/abstractions.md

Shows a custom ICorrelationIdProvider implementation that combines the X-Tenant header with a GUID, and its registration using WithCustomProvider<T> in Startup.ConfigureServices.

```csharp
using CorrelationId.Abstractions;
using CorrelationId.DependencyInjection;
using Microsoft.AspNetCore.Http;

public class TenantAwareCorrelationIdProvider : ICorrelationIdProvider
{
    public string GenerateCorrelationId(HttpContext context)
        => $"{context.Request.Headers["X-Tenant"]}--{Guid.NewGuid():N}";
}

// Startup.ConfigureServices
services.AddCorrelationId().WithCustomProvider<TenantAwareCorrelationIdProvider>();
```

--------------------------------

### Basic registration with UseCorrelationId

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-id-extensions.md

Basic registration example showing how to use UseCorrelationId in the Configure method. Must be paired with a ConfigureServices registration (AddDefaultCorrelationId) to avoid the InvalidOperationException. Place UseCorrelationId early in the pipeline before middleware that needs the correlation ID.

```csharp
using CorrelationId;
using CorrelationId.DependencyInjection;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;

public void ConfigureServices(IServiceCollection services)
{
    services.AddDefaultCorrelationId();
}

public void Configure(IApplicationBuilder app)
{
    app.UseCorrelationId(); // add early, before middleware that needs the correlation ID
    app.UseRouting();
    app.UseEndpoints(endpoints => endpoints.MapControllers());
}
```

--------------------------------

### Consumer-side controller using forwarded client

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/http-client.md

Example controller that creates a client via IHttpClientFactory and makes an outgoing request. The client carries the X-Correlation-ID header from the current CorrelationContext.

```csharp
public class WeatherForecastController : ControllerBase
{
    private readonly IHttpClientFactory _httpClientFactory;

    public WeatherForecastController(IHttpClientFactory httpClientFactory)
        => _httpClientFactory = httpClientFactory;

    public IActionResult Get()
    {
        var client = _httpClientFactory.CreateClient("MyClient"); // carries X-Correlation-ID
        client.GetAsync("https://www.example.com");
        return Ok();
    }
}
```

--------------------------------

### CorrelationContext Class

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-context.md

Documentation for the CorrelationContext class, including its constructor, properties, constants, and usage examples.

```APIDOC
## CorrelationContext Class

### Description
Provides access to per request correlation properties. Carries the correlation ID and the header name it was read from/written to for a single request. Instances are created by `ICorrelationContextFactory.Create` (via the middleware) or directly in application/test code — the constructor is public specifically to support creating contexts for unit testing.

### Namespace
`CorrelationId`

### Source
`src/CorrelationId/CorrelationContext.cs`

### Constants

| Constant | Type | Value | Description |
|----------|------|-------|-------------|
| `DefaultCorrelationId` | `string` | `"Not set"` | Used when a `null` correlation ID is passed to the constructor. It is NOT used by the middleware path (the middleware always generates or reads a header value); it applies when constructing a `CorrelationContext` directly with `null`. |

### Constructor

```csharp
public CorrelationContext(string correlationId, string header)
```

#### Parameters
- **correlationId** (string) - Required (may be `null`) - The correlation ID on the context. A `null` value is replaced with `DefaultCorrelationId` (`"Not set"`) via `correlationId ??= DefaultCorrelationId`.
- **header** (string) - Required - The name of the header from which the Correlation ID was read/written.

**Throws:** `ArgumentException` when `header` is `null` or empty.

### Properties

| Property | Type | Description |
|----------|------|-------------|
| `CorrelationId` | `string` (get-only) | The correlation ID applicable to the current request. |
| `Header` | `string` (get-only) | The name of the header from which the Correlation ID was read/written. |

Both properties are set once in the constructor and are immutable.

### Usage Examples

Basic construction (e.g. when unit testing a consumer of `ICorrelationContextAccessor`):

```csharp
using CorrelationId;

var context = new CorrelationContext("ABC-123", CorrelationIdOptions.DefaultHeader);

Console.WriteLine(context.CorrelationId); // ABC-123
Console.WriteLine(context.Header);        // X-Correlation-ID
```

`null` correlation ID falls back to the default constant:

```csharp
var context = new CorrelationContext(null, "X-Correlation-ID");
Console.WriteLine(context.CorrelationId); // "Not set"
```

Error handling for an invalid header:

```csharp
try
{
    var context = new CorrelationContext("ABC-123", string.Empty);
}
catch (ArgumentException ex)
{
    Console.WriteLine(ex.Message); // "A header must be provided. (Parameter 'header')"
}
```
```

--------------------------------

### Register custom provider with AddCorrelationId

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/dependency-injection.md

Builder-based setup using AddCorrelationId and WithCustomProvider to register a custom correlation ID provider.

```csharp
services.AddCorrelationId()
        .WithCustomProvider<TenantAwareCorrelationIdProvider>();
```

--------------------------------

### Error handling for invalid header

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-context-factory.md

Error handling example showing that passing a null header to Create throws an ArgumentException with message "A header must be provided. (Parameter 'header')". The exception propagates from the CorrelationContext constructor.

```csharp
var factory = new CorrelationContextFactory(new CorrelationContextAccessor());

try
{
    factory.Create("abc-123", null);
}
catch (ArgumentException ex)
{
    // "A header must be provided. (Parameter 'header')"
}
```

--------------------------------

### CorrelationIdOptions Class

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-id-options.md

Documentation for the CorrelationIdOptions class, including constants, properties, and usage examples.

```APIDOC
## CorrelationIdOptions Class

### Description
Options for correlation IDs. This is the single options object consumed by `CorrelationIdMiddleware` (via `IOptions<CorrelationIdOptions>`) and configured through the `Action<CorrelationIdOptions>` overloads of the `AddCorrelationId*` extension methods.

### Constants
- `DefaultHeader` (string) - Value: `"X-Correlation-ID"`
- `LoggerScopeKey` (string) - Value: `"CorrelationId"`

### Properties
- `RequestHeader` (string) - Default: `"X-Correlation-ID"` - Name of the header from which the correlation ID is read on the request.
- `ResponseHeader` (string) - Default: `RequestHeader` (null-backed) - Name of the header to which the correlation ID is written on the response. Backed by a private field defaulting to `null`; the getter falls back to `RequestHeader` when unset — it can never be `null`.
- `IgnoreRequestHeader` (bool) - Default: `false` - When `true`, any incoming correlation ID header value is ignored and a new correlation ID is generated.
- `EnforceHeader` (bool) - Default: `false` - When `true` and the correlation ID request header is missing/empty, the request fails immediately with `400 Bad Request`.
- `AddToLoggingScope` (bool) - Default: `false` - When `true`, the correlation ID is added to the logger scope payload (key = `LoggingScopeKey`) for the downstream pipeline.
- `LoggingScopeKey` (string) - Default: `"CorrelationId"` - Key name used when adding the correlation ID to the logger scope.
- `IncludeInResponse` (bool) - Default: `true` - Controls whether the correlation ID is returned in the response headers. The response header is only written if not already present.
- `UpdateTraceIdentifier` (bool) - Default: `false` - When `true` (and a non-empty correlation ID exists), sets `HttpContext.TraceIdentifier` to the correlation ID. Note: v2.1.0 defaulted this to `true`; v3.0.0 changed the default to `false`.
- `CorrelationIdGenerator` (Func<string>) - Default: `null` - Function returning the correlation ID when none is read from the request header. When set, it takes precedence over the registered `ICorrelationIdProvider`.

### Usage
Configuring via the `AddDefaultCorrelationId` configure delegate (as in the sample app `samples/3.1/MvcSample/Startup.cs`):

```csharp
using CorrelationId;
using CorrelationId.DependencyInjection;

services.AddDefaultCorrelationId(options =>
{
    options.CorrelationIdGenerator = () => "Foo";
    options.AddToLoggingScope = true;
    options.EnforceHeader = true;
    options.IgnoreRequestHeader = false;
    options.IncludeInResponse = true;
    options.RequestHeader = "My-Custom-Correlation-Id";
    options.ResponseHeader = "X-Correlation-Id";
    options.UpdateTraceIdentifier = false;
});
```

Reading/validating options directly (they are plain settable POCO properties):

```csharp
var options = new CorrelationIdOptions();
Console.WriteLine(options.RequestHeader);  // X-Correlation-ID
Console.WriteLine(options.ResponseHeader); // X-Correlation-ID (falls back to RequestHeader)
Console.WriteLine(options.IncludeInResponse); // True

options.RequestHeader = "X-Request-Id";
options.ResponseHeader = null;          // back to fallback behaviour
Console.WriteLine(options.ResponseHeader); // X-Request-Id
```

Custom generator function (used instead of the provider):

```csharp
services.AddDefaultCorrelationId(options =>
    options.CorrelationIdGenerator = () => $"corr-{Guid.NewGuid():N}");
```

### Notes
- In v3 the options are no longer accepted by `UseCorrelationId`; they must be registered via DI (`services.Configure(...)` is invoked by the `Action<CorrelationIdOptions>` overloads). See [dependency-injection.md](dependency-injection.md) and [configuration.md](../configuration.md).
- The middleware reads these options through `IOptions<CorrelationIdOptions>`; the `Value` is guaranteed non-null by its constructor guard.
```

--------------------------------

### Register CorrelationId with custom options

Source: https://github.com/stevejgordon/correlationid/wiki/Home

Use this registration to customize CorrelationId behavior. The example sets a custom correlation ID generator, enables logging scope and header enforcement, and specifies custom header names.

```csharp
services.AddDefaultCorrelationId(options =>
{ 
    options.CorrelationIdGenerator = () => "Foo";
    options.AddToLoggingScope = true;
    options.EnforceHeader = true;
    options.IgnoreRequestHeader = false;
    options.IncludeInResponse = true;
    options.RequestHeader = "My-Custom-Correlation-Id";
    options.ResponseHeader = "X-Correlation-Id";
    options.UpdateTraceIdentifier = false;
});
```

--------------------------------

### Error handling for missing service registration

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-id-extensions.md

Error handling example that catches the InvalidOperationException thrown when the required services are not registered. The exception message is shown in the comment and the code rethrows a new exception with additional context. This demonstrates the fail-fast behavior at startup.

```csharp
public void Configure(IApplicationBuilder app)
{
    try
    {
        app.UseCorrelationId();
    }
    catch (InvalidOperationException ex)
    {
        // "Unable to find the required services. You must call the appropriate
        //  AddCorrelationId/AddDefaultCorrelationId method in ConfigureServices
        //  in the application startup code."
        throw new InvalidOperationException("Correlation ID services were not registered.", ex);
    }
}
```

--------------------------------

### Guid and TraceId correlation ID providers

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/types.md

Shows the two built-in correlation ID providers. GuidCorrelationIdProvider returns a random GUID per call, ignoring the HttpContext. TraceIdCorrelationIdProvider returns the trace identifier from the context, which may be null. Register them via WithGuidProvider() or WithTraceIdentifierProvider().

```csharp
public class GuidCorrelationIdProvider : ICorrelationIdProvider
{
    public string GenerateCorrelationId(HttpContext ctx) => Guid.NewGuid().ToString();
}

public class TraceIdCorrelationIdProvider : ICorrelationIdProvider
{
    public string GenerateCorrelationId(HttpContext ctx) => ctx.TraceIdentifier;
}
```

--------------------------------

### Register TraceIdCorrelationIdProvider via DI

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/providers.md

Registers the TraceIdCorrelationIdProvider instead of the GUID provider using the WithTraceIdentifierProvider extension method.

```csharp
using CorrelationId.DependencyInjection;

services.AddCorrelationId().WithTraceIdentifierProvider();
```

--------------------------------

### UseCorrelationId

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-id-extensions.md

Documentation for the UseCorrelationId extension method, including parameters, exceptions, and usage examples.

```APIDOC
## UseCorrelationId

### Description
Adds the CorrelationIdMiddleware to the ASP.NET Core pipeline. This extension method must be called in the application's Configure method, and requires that correlation ID services have been registered in ConfigureServices.

### Method
UseCorrelationId

### Signature
public static IApplicationBuilder UseCorrelationId(this IApplicationBuilder app)

### Parameters
- **app** (IApplicationBuilder) - Required - The application builder to add the middleware to. If null, an ArgumentNullException is thrown.

### Returns
IApplicationBuilder - the same builder instance (app), enabling fluent chaining.

### Exceptions
- **ArgumentNullException** - thrown if `app` is null.
- **InvalidOperationException** - thrown if `ICorrelationContextFactory` is not resolvable from `app.ApplicationServices`. Message: "Unable to find the required services. You must call the appropriate AddCorrelationId/AddDefaultCorrelationId method in ConfigureServices in the application startup code."

### Usage Example
```csharp
using CorrelationId;
using CorrelationId.DependencyInjection;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;

public void ConfigureServices(IServiceCollection services)
{
    services.AddDefaultCorrelationId();
}

public void Configure(IApplicationBuilder app)
{
    app.UseCorrelationId(); // add early, before middleware that needs the correlation ID
    app.UseRouting();
    app.UseEndpoints(endpoints => endpoints.MapControllers());
}
```

### Error Handling Example
```csharp
public void Configure(IApplicationBuilder app)
{
    try
    {
        app.UseCorrelationId();
    }
    catch (InvalidOperationException ex)
    {
        // "Unable to find the required services. You must call the appropriate
        //  AddCorrelationId/AddDefaultCorrelationId method in ConfigureServices
        //  in the application startup code."
        throw new InvalidOperationException("Correlation ID services were not registered.", ex);
    }
}
```

### Notes
- Options are not passed here (v3 removed the `UseCorrelationId(string header)` and `UseCorrelationId(CorrelationIdOptions options)` overloads). Configure options via the `AddCorrelationId*` configure delegates instead.
- Calling `UseCorrelationId()` twice registers the middleware twice; this is safe but not recommended.
- The ASP.NET Core 2.2.0 `TraceIdentifier` regression can be avoided by keeping `UpdateTraceIdentifier = false` (the v3 default).
```

--------------------------------

### Usage of GuidCorrelationIdProvider

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/providers.md

Instantiates the provider directly and calls GenerateCorrelationId with a DefaultHttpContext. The output is a new GUID, verified by Guid.TryParse returning True.

```csharp
using CorrelationId.Abstractions;
using CorrelationId.Providers;
using Microsoft.AspNetCore.Http;

var provider = new GuidCorrelationIdProvider();
var id = provider.GenerateCorrelationId(new DefaultHttpContext());
Console.WriteLine(Guid.TryParse(id, out _)); // True
```

--------------------------------

### Configure AddDefaultCorrelationId with options

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/dependency-injection.md

Typical full setup using AddDefaultCorrelationId with options. Configures the correlation ID generator, logging scope, header enforcement, request/response headers, and trace identifier update. From sample app samples/3.1/MvcSample/Startup.cs.

```csharp
using CorrelationId;
using CorrelationId.DependencyInjection;

public void ConfigureServices(IServiceCollection services)
{
    services.AddDefaultCorrelationId(options =>
    {
        options.CorrelationIdGenerator = () => "Foo";
        options.AddToLoggingScope = true;
        options.EnforceHeader = true;
        options.IgnoreRequestHeader = false;
        options.IncludeInResponse = true;
        options.RequestHeader = "My-Custom-Correlation-Id";
        options.ResponseHeader = "X-Correlation-Id";
        options.UpdateTraceIdentifier = false;
    });
}
```

--------------------------------

### GuidCorrelationIdProvider class implementation

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/providers.md

Generates a correlation ID using a new GUID. The HttpContext argument is ignored. Returns a string that is never null.

```csharp
public class GuidCorrelationIdProvider : ICorrelationIdProvider
{
    public string GenerateCorrelationId(HttpContext ctx) => Guid.NewGuid().ToString();
}
```

--------------------------------

### Catch InvalidOperationException for duplicate provider registration

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/errors.md

Catches the InvalidOperationException thrown when attempting to register a second correlation ID provider. The example shows WithGuidProvider followed by WithTraceIdentifierProvider, which triggers the "A provider has already been added." error. Only a single provider may be registered.

```csharp
try
{
    services.AddCorrelationId().WithGuidProvider();
    services.AddCorrelationId().WithTraceIdentifierProvider(); // second provider
}
catch (InvalidOperationException ex)
{
    // "A provider has already been added."
}
```

--------------------------------

### Register singleton provider instance

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/abstractions.md

Registers a singleton provider instance using WithCustomProvider with an instance of MyProvider.

```csharp
services.AddCorrelationId().WithCustomProvider(new MyProvider());
```

--------------------------------

### GuidCorrelationIdProvider.GenerateCorrelationId

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/providers.md

Generates a correlation ID using a new GUID. Returns a new random GUID per call, ignoring the HttpContext argument.

```APIDOC
## GuidCorrelationIdProvider.GenerateCorrelationId

### Description
Generates a correlation ID using a new GUID. Returns `Guid.NewGuid().ToString()` — a new random GUID per call. The `HttpContext` argument is ignored. Returns `string` (never null).

### Method
GenerateCorrelationId

### Signature
`string GenerateCorrelationId(HttpContext ctx)`

### Parameters
- **ctx** (HttpContext) - Required - The HTTP context (ignored).

### Returns
- **string** - A new GUID string, never null.

### Usage Example
```csharp
using CorrelationId.Abstractions;
using CorrelationId.Providers;
using Microsoft.AspNetCore.Http;

var provider = new GuidCorrelationIdProvider();
var id = provider.GenerateCorrelationId(new DefaultHttpContext());
Console.WriteLine(Guid.TryParse(id, out _)); // True
```
```

--------------------------------

### Register named client with forwarding (MvcSample Startup)

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/http-client.md

Shows how to register a named HttpClient with AddCorrelationIdForwarding and an additional handler. Requires using CorrelationId.HttpClient and Microsoft.Extensions.DependencyInjection.

```csharp
using CorrelationId.HttpClient;
using Microsoft.Extensions.DependencyInjection;

public void ConfigureServices(IServiceCollection services)
{
    services.AddHttpClient("MyClient")
            .AddCorrelationIdForwarding()      // attach the correlation ID to outgoing requests
            .AddHttpMessageHandler<NoOpDelegatingHandler>();
}
```

--------------------------------

### WithCustomProvider (instance overload)

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/dependency-injection.md

Registers an existing provider instance as the singleton ICorrelationIdProvider. Throws if a provider is already registered.

```APIDOC
## WithCustomProvider (instance overload)

### Description
Registers an existing provider instance as the singleton ICorrelationIdProvider. Throws if a provider is already registered.

### Method
Extension method on ICorrelationIdBuilder

### Signature
```csharp
public static ICorrelationIdBuilder WithCustomProvider(this ICorrelationIdBuilder builder, ICorrelationIdProvider provider)
```

### Parameters
- **builder** (ICorrelationIdBuilder) - Required - The builder. Null throws ArgumentNullException.
- **provider** (ICorrelationIdProvider) - Required - The provider instance. Null throws ArgumentNullException.

### Returns
- **ICorrelationIdBuilder** - The same builder for chaining.

### Exceptions
- **ArgumentNullException** - If builder or provider is null.
- **InvalidOperationException** - If a provider is already registered.
```

--------------------------------

### Configure CorrelationIdOptions with AddDefaultCorrelationId or services.Configure

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/configuration.md

Configure CorrelationIdOptions via the AddDefaultCorrelationId configure delegate, or equivalently via services.Configure with an unconfigured registration. The first snippet sets all available options, including a custom header names and EnforceHeader. The second demonstrates the alternative approach of configuring options separately, with only EnforceHeader set.

```csharp
using CorrelationId;
using CorrelationId.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;

services.AddDefaultCorrelationId(options =>
{
    options.CorrelationIdGenerator = () => "Foo";
    options.AddToLoggingScope = true;
    options.EnforceHeader = true;
    options.IgnoreRequestHeader = false;
    options.IncludeInResponse = true;
    options.RequestHeader = "My-Custom-Correlation-Id";
    options.ResponseHeader = "X-Correlation-Id";
    options.UpdateTraceIdentifier = false;
});
```

```csharp
services.Configure<CorrelationIdOptions>(options => options.EnforceHeader = true);
services.AddDefaultCorrelationId();
```

--------------------------------

### Source implementation of Create and Dispose

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-context-factory.md

Exact source implementation of Create and Dispose. Create constructs a CorrelationContext, assigns it to the accessor if present, and returns it. Dispose sets the accessor's CorrelationContext to null if the accessor is not null.

```csharp
public CorrelationContext Create(string correlationId, string header)
{
    var correlationContext = new CorrelationContext(correlationId, header);

    if (_correlationContextAccessor != null)
    {
        _correlationContextAccessor.CorrelationContext = correlationContext;
    }

    return correlationContext;
}

public void Dispose()
{
    if (_correlationContextAccessor != null)
    {
        _correlationContextAccessor.CorrelationContext = null;
    }
}
```

--------------------------------

### Directly Construct CorrelationIdMiddleware for Tests

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-id-middleware.md

Shows direct construction of the middleware for tests or custom hosts, using Options.Create, NullLogger, DefaultHttpContext, and a CorrelationContextFactory. The middleware is invoked with a GuidCorrelationIdProvider.

```csharp
var options = Options.Create(new CorrelationIdOptions());
var logger  = NullLogger<CorrelationIdMiddleware>.Instance;
var context = new DefaultHttpContext();
var factory = new CorrelationContextFactory(new CorrelationContextAccessor());

var middleware = new CorrelationIdMiddleware(
    next: ctx => Task.CompletedTask,
    logger: logger,
    options: options,
    correlationIdProvider: new GuidCorrelationIdProvider());

await middleware.Invoke(context, factory);
```

--------------------------------

### WithCustomProvider instance overload

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/dependency-injection.md

Registers an existing provider instance as the singleton ICorrelationIdProvider using TryAddSingleton. Throws ArgumentNullException for builder or provider, or InvalidOperationException if a provider is already registered.

```csharp
public static ICorrelationIdBuilder WithCustomProvider(this ICorrelationIdBuilder builder, ICorrelationIdProvider provider)
```

--------------------------------

### Access correlation ID via ICorrelationContextAccessor

Source: https://github.com/stevejgordon/correlationid/blob/main/README.md

Shows how to access the current correlation ID by injecting ICorrelationContextAccessor into a class. The example uses constructor injection in a transient class.

```csharp
public class TransientClass
{
   private readonly ICorrelationContextAccessor _correlationContext;

   public TransientClass(ICorrelationContextAccessor correlationContext)
   {
	  _correlationContext = correlationContext;
   }

   ...
}
```

--------------------------------

### Register CorrelationIdMiddleware in Configure

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-id-middleware.md

Shows normal registration of the middleware early in the ASP.NET Core pipeline, after UseHttpsRedirection and before UseRouting. Use this in the Configure method of Startup.

```csharp
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseHttpsRedirection();
    app.UseCorrelationId(); // early in the pipeline
    app.UseRouting();
    app.UseEndpoints(endpoints => endpoints.MapControllers());
}
```

--------------------------------

### Create method signature

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-context-factory.md

Method signature for Create. It creates a new CorrelationContext wrapping the given correlationId and header. Throws ArgumentException if header is null or empty. Does not reject null correlation IDs; they become "Not set". If an accessor is present, it assigns the new context to the accessor's CorrelationContext property.

```csharp
public CorrelationContext Create(string correlationId, string header)
```

--------------------------------

### Register correlation ID services with AddDefaultCorrelationId

Source: https://github.com/stevejgordon/correlationid/blob/main/README.md

Registers the correlation ID services with common defaults inside ConfigureServices. This registers a correlation ID provider that generates new IDs based on a random GUID.

```csharp
services.AddDefaultCorrelationId
```

--------------------------------

### CorrelationIdMiddleware Constructor

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-id-middleware.md

Constructor for the CorrelationIdMiddleware class. It initializes the middleware with the next delegate, logger, options, and an optional correlation ID provider.

```APIDOC
## CorrelationIdMiddleware Constructor

### Description
Initializes a new instance of the CorrelationIdMiddleware class. The middleware attempts to read or create a correlation ID for use in logs and upstream requests.

### Method
Constructor

### Signature
```csharp
public CorrelationIdMiddleware(RequestDelegate next, ILogger<CorrelationIdMiddleware> logger, IOptions<CorrelationIdOptions> options, ICorrelationIdProvider correlationIdProvider = null)
```

### Parameters
- **next** (RequestDelegate) - Required - The next middleware in the pipeline. `null` throws `ArgumentNullException`.
- **logger** (ILogger<CorrelationIdMiddleware>) - Required - Logger instance. `null` throws `ArgumentNullException`.
- **options** (IOptions<CorrelationIdOptions>) - Required - Options wrapper; `options.Value` is used. `null` throws `ArgumentNullException`.
- **correlationIdProvider** (ICorrelationIdProvider) - Optional - Provider used to generate IDs. When `null`, the provider is expected to be registered in DI; a missing provider fails at request time.

### Remarks
In normal usage, the DI-created instance is used; ASP.NET Core resolves `next`, `ILogger<CorrelationIdMiddleware>`, `IOptions<CorrelationIdOptions>`, and any registered `ICorrelationIdProvider` automatically.
```

--------------------------------

### Resolving and using CorrelationContextAccessor in a service

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-context-accessor.md

Example of injecting ICorrelationContextAccessor into a service to read the current correlation ID. Note that CorrelationContext may be null outside a request handled by the middleware, so guard with null-conditional operators.

```csharp
using CorrelationId;
using CorrelationId.Abstractions;

public class MyService
{
    private readonly ICorrelationContextAccessor _accessor;

    public MyService(ICorrelationContextAccessor accessor) => _accessor = accessor;

    public string CurrentCorrelationId()
    {
        // CorrelationContext may be null outside of a request handled by the middleware;
        // the middleware guarantees it exists during the request pipeline.
        return _accessor.CorrelationContext?.CorrelationId;
    }
}
```

--------------------------------

### Combine forwarding with typed client registration

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/http-client.md

Shows chaining AddCorrelationIdForwarding with AddTypedClient to register a typed client with correlation ID forwarding.

```csharp
services.AddHttpClient("ApiClient")
        .AddCorrelationIdForwarding()
        .AddTypedClient<IApiClient, ApiClient>();
```

--------------------------------

### WithGuidProvider

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/dependency-injection.md

Registers GuidCorrelationIdProvider as the singleton ICorrelationIdProvider. Throws if a provider is already registered.

```APIDOC
## WithGuidProvider

### Description
Registers GuidCorrelationIdProvider as the singleton ICorrelationIdProvider. Throws if a provider is already registered.

### Method
Extension method on ICorrelationIdBuilder

### Signature
```csharp
public static ICorrelationIdBuilder WithGuidProvider(this ICorrelationIdBuilder builder)
```

### Parameters
- **builder** (ICorrelationIdBuilder) - Required - The builder. Null throws ArgumentNullException.

### Returns
- **ICorrelationIdBuilder** - The same builder for chaining.

### Exceptions
- **ArgumentNullException** - If builder is null.
- **InvalidOperationException** - If any ICorrelationIdProvider registration already exists.
```

--------------------------------

### ICorrelationContextFactory interface

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/abstractions.md

Defines the contract for creating and disposing correlation contexts. Implemented by CorrelationContextFactory (registered as transient) and consumed by CorrelationIdMiddleware, which calls Create at request start and Dispose after the next delegate completes. UseCorrelationId() throws InvalidOperationException if this service is not registered.

```csharp
public interface ICorrelationContextFactory
{
    CorrelationContext Create(string correlationId, string header);

    void Dispose();
}
```

--------------------------------

### WithGuidProvider extension method

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/dependency-injection.md

Registers GuidCorrelationIdProvider as the singleton ICorrelationIdProvider. Throws ArgumentNullException if builder is null, or InvalidOperationException if a provider is already registered.

```csharp
public static ICorrelationIdBuilder WithGuidProvider(this ICorrelationIdBuilder builder)
```

--------------------------------

### Configure CorrelationIdOptions with AddDefaultCorrelationId

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-id-options.md

Configures the CorrelationIdOptions via the AddDefaultCorrelationId extension method in a Startup.cs file. Sets a custom generator, enables logging scope and header enforcement, and customizes header names.

```csharp
using CorrelationId;
using CorrelationId.DependencyInjection;

services.AddDefaultCorrelationId(options =>
{
    options.CorrelationIdGenerator = () => "Foo";
    options.AddToLoggingScope = true;
    options.EnforceHeader = true;
    options.IgnoreRequestHeader = false;
    options.IncludeInResponse = true;
    options.RequestHeader = "My-Custom-Correlation-Id";
    options.ResponseHeader = "X-Correlation-Id";
    options.UpdateTraceIdentifier = false;
});
```

--------------------------------

### AddCorrelationId with options configuration

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/dependency-injection.md

Calls services.Configure(configure) then AddCorrelationId() (no provider). Throws ArgumentNullException for services or configure.

```csharp
public static ICorrelationIdBuilder AddCorrelationId(this IServiceCollection services, Action<CorrelationIdOptions> configure)
```

--------------------------------

### CorrelationContextFactory

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-context-factory.md

Documentation for the CorrelationContextFactory class, including constructors and methods.

```APIDOC
## CorrelationContextFactory Constructor

### Description
Initializes a new instance of the CorrelationContextFactory class. The parameterless constructor delegates to the parameterized constructor with a null accessor.

### Method
Constructor

### Signature
```csharp
public CorrelationContextFactory()
public CorrelationContextFactory(ICorrelationContextAccessor correlationContextAccessor)
```

### Parameters
- `correlationContextAccessor` (ICorrelationContextAccessor) - Optional - The accessor through which the created CorrelationContext will be set and later cleared. When null, Create/Dispose operate without touching an accessor.
```

```APIDOC
## CorrelationContextFactory.Create

### Description
Creates a new CorrelationContext with the specified correlation ID and header. If an accessor is configured, the created context is assigned to the accessor's CorrelationContext property.

### Method
Create

### Signature
```csharp
public CorrelationContext Create(string correlationId, string header)
```

### Parameters
- `correlationId` (string) - Required - The correlation ID to set on the new CorrelationContext.
- `header` (string) - Required - The header used to hold the correlation ID; stored on the context.

### Returns
CorrelationContext - a new instance wrapping (correlationId, header).

### Exceptions
- ArgumentException - if header is null or empty.

### Remarks
Does not reject null correlation IDs; they become "Not set". When the factory holds a non-null ICorrelationContextAccessor, it assigns the accessor's CorrelationContext property before returning.
```

```APIDOC
## CorrelationContextFactory.Dispose

### Description
Clears the accessor by setting its CorrelationContext property to null. No-op when the accessor is null.

### Method
Dispose

### Signature
```csharp
public void Dispose()
```

### Remarks
The middleware invokes this after the downstream pipeline has completed.
```

--------------------------------

### Usage with accessor

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-context-factory.md

Usage with an accessor, mirroring what the middleware does per request. Create sets the accessor's CorrelationContext to the new context; Dispose clears it to null.

```csharp
using CorrelationId;

var accessor = new CorrelationContextAccessor();
var factory = new CorrelationContextFactory(accessor);

var context = factory.Create("abc-123", "X-Correlation-ID");
Console.WriteLine(ReferenceEquals(accessor.CorrelationContext, context)); // True

// End of request handling:
factory.Dispose();
Console.WriteLine(accessor.CorrelationContext is null); // True
```

--------------------------------

### WithCustomProvider<T> (generic overload)

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/dependency-injection.md

Registers provider type T as the singleton ICorrelationIdProvider. Throws if a provider is already registered.

```APIDOC
## WithCustomProvider<T> (generic overload)

### Description
Registers provider type T as the singleton ICorrelationIdProvider. Throws if a provider is already registered.

### Method
Extension method on ICorrelationIdBuilder

### Signature
```csharp
public static ICorrelationIdBuilder WithCustomProvider<T>(this ICorrelationIdBuilder builder) where T : class, ICorrelationIdProvider
```

### Parameters
- **builder** (ICorrelationIdBuilder) - Required - The builder. Null throws ArgumentNullException.

### Returns
- **ICorrelationIdBuilder** - The same builder for chaining.

### Exceptions
- **ArgumentNullException** - If builder is null.
- **InvalidOperationException** - If a provider is already registered.

### Usage Example
```csharp
services.AddCorrelationId()
        .ClearProvider()
        .WithCustomProvider<TenantAwareCorrelationIdProvider>();
```
```

--------------------------------

### WithTraceIdentifierProvider extension method

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/dependency-injection.md

Registers TraceIdCorrelationIdProvider as the singleton ICorrelationIdProvider, matching HttpContext.TraceIdentifier. Throws ArgumentNullException if builder is null, or InvalidOperationException if a provider is already registered.

```csharp
public static ICorrelationIdBuilder WithTraceIdentifierProvider(this ICorrelationIdBuilder builder)
```

--------------------------------

### CorrelationContextAccessor Class

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-context-accessor.md

Documentation for the CorrelationContextAccessor class, including its purpose, members, registration, usage, and behavior notes.

```APIDOC
## CorrelationContextAccessor Class

### Description
Default implementation of `ICorrelationContextAccessor` that stores the `CorrelationContext` for the current asynchronous flow in a static `AsyncLocal`. This allows the value to flow across `await` boundaries and is isolated per logical execution context, making it safe to use as a singleton.

### Members

#### CorrelationContext Property
- **Type**: `CorrelationContext` (get/set)
- **Description**: Gets or sets the `CorrelationContext` for the current request. Read by application code to obtain `CorrelationContext.CorrelationId`; written by `CorrelationContextFactory.Create` / `CorrelationContextFactory.Dispose`.

### Registration & Lifetime
Registered by every `AddCorrelationId*` extension as a singleton:

```csharp
services.TryAddSingleton<ICorrelationContextAccessor, CorrelationContextAccessor>();
```

Singleton is safe because `AsyncLocal` scopes the value per flow — header values do not leak between concurrent requests.

### Usage Example
Resolve the accessor through the container and read the current correlation ID:

```csharp
using CorrelationId;
using CorrelationId.Abstractions;

public class MyService
{
    private readonly ICorrelationContextAccessor _accessor;

    public MyService(ICorrelationContextAccessor accessor) => _accessor = accessor;

    public string CurrentCorrelationId()
    {
        // CorrelationContext may be null outside of a request handled by the middleware;
        // the middleware guarantees it exists during the request pipeline.
        return _accessor.CorrelationContext?.CorrelationId;
    }
}
```

### Behaviour Notes
- `CorrelationContext` is `null` before the middleware creates one and after `ICorrelationContextFactory.Dispose()` runs (end of the request). Guard against `null` when reading the property.
- Direct manipulation of the property is only needed when writing custom factory implementations or tests.
```

--------------------------------

### AddCorrelationId<T> with options configuration

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/dependency-injection.md

Configures options and registers provider T. Throws ArgumentNullException for services or configure; throws InvalidOperationException if a provider is already registered.

```csharp
public static ICorrelationIdBuilder AddCorrelationId<T>(this IServiceCollection services, Action<CorrelationIdOptions> configure) where T : class, ICorrelationIdProvider
```

--------------------------------

### WithCustomProvider<T> generic overload

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/dependency-injection.md

Registers provider type T as the singleton ICorrelationIdProvider using TryAddSingleton. Throws ArgumentNullException if builder is null, or InvalidOperationException if a provider is already registered.

```csharp
public static ICorrelationIdBuilder WithCustomProvider<T>(this ICorrelationIdBuilder builder) where T : class, ICorrelationIdProvider
```

--------------------------------

### CorrelationContextFactory constructors

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-context-factory.md

Constructors for CorrelationContextFactory. The parameterless constructor delegates to the parameterized one with null. The parameterized constructor accepts an optional ICorrelationContextAccessor; when null, Create and Dispose operate without touching an accessor.

```csharp
public CorrelationContextFactory()
    : this(null)
{ }

public CorrelationContextFactory(ICorrelationContextAccessor correlationContextAccessor)
```

--------------------------------

### Handling invalid header error

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-context.md

Demonstrates the ArgumentException thrown when an invalid (empty) header is provided. The caught exception message is "A header must be provided. (Parameter 'header')".

```csharp
try
{
    var context = new CorrelationContext("ABC-123", string.Empty);
}
catch (ArgumentException ex)
{
    Console.WriteLine(ex.Message); // "A header must be provided. (Parameter 'header')"
}
```

--------------------------------

### Standalone usage without accessor

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-context-factory.md

Standalone usage without an accessor, suitable for unit tests that only need a CorrelationContext. Create returns a context with the given ID and header; Dispose is a no-op because no accessor is wired up.

```csharp
using CorrelationId;

var factory = new CorrelationContextFactory();
var context = factory.Create("8675309", CorrelationIdOptions.DefaultHeader);

Console.WriteLine(context.CorrelationId); // 8675309

factory.Dispose(); // no-op: no accessor wired up
```

--------------------------------

### Chaining provider configuration

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/dependency-injection.md

Chains provider configuration: clears any existing provider and registers a custom provider type.

```csharp
services.AddCorrelationId()
        .ClearProvider()
        .WithCustomProvider<TenantAwareCorrelationIdProvider>();
```

--------------------------------

### Correlation ID Registration and Builder Methods

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/dependency-injection.md

Registration methods and builder methods for configuring correlation ID services in an ASP.NET Core application.

```APIDOC
## AddCorrelationId()

### Description
Registers the correlation ID services without a provider. Returns an `ICorrelationIdBuilder` for further configuration.

### Method
Registration

### Endpoint
N/A - Service registration method

### Parameters
None

### Returns
`ICorrelationIdBuilder`

### Usage Example
```csharp
services.AddCorrelationId();
```
```

```APIDOC
## AddCorrelationId(configure)

### Description
Registers the correlation ID services with an options delegate for configuration. Returns an `ICorrelationIdBuilder`.

### Method
Registration

### Endpoint
N/A - Service registration method

### Parameters
- **configure** (Action<CorrelationIdOptions>) - Required - Options delegate for configuring correlation ID behavior.

### Returns
`ICorrelationIdBuilder`

### Usage Example
```csharp
services.AddCorrelationId(options =>
{
    options.RequestHeader = "X-Correlation-Id";
});
```
```

```APIDOC
## AddCorrelationId<T>()

### Description
Registers the correlation ID services with a custom provider of type `T`. Returns an `ICorrelationIdBuilder`.

### Method
Registration

### Endpoint
N/A - Service registration method

### Parameters
- **T** (Type) - Required - The type of the custom correlation ID provider.

### Returns
`ICorrelationIdBuilder`

### Usage Example
```csharp
services.AddCorrelationId<MyCorrelationIdProvider>();
```
```

```APIDOC
## AddCorrelationId<T>(configure)

### Description
Registers the correlation ID services with a custom provider of type `T` and an options delegate. Returns an `ICorrelationIdBuilder`.

### Method
Registration

### Endpoint
N/A - Service registration method

### Parameters
- **T** (Type) - Required - The type of the custom correlation ID provider.
- **configure** (Action<CorrelationIdOptions>) - Required - Options delegate for configuring correlation ID behavior.

### Returns
`ICorrelationIdBuilder`

### Usage Example
```csharp
services.AddCorrelationId<MyCorrelationIdProvider>(options =>
{
    options.IncludeInResponse = true;
});
```
```

```APIDOC
## AddDefaultCorrelationId()

### Description
Registers the default `GuidCorrelationIdProvider` and returns an `IServiceCollection` for chaining.

### Method
Registration

### Endpoint
N/A - Service registration method

### Parameters
None

### Returns
`IServiceCollection`

### Usage Example
```csharp
services.AddDefaultCorrelationId();
```
```

```APIDOC
## AddDefaultCorrelationId(configure)

### Description
Registers the default `GuidCorrelationIdProvider` with an options delegate and returns an `IServiceCollection`.

### Method
Registration

### Endpoint
N/A - Service registration method

### Parameters
- **configure** (Action<CorrelationIdOptions>) - Required - Options delegate for configuring correlation ID behavior.

### Returns
`IServiceCollection`

### Usage Example
```csharp
services.AddDefaultCorrelationId(options =>
{
    options.CorrelationIdGenerator = () => "Foo";
    options.AddToLoggingScope = true;
    options.EnforceHeader = true;
    options.IgnoreRequestHeader = false;
    options.IncludeInResponse = true;
    options.RequestHeader = "My-Custom-Correlation-Id";
    options.ResponseHeader = "X-Correlation-Id";
    options.UpdateTraceIdentifier = false;
});
```
```

```APIDOC
## WithCustomProvider<T>()

### Description
Configures the correlation ID builder to use a custom provider of type `T`. This is used after calling `AddCorrelationId()`.

### Method
Builder method

### Endpoint
N/A - Builder method on `ICorrelationIdBuilder`

### Parameters
- **T** (Type) - Required - The type of the custom correlation ID provider.

### Returns
`ICorrelationIdBuilder`

### Usage Example
```csharp
services.AddCorrelationId()
        .WithCustomProvider<TenantAwareCorrelationIdProvider>();
```
```

```APIDOC
## WithGuidProvider()

### Description
Configures the correlation ID builder to use the built-in `GuidCorrelationIdProvider`. Throws `InvalidOperationException` if a provider has already been added.

### Method
Builder method

### Endpoint
N/A - Builder method on `ICorrelationIdBuilder`

### Parameters
None

### Returns
`ICorrelationIdBuilder`

### Usage Example
```csharp
services.AddCorrelationId().WithGuidProvider();
```
```

```APIDOC
## WithTraceIdentifierProvider()

### Description
Configures the correlation ID builder to use the built-in trace identifier provider. Throws `InvalidOperationException` if a provider has already been added.

### Method
Builder method

### Endpoint
N/A - Builder method on `ICorrelationIdBuilder`

### Parameters
None

### Returns
`ICorrelationIdBuilder`

### Usage Example
```csharp
services.AddCorrelationId().WithTraceIdentifierProvider();
```
```

--------------------------------

### Register core correlation ID services

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/dependency-injection.md

Core registrations performed by every AddCorrelationId* method. Registers the correlation context accessor as a singleton and the correlation context factory as transient.

```csharp
services.TryAddSingleton<ICorrelationContextAccessor, CorrelationContextAccessor>();
services.TryAddTransient<ICorrelationContextFactory, CorrelationContextFactory>();
```

--------------------------------

### AddDefaultCorrelationId with options configuration

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/dependency-injection.md

Calls AddDefaultCorrelationId() then services.Configure(configure). Throws ArgumentNullException for services or configure; provider conflict on repeat calls as above.

```csharp
public static IServiceCollection AddDefaultCorrelationId(this IServiceCollection services, Action<CorrelationIdOptions> configure)
```

--------------------------------

### Catch ArgumentException for invalid context header

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/errors.md

Catches the ArgumentException thrown when the CorrelationContext constructor or CorrelationContextFactory.Create is called with a null or empty header. The exception message is "A header must be provided." and the parameter name is "header". Use this to handle missing context header failures.

```csharp
try
{
    var factory = new CorrelationContextFactory();
    factory.Create(id, header: null);
}
catch (ArgumentException ex) when (ex.ParamName == "header")
{
    // context header missing
}
```

--------------------------------

### Read and Validate CorrelationIdOptions Properties

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/correlation-id-options.md

Directly instantiates and reads/writes CorrelationIdOptions properties. Shows the fallback behavior of ResponseHeader when set to null and the default values.

```csharp
var options = new CorrelationIdOptions();
Console.WriteLine(options.RequestHeader);  // X-Correlation-ID
Console.WriteLine(options.ResponseHeader); // X-Correlation-ID (falls back to RequestHeader)
Console.WriteLine(options.IncludeInResponse); // True

options.RequestHeader = "X-Request-Id";
options.ResponseHeader = null;          // back to fallback behaviour
Console.WriteLine(options.ResponseHeader); // X-Request-Id
```

--------------------------------

### Direct call to TraceIdCorrelationIdProvider

Source: https://github.com/stevejgordon/correlationid/blob/main/_autodocs/api-reference/providers.md

Sets a TraceIdentifier on a DefaultHttpContext and calls the provider directly, returning the same trace identifier string.

```csharp
using CorrelationId.Abstractions;
using CorrelationId.Providers;
using Microsoft.AspNetCore.Http;

var context = new DefaultHttpContext();
context.TraceIdentifier = "H3A2C1:00000001";

var provider = new TraceIdCorrelationIdProvider();
var id = provider.GenerateCorrelationId(context); // "H3A2C1:00000001"
```
Tokens:
Raw