idtcpserver - herausfinden was empfangen wird

[scrat1979]

Hallo zusammen,

Ich schicke über einen Client gerade einen String mittels

Delphi-Quellcode:

tcpclient.socket.Writeln('Text');

... und empfange ihn im Server im OnExecute-Ereignis mittels

Delphi-Quellcode:

 RecvString := idTCPServer.AContext.Connection.IOHandler.ReadLn;

Das klappt auch wunderbar. Es ist ja aber auch möglich über andere Write-Befehler beim Client Integer und Streams etc. zu verschicken. Da würde ja meine Routine versagen, da ja nur STrings eingelesen werden. Gibt es eine Möglichkeit vor dem eigentlichen Empfangen zu PRüfen ob gerade ein String, INteger, Stream ankommt und so den entsprechenden Read-Befehl beim SErver zu benutzen?

Danke im Voraus,
SCRaT

[marabu]

Hallo,

Struktur und Umfang des Datenaustauschs regelt ein Protokoll. Was hast du denn vor?

Grüße vom marabu

[Corpsman]

Klar, du kannst generell alles versenden.

Mein Balanced versendet mit dieser Methode die Levels für die Multiplayer ( zum verhindern des Cheatens ... )


Dieses Sample was ich aber nur aus nem anderen Sample zusammengestelt habe versendet z.b. Dateien.

[alias5000]

Hi
Narses hat im DF zu Protokollen in der Anwendungsschicht einige Tutorials geschrieben, die ich nicht schlecht finde. Wenn du sie noch nicht kennst findest du hier den Einstieg: http://www.delphi-library.de/topic_60744.html

Gruß
alias5000

[scrat1979]

Danke Euch,

ich werde mich mal mit den Links auseinandersetzen. Ich möchte eben je nach empfangenen Daten (Integer, String, Stream) andere Befehle ausführen.

In Pseudocode:

Delphi-Quellcode:

if empfangene_daten = string dann mache dies...
if empfangene_daten = integer dann mache jenes...

SCRaT

[alias5000]

das sollte ohne weiteres nicht unbedingt möglich sein. Weil du versendest ja im Prinzip nur bits und bytes. Integer oder string ist da drauf ja eigentlich nur ne WEise, wie diese empfangenen Daten interpretiert werden. Ich würde dir dringend zu einem (wenn vllcht auch einfachen) Protokoll raten

Gruß
alias5000

[scrat1979]

Zitat:

Zitat von alias5000

das sollte ohne weiteres nicht unbedingt möglich sein. Weil du versendest ja im Prinzip nur bits und bytes. Integer oder string ist da drauf ja eigentlich nur ne WEise, wie diese empfangenen Daten interpretiert werden. Ich würde dir dringend zu einem (wenn vllcht auch einfachen) Protokoll raten

Gruß
alias5000

Das habe ich mir schon gedacht (oder befürchtet). Werde mir mal die o.g. Tutorials anschauen, die sehen schon einmal sehr vielversprechend aus. Die meisten behandeln leider TClientSocket und TServerSocket, ich verwende ja Indy in der Version 10, die ja leider wiederum relativ sehr von der 9'er abweicht. Naja, falls es Probs gibt melde ich mich wieder :-)

SCRaT

[alias5000]

Ein Protokoll, v.a. so, wie es bei dir erfordert wird, sollte nicht allzu schwer sein. Da dürfte ein Terminatorzeichenprotokoll reichen. Und das muss ja nicht 1000 Befehle haben. Ich schreib an nem dezentralen Netzwerkchat mit eigenem Protokoll (LanChat2 TBX) und da sind das nur um die 20 Protokollbefehle. Für einen ganzen Chat! Bei dir sinds dann viel weniger und dann ist es wirklich nciht so aufwendig.

Das Prinzip von nem Terminatorzeichen-Protokoll ist ganz einfach:
irgendeinstring + Terminatorzeichen + nocheinstring + Terminatorzeichen + nocheinstring

in den strings darf dieses Trennzeichen natürlich nicht vorkommen. Außer:
Du hast einen Befehl, der lautet von mir aus DATA. Als Trennzeichen verwende ich jetzt einfach mal "|"
Parameter dieses fiktiven Befehls wären: DATA|Typ|diedaten, also im Anwendungsfall z.B.

"DATA|string|hallo das ist ein string."
Wenn du den string nach dem Trennzeichen zerlegst, kannst du dir ja gleich merken, dass der Befehl DATA nur aus 3 Teilen besteht. Ergo musst du nur die ersten beiden Trennzeichen beachten. Wenn später noch eins kommt, ignorierst du es, weil es in den Bereich "diedaten" gehört.
Dann wäre es auch möglich, den String "hallo|hallo" zu versenden:
"DATA|string|hallo|hallo".

Andere Datentypen, wie integer musst du halt einfach als String behandeln und dann an den Befehlskommand dranklemmen.
Das war jetzt ein ganz kurzer mini-Crashkurs für einen Protokoll-Typ, den ich spontan vorschlagen würde, weil er sicher ein Stückchen einsteiger freundlicher ist. Wenn du das jetzt nicht verstanden hast (ich weiß nicht, ob das so verständlich ist, immerhin kenn ich sowas gut), dann les einfach nochmal in den Tutorials nach.

Gruß
alias5000

[scrat1979]

@alias5000

Danke für den ausführlichen Mini-Crash-Kurs :-) Ich werde mich nachher mal an die Umsetzung eines solchen Protokolles machen... Bei Bedarf melde ich mich dann wieder :thumb:

SCRaT

[Gausi]

Ich klinke mich hier mal ein, weil ich gerade vor dem selben Problem stehe. Ich möchte auch diverse Sachen übermitteln. Ein paar Integer, Strings, aber auch kompliziertere Datenstrukturen oder ganze Dateien. Mein Ansatz wäre, das einfach über Streams zu regeln, die ich versende. Auf der einen Seite wird ein Stream generiert, gesendet und an der anderen Seite nach dem Empfang wieder aufgedröselt. In den Stream würde ich dann einen Header packen, der darüber Aufschluss gibt, was für Daten in dem Stream sind, damit die entsprechend interpretiert werden können. Ist der Ansatz ok, oder kompletter Unsinn? Die Kommunikation würde dann mehr oder weniger komplett über IoHandler.read(aStream) bzw. IoHandler.write(astream) laufen.

[scrat1979]

Zitat:

Zitat von Gausi

Ich klinke mich hier mal ein, weil ich gerade vor dem selben Problem stehe. Ich möchte auch diverse Sachen übermitteln. Ein paar Integer, Strings, aber auch kompliziertere Datenstrukturen oder ganze Dateien. Mein Ansatz wäre, das einfach über Streams zu regeln, die ich versende. Auf der einen Seite wird ein Stream generiert, gesendet und an der anderen Seite nach dem Empfang wieder aufgedröselt. In den Stream würde ich dann einen Header packen, der darüber Aufschluss gibt, was für Daten in dem Stream sind, damit die entsprechend interpretiert werden können. Ist der Ansatz ok, oder kompletter Unsinn? Die Kommunikation würde dann mehr oder weniger komplett über IoHandler.read(aStream) bzw. IoHandler.write(astream) laufen.

Wow, bin ja froh, daß ich nicht der einzige mit diesem Problem bin :-)
Nein, mal im Ernst. Genau die von Dir genannten komplexen Datenstrukturen sind im Endeffekt das Problem. Simple Strings und INtegers kann man ohne weiteres mit den o.g. "Terminatorzeichen-Protokoll" elegant versenden. Nur bei Streams (z.B. Dateien) kommt man da (denke ich zumindest...) schnell an die Grenzen.

SCRaT

[alias5000]

Das wäre dann ein Binärprotokoll ;) siehe Tutorials von Narses ;)

[Gausi]

Joah, das Tutorial habe ich mal angeguckt, aber 100 Seiten sind da doch erstmal abschreckend. Wenn ich richtig sehe, dann behandelt er da ja auch nicht die Indy-Komponenten, die einem wohl viel Arbeit abnehmen. Meine Idee mit den Streams wären irgendwie nur ein paar Zeilen Code:

Delphi-Quellcode:

//Client:
Erstelle Stream
Schreibe ID in Stream
Schreibe Daten in Stream  // Halt so, wie man Daten in Streams speichert. Strings mit ner Längen-Info vornedran etc.
Sende Stream              // Größe des Streams wird auf Wunsch vornedran gepackt
...
//Server:
Empfange Stream
Lese ID aus Stream
Lese Daten aus Stream
verarbeite Daten entsprechend 
erstelle ggf. einen Stream mit der Antwort  
Sende Antwortstream
...
//Client
empfange Antwortstream
verarbeite Antwort
- fertig.

und dass man dann darüber 100 Seiten schreibt, verwirrt mich etwas, deswegen vermute ich bei mir noch irgendeinen Denkfehler. ;-)