Sgcwebsockets Dotnet Protocols

sgcWebSockets .NET Subprotocols

The subprotocols that ship with the library, each a matching client and server pair. Unlike the message-broker skill, there is no external broker here: the server component is the broker, and both ends come from this assembly.

Read sgcwebsockets-dotnet first. Every component here attaches to a transport, clients through Client and servers through Server, and the transport is what listens or connects.

When to use this skill

• Publish and subscribe over channels between your own client and server
• Stream a file from one end to the other
• Track who is on a channel, and let members invite each other
• Encrypt messages end to end so the server cannot read them
• Talk WAMP v1 or consume a Lightstreamer feed

Components in this skill

Note the casing: the .NET class is TsgcWSPServer_Broker with a capital B, while the Delphi component is TsgcWSPServer_broker. C# is case sensitive, so the .NET spelling is the one that compiles. concepts/coverage.md in the sgcwebsockets-dotnet skill records the divergence.

Before you start, ask the developer

Use a structured question tool if your host has one, for example Claude Code's AskUserQuestion. Otherwise ask in chat:

1. Do both ends belong to you? These protocols are sgc-specific. A browser or a third-party client will not speak them without the matching JavaScript the product ships.
2. Publish/subscribe or request/response? TsgcWSPClient_sgc does both, through Publish/Subscribe and through RPC, and they have different failure modes.
3. Does the server need to read the messages? If yes, E2EE is the wrong tool: the point of it is that the server cannot.
4. How large are the files? File transfer over a WebSocket connection competes with everything else on that connection.

Quickstart, publish and subscribe

using esegece.sgcWebSockets;

var client = new TsgcWebSocketClient();
client.Host = "127.0.0.1";
client.Port = 5000;

var sgc = new TsgcWSPClient_sgc();
sgc.Client = client;

client.OnConnect += (TsgcWSConnection connection) =>
    sgc.Subscribe("prices");

client.Active = true;

// later, from anywhere
sgc.Publish("BTC 65000", "prices");

Publish sends to the channel's subscribers. Broadcast sends to everyone. RPC(idMethod, method, params) calls the other end and Notify(method, params) is the fire-and-forget form. StartTransaction, Commit and RollBack group publishes on a channel.

The server side is the mirror: create TsgcWSPServer_sgc, set its Server to a TsgcWebSocketServer, and start the server.

End-to-end encryption, and what it costs

TsgcWSPClient_E2EE and TsgcWSPServer_E2EE encrypt so the server relays ciphertext it cannot read. GenerateIdentityKeyPair, CreateGroup, JoinGroup, LeaveGroup and SendDirectMessage are the surface.

The consequence is the one people miss: the server cannot filter, log, search or moderate what it cannot read, and it cannot help a user who has lost a key. If the application needs any of that, E2EE is the wrong layer and channel-level authorisation on the server is the right one.

Things that catch people out

• The protocol component is not the connection. Start the transport, not the protocol.
• One transport carries one protocol. Two protocol components on one client is the usual cause of a handshake failing.
• Subscribe on the file protocol takes a channel and a guid. It is not the same signature as the pub/sub Subscribe, and the type pages show both.
• A subscription lives on the connection. After a reconnect it has to be made again, which is why subscribing inside OnConnect rather than after Active = true is the pattern that survives a dropped network.
• Presence tells you who is on a channel, not who is authorised to be. The server decides that, in OnBeforeSubscription.
• TsgcWSPServer_Broker is a server-only component. There is no matching client: the pub/sub client talks to it.

Routing

• API detail: reference/api/<Component>.md has the properties, events and methods, each with its C# signature.
• Option / enum / delegate types: property and event types link to reference/types/<TypeName>.md.
• Examples: examples/<Component>.md is a trimmed snippet from the shipped demo; examples/index.md maps every component to its demo.
• Getting started: concepts/overview.md covers the single using, the target frameworks and the naming.

What is documented

Public instance properties, events and methods declared anywhere in the library's own class chain. Members inherited from the .NET base classes are left out, as are internals, so a page shows the surface a caller writes against and nothing else.

If a component you need is not here, read concepts/coverage.md in the sgcwebsockets-dotnet skill before assuming a different name for it. This assembly carries fewer components than the Delphi library, and saying so is more useful than guessing an API that does not exist.