SuperSocket Documentation

SuperSocket is a high-performance, extensible socket server application framework for .NET. It provides a robust architecture for building custom network communication applications, supporting multiple protocols including TCP, UDP, and WebSocket.

Key features include:

• Flexible Pipeline Architecture: Uses a pipeline processing model with customizable filters for efficient data handling.
• Protocol Abstraction: Simplifies implementation of various protocols (TCP, UDP, WebSocket, or custom).
• Middleware Support: Extensible system for custom connection and packet processing.
• Session Management: Comprehensive lifecycle management for connections.
• Command Processing: Efficient request handling based on a command model.
• Modern .NET Integration: Seamlessly integrates with .NET Dependency Injection, Configuration, and Logging.
• High Performance: Designed for high throughput and low latency using buffer pools and minimal memory allocation.
• Cross-Platform: Runs on all platforms supported by .NET.

Starting with version 2.0.2-beta.1, SuperSocket pipeline filters no longer require a parameterless constructor. You can now use constructor injection to provide dependencies (such as ILogger or IConfiguration) to your pipeline filters. This change is backward compatible; filters with default constructors will continue to function normally.

public class MyPipelineFilter : IPipelineFilter<TextPackageInfo>
{
    private readonly ILogger<MyPipelineFilter> _logger;
    private readonly IConfiguration _configuration;

    // Constructor with dependencies - now supported!
    public MyPipelineFilter(ILogger<MyPipelineFilter> logger, IConfiguration configuration)
    {
        _logger = logger;
        _configuration = configuration;
    }

    // Implementation details...
}

// Register and use the filter
hostBuilder.AsSuperSocketHostBuilder<TextPackageInfo, MyPipelineFilter>();

To set up an MCP server over HTTP, use the SuperSocketHostBuilder with McpHttpRequest and McpHttpPipelineFilter. Use .UseMcpCommands(serverInfo) to register the standard MCP command set. The command registration logic is identical to the TCP implementation, allowing for code reuse across different transports.

using SuperSocket.MCP.Extensions;
using SuperSocket.MCP.Models;
using SuperSocket.Server.Host;

var serverInfo = new McpServerInfo
{
    Name = "MyMcpHttpServer",
    Version = "1.0.0"
};

var host = SuperSocketHostBuilder.Create<McpHttpRequest, McpHttpPipelineFilter>()
    .UseMcpCommands(serverInfo)  // Same command registration
    .ConfigureAppConfiguration((hostCtx, configApp) =>
    {
        configApp.AddInMemoryCollection(new Dictionary<string, string>
        {
            { "serverOptions:name", "McpHttpServer" },
            { "serverOptions:listeners:0:ip", "Any" },
            { "serverOptions:listeners:0:port", "8080" }
        });
    })
    .Build();

await host.RunAsync();

To implement real-time data streaming via SSE, check if a request is an SSE request using request.IsSSERequest(). You can then start an SSE stream using session.StartSSEAsync(), which returns a ServerSentEventWriter. Use this writer to send events, JSON payloads, or start an automatic heartbeat to keep the connection alive.

.UsePackageHandler(async (session, request) =>
{
    if (request.Path == "/events" && request.IsSSERequest())
    {
        // Start SSE stream
        var sseWriter = await session.StartSSEAsync();
        
        // Send events
        await sseWriter.SendEventAsync("Hello SSE!", "greeting");
        await sseWriter.SendJsonEventAsync("{\"type\": \"data\", \"value\": 42}");
        
        // Start automatic heartbeat
        _ = sseWriter.StartHeartbeatAsync(cancellationToken);
        
        // Send more events as needed...
        await sseWriter.SendCloseEventAsync();
    }
    else
    {
        await session.SendHttpResponseAsync(200, "Use /events for SSE", "text/plain");
    }
})