Discussion :

[grinder59]

Bonjour,

dans mon programme, je fais appel à un webservice dont je n'ai pas la gestion... Et qui dit "web service" dit "potentiels problèmes de réseau lors d'un appel". Pour éviter de gaufrer mon programme alors qu'un seul appel ne passe pas suite à une micro coupure, je voudrais mettre en place un time out sur mon appel. Vers quelles fonctions / classes / méthodes m'orienteriez-vous ? (je ne demande pas du code tout fait, mais une piste)

Merci de votre aide !

[smyley]

Utilise un Thread pour appeler ton webservice. ça fera un truc genre

Code c# :

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
 
bool finished = false;
            bool success = false;
            Thread th = new Thread(new ThreadStart(delegate
            {
                SummonZeWebService();
 
                finished = true;
                success = true;
            }));
            th.Start();
 
            DateTime start = DateTime.Now;
            while (!finished && DateTime.Now.Subtract(start).TotalSeconds < 60) /* 60 secondes */
            {
                Thread.Sleep(10);
            }
            if (!finished)
            {
                try
                {
                    th.Abort();
                }
                catch { }
                Failure();
            }
            else
            {
                  Victory();
            }

[grinder59]

Merci de ta réponse...

Par contre je ne connais pas bien le fonctionnement des threads... Le fait que je boucle pour faire plusieurs fois (> 300) appel au même webservice (avec des valeurs différentes) ne risque-t-il pas de poser un souci ? (je pense notamment au nombre d'instances de threads)

Existe-t-il une autre solution sans thread ?

Merci !

[smyley]

Si ils sont appelés de manière successive en gros tu aura qu'un seul thread à la fois qui sera en train d'appeler le WebService donc pas de problème car chaque thread s'arrête lorsque le code qu'il "contient" se termine.
S'ils sont appelés simultanément là ça devient autre chose et tu sera peut être contraint d'utiliser un ThreadPool (google t'en apprendra plus sur ce point).

[grinder59]

Donc ça devrait bien se passer puisque cela va se présenter, en gros, de la façon suivante :

Code :

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

1
2
3
4
5
6
 
for (int i=0; i < nombre_max; i++){
 
   Le code que tu m as donné
 
}

Juste histoire que je sois sûr, tu ne vois pas de contre-indication à l'utilisation du thread ?

[smyley]

Bah ça devrais aller. Mais tu devrais quand même regarder les histoires de ThreadPool, ça pourrai te servir par la suite, vu que question performances c'est toujours un peut lent de démarrer un nouveau thread.

[grinder59]

OK, merci !!!
Toute dernière précision par rapport au code que tu m'a donné pour voir si j'ai bien capté (et si je vais pas l'utiliser à mauvais escient) :
-> dans delegate je mets les instructions qui seront exécutées dans le thread
-> le while me permet d'attendre la fin de l'appel OU la fin du délai "autorisé" pour le traitement (10 secondes)

mais à quoi sert le Thread.Sleep(10); ? et surtout pourquoi lui passer 10 alors que le délai "autorisé" est 60 secondes ?

Merci de tes explications !

[smyley]

-> dans delegate je mets les instructions qui seront exécutées dans le thread

oui

-> le while me permet d'attendre la fin de l'appel OU la fin du délai "autorisé" pour le traitement (10 secondes)

Les deux à la fois

mais à quoi sert le Thread.Sleep(10); ? et surtout pourquoi lui passer 10 alors que le délai "autorisé" est 60 secondes ?

En fait mon idée c'est que pour quelque chose orienté webservice tu as un truc genre une interface avec une message "Veuillez patienter". Pour ne pas bloquer l'interface et que l'utilisateur vois que ton application ne réponds pas, tu crées un autre thread (de la même manière) qu'on va appeler Joe et dedans tu y exécutes ton travail. Donc avec une variable globale tu vérifies grâce à un Timer que l'opération est terminée ou que le thread Joe se soit terminé et si oui tu dit à l'utilisateur que c'est terminé, sinon tu laisses le Veuillez patienter.

Dans Joe maintenant il faudra faire les appels successifs à tes webservice. Il faudra donc créer d'autres threads à partir de Joe avec la boucle que tu as mentionné. Pendant ce temps cependant Joe doit attendre que les threads soit terminées et c'est à ça que servent les variables success et finished. Donc tant que l'appel au webservice n'est pas terminé (if(!finished)) il faut attendre ou abandonner (si ça dépasse 60 secondes, on Abort le sous thread). Ce qui correspond à ma boucle. Sauf que la construction

Code c# :

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

1
2
3
4
 
while(true)
{
}

mange 100% du processeur. Donc il faut attendre gentiment avec le Thread.Sleep(10) qui ne correspond pas à 10 secondes mais à 10 millisecondes et dans ce cas l'utilisation du processeur redescend à ~0%.
Une fois que l'attente est fini on peut donc passer au suivant, et quand Joe sera terminé, ton interface pourra être mise à jour avec le status de l'opération achevée.

[Guulh]

Précisons aussi que pour les webservices, Visual Studio génère le code d'un wrapper automatiquement (via "ajouter une référence web..." dans le menu contextuel de l'explorateur de solutions), et que pour chaque méthode getMachin proposée par le webservice, le wrapper a deux méthodes getMachin et getMachinAsync, cette dernière faisant exactement ce que tu veux.

Et si t'es curieux, libre à toi de regarder le code généré pour savoir comme le bouzin est implémenté

[smyley]

Précisons aussi que pour les webservices, Visual Studio génère le code d'un wrapper automatiquement (via "ajouter une référence web..." dans le menu contextuel de l'explorateur de solutions), et que pour chaque méthode getMachin proposée par le webservice, le wrapper a deux méthodes getMachin et getMachinAsync, cette dernière faisant exactement ce que tu veux.

Hé bah je savais pas, jamais eu l'occasion de tester les webservices

[DarkHerumor]

Bah ça devrais aller. Mais tu devrais quand même regarder les histoires de ThreadPool, ça pourrai te servir par la suite, vu que question performances c'est toujours un peut lent de démarrer un nouveau thread.

Code :

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

ThreadPool.QueueUserWorkItem(new WaitCallback(delegate(object o) { /*myCode*/ }));

La méthode magique!