Débuter avec .NET Remoting en C#

.NET Remoting est une technologie permettant l'implémentation d'applications distribuées. Elle est comparable à RMI en Java.

Le principe général est d'exposer sur une partie serveur des objets accessibles par des clients distants.

Les objets ou leur référence pourront donc transiter via le réseau grâce au principe du marshalling (empaquetage). Les protocoles et formatages possibles sont paramétrables : TCP+Binaire ou Http+Soap par exemple. Par défaut, le framework .NET propose Tcp et Http, mais la technologie .NET Remoting permet à des éditeurs tiers de réaliser leurs propres implémentations et rend donc .NET Remoting potentiellement ouvert.

Voici un schéma simple qui résume le fonctionnement global de .NET Remoting :

Le proxy défini sur le schéma est une couche intermédiaire créée dynamiquement par le framework et qui se charge du routage des demandes du client vers le serveur sur le réseau et inversement de récupérer les réponses du serveur. Donc, lorsque vous réaliserez des appels distants, vous ne dialoguerez pas directement avec le serveur, mais avec le proxy.

Le marshalling et unmarshalling des données correspondent aux principes de transformation de données pour qu'elles puissent circuler sur un réseau selon un protocole et un format définis. Ces processus interviennent autant du côté du client que du côté du serveur dès qu'il y a réception ou envoi de données.

Nous reviendrons sur la notion de « MarshalByRefObject » plus tard dans l'article.

Le but de cet article n'est pas d'entrer dans les détails et subtilités de la technologie .NET Remoting, mais de découvrir son fonctionnement de base par la pratique.

Pour comprendre concrètement le fonctionnement de .NET Remoting, nous allons réaliser trois projets C# :

• l'interface : elle contiendra la déclaration des méthodes de l'objet distribué ;
• le serveur : il possèdera un objet contenant deux méthodes, une qui réalise l'addition de deux entiers et une autre qui incrémente simplement une variable ;
• le client : il s'agira d'une application fenêtrée qui appellera à distance l'objet situé sur le serveur.

Nous testerons ensuite les projets et en observerons les comportements.

Si vous êtes perdu pendant le déroulement de ce tutoriel, voici la structure de la solution finale. Vous pourrez ainsi vous y référer en cas de besoin :

Ajoutez à la solution créée précédemment un nouveau projet C# de type « Application Console », nommez-le « RemotingServeur ».

Ajoutez au projet une référence au projet « RemotingInterfaces ».

Ajouter un fichier « RemoteOperation.cs ».

Indiquez dans ce fichier le code suivant, il s'agit de l'objet distant :

using System;

namespace RemotingServeur
{
        public class RemoteOperation : MarshalByRefObject, RemotingInterfaces.IRemoteOperation
        {
                private int nombre = 0; // sera incrémenté par Incrementation()

                // Indique que l'objet aura une durée de vie illimitée
                public override object InitializeLifetimeService()
                {
                        return null;
                }

                // Définition de Addition, cette méthode sera exposée
                public int Addition(int a,int b)
                {
                        Console.WriteLine(String.Format("Appel client sur Addition() : a={0}, b={1}",a,b));
                        return a + b;
                }

                // Définition de Incrementation, cette méthode sera exposée
                public int Incrementation(int valeur)
                {
                        Console.WriteLine(String.Format("Appel client sur Incrementation() : valeur={0}",valeur));
                        nombre += valeur;
                        return nombre;
                }
        }
}

RemoteOperation sera ensuite directement exposé au client.

1. Il implémente la classe MarshalByRefObject qui indique que le client ne contiendra qu'une référence de l'objet et non l'objet lui-même, une sorte de pointeur de fonction distant. Ce fonctionnement est à opposer à MarshalByValue où une copie complète d'un objet sérialisable est passée au client, mais nous ne l'utilisons pas ici.
2. Les méthodes Addition() et Incrementation() sont aussi définies conformément à l'interface IremoteOperation.
3. InitializeLifetimeService est surchargée en retournant null. Sans cela, la durée de vie de l'objet serait par défaut : au premier appel : 5 min puis de 2 min à chaque appel. Elle est, dans notre cas, infinie.

La possibilité de durée de vie limitée peut être intéressante, mais, dans le cadre de ce tutoriel, il n'y a pas lieu d'en placer.

Ajoutez une référence à « System.Runtime.Remoting ».

Renommez le fichier Class1.cs en « RemoteMain.cs ».

Placez-y le code suivant, il permet de démarrer le serveur et d'exposer notre objet :

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;

namespace RemotingServeur
{
        class RemotingMain
        {
                [STAThread]
                static void Main(string[] args)
                {
                        try
                        {
                                // Création d'un nouveau canal d'écoute sur le port 1069
                                TcpChannel channel = new TcpChannel(1069);
                                // Enregistrement du canal
                                ChannelServices.RegisterChannel(channel);
                                // Démarrage de l'écoute en exposant l'objet en Singleton
                                RemotingConfiguration.RegisterWellKnownServiceType(
                                        typeof(RemoteOperation),
                                        "RemoteOperation",
                                        WellKnownObjectMode.Singleton);

                                Console.WriteLine("Le serveur a démarré avec succès");
                                Console.ReadLine();
                        }
                        catch
                        {
                                Console.WriteLine("Erreur lors du démarrage du serveur");
                                Console.ReadLine();
                        }
                }
        }
}

• Ici, nous créons un nouveau Channel (canal) de type Tcp. Des channels d'autres types pourraient être utilisés comme HttpChannel ou des développements non standards comme IIOPChannel. TcpChannel a l'avantage ici d'être plus rapide que HttpChannel puisque les données transitent en binaire ;
• Ce channel est ensuite enregistré sur le serveur pour être trouvé par le client ;
• Puis l'écoute est lancée avec l'objet RemoteOperation exposé en mode Singleton.

Deux types de modes d'activation côté serveur peuvent être accordés à un objet distant avec la technologie .NET Remoting :

• Singleton : un seul objet est partagé entre les clients et les appels pendant une durée de vie fixée. Lorsque la durée de vie est expirée, l'objet est réinstancié ;
• SingleCall : à chaque appel, le serveur crée une nouvelle instance de l'objet qui est détruit après chaque utilisation.

Sachez également qu'il est possible, en passant par une activation côté client de l'objet, que le serveur crée une instance de l'objet pour chaque client.

Remarque : Nous utilisons RegisterWellKnownServiceType(). Or, il existe une autre méthode de la classe RemotingConfiguration : Configure(). Cette méthode permet de charger un fichier xml contenant toutes les informations de configuration du remoting serveur. Cette alternative peut s'avérer très pratique même si nous ne l'avons pas utilisée ici.

Une fois le code ajouté, compilez le projet « RemotingServeur ».

Ajoutez à la solution créée précédemment un nouveau projet C# de type « Windows Form », nommez-le « RemotingClient ».

Placez sur l'éditeur graphique de Form1, les contrôles comme ceci, en respectant les noms :

Ajoutez une référence au projet « RemotingInterfaces ».

Ajoutez une référence à « System.Runtime.Remoting ».

Ajoutez les déclarations suivantes dans le code de la Form :

using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;

Déclarez dans la classe Form1 :

private RemotingInterfaces.IRemoteOperation remoteOperation;

Ajoutez dans le constructeur (Form1()) de Form1, le code suivant :

try
{
        TcpChannel channel = new TcpChannel();
        ChannelServices.RegisterChannel(channel);
        remoteOperation = (RemotingInterfaces.IRemoteOperation)Activator.GetObject(
                typeof (RemotingInterfaces.IRemoteOperation),
                "tcp://localhost:1069/RemoteOperation");
}
catch{ MessageBox.Show("Erreur de connexion au serveur"); }

On déclare ici un channel de type Tcp puis on instancie une référence à l'objet distant en indiquant l'interface locale, les paramètres de connexion et le nom de l'objet distant implémentant l'interface.
Nous récupérons ainsi un objet « remoteOperation » manipulable comme un objet classique, mais dont l'implémentation est sur un serveur dissocié.

Revenez sur la Form et double-cliquez sur le bouton « Ajouter".

Placez dans la méthode qui est apparue (buttonAdd_Click) :

try
{
        if(remoteOperation != null)
        {
                int a = Int32.Parse(textBoxA.Text);
                int b = Int32.Parse(textBoxB.Text);
                textBoxResAdd.Text = remoteOperation.Addition(a,b).ToString();
        }
}
catch{ MessageBox.Show("Erreur !"); }

Revenez sur la Form et double-cliquez sur le bouton « Incrementation".

Placez dans la méthode qui est apparue (buttonInc_Click) :

try
{
        if(remoteOperation != null)
        {
                int valeur = Int32.Parse(textBoxValeur.Text);
                textBoxResInc.Text = remoteOperation.Incrementation(valeur).ToString();
        }
}
catch{ MessageBox.Show("Erreur !"); }

Compilez le projet.