COMMENT FAIRE : Marshaler un objet par référence à un serveur distant à l'aide de Visual Basic .NET

Traductions disponibles Traductions disponibles
Numéro d'article: 301112 - Voir les produits auxquels s'applique cet article
Ancien nº de publication de cet article : F301112
Cet article a été archivé. Il est proposé « en l'état » et ne sera plus mis à jour.
Agrandir tout | Réduire tout

Sommaire

Résumé

Cet article explique comment marshaler un objet par référence à un serveur distant. Lorsque vous marshalez un objet par référence, le runtime crée un proxy transparent qui permet au serveur d'effectuer des rappels à l'objet sur le client. Le proxy est le seul élément qui soit envoyé au serveur. Le proxy marshale les rappels au client.

Cet article se divise en trois parties : l'objet serveur, l'application serveur et l'application cliente. Il étend le champ des articles suivants de la Base de connaissances Microsoft :
300951 PROCÉDURE : Créer un serveur distant à l'aide de Microsoft Visual Basic .NET
300943 PROCÉDURE : Créer un accès client à un serveur distant à l'aide de Visual Basic .NET

Conditions requises

Les éléments suivants décrivent le matériel, les logiciels, l'infrastructure réseau recommandés ainsi que les compétences, les connaissances et les Service Packs dont vous avez besoin :
  • Windows 2000 Professionnel, Windows 2000 Server, Windows 2000 Advanced Server ou Windows NT 4.0 Server
  • Visual Studio .NET
Vous devez être familier avec les éléments suivants avant d'entreprendre cette procédure :
  • Visual Studio .NET
  • Notions fondamentales du travail en réseau

Création d'un objet serveur distant en passant des objets

La première étape de création de l'application serveur consiste à créer votre objet serveur. L'objet serveur est l'objet que l'application cliente instancie et avec lequel elle communique sur l'ordinateur serveur. L'application cliente effectue cette opération par le biais d'un objet proxy qui est créé sur le client. Votre objet serveur, appelé HelloServer, résidera dans une bibliothèque de classes (DLL). Vous allez également définir dans le même projet la classe qui sera passée du client au serveur. Cette classe sera appelée ForwardMe. Parce que vous voulez que la classe ForwardMe soit marshalée par référence, celle-ci doit hériter de MarshalByRefObject.
  1. Ouvrez Visual Studio .NET.
  2. Créez une application de bibliothèque de classes et nommez-la ServerClassRef.
  3. Renommez le fichier Class1.vb en ServerClassRef.vb.
  4. Ouvrez le fichier ServerClassValue.vb et ajoutez deux classes, HelloServer et ForwardMe, qui héritent toutes deux de MarshalByRefObject. La classe HelloServer sera la classe principale utilisée par l'application cliente. La classe ForwardMe servira à l'envoi de données d'objets, du client au serveur. Votre fichier de code ServerClassRef.vb devrait ressembler à ceci :
    Public Class HelloServer
    	Inherits MarshalByRefObject
    End Class
    Public Class ForwardMe
    	Inherits MarshalByRefObject
    End Class
  5. Ajoutez une méthode publique à HelloServer, intitulée HelloMethod, qui prend un objet ForwardMe. Cette méthode vous permettra de passer un objet ForwardMe au serveur. Elle appelle la méthode CallMe de cet objet. Votre classe HelloServer devrait maintenant ressembler à ceci :
    Public Class HelloServer
        Inherits MarshalByRefObject
        
        Public Sub HelloMethod(ByRef obj As ForwardMe)
            Dim i As Integer
            obj.CallMe()
        End Sub
    End Class
  6. Ajoutez une méthode publique à la classe ForwardMe. Cette méthode obtiendra le nom du processus où ce code est exécuté. Dans la mesure où vous envoyez simplement un stub proxy au serveur et effectuez des rappels au client (marshaler par référence), le code s'exécutera dans le processus du client.
    Public Class ForwardMe
        Inherits MarshalByRefObject
        
        Public Function CallMe() As Object
            Console.WriteLine("CallMe a été exécutée dans : " & _
            Process.GetCurrentProcess.ProcessName.ToString)
        End Function
    End Class
  7. Générez le projet pour créer l'assembly ServerClassRef.dll.
  8. Fermez et enregistrez le projet.

Création d'une application serveur distant

Maintenant que vous avez créé l'objet serveur avec lequel communiquera le client, vous devez inscrire l'objet auprès de l'infrastructure distante. Ce processus implique non seulement l'inscription de l'objet, mais aussi le démarrage du serveur et sa mise en position d'écoute sur un port pour la connexion des clients. Pour ce faire, il vous faut un type de projet qui produira un fichier exécutable. La raison qui a motivé l'inclusion de l'objet serveur dans un projet distinct est que vous pouvez ainsi référencer facilement l'objet serveur à partir du client. Si vous l'aviez inclus dans ce projet, vous ne pourriez pas le référencer, car les références ne peuvent être définies que vers des fichiers DLL.
  1. Ouvrez Visual Studio .NET.
  2. Par souci de simplicité, créez une application console pour démarrer le serveur distant et nommez-la ServerObjectRef.
  3. Renommez le fichier Module1.vb créé par défaut en ServerObjectRef.vb.
  4. Ajoutez une référence à l'espace de noms System.Runtime.Remoting au projet.
  5. Ajoutez une référence à l'assembly ServerClassRef.dll créé à la section précédente.
  6. Utilisez l'instruction Imports sur les espaces de noms Remoting, Remoting.Channels et Remoting.Channels.TCP pour éviter d'avoir à qualifier des déclarations dans ces espaces de noms ultérieurement dans votre code. L'instruction Imports doit être utilisée avant toute autre déclaration :
    Imports System.Runtime.Remoting
    Imports System.Runtime.Remoting.Channels
    Imports System.Runtime.Remoting.Channels.TCP
  7. Déclarez une variable pour initialiser un objet TcpChannel qui sera à l'écoute des connexions des clients sur un port particulier, en l'occurrence le port 8085. Inscrivez le canal qu'utilisera le client pour communiquer avec les services de canaux à l'aide de la méthode RegisterChannel. Ajoutez le code de déclaration dans la procédure Main de Module1 :
    Dim chan As TcpChannel = New TcpChannel(8085)
    ChannelServices.RegisterChannel(chan)
  8. Inscrivez l'objet ServerClassRef auprès de l'infrastructure distante en appelant la méthode RegisterWellKnownType de l'objet RemotingConfiguration. Vous devez préciser les éléments suivants :
    1. Le nom de type complet de l'objet qui est inscrit (dans ce cas ServerClassRef.HelloServer), suivi du nom de l'assembly (ServerClassRef). Vous devez spécifier le nom de l'espace de noms et celui de la classe. Étant donné que vous n'avez pas spécifié d'espace de noms dans la section précédente, l'espace de noms racine par défaut est utilisé.
    2. Précisez ensuite le nom du point d'arrêt où l'objet sera publié. Les clients doivent connaître ce nom pour pouvoir se connecter à l'objet. Utilisez RemoteTestRef.
    3. Le paramètre final spécifie le mode de l'objet, SingleCall ou Singleton. Cet exemple spécifie le mode SingleCall. Le mode de l'objet indique la durée de vie de l'objet lorsqu'il est activé sur le serveur. Dans le cas d'objets SingleCall, une instance de la classe sera créée pour chaque appel effectué à partir d'un client, même si le même client appelle la même méthode plusieurs fois. En revanche, les objets Singleton sont créés une seule fois et tous les clients communiquent avec le même objet :
      RemotingConfiguration.RegisterWellKnownServiceType( _
       Type.GetType("ServerClassRef.HelloServer, ServerClassRef"), _
       "RemoteTestRef", _
       WellKnownObjectMode.SingleCall)
  9. Utilisez la méthode ReadLine de l'objet Console afin de poursuivre l'exécution de l'application serveur :
    Console.WriteLine("Appuyez sur <Entrée> pour quitter...")
    Console.ReadLine()
  10. Générez votre projet.
  11. Fermez et enregistrez le projet.

Création d'un client sur un serveur distant en passant des objets

  1. Ouvrez Visual Studio .NET.
  2. Créez une application console et nommez-la ClientAppRef.
  3. Renommez le fichier Module1.vb créé par défaut en ClientAppRef.vb.
  4. Ajoutez une référence à l'espace de noms System.Runtime.Remoting au projet.
  5. Ajoutez une référence à l'assembly ServerClassRef.dll créé précédemment dans ce document.
  6. Utilisez l'instruction Imports sur les espaces de noms Remoting, Remoting.Channels et Remoting.Channels.TCP pour éviter d'avoir à qualifier des déclarations dans ces espaces de noms ultérieurement dans votre code. L'instruction Imports doit être utilisée avant toute autre déclaration :
    Imports System.Runtime.Remoting
    Imports System.Runtime.Remoting.Channels
    Imports System.Runtime.Remoting.Channels.TCP
  7. Déclarez une variable pour initialiser un objet TcpChannel que le client utilisera pour se connecter à l'application serveur. Vous devez préciser le port lors de l'initialisation de l'objet TcpChannel pour activer une communication bidirectionnelle. Ceci est nécessaire, car vous marshalez un objet par référence et le serveur devra effectuer des rappels au client en utilisant ce port. Le port doit être différent de celui qui sera utilisé pour l'envoi des données. Utilisez la méthode RegisterChannel pour inscrire le canal auprès des services de canaux. Vous devez ensuite initialiser un nouvel objet ForwardMe qui sera passé au serveur distant. Ajoutez le code de déclaration dans la procédure Main de Module1 :
    Dim chan As TcpChannel = New TcpChannel(8086)
    ChannelServices.RegisterChannel(chan)
    Dim objForwardMe As New ServerClassRef.ForwardMe()
  8. Vous pouvez à présent déclarer et instancier le serveur distant. Dans le cas présent, vous utiliserez la méthode GetObject de l'objet Activator pour instancier l'objet HelloServer. Vous devez préciser les éléments suivants :
    1. Le nom de type complet de l'objet qui est inscrit (dans ce cas ServerClassRef.HelloServer), suivi du nom de l'assembly (ServerClassRef). Vous devez indiquer le nom de l'espace de noms et celui de la classe. Étant donné que vous n'avez pas spécifié d'espace de noms dans la section précédente, l'espace de noms racine par défaut est utilisé.
    2. L'URI (Uniform Resource Identifier) de l'objet que vous devez activer. L'URI doit comprendre le protocole (tcp), le nom de l'ordinateur (localhost), le port (8085) et le point d'arrêt de l'objet serveur (RemoteTestRef). Utilisez l'URI "tcp://localhost:8085/RemoteTestRef" pour accéder au serveur distant ServerClass.
      Dim objHelloServer As ServerClassRef.HelloServer
      objHelloServer = CType(Activator.GetObject( _
          Type.GetType("ServerClassRef.HelloServer, ServerClassRef"), _
          "tcp://localhost:8085/RemoteTestRef"), _
          ServerClassRef.HelloServer)
      If objHelloServer Is Nothing Then
          Console.WriteLine("Impossible de localiser le serveur")
      Else
          ' Voir l'étape suivante
      End If
  9. Si l'objet serveur est correctement instancié, vous pouvez appeler la méthode de l'objet serveur et passer l'objet objForwardMe nouvellement créé. Ceci devrait retourner comme résultat la chaîne modifiée, aussi voudrez-vous afficher ce qui suit :
    Dim objHelloServer As ServerClassRef.HelloServer
    objHelloServer = CType(Activator.GetObject( _
    	Type.GetType("ServerClassRef.HelloServer, ServerClassRef"), _
    	"tcp://localhost:8085/RemoteTestRef"), _
    	ServerClassRef.HelloServer)
    If objHelloServer Is Nothing Then
    	Console.WriteLine("Impossible de localiser le serveur")
    Else
    	objHelloServer.HelloMethod(objForwardMe)
    End If
  10. Utilisez la méthode ReadLine de l'objet Console afin de poursuivre l'exécution de l'application cliente :
    Console.WriteLine("Appuyez sur <Entrée>
     pour quitter...")
    Console.ReadLine()
  11. Générez votre projet.
  12. Assurez-vous que l'application serveur est en cours d'exécution.
  13. Exécutez le projet, puis testez la communication client-serveur. Vous devriez voir apparaître le résultat dans la fenêtre de console du client. Puisque vous marshalez par référence, des rappels au client sont effectués.

Références

Vue d'ensemble de .NET Remoting (Guide du développeur .NET Framework).

Classe TcpChannel (bibliothèque de classes du .NET Framework)

Exemples du .NET Framework - Accès distant
http://msdn.microsoft.com/library/techart/remoting.htm
Microsoft .NET Remoting : présentation technique (articles techniques [généraux] relatifs au développement .NET version Bêta 1) :
http://msdn.microsoft.com/library/techart/hawkremoting.htm
Méthode Activator.GetObject (bibliothèque de classes du .NET Framework)

Méthode Type.GetType (bibliothèque de classes du .NET Framework)

Méthode RegisterWellKnownServiceType (bibliothèque de classes du .NET Framework)



Pour plus d'informations, reportez-vous à l'ouvrage suivant (en anglais) :
ROBINSON, Ed, Michael BOND et Robert Ian OLIVER Upgrading Microsoft Visual Basic 6.0 to Microsoft Visual Basic .NET , Microsoft Press, 2001

Propriétés

Numéro d'article: 301112 - Dernière mise à jour: lundi 24 février 2014 - Version: 1.0
Les informations contenues dans cet article s'appliquent au(x) produit(s) suivant(s):
  • Microsoft Visual Basic .NET 2002 Initiation
Mots-clés : 
kbnosurvey kbarchive kbhowto kbhowtomaster KB301112
L'INFORMATION CONTENUE DANS CE DOCUMENT EST FOURNIE PAR MICROSOFT SANS GARANTIE D'AUCUNE SORTE, EXPLICITE OU IMPLICITE. L'UTILISATEUR ASSUME LE RISQUE DE L'UTILISATION DU CONTENU DE CE DOCUMENT. CE DOCUMENT NE PEUT ETRE REVENDU OU CEDE EN ECHANGE D'UN QUELCONQUE PROFIT.

Envoyer des commentaires

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com