Contents Up Previous Next

Vue d'ensemble de la communication inter-processus

Classes: wxServer, wxConnection, wxClient wxWidgets possède un certain nombre de classes pour vous assister dans la communication inter-processus et la programmation réseau. Cette section ne parle que d'une famille de classes -- le protocole assimilé DDE -- mais il existe une liste d'autres classes utiles:

Le protocole assimilé DDE de wxWidgets est un protocole haut niveau basé sur le DDE Windows. Il y a deux implémentations de ce protocole : une utilisant le DDE réel tournant sous Windows uniquement, et une autre utilisant TCP/IP (les sockets) qui tourne sous la plupart des plateformes. Depuis que l'API et virtuellement tout le comportement est le même, mis à part le nom des classes, vous devriez trouver facile de passer d'une implémentation à l'autre.

Notez qu'en incluant <wx/ipc.h> vous devez définir des synonymes pratiques pour les classes IPC : wxServer pour wxDDEServer ou wxTCPServer suivant quelle implémentation est utilisée et la même chose pour wxClient et wxConnection.

Par défaut, l'implémentation DDE est utilisée sous Windows. DDE ne fonctionne qu'au sein d'un ordinateur seulement. Si vous voulez utiliser UIPC entre des stations de travail différentes, vous devez mettre wxUSE_DDE_FOR_IPC à 0 avant d'inclure ce header -- cela va forcer l'utilisation de l'implémentation TCP/IP même sous Windows.

Les descriptions suivantes se réfèrent à wx... mais souvenez-vous que les classes équivalentes wxTCP... et wxDDE... peuvent être utilisées de la même façon.

Il y a trois classes centrales pour l'API assimilée DDE:

  1. wxClient. Représente l'application cliente et est utilisée uniquement au sein d'un programme client.
  2. wxServer. Représente l'application serveur et n'est utilisée qu'au sein d'un programme serveur.
  3. wxConnection. Représente la connexion entre un client et un serveur - chacun d'entre-eux (client et serveur) utilisent une instance de cette classe, une par connexion. La majorité des transactions DDE s'opèrent avec cet objet.

Les messages entre les applications sont généralement identifiés par trois variables : l'objet connexion, le nom du sujet et le nom de l'élément. Une chaine de données est un quatrième élément de certains messages. Pour créer une connexion,(une conversation en langage Windows), l'application cliente utilise wxClient::MakeConnection pour envoyer un message à l'objet serveur, avec une chaine de caractères "nom de service" pour identifier le serveur et un nom de sujet pour identifier ke sujet tout le temps que durera la connexion. Sous Unix, le nom de service peut être soit un entier identificateur de port dans quel cas un socket de domaine Internet sera utilisé pour les communications, ou un nom de fichier valide (qui ne devrait pas exister et sera supprimé à la fin) dans quel cas un socket de domaine Unix est créé.

NOTE DE SECURITE: Utiliser les sockets de domaine Internet est hautement insécurisé pour IPC car il n'y a absolument aucun contrôle d'accès, utilisez les sockets de domaine Unix dès que possible!

Le serveur répond alors et soit il refuse la connexion, soit il l'accepte. S'il l'accepte, les deux objets client et serveur créent des objets wxConnection qui persisteront jusqu'à ce que la connexion soit fermée. L'objet connexion est alors utilisé pour envoyer et recevoir des messages ultérieurs entre le client et le serveur - surcharger les fonctions virtuelles dans votre classe dérivée de wxConnection vous permet de gérer les messages DDE.

Pour créer un serveur fonctionnel, le programmeur doit:

  1. Dériver une classe de wxConnection, en fournissant des gestionnaires pour les différents messages envoyés au côté serveur de la connexion (par exemple, OnExecute, OnRequest, OnPoke). Seuls les gestionnaires requis par l'application ont besoin d'être surchargés.
  2. Dériver une classe de wxServer, et surcharger OnAcceptConnection pour accepter ou rejeter une connexion sur la base de l'argumùent sujet. Ce membre doit créer et retourner une instance de la classe connexion dérivée si elle est acceptée.
  3. Créer une instance de votre objet serveur et appeler Create pour l'activer, en lui donnant un nom de service.

Pour créer un client fonctionnel, le programmeur doit:

  1. Dériver une classe de wxConnection, en fournissant les gestionnaires pour les différents messages envoyés au côté client d'une wxConnection (par exemple, OnAdvise). Seuls les gestionanires actuellement requis par l'application ont besoin d'être surchargés.
  2. Dériver une classe de wxClient, en surchargeant OnMakeConnection pour créer et retourner une instance de la classe connection dérivée.
  3. Créer une instance de votre objet client.
  4. Au moment approprié, créer une nouvelle connexion en utilisant wxClient::MakeConnection, avec les arguments nom d'hôte (utilisé uniquement sous unix, utilisez 'localhost' pour l'ordinateur local), nom de service, et nom du sujet pour cette connexion. L'objet client va appeler OnMakeConnection pour créer un objet connexion de la classe dérivée si la connexion est acceptée.
  5. Utiliser les fonctions membres de wxconnection pour envoyer des messages au serveur.

Transfert de données
Exemples
Plus de détails sur DDE


Transfert de données

Voici les moyens permettant aux données d'être transférées d'une application à une autre. Ce sont des méthodes de wxConnection.

Le type de donnée par défaut est wxCF_TEXT (texte ASCII), et la taille par défaut et la longueur de la chaine de caractères terminée par un caractère zéro. Les types de données spécifiques à Windows peuvent également être utilisés sur le PC.


Exemples

Voyez les programmes d'exemples server et client dans le dossier IPC des exemples Exécutez le serveur, puis le client. Cela démontre l'utilisation des commandes Execute, Request et Poke depuis le client, ensemble avec une boucle Advise: sélectionner un élément dans la zone de liste sur le serveur rend cet élément sélectionné dans la zone de liste du client.


Plus de détails sur DDE

Un objet wxClient entame la partie cliente d'une conversation client-serveur assimilée DDE (Dynamic Data Exchange) disponible à la fois sur Windows et Unix).

Pour créer un client qui peut communiquer avec un serveur, vous devez dériver une classe de wxConnection et une autre de wxClient. La classe wxConnection personnalisée va recevoir les communications sous forme de 'conversations' avec un serveur. Et un wxServeur personnalisé est requis afin qu'une fonction membre wxClient::OnMakeConnection surchargée par l'utilisateur puisse retourner une wxConnection de la classe désirée quand une connextion est effectuée.

Par exemple:

class MyConnection: public wxConnection {
 public:
  MyConnection(void)::wxConnection() {}
  ~MyConnection(void) { }
  bool OnAdvise(const wxString& topic, const wxString& item, char *data, int size, wxIPCFormat format)
  { wxMessageBox(topic, data); }
};

class MyClient: public wxClient {
 public:
  MyClient(void) {}
  wxConnectionBase *OnMakeConnection(void) { return new MyConnection; }
};

Ici, MyConnection va répondre aux messages OnAdvise envoyés par le serveur en affichant une boite de message.

Quand l'application cliente démarre, elle doit créer une instance du wxClient dérivé. Dans le code suivant, les arguments de la ligne de commande sont utilisés pour passer le nom de l'hôte (le nom de la machine sur laquelle le serveur tourne) et le nom du serveur (identifiant le processus serveur). Appeler wxClient::MakeConnection va implicitement créer une instance de Myconnection si la requête pour une connexion est acceptée, et le client va alors demander une boucle Advise au serveur (une boucle Advise est l'endroit où le serveur va appeler le client quand les données ont changé).

  wxString server = "4242";
  wxString hostName;
  wxGetHostName(hostName);

  // Créer un nouveau client
  MyClient *client = new MyClient;
  connection = (MyConnection *)client->MakeConnection(hostName, server, "IPC TEST");

  if (!connection)
  {
    wxMessageBox("Failed to make connection to server", "Client Demo Error");
    return NULL;
  }
  connection->StartAdvise("Item");