Détecter un appel à Control.Invoke bloquant

Version imprimable

Bonjour,

j'aimerais savoir si c'est possible de détecter un appel bloquant à la méthode Control.Invoke(Delegate , params object[]).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
        public delegate void addMessageDelegate(string message);
 
        public void addMessage(string message)
        {
            System.Diagnostics.Debug.Assert(isClosed == false);
 
            if (message != "")
            {
                if (myProgressDialog.InvokeRequired)
                {
                    addMessageDelegate d = new addMessageDelegate(addMessage);
                    myProgressDialog.Invoke(d, new object[] { message }); //Est-ce possible d'accorder par exemple 2 secondes à cette méthode et déclencher une exception si ça prend plus de temps
 
                }
                else
                {
                    myProgressDialog.addMessage(Utilities.getDateString(DateTime.Now, false) + " : " + message + Environment.NewLine);
                }
            }
        }

Merci.

Pas sûr que ce soit exactement ce que tu veux, mais avec l'object Task<T> tu peur lancer une tâche, puis avec Wait() tu peux attendre la fin de cette tâche avec un certain timeout.
Si la tâche n'est toujours pas finie après ce timeout, tu peux annuler la tâche.

Un exemple pris ici :http://stackoverflow.com/questions/4...he-task-finish

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
var cts = new CancellationTokenSource();
 
        var newTask = Task.Factory.StartNew(state =>
                                   {
                                      var token = (CancellationToken)state;
                                      while (!token.IsCancellationRequested)
                                      {
                                      }
                                      token.ThrowIfCancellationRequested();
                                   }, cts.Token, cts.Token);
 
 
        if (!newTask.Wait(3000, cts.Token)) cts.Cancel();

11/04/2012, 14h17
momobjk

Merci beaucoup, c'est exactement ce que je voulais. Je test et je vous dis si ça marche.

EDIT : j'utilise le framework 3.5 et Task n'existe pas malheureusement.
12/04/2012, 09h40
GuruuMeditation

Alors il faudra utiliser des threads ou backgroundworker.

Est-ce qu'il faut réellement l’annuler après 2 secondes? Ou c'est juste pour ne pas bloquer ton application trop longtemps?
12/04/2012, 10h45
momobjk

J'ai dit 2 secondes au hasard. C'est juste que de temps en temps l'application bloque sur cette instruction et je suis obligé de tout redémarrer. Je n'ai pas trouvé le moyen de "killer" cette opération.

En fait j'utilise Invoke car la méthode est appelé par un autre thread de celui qui a créé le Control.
12/04/2012, 11h25
spottt
C'est peut-être un peu "tricky" (et peut-être même pas correct), mais ne serait-ce pas possible d'utiliser un lock autour de ces opérations, avec un timer intégré?

Cela permettrait de ne pas laisser la main tant que l'opération ne s'est pas terminée, et de rendre la main si elle prend plus de temps que ce que tu ne désires.
Code:

1 2 3 4 5 6 7 8 9 10 11 lock (_locker) { int limit = 0; while (limit < 200) { // tes opérations limit++; Thread.Sleep(10); } }
12/04/2012, 14h43
momobjk

Merci pour vos réponse.

J'ai pensé à faire ça mais le problème c'est que la variable ne sera pas incrémenté puisque l'opération est bloquante.