Indy TCPServer -> Client

[Neutral General]

Ich bekomme es beim besten Willen nicht hin vom Server eine Nachricht an den Client zu schicken :roll:

Mein Server :

Delphi-Quellcode:

unit mbknet;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, IdTCPServer, IdBaseComponent, IdComponent, IdTCPConnection,
  IdTCPClient, StdCtrls;

type
  TForm1 = class(TForm)
    IdTCPServer1: TIdTCPServer;
    Edit1: TEdit;
    Button1: TButton;
    Button2: TButton;
    IdTCPClient1: TIdTCPClient;
    procedure FormCreate(Sender: TObject);
    procedure IdTCPServer1Execute(AThread: TIdPeerThread);
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  IDTCPServer1.Active := true;
end;

procedure TForm1.IdTCPServer1Execute(AThread: TIdPeerThread);
begin
  with AThread.Connection do
  begin
    WriteLn('Hello from Basic Indy Server server.');
    end;
end;

end.

Mein Client

Delphi-Quellcode:

unit mbknet_client;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, IdBaseComponent, IdComponent, IdTCPConnection, IdTCPClient,
  StdCtrls, ExtCtrls, IdTCPServer;

type
  TForm1 = class(TForm)
    IdTCPClient1: TIdTCPClient;
    Button1: TButton;
    Edit1: TEdit;
    Edit2: TEdit;
    Button2: TButton;
    Timer1: TTimer;
    IdTCPServer1: TIdTCPServer;
    IdTCPClient2: TIdTCPClient;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure Timer1Timer(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
IDTCPClient1.Host := Edit1.Text;
 with IDTCPClient1 do begin
    Connect;
    Caption := ReadLn;
  end;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  IDTCPClient1.WriteLn('HALLO SERVER'); // kläglicher versuch an den Server eine Nachricht zu senden
end;

procedure TForm1.Timer1Timer(Sender: TObject);
begin
  if IDTCPClient1.Connected then
  Form1.Caption := IDTCPClient1.ReadLn()  // kläglicher Versuch Nachrichten vom Server zu empfangen
end;

end.

Das Meiste ist aus einem Tutorial übernommen... bis auf das was nicht funktioniert :mrgreen:
Wobei ich das aus dem Tutorial wohl verstehe... Ich komme nur nicht mehr weiter :(

[SirThornberry]

kommt die Nachricht denn beim Server an? und hast du mal versucht die Nachricht im OnExecute des Clients abzufragen?

[Neutral General]

Das einzigste was ankommt ist

Delphi-Quellcode:

WriteLn('Hello from Basic Indy Server server.');

beim Client.
Und der Client hat gar kein OnExecute-Ereignis.
Außerdem wird soweit ich weiß OnExecute nur beim Verbinden ausgeführt.

[SirThornberry]

jetzt bin ich verwirrt, erst schreibst du

Zitat:

Ich bekomme es beim besten Willen nicht hin vom Server eine Nachricht an den Client zu schicken

und dann schreibst du das

Zitat:

WriteLn('Hello from Basic Indy Server server.');

beim client ankommt. Das heißt doch aber das die nachricht vom Server doch an den Client geschickt wurde

Zum OnExecute

Zitat:

OnExecute is an event handler for TIdServerThreadEvents. OnExecute occurs when a TIdPeerThread attempts to perform the TIdPeerThread.Run method. OnExecute receives AThread as a parameter, representing the TIdPeerThread thread that will be started.

[jfheins]

TIdTCPServer.Execute() wird immer ausgeführt, wenn es was zu tun gibt. Dass kann ein vonnect sein, das kann aber auch eine nachricht sein ;)

Und was den Client angeht: der muss immer in einer Schleife ein ReadLn() machen, damit er Nachrichten bekommt.

Du müsstest z.B. dem Client über AThread.Connection.WriteLn() direkt eine antwot sen den können ;)

[Neutral General]

Ja danke !!
Ich glaube ich habs raus :)

[prinz_inzide]

am besten bringste die schleife in nem eigenen thread unter!

[Neutral General]

Naja sagen wir ich habs zur hälfte raus :mrgreen:
Ich kann zwar jetzt dem Server Nachrichten senden aber der Server nicht dem Clienten.
Außer halt direkt bei OnExecute. Aber das bringt mir bei einem Chat nichts. Da sollen ja Nachrichten geschickt werden wenn der Benutzer es will.

Der Server kann nun so Nachrichten empfangen :

Delphi-Quellcode:

procedure TForm1.IdTCPServer1Execute(AThread: TIdPeerThread);
begin
  with AThread.Connection do
  begin
   WriteLn('Hello from Basic Indy Server server.');
   Form1.Caption := ReadLn;
  end;
end;

Der Client kann einfach so

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
begin
  IDTCPClient1.WriteLn('HALLO SERVER');
end;

dem Server eine Nachricht schicken, die auch ankommt.
Aber gibt es keine Möglichkeit vom Server dem Clienten eine Nachricht zu schicken auf ButtonClick ?

[mschaefer]

Moin, moin,

also Indy ist eigentlich nicht mein Gebiet, aber wie ist es denn wenn Du auf beiden Seiten
jeweils Client und Server ins Formular nimmst?

Grüße // Martin

[Neutral General]

Ja ich denke das würde gehen aber geht es nicht anders ?
Im Notfall würde ich das machen ...

[Arnulf]

Also Indy TCP ist auch nicht gerade meines :).

1. beim connecten speicherst du dir then thread in eine liste und damit kannst du wieder auf die verbindung zugreifen ( die methode ist eigentlich schlecht, weil der thread beim disconnecten zerstört wird und es leicht zu fehlern kommen kann - auch bei socket errors könnte es hier zu problemen kommen).

2. normalerweise haben diese threads .data eigenschaften wo eben userdaten gespeichert werden.
Das ist thread sicher - heißt wenn der thread (connection) beendet wird, sind auch die daten weg - und es kommt nicht so leicht zu ner access violation .... Damit kannst aber leicht erkennen welcher user hinter dem Thread (connection) steht.

Indy ist da soweit ich mich erinnere nicht ganz so komfortabel wie tserversocket also mußt du dir die funktionen glaub ich selbst basteln ( ich hab auf die schnelle keine funktion gefunden die dir alle threads auflisten würde ).

Das bedeutet du mußt bei indy vermutlich wirklich eine liste aller aktiven threads führen - doof eigentlich.
Und jedesmal wenn ein connect kommt einen neuen eintrag auf der liste machen - wenn ein disconnect kommt den eintrag löschen (und am bessten die liste zusammenschieben).
Und auf jeden fall alles in try except blöcke weil sonst stürtzt dir das ding nur noch ab :).
In der onError solltest du ebenfalls schauen, daß du fehlerhafte sockets zu bekommst und auch die liste aktuell hältst.

Arnulf

[hardy1234]

Zitat:

Zitat von Neutral General

Ja ich denke das würde gehen aber geht es nicht anders ?
Im Notfall würde ich das machen ...

Das mit dem Server beim Client lass mal, das wird nix. Gesetzt den Fall du wolltest das Ding im Inet betreiben und sitzt hinter nem router(gilt natürlich auch für andere User), würdest du durch den router durch keine Connection zu deinem Server(dem beim Client hinkriegen. Der router sperrt i.d.R. jeden Zugang von außen.

Nun zum problem mot dem lesen beim Client. Die beste und auch einfachste Lösung ist es, einen Timer zu benutzen. 300ms haben sich als praktikabler Wert erwiesen. Den initialisiertst du, bevor du den Client-Connect durchführst.
Das sieht als Code etwa so aus:

Delphi-Quellcode:

{/////////////////////////////////////////}
{*** data available and read/send data ***}
{/////////////////////////////////////////}

function NetworkDataAvailable(ACon: TIdTCPConnection): boolean;
begin
  RWSynchro.BeginRead; {*** darf auch TCriticalSection sein ***}
  if ACon.Connected then begin
    Result := ACon.InputBuffer.Size > 0;
    if not Result then begin
      try
        ACon.ReadFromStack(False, 1, False);
        Result := ACon.InputBuffer.Size > 0;
      except
        Result:= false;
      end;
    end; // of if not Result then begin
  end // of if ACon.Connected then begin
  else Result := False;
  RWSynchro.EndRead;
end; // of function NetworkDataAvailable(ACon: TIdTCPConnection): boolean

procedure TChatClt.LookForData(Sender: TObject);
begin
  if FTCPClient.Connected then begin
    FDataAvailable:= NetworkDataAvailable(FTCPClient);
    if FDataAvailable then DoReceiveData;
  end; // of if FTCPClient.Connected then begin
end; // of procedure TChatClt.LookForData(Sender: TObject)

procedure TChatClt.DoReceiveData(Sender: TObject);
var
  FStream: TMemoryStream;
begin
  FStream:= TMemoryStream.Create;
  {*** hier daten einlesen, am prakikabelsten ist ein stream ***}
  {*** dann können auch verschlüsselungen benutzt werden     ***}
  {*** Bsp.: ***}
  FTCPClient.ReadStream(FStream, -1, false);
  {*** ab hier verarbeiten ***}
end;

[Neutral General]

Zitat:

Zitat von hardy1234

Zitat:

Zitat von Neutral General

Ja ich denke das würde gehen aber geht es nicht anders ?
Im Notfall würde ich das machen ...

Das mit dem Server beim Client lass mal, das wird nix. Gesetzt den Fall du wolltest das Ding im Inet betreiben und sitzt hinter nem router(gilt natürlich auch für andere User), würdest du durch den router durch keine Connection zu deinem Server(dem beim Client hinkriegen. Der router sperrt i.d.R. jeden Zugang von außen.

Nun zum problem mot dem lesen beim Client. Die beste und auch einfachste Lösung ist es, einen Timer zu benutzen. 300ms haben sich als praktikabler Wert erwiesen. Den initialisiertst du, bevor du den Client-Connect durchführst.
Das sieht als Code etwa so aus:

Delphi-Quellcode:

{/////////////////////////////////////////}
{*** data available and read/send data ***}
{/////////////////////////////////////////}

function NetworkDataAvailable(ACon: TIdTCPConnection): boolean;
begin
  RWSynchro.BeginRead; {*** darf auch TCriticalSection sein ***}
  if ACon.Connected then begin
    Result := ACon.InputBuffer.Size > 0;
    if not Result then begin
      try
        ACon.ReadFromStack(False, 1, False);
        Result := ACon.InputBuffer.Size > 0;
      except
        Result:= false;
      end;
    end; // of if not Result then begin
  end // of if ACon.Connected then begin
  else Result := False;
  RWSynchro.EndRead;
end; // of function NetworkDataAvailable(ACon: TIdTCPConnection): boolean

procedure TChatClt.LookForData(Sender: TObject);
begin
  if FTCPClient.Connected then begin
    FDataAvailable:= NetworkDataAvailable(FTCPClient);
    if FDataAvailable then DoReceiveData;
  end; // of if FTCPClient.Connected then begin
end; // of procedure TChatClt.LookForData(Sender: TObject)

procedure TChatClt.DoReceiveData(Sender: TObject);
var
  FStream: TMemoryStream;
begin
  FStream:= TMemoryStream.Create;
  {*** hier daten einlesen, am prakikabelsten ist ein stream ***}
  {*** dann können auch verschlüsselungen benutzt werden     ***}
  {*** Bsp.: ***}
  FTCPClient.ReadStream(FStream, -1, false);
  {*** ab hier verarbeiten ***}
end;

Ui... das haut mich um^^ Ich weiß nicht wirklich was damit anzufangen weil ich kaum was davon verstehe :(

[jfheins]

Schau dir auch mal die Indy-Demos an, da sihst du ja, wies funktioniert ;)

[hardy1234]

Ui... das haut mich um^^ Ich weiß nicht wirklich was damit anzufangen weil ich kaum was davon verstehe :([/quote]

Na dann. Zunächst baust du dir mal ein Objekt mit dem schönen Namen TChatClient oder eben wie im Bsp. TChatClt. Etwa so:

Delphi-Quellcode:

uses
  SysUtils, Classes, DateUtils, IdTCPClient;

type

  TChatClient = class(TObject)
  private
    FTCPClient    : TIdTCPClient;
    FReadDataTimer: TTimer;

    procedure LookForData(Sender: TObject); {*** das ding ist für den timer ***}
    procedure DoReadData(Sender: TObject);  {*** das ding liest deine daten vom TCPClient ***}
   
    procedure SendDataToServer(strm: TSteam);
 
  public

    constructor Create;  {*** weil von TObject abgeleitet ohne Owner und override ***}
    destructor  Destroy; {*** desgleichen ***}

    function InitTcpClient(Ahost: string; Aport: integer): boolean; {*** den Client initilisieren ***}

    // hier die methoden zum versenden von daten deklarieren
    // die bauen den Stream zusammen und senden der SendDataToServer zum Chat-Server
    // der kümmert sich dann um die weiterleitung zu dem oder den Empfängern

    procedure SendClientLogin;
    procedure SendChatMessage(Receiver, Msg: string); 
      {*** Bsp: Receiver := 'Paul;Paula;Paulaner;Paulinchen'; ***}
      {*** liest man natürlich per programm-funktion ein ***}
      {*** Im Stream könnte man die User zum Bespiel mit dem Feld:
           '@User' gefolgt von '#len' für die Datenlänge, das sind Feldnamen.
           Nach '#len' trägt man per Stream.WriteBuffer(length(Receiver), SizeOf(integer));
           die stringlänge der Receiverliste ein. Das liest man dann mit nem Scanner vom Stream
           wieder ein:
           Bsp.:
           while (Stream.Position < Stream.Size) do begin
             Stream.ReadBuffer(c, SizeOf(Char));
             case c of
               '@': inc(Stream.Position, 4); // Position auf '#' setzen
               '#': begin
                      inc(Stream.Position, 3);
                      Stream.ReadBuffer(StrLen, SizeOf(integer));
                      SetLength(UserList, StrLen);
                      Stream.ReadBuffer(UserList[1], StrLen); // 
               end; // get Listlength    
             end;
           end;
       ***}

  end; // of TChatClient

var
  ChatClient: TChatClient;

iplementation

constructor TChatClient.Create;
begin
  inherited Create;
  FTCPClient    := TIdTCPClient.Create(nil);
  FReadDataTimer:= TTimer.Create(nil);
  FReadDataTimer.Interval:= 300;
  FReadDataTimer.OnTimer := LookForData;
  FReadDataTimer.Enable  := false;
end; // of constructor TChatClient.Create

// jetzt den Client initialisieren

function TChatClient.InitTcpClient(Ahost: string; Aport: integer): boolean;
begin
  FTCPClient.Host:= Ahost;
  FTCPClient.Port:= Aport;
  FTCPClient.Connect;
  Result:= FTCPClient.Connected;
  if Result then begin
    // wenn noch mehr zu initialisieren dann hier

    FReadDataTimer.Enable:= true;  
    {*** ab jetzt läuft der Timer und ruft ***}
    {*** in regelmäßigen Abständen LookForData auf ***}
    {*** wenn Daten da sind ruft LookForData DoReadData auf und du hast deine Daten zur Verfügung ***}
  end;
end; // of function TChatClient.InitTcpClient(host: string; port: integer): boolean

Nun bindest du die Unit in den jeweiligen Modulen ein, in den denen Daten empfangen werden könnten oder Aufrufe von ChatClient nötig sind.

Das war jetzt Stoff für das 2 Semester Informatik. Viel Spaß damit, hoffentlich hilft es...

[Neutral General]

Zitat:

Das war jetzt Stoff für das 2 Semester Informatik. Viel Spaß damit, hoffentlich hilft es...

omg kein Wunder das ich das nicht verstehe :D
Naja dann wende ich dann mal die böse Methode copy&paste&nixverstehen an :mrgreen:
wobei ich befürchte das ich zumindest ansatzweise verstehen muss, weil ichs sonst nicht anzuwenden weiß ...

[hardy1234]

Zitat:

Zitat von Neutral General

Zitat:

Das war jetzt Stoff für das 2 Semester Informatik. Viel Spaß damit, hoffentlich hilft es...

omg kein Wunder das ich das nicht verstehe :D
Naja dann wende ich dann mal die böse Methode copy&paste&nixverstehen an :mrgreen:
wobei ich befürchte das ich zumindest ansatzweise verstehen muss, weil ichs sonst nicht anzuwenden weiß ...

Es soll da bei Delphi so ne hübsche Einrichtung namens Debugger geben. Da baut man sich dann halt nen kleinen Client und sendet Daten und den Server untersucht man mit dem Debugger. Dat geiht. Dann siehste Du schon wie das abläuft. Ich würde Dir aber raten lieber die UDP-Compos von Indy zu nehmen. Dann brauchst Du beim Server den Feetz mit dem Execute und Connect/Disconnect nicht machen. Um die Verbindung zu testen kan man ja zur not eine normale TCP-Komponente auf nem anderen Port verwenden. Dann weiß man ob der Server da ist.