Discussion :

[Bluedeep]

Bonjour

J'ai un petit soucis pour lequel j'ai trouvé une solution mais qui ne me satisfait que moyennement.

Je vous expose aussi simplement que possible la situation :
j'ai une application serveur qui reçoit des ordres de clients via invocation de méthodes.
Quand l'application serveur a reçu la demande, la méthode retourne, un thread est démarré qui exécute
la tâche demandée; quand cette tâche est exécutée, le serveur invoque une méthode sur le client
(via l'interface spécifié comme CallbackContract).

Jusque là, tout va bien.

Le soucis est quand le client se déconnecte pour se reconnecter après (que ce soit avant la fin de la tâche ou après, étant entendu qu'il s'agit de flux d'opérations pouvant s'étaler sur plusieurs heures voire jours), là ça se complique.

J'ai fini par trouver une solution, mais qui fait un peu "usine à gaz" (elle est basée sur un test de la présence du client avant le callback, si client absent mise en queue des appels de méthode et despooling de la queue lors de la reconnection).

Donc, ma question, existe-t-il une solution plus intégrée pour les callback sur des clients "reconnectés" avec WCF ?

Merci !

[Bluedeep]

Un petit up.

Personne n'a une idée car la solution là me plait vraiment que moyennement :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
 
       private Queue<ItemToCall> _queue = new Queue<ItemToCall>();
       private OperationContext _context;
 
        internal bool HasPendingCalls()
        {
            return _queue.Count > 0;
        }
 
        internal bool CallOrQueue<T>( string methodName, params object[] parameters )
        {
            bool ret = false;
            if (_context == null)
            {
                throw new NullReferenceException();
            }
 
            MethodInfo method = typeof( T ).GetMethod( methodName );
            ItemToCall itemToCall = new ItemToCall();
            itemToCall.method = method;
            itemToCall.parameters = parameters;
 
            ret = call<T>( itemToCall );
            if(ret == false) // queue
            {
                _queue.Enqueue( itemToCall );
            }
 
            return ret;
        }
 
        private bool call<T>( ItemToCall itemToCall )
        {
            bool ret = false;
            if (_context.Channel.State == CommunicationState.Opened)
            {
                try
                {
                   T callbackInterface = _context.GetCallbackChannel<T>();
                    itemToCall.method.Invoke( callbackInterface, itemToCall.parameters );
                    //Console.WriteLine( "{0} invoked from queue", itemToCall.method.Name );
                    ret = true;
                }
                catch (Exception)
                {
                    ret = false;
                }
            }
            return ret;
        }
        internal void CallPendingMethods<T>()
        {
            if (_context == null)
            {
                throw new NullReferenceException();
            }
            while (_queue.Count > 0)
            {
                ItemToCall itemToCall = _queue.Dequeue();
                bool ret = call<T>( itemToCall );
                if (ret == false)
                {
                     throw new Exception( "Channel closed" );
                }
 
            }
        }
 
        private class ItemToCall
        {
            internal MethodInfo method;
            internal object[] parameters;
        }