Discussion :

[davcha]

Admettons que j'ai une application distribuée qui traite de généalogie.
J'ai, notamment, une couche métier, exposée par un service WCF, qui s'exécute sur un serveur.

Un de mes objets métier qui transitent entre le serveur et les clients est "Personne".
Très simple, il comporte 3 propriétés. Deux strings : Prénom, Nom. Et une relation 1-0..1 avec un autre objet "Personne" : Conjoint.

J'ai une jolie petite interface graphique pour manipuler ces données :


Mon service WCF expose, entre autres, deux méthodes de la couche métier :
void SeMarie(Personne a, Personne b);
void Divorce(Personne a);
Bon, ce cas est tellement simple qu'on pourrait se contenter de faire un update simple, du genre Personne.Conjoint = .....;
Mais pour la clarté du problème, on va garder nos méthodes SeMarie et Divorce.

Admettons que Jean Dupond n'est pas marié avec Jeanne. Si j'appelle service.SeMarie(jean,jeanne), jean et jeanne se retrouvent modifiés côté serveur. Cool. Qu'en est-il de l'IHM ? Comment garder la cohérence des données à ce niveau là ? N'y a-t-il pas moyen de rapatrier les modifications survenues sur le serveur au niveau du client ?

Admettons que, plus tard, rien ne va plus et Jean décide de divorcer. service.Divorce(jean), donc.
Aucune référence à Jeanne n'est passée au serveur, il pourra malgré tout modifier jean et jeanne sur le serveur, mais qu'en est-il du client ?

En bref, comment répercuter, sur le client, les modifications, des objets métier, intervenues sur le serveur ?

[Philippe Vialatte]

euh...
si tu maries jean avec jeanne, soit tu rafraichis tout jean apres mise a jour, soit tu geres la mise a jour cote client de jean, et, la prochaine fois que tu affiche jeanne, tu fais un aller-retour serveur, non ?

Ou j'ai loupe une subtilité

[davcha]

si jean et jeannes sont affichés en même temps ?

[tomlev]

si jean et jeannes sont affichés en même temps ?

tu rafraichis les 2...
pour le divorce, tu sauvegardes la référence à jeanne avant d'appeler Divorce, de façon à pouvoir rafraichir jeanne après

[The_badger_man]

J'ai une jolie petite interface graphique pour manipuler ces données :

T'as été conseillé par Thomas Lebrun en design ?

[tomlev]

T'as été conseillé par Thomas Lebrun en design ?

rhooo.... comme c'est méchant

[Thomas Lebrun]

T'as été conseillé par Thomas Lebrun en design ?

Rhoo, n'en mais t'as pas bientôt finit de te moquer de mes talents de designer

[davcha]

T'as été conseillé par Thomas Lebrun en design ?

C'était juste un exemple vite fait, destiné à illustrer ce post :p

Sinon, pour mon problème, je pense que je vais me tourner vers un canal duplex et un contrat de callback.

Donc en gros, sur mon service, les méthodes SeMarie(Personne item, Personne withitem) et Divorce(Personne item) appellent un callback du genre ConjointChanged(Personne item) chez le client.
Par contre, comment conserver la référence "item" et "withitem" lors de sa serialisation/déserialisation ?
J'ai tenté [DataContract(IsReference = true)], mais ça ne résoud pas le problème (c'est juste bon pour les références cycliques en fait)



Du coup, actuellement, dans ma solution de test, j'ai un système que je trouve un peu bâtard :

Côté serveur, j'ai un Dictionary<long, Personne> et un "long NextOID".
Dans la classe "Personne", j'ai un attribut "OID" long.
Quand le serveur instancie de nouvelles personnes, il renseigne l'attribut OID avec NextOID, puis insère la personne dans le dictionnaire, avec comme clef NextOID. Ensuite, NextOID est incrémenté de 1.
Ce qui fait que chaque personne a un OID unique.

Quand une personne transite par wcf sur le client, puis revient au niveau du serveur, l'attribut OID étant sérialisé, je peux retrouver la bonne référence dans mon dictionnaire.

Je trouve cette solution particulièrement pas top. D'autant plus que si je veux pouvoir faire mon truc avec un canal duplex, il faudra que j'ai +/- le même système côté client.

Y a-t-il un moyen pour conserver les références des objets qui transitent à travers un canal wcf ?...

[The_badger_man]

Donc en gros, sur mon service, les méthodes SeMarie(Personne item, Personne withitem) et Divorce(Personne item) appellent un callback du genre ConjointChanged(Personne item) chez le client.
Par contre, comment conserver la référence "item" et "withitem" lors de sa serialisation/déserialisation ?
J'ai tenté [DataContract(IsReference = true)], mais ça ne résoud pas le problème (c'est juste bon pour les références cycliques en fait)

Objet coté client != objet coté serveur
Tu ne fais pas transiter des références mais des données.

Côté serveur, j'ai un Dictionary<long, Personne> et un "long NextOID".
Dans la classe "Personne", j'ai un attribut "OID" long.
Quand le serveur instancie de nouvelles personnes, il renseigne l'attribut OID avec NextOID, puis insère la personne dans le dictionnaire, avec comme clef NextOID. Ensuite, NextOID est incrémenté de 1.
Ce qui fait que chaque personne a un OID unique.

Tu risques d'avoir des pb quand plusieurs threads utilisent NextOID pour l'incrémenter.
Utilises plutôt les Guid. Tu fais Guid.NewGuid() et c'est bon, t'as un ID unique.

[davcha]

Objet coté client != objet coté serveur
Tu ne fais pas transiter des références mais des données.


Tu risques d'avoir des pb quand plusieurs threads utilisent NextOID pour l'incrémenter.
Utilises plutôt les Guid. Tu fais Guid.NewGuid() et c'est bon, t'as un ID unique.

Ca forcément que les références sont différentes, comme on est pas forcément sur le même ordinateur. Je me demandais juste s'il n'y avait pas une méthode moins merdique que celle que j'utilise.

(Merci pour le Guid, je connaissais pas :p)