Home » Tutorials » Netzwerk und Internet » WinSocket-Programmierung

WinSocket-Programmierung

Kommunication mittels SendBuf

Eine weitere Möglichkeit zwischen einem Server und einem Clienten zu kommunizieren ist das versenden von einem Buffer spezifischer Größe. ZB ist es so möglich einen ganzen Record zu verschicken. Wir werden diesmal, aus Einfachheits-Gründen Client und Server in ein einziges Programm packen (ja, das ist möglich!). Wir wollen einen Record, der aus einem String[20] und einem byte besteht verschicken. Hier erstmal der Record:

type
 CustomRec = record
 Text: String[20];
 Zahl: byte;
end;

So sollte unser Record aussehen. Wir wollen, dass unsere Sockets gleich zu Programmstart Verbindung zueinander aufbauen. Das verwiklichen wir indem folgenden Code in die onCreate Prozedure von Form1 schreiben:

begin
 //hierzu sind keine Erläuterungen mehr notwendig
 Client := TClientSocket.Create;
 Server := TServerSocket.Create;
 Server.Port:=10024;
 Client.Port:=10024;
 Client.Host := '127.0.0.1';
 Server.Open;
 Client.Open;
end;

Damit das funktioniert muss Client und Server als GlobalVariable des Typs TClientSocket und TServerSocket deklariert werden! Nun fügt ihr ein MemoFeld, zwei EditFelder und einen Button hinzu. Für das OnClick Ereigniss des Buttons wird folgender Quelltext eingefügt:

//Wir brauchen eine Instanz unseres Records 
var
 Rec: CustomRec;
begin
 //Unserem Record werden Werte zugewiesen
 with Rec do begin
 Text := Edit1.Text;
 //In Edit2 nur Zahlen eingeben!
 Zahl := StrToInt(Edit2.Text));
 end;
 //Unser Record wird verschickt!
 Client.Socket.SendBuf(Rec,sizeof(Rec));
end;

Das hier ist jetzt schon etwas komplizierter als das Versenden eines einfachen Strings. Zuerst weisen wir dem Record Werte zu, die wir aus den EditFeldern entnehmen. Beachtet bitte, dass im Edit2 nur Zahlen stehen, sonst kommt es zu einem EConvertError. Nachdem unserem Record die Werte zugewiesen worden sind, Senden wir den Record mit der Methode function SendBuf(var Buf; Count: Integer): Integer; wobei die Anzahl der tatsächlich geschriebenen Bytes zurück gegeben wird. Das interessiert uns hier aber nichtund deshalb lassen wir die Verarbeitung des Rückgabewertes weg.

Damit wir die gesendeten Daten auch nach dem Empfang wieder einsehen können, müssen wir noch ein OnClientRead Ereigniss für den Server schreiben. Das sieht folgender Maßen aus:

//wieder eine Instanz des Typs CustomRec
var
 Rec: CutomRec;
begin
 //wir holen unseren Record ab...
 ReceiveBuf(Rec,SizeOf(Rec));
 //...und übertragen den Inhalt in das MemoFeld
 with Rec do begin
 Memo1.Lines.Add(Text);
 Memo1.Lines.Add(IntToStr(Zahl));
 end;
end;

Auch hier bitte nicht vergessen dem Ereigniss die Prozedur (siehe SendText) zuzuweisen! Mittels der Funktion ReceiveBuf(var Buffer, Size: Integer) können wir einen einen Buffer beliebiger größe empfangen. Oben haben wir die größe des Buffers mit SizeOf(Rec) ermittelt.
Damit hätten wir auch einen Record verschickt und wieder empfangen. War gar nicht so schwer, oder?