Hey,

folgendes Problem:

zusammenfalten · markieren

Delphi-Quellcode:

program ClientSocketTest;

uses
  Windows, ScktComp, SysUtils, Classes;

type
  TTCPThread = class(TThread)
  private
    procedure DoConnect;
  public
    Client: TClientSocket;
    procedure Execute; override;
  end;

  TTCPObject = class(TObject)
  private

  public
    Client: TClientSocket;

    procedure OnConnect(Sender: TObject; Socket: TCustomWinSocket);
    procedure OnDisconnect(Sender: TObject; Socket: TCustomWinSocket);
    procedure OnRead(Sender: TObject; Socket: TCustomWinSocket);
    procedure OnError(Sender: TObject; Socket: TCustomWinSocket;
      ErrorEvent: TErrorEvent; var ErrorCode: Integer);

    constructor Create;
    destructor Destroy; override;
    procedure StartConnecting;
  end;

constructor TTCPObject.Create;
begin
  inherited;
  Client := TClientSocket.Create(nil);
  Client.OnConnect := OnConnect;
  Client.OnDisconnect := OnDisconnect;
  Client.OnRead := OnRead;
  Client.OnError := OnError;
  Client.Host := 'localhost';
  Client.Port := 6000;
end;

destructor TTCPObject.Destroy;
begin
  Client.Free;
  inherited;
end;

procedure TTCPObject.OnConnect(Sender: TObject; Socket: TCustomWinSocket);
begin

end;

procedure TTCPObject.OnDisconnect(Sender: TObject; Socket: TCustomWinSocket);
begin

end;

procedure TTCPObject.OnError(Sender: TObject; Socket: TCustomWinSocket;
  ErrorEvent: TErrorEvent; var ErrorCode: Integer);
begin

end;

procedure TTCPObject.OnRead(Sender: TObject; Socket: TCustomWinSocket);
begin

end;

procedure TTCPObject.StartConnecting;
var
  TCPThread: TTCPThread;
begin
  TCPThread := TTCPThread.Create(true);
  TCPThread.FreeOnTerminate := true;
  TCPThread.Client := Client;
  TCPThread.Resume;
end;

procedure TTCPThread.DoConnect;
begin
  Client.Active := true; // wird niemals aufgerufen
end;

procedure TTCPThread.Execute;
begin
  inherited;

  repeat
    Synchronize(DoConnect); // Bis hierhin und nicht weiter ..
    Sleep(1000);
  until (Terminated) or (Client.Active);
end;

var
  Msg: TMsg;
  TCP: TTCPObject;
begin
  TCP := TTCPObject.Create;
  TCP.StartConnecting;

  while GetMessage(Msg, 0, 0, 0) do
  begin
    TranslateMessage(Msg);
    DispatchMessage(Msg);
  end;
end.

Beim Aufruf von Synchronize wird das zu synchronisierende Event nicht aufgerufen. Woran kann das liegen?

Gruß Florian

Hi,
Was ist das denn für ein Konstrukt?

zusammenfalten · markieren

Delphi-Quellcode:

procedure TTCPThread.Execute;
begin
  inherited; // kann/muss weg!

  repeat
    Synchronize(DoConnect); // Bis hierhin und nicht weiter ..
    Sleep(1000);
  until (Terminated) or (Client.Active);
end;

var //was soll das sein? Compilerverwirrung?
  Msg: TMsg;
  TCP: TTCPObject;
begin
  TCP := TTCPObject.Create;
  TCP.StartConnecting;

  while GetMessage(Msg, 0, 0, 0) do
  begin
    TranslateMessage(Msg);
    DispatchMessage(Msg);
  end;
end.

Bin mir auch nicht sicher ob Synchronize in einer Klasse funktioniert, da sich das Handle des Hauptthread möglicherweise nicht ermitteln lässt

Ne keine Compilerverwirrung sondern ein globales Variablenfeld. Bei Konsolenanwendungen deklariert man die Msg Variable meist direkt über der Main Routine, so wie ich es getan habe .. mit dem inherited werd ich mir mal angucken, sollte aber nicht zu meinem Problem führen. Das mit der Klasse kann es auch nicht sein, da TThread selbst eine Klasse ist und diese Funktion direkt zur Verfügung stellt. Denke da hängt eher was an der Nachrichtenschleife, aber ich komm nicht drauf was

Also gut ich nehm alles zurück und behaupte das Gegenteil

Möglicherweise fügt Delphi noch was dem Nachrichtenhandler hinzu wenn ein Thread in der Anwendung vorhanden ist eine Möglichkeit wäre die Nachrichten mitzuschreiben um dann selbst auf die Synchronize Nachricht zu reagieren.

Hi,

wofür soll denn das Synchronize gut sein, wenn das eine Konsolen-Anwendung ist ?

Das kann gar nicht ausgeführt werden, da es keine Nachrichtenschleife gibt, die darauf reagiert.

Lass das mal mit dem Synchronize und dann läuft auch dein Thread.

Gruss

Na ich will, dass das Verbinden im Kontext des Hauptthreads ausgeführt wird. Das hat den Hintergrund, dass die Sockets von sich aus mit Threads arbeiten und keine Verbindung zu Stande kommt, wenn ich im Thread einfach direkt das Socket aktiviere.