Débuter avec .NET Remoting en C#

Formation débuter avec .NET Remoting en C#, tutoriel & guide de travaux pratiques en pdf.

L’interface

Pour que le client ait connaissance des méthodes distantes, une interface contenant leur déclaration doit être distribuée côté client et côté serveur. L’objet exposé sur le serveur devra implémenter cette interface.
Cette interface sera le seul élément commun entre le serveur et le client. Donc pour simplifier sa distribution, nous allons créer une dll.

Ouvrez Visual Studio .NET

Créez une nouvelle solution vierge : « RemotingSolution »
Ajoutez à la solution un nouveau projet C# de type « Librairie de classes », nommez le :
« RemotingInterfaces »
Renommez le fichier Class1.cs en « IRemoteOperation.cs »
Remplacez la classe Class1 dans le code par :

C#
namespace RemotingInterfaces
{
public interface IRemoteOperation
{
int Addition(int a, int b);
int Incrementation(int valeur);
}
}

Le serveur

L’objet distribué
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 :

C#
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.
– 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.
– Les méthodes Addition() et Incrementation() sont aussi définies conformément à l’interface IRemoteOperation.
– 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 tutorial, il n’y a pas lieu d’en placer.
Pour plus de simplicité, le code d’addition et de multiplication est directement écrit dans les méthodes exposées. En général, il est préférable d’écrire des classes spécifiques à ces traitements et laisser les classes en front s’occuper uniquement des appels.
Configuration et lancement du serveur
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 :

C#
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();
http://defaut.developpez.com/tutoriel/dotnet/remoting/cs/
Débuter avec .NET Remoting en C# par Julien DEFAUT
C#
}
}
}
}

– 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 modeSingleton.
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 uneactivation 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 ».
Pour simplifier et ne pas multiplier les classes, nous avons mis le code de configuration et de démarrage du serveur dans la méthode Main(). Il est cependant préférable de réaliser une classe dédiée cette tâche.

Le client

Interface graphique
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 :
Récupération de la référence à l’objet distant
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 :

C#
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
http://defaut.developpez.com/tutoriel/dotnet/remoting/cs/
Débuter avec .NET Remoting en C# par Julien DEFAUT
C#
using System.Runtime.Remoting.Channels.Tcp;
Déclarez dans la classe Form1 :
C#
private RemotingInterfaces.IRemoteOperation remoteOperation;
Ajoutez dans le constructeur (Form1()) de Form1, le code suivant :
C#
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é.
Appels aux méthodes distantes
Revenez sur la Form et double-cliquez sur le bouton « Ajouter »

1 – Présentation
.NET Remoting, c’est quoi ?
Objectif de l’article
2 – L’interface
3 – Le serveur
L’objet distribué
Configuration et lancement du serveur
4 – Le client
Interface graphique
Récupération de la référence à l’objet distant
Appels aux méthodes distantes
5 – Tests
6 – .NET Remoting ou Web Services ?