.NET SDK - Dependency injection

Package: WestyxNexus.Extensions.DependencyInjection (v0.11.0+) AddWestyxNexus() registers the client as a singleton, wires it through IHttpClientFactory and the application’s ILoggerFactory, and performs the initial sync during host startup.

dotnet add package WestyxNexus.Extensions.DependencyInjection

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddWestyxNexus(options =>
{
    options.BaseUrl = builder.Configuration["Nexus:BaseUrl"]!;
    options.ApiKey  = builder.Configuration["Nexus:ApiKey"];
});

var app = builder.Build();

A configuration section can be passed instead, which binds the whole block:

builder.Services.AddWestyxNexus(builder.Configuration.GetSection("Nexus"));

{
  "Nexus": {
    "BaseUrl": "https://blue-ocean-a5rx7.westyx.dev",
    "ApiKey": "wxs_...",
    "Ttl": "00:01:00",
    "SseReconnectCooldown": [ 5, 10, 20, 40, 60 ],
    "Wif": {
      "Enabled": true,
      "Provider": "kubernetes"
    }
  }
}

An existing NexusConfig - the same object the configuration source takes - can be passed directly instead of retyping its fields:

builder.Services.AddWestyxNexus(config);

HttpClient, StreamHandler and PooledConnectionLifetime are rejected on this path rather than ignored, naming the property: IHttpClientFactory owns all three here. This registers a client of its own. If Nexus configs should reach IConfiguration as well, use builder.AddWestyxNexus(config) - adding builder.Configuration.AddWestyx(config) next to this call creates a second client, with its own sync loop and its own SSE connection. Then inject NexusClient anywhere:

public sealed class CheckoutService(NexusClient nexus)
{
    public bool NewFlowEnabled() => nexus.GetFlag("new.checkout");
}

Options

Property	Default	Notes
`BaseUrl`	(required)	The full service endpoint, e.g. `https://blue-ocean-a5rx7.westyx.dev`
`ApiKey`	-	Required unless `Wif` is enabled
`Ttl`	60 s	Cache lifetime before a background refresh
`Wif`	-	Workload Identity Federation config, as a `WifOptions`
`SseReconnectCooldown`	`[5, 10, 20, 40, 60]`	Reconnect schedule, in minutes
`StreamIdleTimeout`	90 s	Silence on the SSE stream before the SDK reconnects
`StreamConnectTimeout`	10 s	Bound on the SSE connect-to-headers phase
`EnableStream`	`true`	Start the SSE live-update stream after initialisation

HttpClient, StreamHandler, LoggerFactory and Observer are deliberately absent from NexusOptions (since v0.17.0 for the latter two). HttpClient/StreamHandler come from IHttpClientFactory on this path - configure them by name instead. LoggerFactory and IStreamObserver are service references a configuration binder can never construct, so they are registered in the container instead and AddWestyxNexus resolves them from there:

builder.Services.AddSingleton<ILoggerFactory>(myLoggerFactory);   // optional - falls back to the app's own ILoggerFactory
builder.Services.AddSingleton<IStreamObserver, MyObserver>();
builder.Services.AddWestyxNexus(builder.Configuration.GetSection("Nexus"));

WifOptions

NexusOptions.Wif is a WifOptions, the configuration-bindable form of WifConfig:

Property	Type	Notes
`Enabled`	`bool`	Master switch
`Provider`	`string?`	`auto` (default), `kubernetes`, `aws`, `gcp`, `azure`, `developer`. The C# member spelling (`AwsIam`) is accepted too, case-insensitively. An unknown value throws `ArgumentException` naming the property and listing what is valid
`Audience`	`string?`	Required on the Azure IMDS path

WifOptions has no CredentialSource property - a credential source is a service reference, not a configuration value, so it is registered in the container instead. See Registering a credential source below. aws_iam is not a Provider value - it is a credential source. Add WestyxNexus.Wif.Aws and call services.AddWestyxNexusAwsIam("eu-central-1"), which also takes the region; a configuration that names aws_iam throws at startup saying exactly that. Provider is a string here while WifConfig.Provider is an enum, and that is deliberate - see Design decisions.

Registering a credential source

A credential source registered in the container is picked up automatically, so nothing has to be set in code on the options:

builder.Services.AddSingleton<IWifCredentialSource, MyCredentialSource>();
builder.Services.AddWestyxNexus(builder.Configuration.GetSection("Nexus"));

The container is the only source of a credential source on this path - WifOptions has no property to set one directly. See Workload identity for the non-DI path, where WifConfig.CredentialSource is a settable property.

Startup is asynchronous

The initial sync is a network call. A plain singleton factory would have to block:

// Do not do this. It blocks a thread-pool thread during host startup.
services.AddSingleton(sp => NexusClient.CreateAsync(cfg).GetAwaiter().GetResult());

AddWestyxNexus() instead starts the work once and awaits it in an IHostedService, so host startup stays properly asynchronous and a misconfiguration surfaces as a startup failure rather than as a failure on the first request. The hosted service is inserted at the front of the service collection, so the client is ready before any hosted service you registered can resolve it.

Customising the HTTP clients

Two named clients are registered:

Name	Used for	Timeout
`NexusHttpClientNames.Sync` (`"westyx-nexus"`)	`/v1/sync`, WIF token exchange, AB evaluation	10 s
`NexusHttpClientNames.Stream` (`"westyx-nexus-stream"`)	The long-lived SSE connection	infinite

Add your own handlers, retry policies or timeouts to either:

builder.Services.AddHttpClient(NexusHttpClientNames.Sync)
    .AddPolicyHandler(myRetryPolicy);

Handler rotation is safe for SSE

IHttpClientFactory rotates handlers every two minutes, which looks fatal for a connection that stays open for hours. It is not: the factory only stops handing an expired handler to new requests - a request already in flight keeps its handler until it completes.

Do not “fix” this with SetHandlerLifetime(Timeout.InfiniteTimeSpan). That reintroduces exactly the stale-DNS problem the factory exists to solve: a process that never recycles a connection never observes an ingress reconfiguration or a load-balancer replacement.

Secrets binding - IOptions<T> for secrets
Feature management - Nexus flags through IFeatureManager
ASP.NET Core configuration - configs through IConfiguration
Design decisions

Overview

Backend SDKs

Browser SDKs

OpenFeature Providers

.NET SDK - Dependency injection

Options

WifOptions

Registering a credential source

Startup is asynchronous

Customising the HTTP clients

Handler rotation is safe for SSE

Next

​Options

​WifOptions

​Registering a credential source

​Startup is asynchronous

​Customising the HTTP clients

​Handler rotation is safe for SSE

​Next

Options

WifOptions

Registering a credential source

Startup is asynchronous

Customising the HTTP clients

Handler rotation is safe for SSE

Next