Hi!

Ich benutze Indy 9 und will einen Client-Server-Chat programmieren.
(mit TidTCPClient und TidTCPServer)
Anmeldung funktioniert schonmal.
Ich möchte aber bei der Anmeldung den AThread bei Server.OnExecute irgentwie einem Recordfeld zuweisen.
Das könnte ich mir als Zeiger (vielleicht zu unsicher) oder einfach nur als Integer mit dem Index vom Thread.
Im Forum sagen viele sie machen eine Liste und sowas würde ich auch gerne, aber ich sehe keine Lösung um den Thread wieder zufinden.

Also ich möchte das der Client was zum Server sendet, der wertet aus und schickt es an den Clienten X weiter. Wie bekomme ich also den Thread zum Clienten X? Am besten so was, was auch im OnExecute funktioniert, aber ich stelle keine Ansprüche
Das senden zum Server ist kein Problem.

Ich denke mal das das Problem sehr allgemein ist und das Problem wahrscheinlich eher logischem Ursprung, deswegen keine Quelltext von mir.

halinchen

In etwa so? (entnommen dem IndyChat-Demo)

zusammenfalten · markieren

Delphi-Quellcode:

procedure TfrmMain.tcpServerExecute(AThread: TIdPeerThread);
var
  Client : TSimpleClient;
  Com, // System command
  Msg : String;
 begin
{ Get the text sent from the client }
  Msg := AThread.Connection.ReadLn;
{ Get the clients package info }
  Client := Pointer(AThread.Data);
{ Check to see if the clients name has been assigned yet }
  if Client.Name = 'Logging In' then
    begin
    { if not, assign the name and announce the client }
      Client.Name := Msg;
      UpdateClientList;
      BroadcastMessage('System', RipName(Msg) + ' has just logged in.');
      AThread.Connection.WriteLn(memEntry.Lines.Text);
    end
  else
  { If name is set, then send the message }

  if Msg[1] <> '@' then
    begin
    { Not a system command }
       BroadcastMessage(RipName(Client.Name), Msg);
    end
  else
    begin
    { System command }
      Com := UpperCase(Trim(Copy(Msg, 2, Pos(':', Msg) -2)));
      Msg := UpperCase(Trim(Copy(Msg, Pos(':', Msg) +1, Length(Msg))));
      if Com = 'CLIENTS' then
        AThread.Connection.WriteLn( '@' + 'clients:' +
                                    lbClients.Items.CommaText);
   ...

Die Klasse TSimpleClient sieht dabei so aus:

markieren

Delphi-Quellcode:

type
  TSimpleClient = class(TObject)
    DNS,
    Name : String;
    ListLink : Integer;
    Thread : Pointer;
  end;

Danke für deine Hilfe.

Die Beispiele von Indy hab ich mir heruntergeladen, aber leider nicht zum laufen bekommen. (es fehlen ein paar Komponenten)
Ich denke nicht das darin die Lösung zu meinem Problem liegt. Der Server von den Beispielen schickt glaube ich an alle Clienten die Nachricht.
Ich erklär das nochmal:
15 Clienten sind mit dem Server verbunden. Client 1 will Client 2 eine Nachricht schicken --> er sendet die nachricht an den Server mit dem Empfänger in den Daten. Der Server überprüft nun den Namen und will Client 2 die Nachricht schicken. Er weiß aber nicht welchen Thread er nehmen muss, dass die Nachricht auch bei dem richtigen ankommt.

Ich hab in der DP gelesen das in Server.Threads alle Leitungen drin stehen und es für jeden Clienten einen Thread gibt.

zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var i: integer;
    LThreads: TList;
begin
  LThreads := IdTCPServer1.Threads.LockList;
  try
    for i := 0 to LThreads.Count - 1 do
    begin
      with TIdPeerThread(LThreads[i]) do
      begin
        WriteLn('Hallo Client');
      end;
    end;
  finally
    IdTCPServer1.Threads.UnlockList;
  end;
end;

Müsste ich dann auf den Thread x zugreifen. Allerdings weiß ich im OnExecute-Erreignis nicht, welchen Index dieser Thread hat.

(Das alles hab ich von guste hier)

Ich will aber nun nur nicht an alle sondern an einen speziellen senden, und dafür brauch den Index (oder sonstirgentwas ) des Threads.

Ich denke ich müsste irgentwie den Index herausbekommen, oder eine besondere Eigenschaft finden, die bei jedem Thread anders ist (das wäre ja wieder der Index).

//Edit: Falls deine Lösung doch mein Problem löst, sag es mir bitte. Dann hab ich Tomaten auf den Augen .

Ich glaube aber , das in dem Code aus dem IndyChat schon die Lösung steckt.
Es gibt da nämlich auch die Möglichkeit, vom Server eine Nachricht an einen ausgewählten Client zu schicken:

zusammenfalten · markieren

Delphi-Quellcode:

procedure TfrmMain.btnPMClick(Sender: TObject);
var
  Msg : String;
  Client : TSimpleClient;
begin
  Msg := InputBox('Private Message', 'What is the message', '');
  Msg := Trim(Msg);
  Msg := edSyopName.Text + '> ' + Msg;
  if (Msg <> '') and
     (lbClients.ItemIndex <> -1) then
    begin
      Client := Clients.Items[lbClients.ItemIndex];
      TIdPeerThread(Client.Thread).Connection.WriteLn(Msg);
    end;
end;

Entscheidend ist hier die Zuweisung an die Klasse TSimpleClient (über einen String aus der Stringlist lbClients) und das Identifizieren des Threads über Client.Thread.
Das müßte doch ein Ansatz für Dein Problem sein, Du bräuchtest eigentlich nur noch die richtige Zuweisung.

Ich glaube jetzt versteh ich was du meinst.
So wie es aussieht haben die Clients in der ListBox genau den selben Index wie die Threads.

Ich guck mir auf jeden Fall das Indy-Demo nochmal an. Mal sehen ob sich die fehlende Komponente auffinden lässt (Wenn es läuft versteh ich fremden Text besser ).

Danke für deine Hilfe!

Hi,

ich benutze immer die Eigenschaft .Data vom TIdPeerThread.

Data ist vom Typ TObject, d.h. man kann dort alles ablegen,
und über Data auf den entsprechenden Thread suchen und wieder finden.
Um einen bestimmten Client zu finden muss man nur wie folgt vorgehen :

zusammenfalten · markieren

Delphi-Quellcode:

Var tmpList : TList;
    i : Longint;
    tmpClient : TClientData; // der Typ den Ihr zum identifizieren des Clients braucht(z.B. String, Longint, Record)
begin
  tmpList := myIndySerer.Threads.Locklist;
  try
    for i := 0 to tmpList.Count - 1 do begin
      if Assigned(tmpList[i]) then begin
        try
          tmpClient := TClientData(tmpList[i]);
        except
          tmpClient := nil;
        end;
        if Assigned(tmpClient) then begin
          if tmpClient.Ident = sSearchIdent then begin
            // gefunden
            break; // Suche abbrechen
          end;
        end;
      end;
    end;
  finally
    myIndyServer.Threads.unlockList;
  end;
end;

Greetz DataCool

Hi!

Danke für deine Nachricht.

Ich mach jetzt auch fast das selbe: (Wie bei den Indy-Demo, bischen abgucken schadet nicht )
Ich hab meine Klasse TSimpleClient mit allen Daten und davon ein TList. Und in TidPeerThread.Data schreibe ich den Pointer auf meine Klasse. Somit kann ich problemlos Daten ändern und die sind überall aktuell.