Introduction au connecteur mobile CSharp Silverlight DataSnap
Remonter à Introduction aux connecteurs mobiles DataSnap
Cette rubrique est un guide d'introduction à la génération et à l'utilisation du proxy C# Silverlight DataSnap, pour un usage avec le développement mobile Windows Phone 7. Le proxy C# Silverlight supporte les mêmes types de données que DataSnap supporte lui-même. Des classes C# spéciales ont été créées pour encapsuler ces types DBX et Delphi, et leur usage est similaire à celui dans Delphi.
A la demande, le serveur DataSnap REST génère et répartit la classe proxy utilisée pour invoquer les méthodes sur le serveur. C'est très similaire à la génération de proxy que vous connaissez déjà, mais vous avez en plus le processus de zippage du proxy et de toutes les dépendances, et l'envoi de ce fichier zip au demandeur.
Pour de plus amples informations sur ce processus, voir Introduction aux connecteurs mobiles DataSnap.
Sommaire
Comment télécharger les fichiers proxy C# Silverlight à partir d'un serveur DataSnap REST
Vous devez d'abord obtenir une copie de Win32ProxyDownloader.exe, disponible dans le répertoire \bin de votre répertoire d'installation. Ce fichier est traité dans Introduction aux connecteurs mobiles DataSnap, ainsi que l'emplacement où en obtenir une copie.
Le téléchargeur est un utilitaire simple qui vous aide à demander au serveur le proxy et les autres fichiers nécessaires à la communication avec le serveur.
Pour utiliser le téléchargeur de proxy, vous devez fournir les paramètres suivants :
- -language (obligatoire) : Spécifie la plate-forme et le langage du proxy requis. Pour Windows Phone 7, utilisez csharp_silverlight.
- -protocol : Spécifie le protocole de connexion à utiliser : http ou https. La valeur par défaut est http.
- -host : Spécifie le port, et l'adresse IP ou le nom de l'hôte sur lequel se connecter. La valeur par défaut est localhost avec le port 80. Pour spécifier un port ou un nom différent, qualifiez entièrement le nom avec le numéro de port, séparé par un deux-points (":").
- -output : Spécifie le dossier dans lequel télécharger les fichiers proxy. S'il n'est pas spécifié, le dossier en cours est utilisé.
L'exemple suivant utilise la plupart des paramètres mentionnés ci-dessus :
C:\Win32ProxyDownloader.exe -language csharp_silverlight -host 127.0.0.1:8080 -output C:\test
Après l'exécution du téléchargeur, les fichiers proxy C# Silverlight sont copiés dans le dossier de sortie spécifié. Voici ces fichiers :
- La dll d'analyse JSON
- Les fichiers source C# statiques requis par le proxy
- DSProxy.cs, le proxy généré
Le fichier principal, DSProxy.cs, déclare la classe qui contient toutes les méthodes définies sur le serveur.
Comment utiliser la classe DSProxy
Le code ci-dessous montre le fichier DSProxy.cs (C#) généré par le serveur. Il contient une classe TServerMethods1, qui encapsule les méthodes serveur. Le serveur a seulement une méthode (EchoString), et la classe C# TServerMethods1 l'implémente en conséquence. Le générateur de proxy a automatiquement généré le code pour la connexion au serveur et l'exécution des méthodes. Voir le code C# pour la méthode EchoString ci-dessous :
using System;
using System.Threading;
namespace Embarcadero.DataSnap.WindowsPhone7
{
public class DSProxy
{
public class TServerMethods1 : DSAdmin
{
public TServerMethods1(DSRESTConnection Connection, ExceptionCallback ExCal) : base(Connection, ExCal)
{
}
private DSRESTParameterMetaData[] TServerMethods1_EchoString_Metadata;
private DSRESTParameterMetaData[] get_TServerMethods1_EchoString_Metadata() {
if (TServerMethods1_EchoString_Metadata == null) {
TServerMethods1_EchoString_Metadata = new DSRESTParameterMetaData[] {
new DSRESTParameterMetaData("Value", DSRESTParamDirection.Input,
DBXDataTypes.WideStringType, "string"),
new DSRESTParameterMetaData("", DSRESTParamDirection.ReturnValue,
DBXDataTypes.WideStringType, "string"),
};
}
return TServerMethods1_EchoString_Metadata;
}
/**
* @param Value [in] - Type on server: string
* @return result - Type on server: string
*/
public delegate void EchoStringCallback(String Result);
public void EchoString(String Value, EchoStringCallback callback = null, ExceptionCallback ExCal = null)
{
DSRESTCommand cmd = getConnection().CreateCommand();
cmd.setRequestType(DSHTTPRequestType.GET);
cmd.setText("TServerMethods1.EchoString");
cmd.prepare(get_TServerMethods1_EchoString_Metadata());
InternalConnectionDelegate EchoStringDel = () => {
if (callback != null) {
try {
callback.DynamicInvoke(cmd.getParameter(1).getValue().GetAsString());
} catch (Exception ex) {
if (ExCal != null)
getConnection().syncContext.Send(new SendOrPostCallback(x =>
ExCal.DynamicInvoke(ex.InnerException)), null);
else
getConnection().syncContext.Send(new SendOrPostCallback(x =>
BaseExCal.DynamicInvoke(ex.InnerException)), null);
}
}
};
cmd.getParameter(0).getValue().SetAsString(Value);
getConnection().execute(cmd, this, EchoStringDel, ExCal);
}
}
}
}
La première étape de l'utilisation de la classe proxy consiste à créer et à configurer une connexion au serveur. La classe DSRESTConnection encapsule toutes les propriétés et méthodes nécessaires à la connexion au serveur. Créez simplement la connexion et configurez les propriétés, comme illustré ci-dessous :
DSRESTConnection connection = new DSRESTConnection();
connection.setHost("hostname");
connection.setPort(portnumber);
connection.setProtocol("http");
- La propriété host spécifie le nom de l'hôte ou l'adresse IP.
- La propriété port spécifie le port sur lequel le serveur écoute.
- La propriété protocol spécifie le protocole à utiliser pour la connexion. Spécifiquement : http ou https.
Pour invoquer les méthodes serveur à distance, créez simplement la classe proxy, en passant la connexion, puis appelez la méthode :
DSRESTConnection connection = new DSRESTConnection();
connection.setHost("localhost");
connection.setPort(8080);
connection.setProtocol("http");
DSProxy.TServerMethods1 Proxy = new DSProxy. TServerMethods1(connection, ExceptionCallback);
Proxy.EchoString("teststring", (String Result) =>
{
// ...
}, ExceptionCallback);
public void ExceptionCallback(Exception e)
{
// ...
}
Exemple d'une méthode serveur avec un paramètre var
L'exemple suivant est le code qui est généré quand votre méthode serveur contient un paramètre var ou renvoie plusieurs résultats. Voici le code Delphi pour la méthode serveur :
function TServerMethods1.VarParamTest(var Value: string): string;
begin
Value := StrUtils.ReverseString(Value);
Result := Value;
end;
Et voici le code proxy généré pour invoquer cette méthode serveur :
private DSRESTParameterMetaData[] TServerMethods1_VarParamTest_Metadata;
private DSRESTParameterMetaData[] get_TServerMethods1_VarParamTest_Metadata()
{
if (TServerMethods1_VarParamTest_Metadata == null) {
TServerMethods1_VarParamTest_Metadata = new DSRESTParameterMetaData[] {
new DSRESTParameterMetaData("Value", DSRESTParamDirection.InputOutput,
DBXDataTypes.WideStringType, "string"),
new DSRESTParameterMetaData("", DSRESTParamDirection.ReturnValue,
DBXDataTypes.WideStringType, "string"),
};
}
return TServerMethods1_VarParamTest_Metadata;
}
/**
* @param Value [in/out] - Type on server: string
Notez que la méthode renvoie une instance de VarParamTestReturns. Cette classe spéciale contient les informations sur les paramètres var (in/out), ainsi que le résultat. L'exemple suivant montre comment invoquer la méthode et lire les valeurs résultantes :
Proxy. VarParamTest ("Hello, World!",
(DSProxy.TServerMethods1.VarParamTestReturns Result) => {
Debug.WriteLine(Result.Value);
Debug.WriteLine(Result.returnValue);
}
);
La nouvelle valeur du paramètre transmis et la valeur du résultat sont contenues dans l'instance de Result. La valeur de Result.Value est "!dlroW ,olleH", et la valeur de Result.returnValue est "Hello, World!".
Comment utiliser les rappels avancés
Les rappels avancés fournissent un moyen, aux serveurs DataSnap, d'envoyer des notifications presque instantanées aux clients REST. Un client peut enregistrer un rappel pour une rubrique spécifique du serveur qui l'intéresse. Ainsi, à chaque fois que cette rubrique est mise à jour, le client reçoit une notification. C'est, bien entendu, une description très simplifiée de ce que les rappels avancés accomplissent, mais qui doit être suffisante pour les besoins de ce document.
La première étape lors de l'utilisation des rappels dans votre application consiste à créer une classe de rappel personnalisé qui hérite de la classe abstraite DBXCallback et à redéfinir la méthode abstraite "Execute". Voici un exemple d'implémentation de cette classe :
public class MyCallback : DBXCallback {
public override TJSONValue Execute(TJSONArray params) {
Debug.WriteLine(Params.ToString());
return new TJSONTrue();
}
}
La classe DSClientCallbackChannelManager gère les rappels du client. Elle fournit les méthodes pour l'enregistrement et le désenregistrement des rappels, et la fermeture d'un rappel ou de tous les rappels.
Le constructeur de DSClientCallbackChannelManager accepte trois paramètres :
- DSRESTConnection, spécifiant les informations de connexion au serveur
- Une chaîne contenant le nom du canal serveur avec lequel enregistrer
- Une chaîne contenant l'ID du gestionnaire (unique au serveur)
DSCallbackChannelManager mngr =
new DSCallbackChannelManager(Connection, "chname", DSCallbackChannelManager.getNewManagerID());
Voici un exemple d'enregistrement d'un rappel puis de la diffusion sur le canal où il a été enregistré :
public void testCallbacks(){
DSAdmin admin = new DSAdmin(Connection, ManageExceptionCallback);
mngr = new DSCallbackChannelManager(Connection," chname",DSCallbackChannelManager.getNewManagerID());
mngr.registerCallback("mycb01", new MyCallback(), () =>
{
admin.BroadcastToChannel("chname", new TJSONString("This is a broadcast"),(bool b) =>
{
mngr.closeClientChannel();
});
}
public void ManageExceptionCallback(Exception e)
{
// ...
}
Le premier paramètre de la méthode 'registerCallback' est un ID pour le rappel (un ID unique au canal client). Le deuxième paramètre est l'instance de rappel réelle à enregistrer, et le troisième paramètre est une méthode déléguée pour invoquer quand l'enregistrement s'achève.
Le code ci-dessus enregistre une nouvelle instance de la classe MyCallback sur le serveur, qui écoute sur le canal chname. Quand cet enregistrement a réussi, le client appelle BroadcastToChannel, en envoyant la chaîne "This is a broadcast" à tous les rappels (y compris lui-même) qui écoutent sur le canal "chname".
Le troisième paramètre de l'appel de BroadcastToChannel est un délégué qui est invoqué quand l'appel revient du serveur, en contenant une valeur booléenne qui indique si le serveur a géré avec succès la requête de diffusion. Le code ci-dessus, dans cette déclaration de délégué imbriquée, ferme ensuite le gestionnaire du canal afin de ne plus recevoir de diffusions.