Lib.AspNetCore.ServerSentEvents

The disconnection flow works by responding with a 204 No Content status code to a reconnection attempt. To make this work, you must implement IServerSentEventsNoReconnectClientsIdsStore to track which identifiers are forbidden from reconnecting.

There are two built-in implementations available:

1. In-Memory Store: Use AddInMemoryServerSentEventsNoReconnectClientsIdsStore() for local, single-instance scenarios.
2. Distributed Cache Store: Use the distributed cache-backed implementation (method name not explicitly shown in snippet, but available via documentation) for multi-instance/scaled environments.

Both require IServerSentEventsClientIdProvider to be registered first.

public void ConfigureServices(IServiceCollection services)
{
    services.AddServerSentEvents();

    // 1. Register the identifier provider
    services.AddServerSentEventsClientIdProvider<CookieBasedServerSentEventsClientIdProvider>();

    // 2. Register the store (In-Memory example)
    services.AddInMemoryServerSentEventsNoReconnectClientsIdsStore();
}

To add Server-Sent Events (SSE) support to an ASP.NET Core application, you must register the required services and map the middleware.

Basic Setup

Use AddServerSentEvents() in ConfigureServices to register the default service and MapServerSentEvents(path) in Configure to map it to an endpoint.

Creating Distinguishable Endpoints

By default, all endpoints mapped via MapServerSentEvents share the same service instance, making them indistinguishable. To create unique endpoints with unique services (e.g., for different notification types), you must register a custom implementation of ServerSentEventsService and map it using the generic overload.

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Register default service
        services.AddServerSentEvents();

        // Register a custom service for a specific endpoint
        services.AddServerSentEvents<INotificationsServerSentEventsService, NotificationsServerSentEventsService>();
    }

    public void Configure(IApplicationBuilder app)
    {
        // Map the default endpoint
        app.MapServerSentEvents("/default-sse-endpoint");

        // Map a specific endpoint to the custom service
        app.MapServerSentEvents<NotificationsServerSentEventsService>("/notifications-sse-endpoint");
    }
}

// Custom service implementation example
internal interface INotificationsServerSentEventsService : IServerSentEventsService { }

internal class NotificationsServerSentEventsService : ServerSentEventsService, INotificationsServerSentEventsService
{
    public NotificationsServerSentEventsService(IOptions<ServerSentEventsServiceOptions<NotificationsServerSentEventsService>> options)
        : base(options.ToBaseServerSentEventsServiceOptions())
    { }
}

To enable client disconnection, you must provide a way to identify clients consistently across reconnect attempts. You do this by implementing IServerSentEventsClientIdProvider.

This provider must implement two methods:

1. AcquireClientId(HttpContext context): Returns a unique identifier (e.g., a Guid) for the client. This ID must persist if the client reconnects.
2. ReleaseClientId(Guid clientId, HttpContext context): Cleans up the identifier when appropriate.

Use the AddServerSentEventsClientIdProvider<T> extension method to register your implementation in IServiceCollection.

internal class CookieBasedServerSentEventsClientIdProvider : IServerSentEventsClientIdProvider
{
    private const string COOKIE_NAME = ".ServerSentEvents.Guid";

    public Guid AcquireClientId(HttpContext context)
    {
        Guid clientId;

        string cookieValue = context.Request.Cookies[COOKIE_NAME];
        if (String.IsNullOrWhiteSpace(cookieValue) || !Guid.TryParse(cookieValue, out clientId))
        {
            clientId = Guid.NewGuid();
            context.Response.Cookies.Append(COOKIE_NAME, clientId.ToString());
        }

        return clientId;
    }

    public void ReleaseClientId(Guid clientId, HttpContext context)
    {
        context.Response.Cookies.Delete(COOKIE_NAME);
    }
}

// Registration in Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddServerSentEvents();
    services.AddServerSentEventsClientIdProvider<CookieBasedServerSentEventsClientIdProvider>();
}