SbeServer

SbeServer

public SbeServer(IAuthorization authorization, ITransactionIdStorage transactionIdStorage, string licenseFeatureId, DateTime componentTimestamp, IMessageConverter converter)

sbeServer = SbeServer(authorization, transactionIdStorage, licenseFeatureId, componentTimestamp, converter)

Initialisiert eine neue Instanz von SbeServer.

Authorization

public IAuthorization Authorization { get; }

value = sbeServer.Authorization

Die Kundenauthentifizierung.

ComponentTimestamp

public DateTime ComponentTimestamp { get; }

value = sbeServer.ComponentTimestamp

Komponentenzeitstempel.

Converter

public IMessageConverter Converter { get; }

value = sbeServer.Converter

Nachrichtenkonverter.

LicenseFeatureId

public string LicenseFeatureId { get; }

value = sbeServer.LicenseFeatureId

Lizenz-Feature-ID.

SendOutHeartbeats

public bool SendOutHeartbeats { get; set; }

value = sbeServer.SendOutHeartbeats
sbeServer.SendOutHeartbeats = value

Senden Sie Herzschlag über ausgehende Nachrichten Kanal.

TransactionIdStorage

public ITransactionIdStorage TransactionIdStorage { get; }

value = sbeServer.TransactionIdStorage

ConfigureAcceptedSocket

private void ConfigureAcceptedSocket(TcpClient client)

sbeServer.ConfigureAcceptedSocket(client)

TCP KeepAlive auf einen akzeptierten Client-Sockel anwenden. Keep-alive Sonden halten NAT / Firewall-Flow-Einträge am Leben und Oberfläche tote Peers schnell.

CreateSubscription

protected override SbeServerSubscription CreateSubscription(ClientSbeSession session, string requestId, ServerSubscription subscription, MessageTypes type)

result = sbeServer.CreateSubscription(session, requestId, subscription, type)

GetSessionKey

protected override string GetSessionKey(ClientSbeSession session)

result = sbeServer.GetSessionKey(session)

IsStubSubscription

protected override bool IsStubSubscription(SbeServerSubscription subscription)

result = sbeServer.IsStubSubscription(subscription)

NextResponseId

private static string NextResponseId()

result = SbeServer.NextResponseId()

Generieren Sie eine eindeutige Antwort-ID, die NICHT TransactionIdStorage verschmutzt. Verhindert Kollisionen zwischen servergenerierten Antwort-IDs und von Clients bereitgestellten mdReqIds.

OnClearListenerState

protected override void OnClearListenerState()

sbeServer.OnClearListenerState()

Klarer protokollspezifischer Listener-Zustand (Stop Listener, etc.).

OnProcess

private IAsyncEnumerable<Message> OnProcess(ClientSbeSession session, ushort templateId, byte[] payload, CancellationToken cancellationToken)

result = sbeServer.OnProcess(session, templateId, payload, cancellationToken)

Senden Sie eingehende SBE-Nachricht von templateId.

OnStartListeners

protected override void OnStartListeners(CancellationToken cancellationToken)

sbeServer.OnStartListeners(cancellationToken)

Starten Sie protokollspezifische Listener (TCP, etc.). Fügen Sie Aufgaben zu _backgroundTasks hinzu.

ProcessInMessage

protected override void ProcessInMessage(Message message, CancellationToken cancellationToken)

sbeServer.ProcessInMessage(message, cancellationToken)

Verarbeiten Sie eine eingehende Nachricht und Route zu abonnierten Clients.

ProcessLogout

protected override void ProcessLogout(ClientSbeSession session)

sbeServer.ProcessLogout(session)

ReadFramedMessageAsync

private static Task<byte[]> ReadFramedMessageAsync(Stream stream, CancellationToken cancellationToken)

result = SbeServer.ReadFramedMessageAsync(stream, cancellationToken)

SBE Framing: read [4-Byte Länge][Payload].

ScheduleSessionWork

protected override void ScheduleSessionWork(ClientSbeSession session, ServerSubscription subscription, string requestId, Func<ClientSbeSession, string, CancellationToken, ValueTask<bool>> handler)

sbeServer.ScheduleSessionWork(session, subscription, requestId, handler)

WriteFramedAsync

private ValueTask<bool> WriteFramedAsync(ClientSbeSession session, Func<SbeRecordSerializer, byte[], int> serialize, CancellationToken cancellationToken)

result = sbeServer.WriteFramedAsync(session, serialize, cancellationToken)

Zentraler ausgehender Schreibpfad: Serialisieren Sie die Nachricht in den Session-Schreibpuffer (wachsen und erneutes Ausprobieren, so dass große Frames nicht fallen gelassen werden), dann Frame und senden Sie sie. Der Puffer kann von Int32 neu zugewiesen werden, so dass er nach der Serialisierung erneut gelesen wird.