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:

Add: Um einen Thread hinzuzufügen
Delete: Um einen Thread zu entfernen
Clients (Default) um den Thread eines Clients zu bekommen
IndexOf um den Index zu einem Thread zu bekommen
Count um die Anzahl der verbundenen Clients festzustellen
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]