CavemanTcp Download - CavemanTcp -Quellcode herunterladen

CavemanTcp

Andere Kategorien

1.0.0

Herunterladen

Alt-Tag

CavemanTcp

CavemanTcp gibt Ihnen die ultimative Kontrolle beim Erstellen von TCP-basierten Anwendungen mit Clients und Servern.

Mit CavemanTcp haben Sie die volle Kontrolle über das Lesen und Schreiben von Daten. CavemanTcp wurde für diejenigen entwickelt, die explizit steuern möchten, wann Daten gelesen oder geschrieben werden, oder eine Zustandsmaschine auf TCP aufbauen möchten.

Wichtig:

Wenn Sie nach einem Paket suchen, das kontinuierlich Daten liest und beim Empfang von Daten Ereignisse auslöst, lesen Sie SimpleTcp: https://github.com/jchristn/simpletcp
Wenn Sie nach einem All-in-One-Paket suchen, das die Zustellung wohlgeformter Nachrichten auf Anwendungsebene übernimmt, sehen Sie sich WatsonTcp an: https://github.com/jchristn/watsontcp

Umgang mit Verbindungsabbrüchen

Da CavemanTcp darauf angewiesen ist, dass die konsumierende Anwendung angibt, wann gelesen oder geschrieben werden soll, gibt es keine Hintergrundthreads, die den Status der TCP-Verbindung kontinuierlich überwachen (im Gegensatz zu SimpleTcp und WatsonTcp). Daher sollten Sie bei der Erstellung Ihrer Apps davon ausgehen, dass während eines Lese- oder Schreibvorgangs möglicherweise eine Ausnahme ausgelöst wird.

Ab v1.3.0 wurde TCP-Keepalive-Unterstützung für .NET Core und .NET Framework hinzugefügt; Leider bietet .NET Standard diese Unterstützung nicht und ist daher nicht für Apps verfügbar, die CavemanTcp verwenden, die auf .NET Standard ausgerichtet sind.

Neu in v2.0.x

Bahnbrechende Veränderungen
Auf Clients wird jetzt durch Guid statt durch string ipPort verwiesen
ListClients gibt jetzt eine Aufzählung von ClientMetadata zurück
Send und Read , die string ipPort verwenden, sind als veraltet markiert
AddClient ist der Verbindungsannahme näher gekommen
Ziel: net461 net472 net48 net6.0 net7.0 und net8.0
Bessere Erkennung von Verbindungsabbrüchen
Deaktivieren Sie den Nagle-Algorithmus standardmäßig

Beispiele

Serverbeispiel

 using CavemanTcp ;

// Instantiate
TcpServer server = new TcpServer ( "127.0.0.1" , 8000 , false , null , null ) ;
server . Logger = Logger ;

// Set callbacks
server . Events . ClientConnected += ( s , e ) => 
{ 
    Console . WriteLine ( "Client " + e . Client . ToString ( ) + " connected to server" ) ;
} ;
server . Events . ClientDisconnected += ( s , e ) => 
{ 
    Console . WriteLine ( "Client " + e . Client . ToString ( ) + " disconnected from server" ) ; 
} ; 

// Start server
server . Start ( ) ; 

// Send [Data] to client at [guid] 
Guid guid = Guid . Parse ( "00001111-2222-3333-4444-555566667777" ) ;
WriteResult wr = null ;
wr = server . Send ( guid , "[Data]" ) ;
wr = server . SendWithTimeout ( [ ms ] , guid , "[Data]" ) ;
wr = await server . SendAsync ( guid , "[Data]" ) ;
wr = await server . SendWithTimeoutAsync ( [ ms ] , guid , "[Data]" ) ;

// Receive [count] bytes of data from client at [guid]
ReadResult rr = null ;
rr = server . Read ( guid , [ count ] ) ;
rr = server . ReadWithTimeout ( [ ms ] , guid , count ) ;
rr = await server . ReadAsync ( guid , [ count ] ) ;
rr = await server . ReadWithTimeoutAsync ( [ ms ] , guid , [ count ] ) ;

// List clients
List < ClientMetadata > clients = server . GetClients ( ) . ToList ( ) ;

// Disconnect a client
server . DisconnectClient ( guid ) ;

Kundenbeispiel

 using CavemanTcp ; 

// Instantiate
TcpClient client = new TcpClient ( "127.0.0.1" , 8000 , false , null , null ) ;
client . Logger = Logger ;

// Set callbacks
client . Events . ClientConnected += ( s , e ) => 
{ 
    Console . WriteLine ( "Connected to server" ) ; 
} ;

client . Events . ClientDisconnected += ( s , e ) => 
{ 
    Console . WriteLine ( "Disconnected from server" ) ; 
} ;

// Connect to server
client . Connect ( 10 ) ;

// Send data to server
WriteResult wr = null ;
wr = client . Send ( "[Data]" ) ;
wr = client . SendWithTimeout ( [ ms ] , "[Data]" ) ;
wr = await client . SendAsync ( "[Data]" ) ;
wr = await client . SendWithTimeoutAsync ( [ ms ] , "[Data]" ) ;

// Read [count] bytes of data from server
ReadResult rr = null ;
rr = client . Read ( [ count ] ) ;
rr = client . ReadWithTimeout ( [ ms ] , count ) ;
rr = await client . ReadAsync ( [ count ] ) ;
rr = await client . ReadWithTimeoutAsync ( [ ms ] , [ count ] ) ;

WriteResult und ReadResult

WriteResult und ReadResult enthalten eine Status , die eines der folgenden angibt:

ClientNotFound – gilt nur für Server-Lese- und Schreibvorgänge
Success – die Operation war erfolgreich
Timeout – der Vorgang ist abgelaufen (reserviert für zukünftige Verwendung)
Disconnected : Der Peer ist nicht verbunden

WriteResult umfasst außerdem:

BytesWritten – die Anzahl der in den Socket geschriebenen Bytes.

ReadResult umfasst außerdem:

BytesRead – die Anzahl der vom Socket gelesenen Bytes.
DataStream – ein MemoryStream der die angeforderten Daten enthält.
Data – eine byte[] -Darstellung von DataStream . Durch die Verwendung dieser Eigenschaft wird DataStream vollständig bis zum Ende gelesen.

Lokale vs. externe Verbindungen

WICHTIG

Wenn Sie 127.0.0.1 als Listener-IP-Adresse angeben, kann dieser nur Verbindungen vom lokalen Host aus akzeptieren.
So akzeptieren Sie Verbindungen von anderen Computern:
- Verwenden Sie eine bestimmte Schnittstellen-IP-Adresse oder
- Verwenden Sie null , * , + oder 0.0.0.0 für die Listener-IP-Adresse (erfordert Administratorrechte, um jede IP-Adresse abzuhören).
Stellen Sie sicher, dass Sie in Ihrer Firewall eine Zulassungsregel erstellen, um eingehende Verbindungen an diesem Port zuzulassen
Wenn Sie eine Portnummer unter 1024 verwenden, sind Administratorrechte erforderlich

Operationen mit Zeitüberschreitungen

Wenn Sie eine der APIs verwenden, die es Ihnen ermöglichen, eine Zeitüberschreitung anzugeben (z. B. SendWithTimeout , SendWithTimeoutAsync , ReadWithTimeout und ReadWithTimeoutAsync ), geben die resultierenden WriteResult und ReadResult wie oben erwähnt an, ob beim Vorgang eine Zeitüberschreitung aufgetreten ist.

Es ist wichtig zu verstehen, was eine Zeitüberschreitung bedeutet und noch wichtiger, was sie nicht bedeutet.

Eine Zeitüberschreitung bei einem Schreibvorgang hat nichts damit zu tun, ob der Empfänger die Daten gelesen hat oder nicht . Es geht vielmehr darum, ob CavemanTcp die Daten in den zugrunde liegenden NetworkStream oder SslStream schreiben konnte oder nicht
Bei einem Lesevorgang tritt eine Zeitüberschreitung auf, wenn CavemanTcp die angegebene Anzahl von Bytes nicht innerhalb der zugewiesenen Anzahl von Millisekunden vom zugrunde liegenden NetworkStream oder SslStream lesen kann
Gültige Werte für timeoutMs sind -1 oder eine beliebige positive Ganzzahl. -1 gibt an, dass kein Timeout vorliegt, und entspricht der Verwendung einer API, die kein Timeout angibt
Achten Sie im Falle einer Zeitüberschreitung genau auf BytesRead oder BytesWritten (wenn Sie gelesen oder geschrieben haben). Die Zeitüberschreitung kann mitten im Betrieb aufgetreten sein und daher ist es wichtig, den Fehler zu beheben.
- Beispielsweise sendet der Server 50.000 Bytes an den Client
- Auf dem Client wurde ein ReadWithTimeout mit einem Zeitlimit von 10 Sekunden initiiert, bei dem versucht wurde, 50.000 Bytes zu lesen
- In diesen 10 Sekunden konnte der Client nur 30.000 Bytes lesen
- Ein ReadResult mit Status == ReadResultStatus.Timeout wird zurückgegeben und die BytesRead Eigenschaft wird auf 30.000 gesetzt
- In diesem Fall warten noch 20.000 Bytes vom Server im zugrunde liegenden NetworkStream oder SslStream des Clients
- Daher wird empfohlen, dass Sie die Verbindung nach einer Zeitüberschreitung zurücksetzen (dies ist jedoch Ihre Entscheidung).

TCP-Keepalives

Ab Version 1.3.0 wurde CavemanTcp Unterstützung für TCP-Keepalives hinzugefügt, hauptsächlich um das Problem zu beheben, dass eine Netzwerkschnittstelle heruntergefahren, das Kabel abgezogen wird oder das Medium aus anderen Gründen nicht mehr verfügbar ist. Es ist wichtig zu beachten, dass Keepalives in .NET Core und .NET Framework unterstützt werden, NICHT jedoch in .NET Standard. Ab dieser Version bietet .NET Standard keine Funktionen für TCP-Keepalives.

TCP-Keepalives sind standardmäßig aktiviert.

 server . Keepalive . EnableTcpKeepAlives = true ;
server . Keepalive . TcpKeepAliveInterval = 5 ;      // seconds to wait before sending subsequent keepalive
server . Keepalive . TcpKeepAliveTime = 5 ;          // seconds to wait before sending a keepalive
server . Keepalive . TcpKeepAliveRetryCount = 5 ;    // number of failed keepalive probes before terminating connection

Einige wichtige Hinweise zu TCP-Keepalives:

Diese Funktion wird durch das zugrunde liegende Framework und Betriebssystem ermöglicht und nicht von dieser Bibliothek bereitgestellt
Keepalives funktionieren nur in .NET Core und .NET Framework
Keepalives können entweder auf dem Client oder auf dem Server aktiviert werden, funktionieren aber im Allgemeinen nur auf dem Server (wird untersucht).
Keepalive.TcpKeepAliveRetryCount gilt nur für .NET Core; Für .NET Framework wird dieser Wert auf 10 erzwungen