Indy TCPServer -> Client

[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...