Verwaltung der Clientthreads mit IdTCPServer

[jfheins]

Kurz zur Geschichte:
Ich wollte einen Chat erstellen, an dem mehrere Leute teilhaben können.
Auch nach den Indy-Beispielen war mir die Verwaltung der Clients auf dem Server ein Rätsel.
Also beschloß ich, mir eine Klase zu coden, welche die Clientthread-Verwaltung für mich übernimmt.

Hier ist sie:

Benötigt:
Indys
TIdTCPServer
TIdTCPClient

Sie enthält folgendes:

:arrow: Add: Um einen Thread hinzuzufügen
:arrow: Delete: Um einen Thread zu entfernen
:arrow: Clients (Default) um den Thread eines Clients zu bekommen
:arrow: IndexOf um den Index zu einem Thread zu bekommen
:arrow: Count um die Anzahl der verbundenen Clients festzustellen
:arrow: Broadcast um an alle verbunden Clients einen Record vom Typ TMessageRecord zu schicken
(Letzeres bei Bedarf anpassen)

Eine Nachricht an einen Client senden:

Delphi-Quellcode:

  TClients = class (TObject)
               constructor Create;
              private
               ArrCount: Byte;
               ClArray: Array[1..32] of TIdPeerThread;
               function GetClient (id: integer): TIdPeerThread;
              public
               procedure Add (Thread: TIdPeerThread);
               procedure Delete (id: integer);
               procedure Broadcast (MessageRecord: TMessageRecord);
               function IndexOf (Thread: TIdPeerThread): integer;
               property Count: Byte read ArrCount;
               property Clients[id: integer]: TIdPeerThread read GetClient; default;
             end;

var
  Form1: TForm1;
  clients: TClients;
 
implementation

{$R *.dfm}

constructor TClients.Create;
var
  i: Byte;
begin
  inherited Create;
  ArrCount := 0;
  for i := 1 to 32 do ClArray[i] := nil ;
end;

function TClients.GetClient (id: integer): TIdPeerThread;
begin
  Result := nil;
  if (id < 1) or (id > 32) then exit;
  Result := ClArray[id];
end;

procedure TClients.Add (Thread: TIdPeerThread);
var
  i: Byte;
begin
  for i := 1 to 32 do
  begin
    if ClArray[i] = nil then
    begin
     ClArray[i] := Thread;
     inc (ArrCount);
     exit;
    end;
  end;
end;

procedure TClients.Delete (id: integer);
var
  i: Byte;
begin
  if (id < 1) or (id > 32) or (ClArray[id] = nil) then exit;

  ClArray[id] := nil;
  dec (ArrCount);

  for i := id to 32 do
  begin
    if ClArray[i] <> nil then ClArray[i-1] := ClArray[i];
  end;
end;

procedure TClients.Broadcast (MessageRecord: TMessageRecord);
var
  i: Byte;
begin
  for i := 1 to 32 do
  begin
    try
      if ClArray[i] <> nil then ClArray[i].Connection.WriteBuffer(MessageRecord, SizeOf(MessageRecord), True);
    except
    end;
  end;
end;

function TClients.IndexOf (Thread: TIdPeerThread): integer;
var
  i: Byte;
begin
  Result := 0;
  if (Thread = nil) then exit;
  for i := 1 to 32 do
  begin
    if ClArray[i] = Thread then
    begin
      Result := i;
      break;
    end;
  end;
end;

Die Maximale Anzahl von Clients beträgt hier 32, bei Bedarf einfach überall die 32 ersetzen.

[edit=Chakotay1308]Von jfheins korrigierte Version eingefügt. Mfg, Chakotay1308[/edit]
[edit=Matze]Code formatiert. Mfg, Matze[/edit]