Discussion :

[waxman]

Bonjour,

Voici en quelques lignes le projet:
Il s'agit d'une application windows testant des temps de réactivité de l'utilisateur. Elle émet donc un signal et mesure le temps entre le signal et la réaction de l'utilisateur.

Je suis parti sur un modèle multithread afin que le code qui lance le signal et attend ne pénalise pas l'interface utilisateur.

Mon form principal possède un backgroundworker qui lance une classe chargée d’émettre le signal (son) et d'attendre la réaction de l'utilisateur

J'ai donc le code suivant:

Dans le form principal

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
 
        AudioTestsWorker runningTest;
 
        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            // This event handler is where the actual work is done.
            // This method runs on the background thread.
 
            // Get the BackgroundWorker object that raised this event.
            System.ComponentModel.BackgroundWorker bgWorker;
            bgWorker = (System.ComponentModel.BackgroundWorker)sender;
 
            // Get the Worker object and call the main method.
            AudioTestsWorker wk = (AudioTestsWorker)e.Argument;
            wk.RunTest(bgWorker, e, 10);
        }
 
        private void StartWorkerThread()
        {
            // Initialize the object that the background worker calls.
            runningTest = new AudioTestsWorker();
 
            // Start the asynchronous operation.
            backgroundWorker1.RunWorkerAsync(runningTest);
        }
        private void Form1_KeyDown(object sender, KeyEventArgs e)
        {
            if (runningTest != null)
                runningTest.KeyPressed(DateTime.Now);
        }

Dans ma classe AudioTestsWorker

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
 
    public class AudioTestsWorker
    {
        protected DateTime _startTime;
        protected DateTime _keyTime;
        protected Boolean _keyPressed;
        protected int[] _results;
 
        public void RunTest(
                System.ComponentModel.BackgroundWorker worker,
                System.ComponentModel.DoWorkEventArgs e,
                int count)
        {
            _results = new int[count];
 
            for (int cpt=0;cpt<count;cpt++) {
                if (worker.CancellationPending) {
                    e.Cancel = true;
                    break;
                }
                else {
                    worker.ReportProgress(0, cpt+1);
                }
 
                Random rnd      = new Random(unchecked((int)(DateTime.Now.Ticks)));
                int waitTime    = rnd.Next(6000);
                Thread.Sleep(waitTime);
 
                _keyPressed      = false;
 
                SystemSounds.Beep.Play();
                _startTime = DateTime.Now;
 
                for (int cpt2 = 0; cpt2 < 20; cpt2++)
                {
                    if (_keyPressed)
                        break;
                    Thread.Sleep(1000);
                }
 
                if (!_keyPressed)
                    throw new Exception("Vous n'avez pas appuyé dans les temps");
                else
                    _results[cpt] = (_keyTime - _startTime).Milliseconds;
 
            }
        }
 
        public void KeyPressed(DateTime keyTime) {
            if (!_keyPressed)
            {
                _keyPressed = true;
                _keyTime = keyTime;
            }
        }
 
    }

Donc le thread enfant lance le son, et attend jusqu'à 20sec pour déclarer qu'on n'a pas réagit à temps.
Comme le thread enfant est bloqué en sleep, c'est le form principal qui capte le keypress et le passe au thread enfant.

Donc tout se passe bien, les temps de réaction sont bien mesurés mais... et oui, il y a un mais...

Au moment où l'utilisateur presse une touche, l'application effet un bip de mécontentement.
Apres reflexion, je me demande si ce n'est pas la ligne suivante (en fin du mainform):

Code :

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

1
2
 
                runningTest.KeyPressed(DateTime.Now);

Qui rale car j'appelle une méthode sur un thread en sleep et du coup, ça pose probleme

si c'est bien ça, comment appréhender ce genre de problématique ???

J'ai pensé à une autre approche:
Le form principal gére l'emission du signal et en note la date/heure.
Ce dernier ne se bloque pas en sleep et ne fait rien.
La méthode keypress note la date/heure de la réaction de l'utilisateur.

Jusque là tout est beau, aucun thread n'est bloqué et tout devrait bien se passer. Mais il faut mettre en place un timeout et ne pas attendre indéfiniment que l'utilisateur réagisse.
Du coup, j'ai pensé faire un thread enfant juste pour attendre, avec un sleep(20000)

Donc le form lance le signal, note la date/heure et déclenche le thread enfant.
Si une touche est pressée, le form principal coupe le thread enfant, et calcule le temps de réaction
Si le thread enfant arrive à son temps écoulé, il se ferme et le form, alors déclare qu'il y a eu timeout dans une méthode backgroundWorker1_RunWorkerCompleted

N'est ce pas mieux ?

Merci d'avance pour votre aide

[Graffito]

Utiliser du multithread me semble inutilement compliquer ls choses.

On crée un timer de 20 seondes pour le TimeOut (enabled=false au départ).

Après le SystemSounds.Beep.Play(), on "enable" le timer et on active l'event KeyDown.

Quand un des evénements KeyDown (avec KeyPress) ou timer se produit, on obtient le délai de réaction, on désactive KeyDown, "disable" le Timer et on poursuit l'expérience.

[waxman]

Bonjour,

Merci pour cette piste.
J'ai appliqué l'exemple d'ici http://msdn.microsoft.com/fr-fr/library/k0wdddfy.aspx en le modifiant pour mon projet.

Je me retrouve face à un nouveau problème. En effet, le timer ne fait rien d'autre, si j'ai bien compris, que ce que j'avais manuellement fait, c'est à dire qu'il fonctionne sur un nouveau thread.

Du coup, la fonction de timeout est appelée non par le thread principal mais par le thread enfant du timer.
De ce fait, cette fonction ne peut accéder aux objets/variables d'instance du thread principal.

Par exemple:

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
 
        private void endTests()
        {
            _running = false;
            Cancel.Enabled = false;
            Start.Enabled = true;
        }
 
        private void beginUnitTest()
        {
            if (!_running)
                return;
            if (_currentTestNumber >= _totalTest)
                return;
 
            _currentTestNumber++;
 
            Random rnd = new Random(unchecked((int)(DateTime.Now.Ticks)));
            int waitTime = rnd.Next(6000);
            Thread.Sleep(waitTime);
 
            SystemSounds.Beep.Play();
            _startTime = DateTime.Now;
 
            aTimer = new System.Timers.Timer(10000);
            aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
            aTimer.AutoReset = false;
            aTimer.Enabled = true;
 
        }
        private void OnTimedEvent(object source, ElapsedEventArgs e)
        {
            endTests();
        }

du coup, je prends une exception à la seconde ligne de endTests car Cancel, qui est un bouton de mon form, a été instancié par le thread principal alors que la méthode endTests est invoquée par le thread du timer....

Comment faire ?

encore merci

[Graffito]

Reprenons le tout (J'ai mis le KeyPress sur une TextBox) :

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
 
public partial class Form1 : Form
{
  private DateTime StartTime ;
  private DateTime EndTime ;
 
  public Form1()
  {
    InitializeComponent();
    timer1.Interval=20000 ;
    EnableEvents(false);
  }
 
  private bool EnableEvents(bool Enable)
  {
     timer1.Enabled=Enable ;
     textBox1.KeyPress-=textBox1_KeyPress ;
     if (Enable) textBox1.KeyPress+=textBox1_KeyPress ;
  }
 
  private void button1_Click(object sender, EventArgs e)
  {
     PlaySound() ;
     StartTime=DateTime.Now ;
     EnableEvents(true) ;
  }
 
  private void timer1_Tick(object sender, EventArgs e)
  {
     EnableEvents(false) ;
     MessageBox.Show("TimeOut") ;
   }
 
  private void textBox1_KeyPress(object sender, KeyPressEventArgs e)
  {
     EndTime=DateTime.Now ;
     EnableEvents(false) ;
     MessageBox.Show("Temps de reaction = "+EndTime.Subtract  (StartTime).ToString()) ;
  }
 
  private void PlaySound()
  {
    // ...
   }

}

[waxman]

Merci

J'imagine que c'est une vue partielle du code car je ne vois pas où tu mappes le timer1_Tick sur l'expiration du timer (ni sa déclaration et instanciation d'ailleurs)

Il y a une partie que je ne comprends pas:
textBox1_KeyPress-=textBox1.KeyPress ;

comment fonctionne cette instruction ? Je connaissais le += pour ajouter une fonction sur l'évenement mais ça, je découvre

encore merci

[Graffito]

J'ai supposé que l'on mettait le Timer sur la form avec le designer et que l'on créait aussi à partir du Designer l'event Tick.

L'instruction "-=" est le pendant du "+=" et enlève la procédure de la liste des procédures inscrites dans l'event. Si la procedure n'existe pas dans la liste, il ne se passe rien : pas d'exception.

Edit : j'ai corrigé l'instruction :

if (Enable) textBox1.KeyPress+=textBox1_KeyPress ;

[waxman]

Et la syntaxe c'est donc
prodécureARetirer -= eventConcerné ?

Tu es sur que ce n'est pas l'inverse ? (Aussi bienpour l'ajout que pour le retrait)

[Graffito]

Ah si : erreur de ma part !!!!

[waxman]

Ce n'est pas méchant

Merci pour cette piste, je vais la tester dès demain.

Il se peut que je revienne avec d'autres questions mais en tous cas merci et bonne soirée

[waxman]

Salut,
désolé pour ce retour tardif mais je n'ai pas eu le temps de m'y remettre depuis.

comme je le craignais, ta solution conduit très exactement au même problème que celui que j'avais. Ceci est tout à fait normal, le timer ne fait que masquer l'utilisation de thread enfant mais c'est pourtant comme ça qu'il fonctionne....

A partir de ton code, j'ai simplement apporté les modifications suivantes:

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
 
private void EnableEvents(bool Enable) {
            timer1.Enabled=Enable ;
            this.KeyPress-= form_KeyPress ;
            if (Enable)
            {
                this.KeyPress += form_KeyPress;
                Start.Enabled = false;
                Cancel.Enabled = true;
            }
            else
            {
                Start.Enabled = true;
                Cancel.Enabled = false;
            }

Sachant que Start et Cancel sont des boutons de mon form.

Au moment du timeout du timer, j'ai donc l'exception suivante:

Opération inter-threads non valide : le contrôle 'Start' a fait l'objet d'un accès à partir d'un thread autre que celui sur lequel il a été créé.

C'est normal, le timer lance un thread fils, au moment du timeout il exécute la méthode timer1_Tick dans ce thread et donc il n'a pas accès à mon instance du thread principal et à ses membres

Le problème reste donc entier, comment faire pour agir et lancer des traitements dans mon thread principal au moment de l'expiration du délai?

Merci encore pour ton aide

[waxman]

en fait, je suis persuadé que la solution passe par le backgroundworker.

Ce dernier permet d'instancier manuellement une classe dans un thread enfant. Parmi les évenements disponibles dans le backgroundworker, on peut mapper une méthode appelée lorsque le thread enfant se termine et une autre lorsque le thread enfant signale un changement d'état.

Ces deux méthodes sont exécutées dans le thread principal.

Du coup, je fais une classe très simple, qui fait juste un sleep(n).

Je déclenche mon son, lance le thread enfant. Tout le reste est géré dans mon thread principal. Si une touche est pressée, je coupe le thread enfant et calcule le temps de réaction. Si le thread enfant se ferme tout seul (expiration de son sleep), je conclus à un timeout.

Je pars là dessus et vous donne le code si ça fonctionne

[giova_fr]

Dans un autre topic, Pol63 a donné la solution à ce que tu recherche :
http://www.developpez.net/forums/d13...z/#post7189768

C'est d'ailleur ce qu'utilise le BackgroundWorker pour que la callback JobDone s'execute dans le thread qui a créé le BackgroundWorker (généralement le thread de l'UI).

J'ai également trouvé cet article interressant en anglais :
http://www.codeproject.com/Articles/...ionContext-Cla

Mais le plus simple c'est quand meme le backgroundworker qui de toute façon fait tout ça.

Seul problème : si tu utilise plusieurs AppDomain, c'est ce qui m'arrive et je n'ai pas encore trouvé de solution simple et efficace.

[waxman]

En effet, je confirme que c'est la (une ?) solution qui fonctionne.

Voici le code que j'ai et qui me satisfait:

Une simple classe juste pour faire le timer

Code :

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

1
2
3
4
5
6
7
8
9
10
class Waiter
    {
        public void Run(
                System.ComponentModel.BackgroundWorker worker,
                System.ComponentModel.DoWorkEventArgs e,
                int delay)
        {
            Thread.Sleep(delay);
        }
    }

et le code principal

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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
    public partial class TestForm : Form
    {
        Waiter waiter1;
        int nbTests = 5;
        int currentTest = 0;
        Boolean runningTest;
        Boolean runningSerie;
        DateTime startTime;
        DateTime endTime;
 
        public TestForm()
        {
            InitializeComponent();
        }
 
        private void Start_Click(object sender, EventArgs e)
        {
            StartTestSerie();
        }
 
        private void Cancel_Click(object sender, EventArgs e)
        {
            CancelTestSerie();
        }
 
        private void StartTestSerie()
        {
            currentTest = 0;
            Start.Enabled = false;
            Cancel.Enabled = true;
            runningSerie = true;
            KeyDown -= this.Form1_KeyDown;
            KeyDown += this.Form1_KeyDown;
 
            RunNextTest();
        }
 
        private void RunNextTest()
        {
            if (!runningSerie)
                return;
 
            currentTest++;
            if (currentTest > nbTests) {
                CancelTestSerie();
                return;
            }
 
            LabelNumber.Text = currentTest.ToString();
            LabelNumber.Refresh();
            RunUniqueTest();
        }
 
        private void CancelTestSerie()
        {
            Start.Enabled = true;
            Cancel.Enabled = false;
            runningSerie = false;
            backgroundWorker1.RunWorkerCompleted -= backgroundWorker1_RunWorkerCompleted;
            KeyDown -= new System.Windows.Forms.KeyEventHandler(Form1_KeyDown);
        }
 
        private void RunUniqueTest()
        {
            waiter1 = new Waiter();
            backgroundWorker1 = new System.ComponentModel.BackgroundWorker();
            backgroundWorker1.RunWorkerCompleted += this.backgroundWorker1_RunWorkerCompleted;
            this.backgroundWorker1.DoWork += this.backgroundWorker1_DoWork;
 
            Random rnd = new Random(unchecked((int)(DateTime.Now.Ticks)));
            int waitTime = rnd.Next(1000,6000);
            Thread.Sleep(waitTime);
 
            SystemSounds.Beep.Play();
            startTime = DateTime.Now;
            runningTest = true;
            // Start the asynchronous operation.
            backgroundWorker1.RunWorkerAsync(waiter1);
        }
 
        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            // This event handler is where the actual work is done.
            // This method runs on the background thread.
 
            // Get the BackgroundWorker object that raised this event.
            System.ComponentModel.BackgroundWorker bgWorker;
            bgWorker = (System.ComponentModel.BackgroundWorker)sender;
 
            // Get the Worker object and call the main method.
            Waiter w = (Waiter)e.Argument;
            w.Run(bgWorker, e, 5000);
        }
 
        private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (!runningTest)
                return;
 
            // This event handler is called when the background thread finishes.
            // This method runs on the main thread.
            MessageBox.Show("timeout");
            CancelTestSerie();
        }
 
        private void Form1_KeyDown(object sender, KeyEventArgs e)
        {
            if (!runningSerie || !runningTest)
                return;
 
            endTime = DateTime.Now;
            runningTest = false;
            backgroundWorker1.RunWorkerCompleted -= backgroundWorker1_RunWorkerCompleted;
            labelLastResultValue.Text   =(endTime-startTime).TotalMilliseconds.ToString() + " msec";
            labelLastResultValue.Refresh();
            RunNextTest();
        }