Discussion :

[Piet]

Bonjour,

Par la "reflection", il est possible d'envoyer le nom de la méthode et ses paramètres pour l'exécution au travers de InvokeMember(...)

Dans une exécution sur le poste local, pas de problème, ceci fonctionne bien, mais par contre lorsque je travaille avec du remoting, je ne sais pas comment passer les arguments à InvokeMember. Soit le type est vu comme un proxy et je ne sais pas faire grand chose, soit le type est forcément mauvais (puisque l'interface n'implémente rien)

Après avoir cherché, je suis tombé sur http://blogs.msdn.com/manishg/archiv...09/227400.aspx, mais ceci ne m'aide pas...

Quelqu'un peut-il m'aider?

Voici de plus amples informations sur le contexte (si ça peut aider à la compréhension) :

IRemoteOperation.cs

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
namespace RemotingInterfaces
{
    public interface IRemoteOperation
    {
        bool Action(type1 param1, type2 param2, ...);
    }
}

RemoteOperations.cs

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
namespace RemotingInterfaces
{
    public class RemoteOperation : MarshalByRefObject, RemotingInterfaces.IRemoteOperation
    {
        bool Action(type1 param1, type2 param2, ...)
        {
            // Action is executed here
        }
    }
}

Ceci fonctionne très bien et m'exécute bien l'action sur le pc souhaité :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
RemotingInterfaces.IRemoteOperation op;
string pcName = "PC-DE-TEST";
int port = 12345;
op = (RemotingInterfaces.IRemoteOperation)Activator.GetObject(
    typeof(RemotingInterfaces.IRemoteOperation),
    "tcp://" + pcName + ":"+port.ToString()+"/RemoteOperation");
 
bool b = op.Action(Param1, Param2, ...)

Pour une économie et une réutilisation du code, je souhaite envoyer toutes les actions vers une fonction plus générale :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
bool GeneralAction( string action, object [] params)

Ceci pourra me permettre de faire les mêmes opérations de vérification pour toutes les actions.

Pour une exécution locale, je n'ai pas de problème :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
private bool LocalExecute(string action, object[] myParams)
{
    Type type1 = typeof(RemoteOperation);
    object obj = Activator.CreateInstance(type1);
    bool res = (bool)type1.InvokeMember(action, System.Reflection.BindingFlags.InvokeMethod, null, obj, myParams);
}

Par contre, pour exécuter sur le client, je n'arrive pas à prendre le type de op et donc de pouvoir passer par l'interface :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
private bool RemoteExecute(string action, object[] myParams, string pcName, DateTime expirationDate)
{
    Type myType = typeof(IRemoteOperation);
    string url = "tcp://" + pcName + ":"+port.ToString()+"/RemoteOperation";
    op = (IRemoteOperation)Activator.GetObject(myType,url);
    //Ce qui suit est faux!
    Type type2 = typeof(IRemoteOperation);
 
    bool res2 = (bool)type2.InvokeMember(action, System.Reflection.BindingFlags.InvokeMethod,null, op, myParams);
 
}

Comment faire?

Toute solution est la bienvenue.

Merci d'avance.

[Pol63]

et en invokant un membre de l'interface avec de la reflection sur l'interface ?

[Piet]

C'est bien ce que j'essaie de faire, mais je ne vois pas trop comment... C'est ce que la dernière frame de code montre.

En gros, de quoi dois-je faire un "CreateInstance()" ?

[Piet]

On peut faire un invokemember sur un membre d'interface?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
Type myType = typeof(IRemoteOperation);//type1.GetInterface("RemotingInterfaces.IRemoteOperation");
 
string url = "tcp://" + pcName + ":"+port.ToString()+"/RemoteOperation";
IRemoteOperation theRemoteOperation = null;
theRemoteOperation = (IRemoteOperation)Activator.GetObject(myType,url);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
object objro01 = Activator.CreateInstance(myType);

Crée une exception :

"impossible de créer une interface"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
object objro02 = Activator.CreateInstance(theRemoteOperation.GetType());

crée une exception :

"impossible de créer une méthode abstraite"

Une idée?

Je ne vois plus clair...

[Pol63]

si c'est pour instancier des objets, on ne peut pas avec juste une interface (trouver une méthode encore ca devrait etre faisable)

donc si tu veux créer une instance dont le type est sur le serveur, je pense qu'il faut que tu demandes l'instance au serveur qui lui aura accès aux classes

[Piet]

ok... Et comment puis-je faire ça?

[Pol63]

et bien le remoting sert à exposer des membres du serveur au client
du fait une fonction qui instancie un machin et le retourne
et le client l'appelle

[Piet]

Mais j'ai normalement accès aux membres du serveur

Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
RemotingInterfaces.IRemoteOperation op;
string pcName = "PC-DE-TEST"; 
int port = 12345;
op = (RemotingInterfaces.IRemoteOperation)Activator.GetObject(
    typeof(RemotingInterfaces.IRemoteOperation),
    "tcp://" + pcName + ":"+port.ToString()+"/RemoteOperation");
 
bool b = op.Action(Param1, Param2, ...)

je souhaiterais juste pouvoir faire un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

bool b = (bool)TypeX.InvokeMember("op."+action, myParams);

à la place de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

bool b = op.Action(Param1, Param2, ...)

Ai-je vraiment besoin de demander une instance au serveur pour ça?

Le problème, c'est que :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

bool b = (bool)theRemoteOperation.GetType().InvokeMember(action, System.Reflection.BindingFlags.InvokeMethod, null, theRemoteOperation, myParams);

donne :

Méthode 'System.MarshalByRefObject.PopUp' introuvable.

où action= "PopUp", existe dans la classe et dans l'interface.

De toute façon, le serveur ne peut me répondre que les types suivants :
- IRemoteOperation
- RemoteOperation
et le client ajoutera :
- System.MarshalByRefObject

A la limite, je veux même bien le fixer en dur, mais ça ne changera rien que ce soit le serveur qui me réponde "IRemoteOperation" ou que je le fixe...

[Pol63]

je suis pas vraiment expert en remoting, mais vu que t'avais pas spécialement de réponse j'ai tenté ma chance
de plus je comprends pas trop ton code et ce que tu veux faire

mais le principe du remoting c'est une interface commune de chaque coté
cette interface est implémentée de chaque coté par des classes qui peuvent etre différentes
le serveur se met en écoute et expose une classe implémentant l'interface
quand un client se connecte il instancie un élement de la classe coté serveur
et le client voit cette instance
ensuite il peut appeler des membres de l'interface et c'est le serveur qui répond
et pour avoir accès aux membres coté client on cast l'instance retournée par le serveur sur l'interface, il n'y a donc rien à instancier ..

[Piet]

Sorry, je m'en veux énormément...

En fait, ça fonctionne très bien et sans doute depuis le début... Le seul problème était dû au comportement de la machine car le même exe était toujours dans la liste des processus... :-s et donc, certaines info ne revenaient pas... Le pire, c'est que ça m'était déjà arrivé il y a quelques années et que j'avais pesté de la même façon...

Vraiment désolé pour le dérangement Pol63... et merci pour tes tentatives de résolution.

[Piet]

Oui, c'est bien ça le remoting...

C'est surtout pour avoir une définition commune au client et au serveur et avoir une communication bidirectionnelle que je l'utilise en fait.

Merci pour ton aide en tout cas.