Je ne suis pas vraiment sûr de savoir comment gérer le scénario que j'ai en respectant le code.
Le critère de base de mon travail est le suivant :
- Une application WPF qui consomme un service WCF
- Le service utilise l'instanciation par session
- La session commence peu après le démarrage de l'application et doit durer pendant toute la durée de vie de l'application (à quelques exceptions près).
- Certains appels de méthodes dans une session doivent précéder et être terminés avant que d'autres ne soient appelés.
Cela signifie que je dois pouvoir disposer d'une seule instance d'un client proxy dans toute l'application. Je devrai également être capable de gérer les appels asynchrones, afin que le client ne raccroche pas, tout en s'assurant qu'il a terminé.
Ma compréhension technique de WCF est assez limitée pour ne pas savoir si certains scénarios fonctionneraient comme prévu. Ainsi je vais énumérer mes incertitudes :
- Quand une session commence-t-elle et quand se termine-t-elle ? Est-elle basée sur la création de clients ou un autre client peut-il accéder à la même session si le premier tombe en panne ?
- Quelle est la meilleure façon de traiter des exceptions par un service de WCF
- Est-ce que ChannelFactory est quelque chose que je devrais regarder pour m'aider à mettre ici.
Donc ce que j'ai fait dans la première itération pour essayer de résoudre certains de ces problèmes.
- J'ai utilisé l'injection de dépendances pour injecter l'instance du client dans toutes les classes de mon application WPF (j'utilise MVVM) afin de m'assurer que la même instance se trouve partout.
- J'ai créé la référence du service en utilisant la méthode de génération asynchrone pour obtenir les versions Begin et End de toutes les méthodes afin de garantir que les appels seront asynchrones.
- J'ai utilisé la fonction Coroutine (interface IResult) du framework Caliburn.Micro pour m'assurer qu'une action asynchrone est terminée avant que l'autre ne commence (je n'ai aucune idée si c'est une utilisation correcte ou si c'est une démarche intelligente).
Le problème que je rencontre encore est bien sûr de savoir comment gérer un état défaillant du client. Je suppose pour l'instant que je pourrais réinstaller le client et sauver la session ou que je pourrais simplement le réinstaller tel qu'il était. Je dois maintenant le réinstaller à chaque endroit où je l'ai injecté avec la même nouvelle instance.
J'ai donc pensé qu'il serait peut-être préférable de créer une classe ClientManager qui envelopperait le Client. De cette façon, je pourrais injecter ce ClientManager et le réinstaller à l'intérieur si nécessaire. Je suppose que je devrais l'exposer à l'extérieur pour pouvoir faire des appels de méthode, mais ce serait génial si je pouvais gérer les erreurs à l'intérieur de lui d'une manière ou d'une autre. J'ai du mal à tester mes méthodes et je ne suis jamais certain qu'elles fonctionneront correctement en intégration, car je ne comprends pas tous les rouages de WCF, des coroutines et du threading.
Y a-t-il quelqu'un qui a plus d'expérience que moi dans ce domaine et qui pourrait me donner quelques conseils ou au moins me dire comment WCF fonctionne dans ces situations (par session) et ce que je fais de mal et de bien.
