dotnet-realtime-communication

name	dotnet-realtime-communication
description	Builds real-time features. SignalR hubs, SSE (.NET 10), JSON-RPC 2.0, gRPC streaming, scaling.
metadata	{"short-description":".NET skill guidance for api tasks"}

dotnet-realtime-communication

Real-time communication patterns for .NET applications. Compares SignalR (full-duplex over WebSockets with automatic fallback), Server-Sent Events (SSE, built-in to ASP.NET Core in .NET 10), JSON-RPC 2.0 (structured request-response over any transport), and gRPC streaming (high-performance binary streaming). Provides decision guidance for choosing the right protocol based on requirements.

Scope

• SignalR hubs (WebSocket, auto-fallback, scaling)
• Server-Sent Events (SSE, built-in .NET 10)
• JSON-RPC 2.0 over any transport
• gRPC streaming for high-performance binary
• Protocol comparison and decision guidance

Out of scope

• HTTP client factory and resilience pipelines -- see [skill:dotnet-http-client] and [skill:dotnet-resilience]
• Native AOT architecture and trimming -- see [skill:dotnet-native-aot] and [skill:dotnet-trimming]
• Blazor-specific SignalR usage -- see [skill:dotnet-blazor-patterns]

Cross-references: [skill:dotnet-grpc] for gRPC streaming implementation details and all four streaming patterns. See [skill:dotnet-integration-testing] for testing real-time communication endpoints. See [skill:dotnet-blazor-patterns] for Blazor-specific SignalR circuit management and render mode interaction.

---

Protocol Comparison

Protocol	Direction	Transport	Format	Browser Support	Best For
SignalR	Full-duplex	WebSocket, SSE, Long Polling (auto-negotiation)	JSON or MessagePack	Yes (JS/TS client)	Interactive apps, chat, dashboards, collaborative editing
SSE (.NET 10)	Server-to-client only	HTTP/1.1+	Text (typically JSON lines)	Yes (native EventSource API)	Notifications, live feeds, status updates
JSON-RPC 2.0	Request-response	Any (HTTP, WebSocket, stdio)	JSON	Depends on transport	Tooling protocols (LSP), structured RPC over simple transports
gRPC streaming	All four patterns	HTTP/2	Protobuf (binary)	Limited (gRPC-Web)	Service-to-service, high-throughput, low-latency streaming

When to Choose What

• SignalR: You need bidirectional real-time communication with browser clients. SignalR handles transport negotiation automatically (WebSocket preferred, falls back to SSE, then Long Polling). Use when clients need to both send and receive in real time.
• SSE (.NET 10 built-in): You only need server-to-client push. Simpler than SignalR when bidirectional communication is not required. Built into ASP.NET Core in .NET 10 -- no additional packages needed. Works with the browser's native EventSource API.
• JSON-RPC 2.0: You need structured request-response semantics over a simple transport. Used by Language Server Protocol (LSP) and some .NET tooling. Not a streaming protocol -- use when you need named methods with typed parameters over WebSocket or stdio.
• gRPC streaming: Service-to-service streaming with maximum performance. Supports all four streaming patterns (unary, server streaming, client streaming, bidirectional). Best when both endpoints are .NET services or gRPC-compatible. See [skill:dotnet-grpc] for implementation details.

---

SignalR

SignalR provides real-time web functionality with automatic connection management and transport negotiation.

Server Setup

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSignalR(options =>
{
    options.EnableDetailedErrors = builder.Environment.IsDevelopment();
    options.MaximumReceiveMessageSize = 64 * 1024; // 64 KB
    options.KeepAliveInterval = TimeSpan.FromSeconds(15);
});

var app = builder.Build();

app.MapHub<NotificationHub>("/hubs/notifications");

```text

### Hub Implementation

```csharp

public sealed class NotificationHub(
    ILogger<NotificationHub> logger) : Hub
{
    public override async Task OnConnectedAsync()
    {
        var userId = Context.UserIdentifier;
        if (userId is not null)
        {
            await Groups.AddToGroupAsync(Context.ConnectionId, $"user:{userId}");
        }

        await base.OnConnectedAsync();
    }

    // Client-to-server method
    public async Task SendMessage(string channel, string message)
    {
        // Broadcast to all clients in the channel group
        await Clients.Group(channel).SendAsync("ReceiveMessage",
            Context.UserIdentifier, message);
    }

    // Server-to-client streaming
    public  <> ()
    {
         (!cancellationToken.IsCancellationRequested)
        {
            ;
             Task.Delay(, cancellationToken);
        }
    }
}

```text



Use interfaces to  compile-time safety  client method calls:

```csharp

  
{
    ;
    ;
}


{
    
    {
        
         Clients.Group(channel).ReceiveMessage(
            Context.UserIdentifier!, message);
    }
}

```text



Inject `IHubContext` to send messages  background services  controllers:

```
{
    
    {
        
         hubContext.Clients.Group()
            .OrderStatusChanged(orderId, status);
    }
}

```text



SignalR automatically negotiates the best transport:

 **WebSocket** (preferred) -- full-duplex, lowest latency
 **Server-Sent Events** -- server-to-client only, falls back  WebSockets unavailable
 **Long Polling** -- universal fallback, highest latency

Force a specific transport  needed:

```csharp


app.MapHub<NotificationHub>(, options =>
{
    options.Transports = HttpTransportType.WebSockets |
                         HttpTransportType.ServerSentEvents;
    
});

```text



Use MessagePack  smaller payloads  faster serialization:

```csharp


builder.Services.AddSignalR()
    .AddMessagePackProtocol();







```text



Override `OnConnectedAsync`  `OnDisconnectedAsync` to manage connection state:

```
{
    
    {
         userId = Context.UserIdentifier;
         connectionId = Context.ConnectionId;

        logger.LogInformation(,
            connectionId, userId);

        
         (userId   )
        {
             tracker.AddConnectionAsync(userId, connectionId);
             Groups.AddToGroupAsync(connectionId, );
        }

         .OnConnectedAsync();
    }

    
    {
         userId = Context.UserIdentifier;
         connectionId = Context.ConnectionId;

         (exception   )
        {
            logger.LogWarning(exception,
                , connectionId);
        }

         (userId   )
        {
             tracker.RemoveConnectionAsync(userId, connectionId);
        }

         .OnDisconnectedAsync(exception);
    }
}

```text



Groups provide a lightweight pub/sub mechanism. Connections can belong to multiple groups   membership  managed per-connection:

```csharp

    : <>
{
    
    
    {
         Groups.AddToGroupAsync(Context.ConnectionId, roomName);
         Clients.Group(roomName).UserJoined(Context.UserIdentifier!, roomName);
    }

    
    
    {
         Groups.RemoveFromGroupAsync(Context.ConnectionId, roomName);
         Clients.Group(roomName).UserLeft(Context.UserIdentifier!, roomName);
    }

    
    
    {
         Clients.Group(roomName).ReceiveMessage(
            Context.UserIdentifier!, message);
    }

    
    
    {
         Clients.Others.ReceiveMessage(
            Context.UserIdentifier!, message);
    }
}

```text

Groups are  persisted -- they are cleared  a connection disconnects. Re- connections to groups  `OnConnectedAsync` 
{
    
    
    {
          ( reading  stream.WithCancellation(cancellationToken))
        {
             ProcessReading(reading);
        }
    }
}

```text



SignalR uses the same authentication  the ASP.NET Core host. For WebSocket connections, the access token  sent via query  because WebSocket does  support custom headers:

```csharp


builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.Authority = ;
        options.Events =  JwtBearerEvents
        {
            OnMessageReceived = context =>
            {
                
                 accessToken = context.Request.Query[];
                 path = context.HttpContext.Request.Path;
                 (!.IsNullOrEmpty(accessToken) &&
                    path.StartsWithSegments())
                {
                    context.Token = accessToken;
                }
                 Task.CompletedTask;
            }
        };
    });

builder.Services.AddAuthorization();

 app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

app.MapHub<NotificationHub>()
    .RequireAuthorization();

```text

Access `Context.UserIdentifier`  the hub to identify the authenticated user. By   maps to the `ClaimTypes.NameIdentifier` claim. Customize  `IUserIdProvider`:

```csharp

    : 
{
     ? GetUserId(HubConnectionContext connection)
    {
         connection.User?.FindFirst(ClaimTypes.Email)?.Value;
    }
}


builder.Services.AddSingleton<IUserIdProvider, EmailUserIdProvider>();

```text



For multi-server deployments, use a backplane to synchronize messages across instances. Without a backplane, messages sent  one server are  visible to connections  other servers.

**Redis backplane:**

```csharp

builder.Services.AddSignalR()
    .AddStackExchangeRedis(builder.Configuration.GetConnectionString()!,
        options =>
        {
            options.Configuration.ChannelPrefix =
                RedisChannel.Literal();
        });

```text

**;

```csharp

Azure SignalR Service offloads connection management entirely -- the ASP.NET Core server handles hub logic  Azure manages WebSocket connections, scaling,  message routing.

---



.NET  adds built- SSE support to ASP.NET Core, making server-to-client streaming straightforward without additional packages.



```csharp

app.MapGet(,  (
    OrderEventService eventService,
    CancellationToken cancellationToken) =>
{
    
     TypedResults.ServerSentEvents(
        eventService.GetOrderEventsAsync(cancellationToken));
});

```text



```csharp

   
{
      IAsyncEnumerable<SseItem<OrderEvent>> GetOrderEventsAsync(
        [] CancellationToken cancellationToken)
    {
         (!cancellationToken.IsCancellationRequested)
        {
             evt =  WaitForNextEvent(cancellationToken);
            ;
        }
    }
}

```text



```javascript

 source =  EventSource();

source.addEventListener(, () => {
     order = JSON.parse(.data);
    updateDashboard(order);
});

source.onerror = () => {
    
    console.log();
};

```text



- **One-way push only** -- SSE  simpler  you   need client-to-server messages
- **Browser native** -- 
{: , : , : {...}, : }


{: , : {...}, : }


{: , : , : {...}}


{: , : {: , : }, : }

```json



`StreamJsonRpc`  the primary .NET library  JSON-RPC :

```xml

<PackageReference Include= Version= />

```json

```csharp


 StreamJsonRpc;

   
{
     => a + b;
     =>
        b ==  ?   ArgumentException()
               : Task.FromResult(a / b);
}


app.UseWebSockets();
app.Map(,  (HttpContext context) =>
{
     (!context.WebSockets.IsWebSocketRequest)
    {
        context.Response.StatusCode = ;
        ;
    }

     ws =  context.WebSockets.AcceptWebSocketAsync();
      rpc =  JsonRpc( WebSocketMessageHandler(ws));
    rpc.AddLocalRpcTarget( CalculatorService());
    rpc.StartListening();
     rpc.Completion;
});

```text

```csharp


  ws =  ClientWebSocket();
 ws.ConnectAsync( Uri(),
    CancellationToken.None);

  rpc =  JsonRpc( WebSocketMessageHandler(ws));
rpc.StartListening();

 result =  rpc.InvokeAsync<>(, , );


```text



- 

Code Navigation (Serena MCP)

Primary approach: Use Serena symbol operations for efficient code navigation:

1. Find definitions: serena_find_symbol instead of text search
2. Understand structure: serena_get_symbols_overview for file organization
3. Track references: serena_find_referencing_symbols for impact analysis
4. Precise edits: serena_replace_symbol_body for clean modifications

When to use Serena vs traditional tools:

• Use Serena: Navigation, refactoring, dependency analysis, precise edits
• Use Read/Grep: Reading full files, pattern matching, simple text operations
• Fallback: If Serena unavailable, traditional tools work fine

Example workflow:

# Instead of:
Read: src/Services/OrderService.cs
Grep: "public void ProcessOrder"

# Use:
serena_find_symbol: "OrderService/ProcessOrder"
serena_get_symbols_overview: "src/Services/OrderService.cs"