Discussion :

[titou640]

Bonjour,

Pour qu'une dll écrite en delphi7 communique avec une application en c# /wpf, je voulais créer un ServerSocket.
Or j'ai 2 problemes, tout d'abord je suis grand débutant en delphi ! Et ensuite il semble que mon ServerSocket n'est pas instancier ...
Donc mes questions sont: faut il obligatoirement une Form pour pouvoir utiliser un ServerSocket (vous l'aurez compris il n'y a pas de Form ici)?
Est ce que ServerSocket/ClientSocket sont les mauvais objets? Y en a t il d'autres à utiliser?

Merci d'avance de votre aide.

PS: dans la dll delphi il y a un port COM (TComPort) qui est utilisé, mais pour lui nous avons :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 FPort := TComPort.Create(nil);

[ShaiLeTroll]

Pour ma part, j'ai souvent utilisé une Form avec TServerSocket ou TClientSocket
As-tu essayé de faire avec le TServerSocket\TClientSocket une instanciation manuelle comme celle du TComPort, d'affecter les Evènement OnConnect et OnRead en RunTime comme je l'avais proposé dans le sujet Les sockets sous les applications console où il n'y avait ni TForm ni même un TApplication remplacé par un TClientApplication encapsulant un TClientSocket cela fonctionnait très bien en mode ctBlocking (implique un petit thread)

tu peux utiliser TTCPServer, il fonctionne sans TForm, par contre, il te faut maitriser les Threads
Il y a aussi TIdTCPServer de Indy

[titou640]

OK, merci. Je vais essayer d'étudier ton exemple.
Juste par rapport à

As-tu essayé de faire avec le TServerSocket\TClientSocket une instanciation manuelle comme celle du TComPort

j'ai essayer mais il semblerait qu'il n'y ai pas de "create", d'où mon inquiétude qu'une Form soit nécéssaire.

Je vous tiens au courant .

[ShaiLeTroll]

Tout objet héritant du TObject a un Create et un Destroy !
Il y en a un c'est garanti pour le TServerSocket et TClientSocket qui héritent des Constructeurs et destructeurs du TCustomSocket eux mêmes provenant du TComponent

PS : La documentation en Ligne, est certe 10 ans plus récente que D7 mais pour le TClientSocket\TServerSocket, cela n'a pas bougé de puis D5 ! Tu peux te fier à cette documentation
Mais tu peux aussi consulter le HLP local de D7 (installe au besoin WinHlp32)

[edam]

voir les composant ics, et les example avec, il y a même un ou deux sont prés à l'emplois, j'ai déjà utilisé,
pour utilisé un composant non visuelle et recepteur de message windows sans forms, "comme j'ai dis avant" le meilleur example est la class TTimer, voir son code de création

[ShaiLeTroll]

pour utilisé un composant non visuelle et recepteur de message windows sans forms,

C'est pour cela que TClientSocket\TServerSocket ont une propriété ClientType avec

• ctNonBlocking\stNonBlocking utilisant des Message via WSAAsyncSelect
• ctBlocking\stThreadBlocking que l'on manipule via un Stream dans un Thread

A l'époque Borland avait prévu une utilisation autonome sans devoir bidouiller comme le TTimer

[titou640]

Bonjour,

Alors j'ai repris le code que ShaiLeTroll suggérait dans le sujet " Les sockets sous les applications console ", je l'ai modifié pour que ce soit un server.
(donc je n'utilise pas le "Run")
Pour commencer je voulais juste tester la connexion. Ca ne marche pas, ne comprenant pas vraiment ce que je fait (et juste pour le premier test) j'ai essayer de changer le ServerType de stThreadBlocking à stNonBlocking, pas de changement ... puis je me suis rendu compte que, malgré le fait que le client me dise qu'il se connecte effectivement à ce serverSocket, dans le delphi je ne passe pas dans la fonction de surcharge du OnClientConnect :S.

Ma question est donc (et là je vais me faire engueuler :p) pour surcharger une méthode on écrit juste "objet.methode := nomMethodeSurcharge;" ?
A la compile ça passe, mais par la suite je ne passe pas dans ladite méthode.

Ai je manqué quelque chose?

Merci.

[ShaiLeTroll]

En fait, le Run doit être remplacé par un ou plusieurs Thread pour chaque client connecté, je te conseille de lire cette page, tu verras OnClientConnect ne que l'un des nombreux évènements !

et là je vais me faire engueuler :p

Oh ! si peu
Donc le terme "fonction de surcharge" est inapproprié, ce n'est que la création d'un Gestionnaire d’Événement, là pour OnClientConnect et oui l'affectation par := est suffisante

Tu peux utiliser un Telnet pour tester la connexion et le dialogue !

As-tu des "points bleu" dans le code de "nomMethodeSurcharge" qui faudrait appeler "ClientConnectEventHandler" ?

[titou640]

oui j'ai des points bleus dans mon OnClientConnectEventHandler, qu'est ce que ca vaut dire?

[Paul TOTH]

je viens de tester, en effet OnClientConnect n'est pas invoqué...mais OnThreadStart l'est

[ShaiLeTroll]

J'ai toujours utilisé le mode stNonBlocking, je n'ai jamais eu de problème et cela même sans fenêtre car TServerSocket créé une fenêtre interne AllocateHwnd
C'est ce qu'évoquait edam au sujet du TTimer, les développeurs ont repris la même logique !

Je n'ai pas Delphi, voici le code entier du Main CPP lié à un BPR de C++Builder 6
Cela fonctionne très bien !
Cela renvoie une réponse à chaque packet (sous telnet à chaque caractère)
Echap ferme la connexion
Une fois toutes les connexions fermées, le serveur s'arrête !

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#include <ScktComp.hpp>
#include <StrUtils.hpp>
//---------------------------------------------------------------------------
/* Forward Declarations */
class DELPHICLASS TServerApplication;
void RunServer();
 
//---------------------------------------------------------------------------
WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
  try
  {
    RunServer();
  }
  catch (Exception &exception)
  {
    OutputDebugString((exception.Message + " : " + exception.ClassName()).c_str());
  }
  catch (...)
  {
    OutputDebugString("...");
  }
  return 0;
}
 
//---------------------------------------------------------------------------
class TServerApplication : public TObject
{
private:
  TServerSocket* FServerSocket;
  bool FServerTerminated;
  int FConnectCount;
  int FReadCount;
  int FReadCharCount;
  bool FStopped;
 
  void __fastcall ClientConnectEventHandler(TObject* Sender, TCustomWinSocket* Socket);
  void __fastcall ClientReadEventHandler(TObject* Sender, TCustomWinSocket* Socket);
  void __fastcall ClientDisconnectEventHandler(TObject* Sender, TCustomWinSocket* Socket);
 
public:
  /*constructor*/__fastcall TServerApplication();
  /*destructor*/virtual __fastcall ~TServerApplication();
 
  void Run();
};
 
//---------------------------------------------------------------------------
void RunServer()
{
  TServerApplication* Server = new TServerApplication();
  try
  {
    Server->Run();
  }
  __finally
  {
    delete Server;
  }
};
 
//---------------------------------------------------------------------------
/*constructor*/__fastcall TServerApplication::TServerApplication()
{
  FServerSocket = new TServerSocket(NULL);
  FServerSocket->Port = 12345;
  FServerSocket->ServerType = stNonBlocking; // C'est le plus simple à gérer !
  FServerSocket->OnClientConnect = ClientConnectEventHandler;
  FServerSocket->OnClientRead = ClientReadEventHandler;
  FServerSocket->OnClientDisconnect = ClientDisconnectEventHandler;
}
 
//---------------------------------------------------------------------------
/*destructor*/__fastcall TServerApplication::~TServerApplication()
{
  delete FServerSocket;
  FServerSocket = NULL;
}
 
//---------------------------------------------------------------------------
void TServerApplication::Run()
{
  FServerSocket->Open();
 
  while ( ! FServerTerminated)
  {
    if (WaitMessage())
    {
      TMsg Msg;
      if (PeekMessage(&Msg, 0, 0, 0, PM_REMOVE))
      {
        switch (Msg.message)
        {
          case WM_QUIT :
            FServerTerminated = true;
          break;
 
          case CM_SOCKETMESSAGE :
          case CM_DEFERFREE :
          case CM_LOOKUPCOMPLETE :
            DispatchMessage(&Msg);
          break;
        }
 
        if (FConnectCount && (FServerSocket->Socket->ActiveConnections == 0))
          FServerTerminated = true;
      }
    }
    else
      FServerTerminated = true;
  }
}
 
//---------------------------------------------------------------------------
void __fastcall TServerApplication::ClientConnectEventHandler(TObject* Sender, TCustomWinSocket* Socket)
{
  OutputDebugString(("Connect : " + Socket->RemoteAddress).c_str());
  Socket->SendText(Socket->RemoteAddress + " : your are connection N°" + IntToStr(++FConnectCount) + sLineBreak);
}
 
//---------------------------------------------------------------------------
void __fastcall TServerApplication::ClientReadEventHandler(TObject* Sender, TCustomWinSocket* Socket)
{
  AnsiString Buf = Socket->ReceiveText();
  int CharCount = Buf.Length();
  FReadCharCount += CharCount;
  Socket->SendText(Socket->RemoteAddress + " : server have receive " + IntToStr(CharCount) + " chars [total : " + IntToStr(FReadCharCount) + " chars, " + IntToStr(++FReadCount) + " packets]" + sLineBreak);
 
  if (CharCount == 1)
  {
    if (Buf[1] == VK_ESCAPE)
      Socket->Close();
  }
  else
    if (AnsiContainsText(Buf, "STOP"))
      FServerTerminated = true;
}
 
//---------------------------------------------------------------------------
void __fastcall TServerApplication::ClientDisconnectEventHandler(TObject* Sender, TCustomWinSocket* Socket)
{
  OutputDebugString(("Disconnect : " + Socket->RemoteAddress).c_str());
}

[Paul TOTH]

c'est tout de même plus simple sous Delphi ^^

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
program Server;
 
{$APPTYPE CONSOLE}
 
uses
 ScktComp;
 
type
  TMyServer = class(TServerSocket)
    constructor Create; reintroduce;
    procedure OnClient(Sender: TObject; Thread: TServerClientThread);
  end;
 
constructor TMyServer.Create;
begin
  inherited Create(nil);
  Port := 1234;
  ServerType := stThreadBlocking;
  OnThreadStart := OnClient;
  Open;
end;
 
procedure TMyServer.OnClient(Sender: TObject; Thread: TServerClientThread);
begin
  WriteLn('Connexion ! ');
end;
 
var
  MyServer: TMyServer;
begin
  MyServer := TMyServer.Create();
  WriteLn('Appuyez sur ENTREE pour terminer le programme');
  ReadLn;
end.

[ShaiLeTroll]

Euh pas vraiment, je n'ai pas fait une application console mais une application VCL sans Application ni Form
Le code en Delphi pour ce comportement là aurait été exactement le même !
Le code semble long parce que cela inclu aussi la boucle Run que l'on a pas l'habitude de voir !

Evidemment, mettre un Objet gérant des Messages Windows dans une application Console, cela ne doit pas fonctionner !

Mon code gère OnClientConnect, OnClientRead et OnClientDisconnect !
Si tu titoi640 débute, un OnThreadStart et les Threads\Stream qui vont avec ce n'est pas un cadeau, surtout si OnRead et ReceiveText fonctionne !
D'ailleurs, pour un échange binaire, il faut utiliser ReveiveBuf de préférence !

Voici, la version Delphi, j'ai séparé dans un autre fichier car C++Builder 6 permet d'inclure du Pascal, voici le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
unit ServerApplicationClasses;
 
interface
 
uses
  Windows, SysUtils, Messages, StrUtils, ScktComp;
 
type
  TServerApplication = class(TObject)
  private
    FServerSocket: TServerSocket;
    FServerTerminated: Boolean;
    FConnectCount: Integer;
    FReadCount: Integer;
    FReadCharCount: Integer;
 
    procedure ClientConnectEventHandler(Sender: TObject; Socket: TCustomWinSocket);
    procedure ClientReadEventHandler(Sender: TObject; Socket: TCustomWinSocket);
    procedure ClientDisconnectEventHandler(Sender: TObject; Socket: TCustomWinSocket);
 
  public
    constructor Create();
    destructor Destroy; override;
 
    procedure Run();
  end;
 
procedure RunServer();
 
implementation
 
//---------------------------------------------------------------------------
procedure RunServer();
begin
  with TServerApplication.Create() do
  try
    Run();
  finally
    Free();
  end
end;
 
//---------------------------------------------------------------------------
constructor TServerApplication.Create();
begin
  inherited Create();
 
  FServerSocket := TServerSocket.Create(nil);
  FServerSocket.Port := 12345;
  FServerSocket.ServerType := stNonBlocking; // C'est le plus simple à gérer !
  FServerSocket.OnClientConnect := ClientConnectEventHandler;
  FServerSocket.OnClientRead := ClientReadEventHandler;
  FServerSocket.OnClientDisconnect := ClientDisconnectEventHandler;
end;
 
//---------------------------------------------------------------------------
destructor TServerApplication.Destroy();
begin
  FreeAndNil(FServerSocket);
 
  inherited Destroy();
end;
 
//---------------------------------------------------------------------------
procedure TServerApplication.Run();
var
  Msg: TMsg;
begin
  FServerSocket.Open();
 
  while not FServerTerminated do
  begin
    if WaitMessage() then
    begin
      if PeekMessage(Msg, 0, 0, 0, PM_REMOVE) then
      begin
        case Msg.message of
          WM_QUIT :
            FServerTerminated := True;
 
          CM_SOCKETMESSAGE,
          CM_DEFERFREE,
          CM_LOOKUPCOMPLETE :
            DispatchMessage(Msg);
        end;
 
        if (FConnectCount > 0) and (FServerSocket.Socket.ActiveConnections = 0) then
          FServerTerminated := True;
      end
    end
    else
      FServerTerminated := True;
  end
end;
 
//---------------------------------------------------------------------------
procedure TServerApplication.ClientConnectEventHandler(Sender: TObject; Socket: TCustomWinSocket);
begin
  OutputDebugString(PChar('Connect : ' + Socket.RemoteAddress));
  Inc(FConnectCount);
  Socket.SendText(Socket.RemoteAddress + ' : your are connection N°' + IntToStr(FConnectCount) + sLineBreak);
end;
 
//---------------------------------------------------------------------------
procedure TServerApplication.ClientReadEventHandler(Sender: TObject; Socket: TCustomWinSocket);
var
 Buf: String;
 CharCount: Integer;
begin
  Buf := Socket.ReceiveText();
  CharCount := Length(Buf);
  Inc(FReadCharCount, CharCount);
  Inc(FReadCount);
  Socket.SendText(Socket.RemoteAddress + ' : server have receive ' + IntToStr(CharCount) + ' chars [total : ' + IntToStr(FReadCharCount) + ' chars, ' + IntToStr(FReadCount) + ' packets]' + sLineBreak);
 
  if (CharCount = 1) then
  begin
    if Ord(Buf[1]) = VK_ESCAPE then
      Socket.Close();
  end
  else
    if AnsiContainsText(Buf, 'STOP') then
      FServerTerminated := True;
end;
 
//---------------------------------------------------------------------------
procedure TServerApplication.ClientDisconnectEventHandler(Sender: TObject; Socket: TCustomWinSocket);
begin
  OutputDebugString(PChar('Disconnect : ' + Socket.RemoteAddress));
end;
 
end.

le Main CPP est plus court

Code cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#include <ServerApplicationClasses.hpp>
//---------------------------------------------------------------------------
 
WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
  try
  {
    RunServer();
  }
  catch (Exception &exception)
  {
    OutputDebugString((exception.Message + " : " + exception.ClassName()).c_str());
  }
  catch (...)
  {
    OutputDebugString("...");
  }
  return 0;
}

cela doit donner ceci en Delphi (théoriquement)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
program Server;
 
uses
  ServerApplicationClasses in 'ServerApplicationClasses.pas';
 
{$R *.res}
 
begin
  RunServer();
end.

[titou640]

Bonjour,

Je viens juste pour vous remerciez de votre aide, mais hélas ca ne marche tj pas :S.

Je m'explique, j'ai fait un "server delphi", "un client delphi", "un client .NET" et "un server .NET"

server .NET / client .NET => OK
server Delphi / client Delphi => OK
server .NET / client Delphi => KO
server Delphi / client .NET => KO

Le plus étrange est que dans la config server .NET / client Delphi
Si le client Delphi envoie un buffer commençant par '\0' je le vois arriver du coté server .NET en erreur (mais il arrive !!!) tandis que lorsque mon buffer a des données et fini par le '\0' je ne le vois JAMAIS arrivé :S ni ok ni en erreur.
(à ce niveau je n'essaye même pas encore d'analyser le buffer)

Et dans la config server Delphi / client .NET : rien du tout.

Si vous avez une derniere idée?! Merci d'avance.

[ShaiLeTroll]

teste aussi avec telnet en ligne de commande

server .NET / client telnet => ?
server Delphi / client telnet => ?

Sinon, cela me rappele un bug en Windev 7.0 qui ne supportait pas un zéro dans un buffer TCP IP et bouclait indéfiniment, c'est pour cela que Windev recommandait l'utilisation d'un mode spécial qui ajoutait 4 octets pour la longueur de buffer
Surement un bug de chaine à zéro terminal !

Bug corrigé en Windev 7.5 mais pas celui où lorsque l'on écoutait plusieurs ports simultanément,
avec un client windev sur le server windev, cela fonctionnait
mais avec server Delphi ou MSVisualC++, l'ouverture des sockets sur plusieurs ports étaient trop rapides, Windev donnait pour des sockets différentes le même identifiant (censé être unique)
Depuis 10 ans ont passé, ça doit mieux fonctionner

On peut espérer que le .NET c'est un framework fiable, donc ton problème est forcément lié à la récupération ou l'envoi du buffer .

Attention aussi à l'encodage des données, veille à n'utiliser qu'un mode binaire des DEUX côtés !
Evite toute manipulation par Chaine, en Delphi 7, c'est de l'ANSI, en Delphi 2009 à XE2+, c'est de l'Unicode
En C#...Net, je l'ignore mais je présume de l'Unicode et de toute façon, le .NET recommande l'utilisation de Byte[] ou de NetworkStream

[edam]

au début; oublie le mode console et utilise la vcl avec application.show:=false;
car delphi sait géré mieux les événements et la boucle des messages
et si tu veux faire des testes tu n'a qu'a mettre application.show:=false; en commentaire

[titou640]

Bonjour,

Mes excuses pour revenir vers vous seulement maintenant, merci de votre aide mais ça ne marche toujours pas . Or j'ai d'autre chose à faire dans le pipe donc j'y reviendrais plus tard. Je vais conclure la discussion et la ré ouvrirais (si je peux) dans qq semaines quand j'aurais réduit ma pile de TODO.

Merci encore.