[C#] InvalidOperationException generee par PerformanceCounter.NextValue()

Bonjour,

J'essaye d'implementer une application WinForm qui fait plusieurs choses afin d'enregistrer l'activite d'un utilsitateur. L'une des fonctionnalites de l'application est de recuperer la liste des processus actifs associes a leur % d'utilisation du CPU. C'est au niveau du code suivant que j'ai une erreur que je ne comprend pas :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public void OnCPUTimerElapsed(object sender, ElapsedEventArgs e, ProcessCPUListener p_Process)
        {
            p_Process.GetProcess();
            var l_Counters = new List<PerformanceCounter>();
            int l_Indice =0;
            string l_ToWrite = "";
 
            foreach (Process l_Process in p_Process.Processes)
            {
                var l_Counter = new PerformanceCounter("Process", "% Processor Time", l_Process.ProcessName);
                l_Counter.NextValue();
                l_Counters.Add(l_Counter);
            }
            Thread.Sleep(1000);
 
            foreach (var l_Counter in l_Counters)
            {
                l_ToWrite = p_Process.Processes[l_Indice].ProcessName + "       | CPU% " + (Math.Round(l_Counter.NextValue(),1));
                l_Indice++;
                m_FileWriter.ProcessCPUListenerWritting(l_ToWrite);
            }
        }

Voici un screenshot de l'erreur :

Pièce jointe 160207

C'est ici que ca plante et je ne comprends pas. Quand je run le programme, au debut ca marche et au bout d'une quinze-vingtaine de secondes j'ai cette erreur.

Quelques precisions sur l'application. Elle est divise en 3 parties, la premiere partie est une WinForm qui en gros fait le role d'interface utilisateur.

La deuxieme partie est une bibliotheque de classe RecorderHandler (qui dans mon cas sert surtout de dossier c'est juste pour essayer de structurer l'application). Dans cette bibliotheque de classe, on trouve une classe Controller.cs qui cree les instances des objets dont jai besoin (ex: j'utilise un Hook Clavier, un Hook souris, une classe qui contient en gros un FileWatcher, une classe qui me permet de checker le CPU/les process), qui attache les methodes aux evenements et qui permet de faire start / stop. Une classe OnActionMethod.cs qui contient les methodes que j'utilise pour traiter mes evenements, et enfin une classe FileWriting qui permet d'ecrire apres les infos que je recupere dans un fichier text.

La troisieme partie de l'application contient les differentes classes des objets qui me permettent de recuper les infos qui m'interessent (les objets que jinstancie dans Controller.cs), elles aussi rangees dans une bibliotheque de classe RecorderData.

Controller.cs :

Code:

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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
public class Controller
    {
 
        #region Attributs
 
        private OnActionMethod m_OnEventAction;
        private Hook m_KeyboardHook;
        private MouseHook m_MouseH;
        private bool m_HookKeyBoardLaunched { get; set; }
        private bool m_HookMouseLaunched { get; set; }
        private FileListener m_Listener;
        private ProcessCPUListener m_Process;
        private bool m_ProcessCPUListenerLaunched;
 
        #endregion
 
        #region Constructor
 
        public Controller()
        {
            //The constructor instanciates every class of RecorderData.
 
            //Hook and MouseHook
            m_KeyboardHook = new Hook(Hook.HookType.KeyBoard, Hook.HookVisibility.Global);
            m_MouseH = new MouseHook();
            m_HookKeyBoardLaunched = false;
            m_HookMouseLaunched = false;
 
            //FileListener
            m_Listener = new FileListener();
            m_Listener.FileWatcher.EnableRaisingEvents = false;
 
            //ProcessCPUListener
            m_Process = new ProcessCPUListener();
            m_ProcessCPUListenerLaunched = false;
 
 
            //OnEventAction : instanciates the classe that contains all the methods that deals with the event.
            m_OnEventAction = new OnActionMethod();
 
 
        }
 
        #endregion
 
        #region Controller commands
 
        public void Initialization()
        {
            this.InitializationKeyboardHook();
            this.InitializationMouseHook();
            this.InitializationFileListener();
            this.InitializationProcessCPUListener();
        }
 
        public void Start()
        {
            this.KeyboardHookStart();
            this.MouseHookStart();
            this.FileListenerStart();
            this.ProcessCPUListenerStart();
        }
 
        public void Stop()
        {
            this.KeyboardHookStop();
            this.MouseHookStop();
            this.FileListenerStop();
            this.ProcessCPUListenerStop();
 
        }
 
        #endregion
 
        #region Hook Controller
 
        private void InitializationKeyboardHook()           //Initialization function for the keyboard Hook. Attaches the methods to the event and starts it.
        {
            m_KeyboardHook.OnKeyDown += new KeyEventHandler(m_OnEventAction.OnKeyDownAction);
            m_KeyboardHook.OnKeyPress += new KeyPressEventHandler(m_OnEventAction.OnKeyPressAction);
            m_KeyboardHook.OnKeyUp += new KeyEventHandler(m_OnEventAction.OnKeyUpAction);
        }
 
        private void InitializationMouseHook()              //Initialization function for the mouse hook. Attaches the methods to the event and starst it.
        {
            m_MouseH.GlobalHook.OnMouseClick += new MouseEventHandler(m_OnEventAction.OnMouseClickAction);
        }
 
        private void KeyboardHookStart()                     //Function that allows the keyboard hook to start if it is not already started.
        {
            if (m_HookKeyBoardLaunched == false)
            {
                m_KeyboardHook.Start();
                m_HookKeyBoardLaunched = true;
            }
        }
 
        private void MouseHookStart()                        //Function that allows the mouse hook to start if it is not already started.
        {
            if (m_HookMouseLaunched == false)
            {
                m_MouseH.GlobalHook.Start();
                m_HookMouseLaunched = true;
            }
        }
 
        private void MouseHookStop()                         //Function that allows the keyboard hook to stop if it is not already stoped.
        {
            if (m_HookMouseLaunched == true)
            {
                m_MouseH.GlobalHook.Stop();
                m_HookMouseLaunched = false;
            }
        }
 
        private void KeyboardHookStop()                     //Function that allows the mouse hook to stop if it is not already stoped.
        {
            if (m_HookKeyBoardLaunched == true)
            {
                m_KeyboardHook.Stop();
                m_HookKeyBoardLaunched = false;
            }
        }
 
        #endregion
 
        #region FileListener controller
 
 
        private void InitializationFileListener()           //Initialization function for the FileListener. Attaches the methods to the event and starts it.
        {
            m_Listener.FileWatcher.Changed += new FileSystemEventHandler(m_OnEventAction.OnFileChanged);
            m_Listener.FileWatcher.Created += new FileSystemEventHandler(m_OnEventAction.OnFileCreated);
            m_Listener.FileWatcher.Deleted += new FileSystemEventHandler(m_OnEventAction.OnFileDeleted);
            m_Listener.FileWatcher.Renamed += new RenamedEventHandler(m_OnEventAction.OnFileRenamed);
        }
 
        private void FileListenerStart()                     //Function that allows the FileListener to start if it is not already started.
        {
            if (m_Listener.FileWatcher.EnableRaisingEvents == false)
            {
                m_Listener.FileWatcher.EnableRaisingEvents = true;
            }
        }
 
        private void FileListenerStop()                      //Function that allows the FileListener to stop if it is not already stoped.                   
        {
            if (m_Listener.FileWatcher.EnableRaisingEvents == true)
            {
                m_Listener.FileWatcher.EnableRaisingEvents = false;
            }
        }
 
 
 
        #endregion
 
        #region ProcessCPUListener controller
 
        private void InitializationProcessCPUListener()
        {
            m_Process.Timer.Elapsed += new ElapsedEventHandler( (sender, e) => m_OnEventAction.OnCPUTimerElapsed(sender, e, m_Process) );
        }
 
        private void ProcessCPUListenerStart()
        {
            if (m_ProcessCPUListenerLaunched == false)
            {
                m_Process.Timer.Start();
                m_ProcessCPUListenerLaunched = true;
            }
        }
 
        private void ProcessCPUListenerStop()
        {
            if (m_ProcessCPUListenerLaunched == true)
            {
                m_Process.Timer.Stop();
                m_ProcessCPUListenerLaunched = false;
            }
        }
 
 
        #endregion
    }

OnActionMethod.cs

Code:

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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
public class OnActionMethod
    {
 
        #region Attributs
 
        private HookFlags m_Flag;
        private SysCharacterMap m_SysCharac;
        private InfoChecker m_InfoChecker;
        private FileWriting m_FileWriter;
 
        #endregion
 
        #region Constructor
 
        public OnActionMethod()
        {
            m_Flag = new HookFlags();
            m_SysCharac = new SysCharacterMap();
            m_FileWriter = new FileWriting();
            m_InfoChecker = new InfoChecker();
        }
 
        #endregion
 
        #region Hook events methods
 
        public void OnKeyUpAction(object sender, KeyEventArgs e)
        {
            m_Flag.UnMappingModifiers(e.KeyValue);
            if (m_SysCharac.MappingMethod(e.KeyValue, m_Flag) == true)
                m_SysCharac.WasWritten = false;
 
        }
 
        public void OnKeyDownAction(object sender, KeyEventArgs e)
        {
            string l_ShiftTextMark = "";
            string l_ToWrite = "";
            m_Flag.MappingModifiers(e.KeyValue);
 
 
            if (m_SysCharac.MappingMethod(e.KeyValue, m_Flag) == true)
            {
                if (m_Flag.WriteShift(e.KeyValue))
                    l_ShiftTextMark = " Shift + ";
 
                l_ToWrite = " | " + l_ShiftTextMark + e.KeyCode + " | ";
                m_FileWriter.HookedKeyWritting(l_ToWrite);
 
                m_SysCharac.WasWritten = true;              //Boolean that records the fact that a non character key was written. Allows us not to write it in KeyPress. Shift + Character key will be written in KeyPress (eg. Shift + a = A)
            }
 
            if (m_Flag.WriteAlt(e.KeyValue))
            {
                l_ToWrite = " | Alt + " + e.KeyCode + " | ";
                m_FileWriter.HookedKeyWritting(l_ToWrite);
            }
 
            if (m_Flag.WriteControl(e.KeyValue))
            {
                l_ToWrite = " | Ctrl + " + e.KeyCode + " | ";
                m_FileWriter.HookedKeyWritting(l_ToWrite);
            }
 
            if (m_Flag.WriteAltShift(e.KeyValue))
            {
                l_ToWrite = " | Alt + 11Shift + " + e.KeyCode + " | ";
                m_FileWriter.HookedKeyWritting(l_ToWrite);
            }
 
            if (m_Flag.WriteCtrlShift(e.KeyValue))
            {
                l_ToWrite = " | Ctrl + Shift + " + e.KeyCode + " | ";
                m_FileWriter.HookedKeyWritting(l_ToWrite);
            }
 
            if (m_Flag.WriteAltGr(e.KeyValue))
            {
                l_ToWrite = " | AltGr + " + e.KeyCode + " | ";
                m_FileWriter.HookedKeyWritting(l_ToWrite);
            }
 
            if (m_Flag.WriteAltCtrl(e.KeyValue))
            {
                l_ToWrite = " | Ctrl + " + " Alt + " + e.KeyCode + " | ";
                m_FileWriter.HookedKeyWritting(l_ToWrite);
            }
 
            if (m_Flag.WriteCtrlAltShift(e.KeyValue))
            {
                l_ToWrite = " | Ctrl + " + " Alt + " + " Shift + " + e.KeyCode + " | ";
                m_FileWriter.HookedKeyWritting(l_ToWrite);
            }
        }
 
        public void OnKeyPressAction(object sender, KeyPressEventArgs e) //Each time a keystroke is catched by the hook, this method is called.
        {
            string l_ToWrite = "";
            switch (e.KeyChar)
            {
                case '\b':      //Backspace is a NONSYS character that is catched by keypress. We are already writting it down in the OnKeyUp event handler so we don't write it again.
                    break;
 
                case '\r':      //Same as for backspace.
                    break;
 
                default:
                    if (m_Flag.FlagCtrl)     //If one of the flags is activated, we don't write the keypress.
                        break;
                    if (m_SysCharac.WasWritten)
                        break;
                    if (m_Flag.FlagAlt)
                        break;
                    if (m_Flag.FlagAltShift)
                        break;
                    if (m_Flag.FlagAltGr)
                        break;
                    if (m_Flag.FlagCtrlAlt)
                        break;
                    if (m_Flag.FlagCtrlShift)
                        break;
                    if (m_Flag.FlagCtrlAltShift)
                        break;
                    else                    //When it's just a character pressed, we write it down.
                    {
                        l_ToWrite = " | " + e.KeyChar + " | ";
                        m_FileWriter.HookedKeyWritting(l_ToWrite);
                        break;
                    }
            }
        }
 
        public void OnMouseClickAction(object sender, MouseEventArgs e)
        {
            string l_ToWrite = "";
            if (e.Button == MouseButtons.Left)
            {
                l_ToWrite = "Left X: " + e.X + " Y: " + e.Y + " | ";
                m_FileWriter.HookedMouseWritting(l_ToWrite);
            }
 
            if (e.Button == MouseButtons.Right)
            {
                l_ToWrite = "Right X: " + e.X + " Y: " + e.Y + " | ";
                m_FileWriter.HookedMouseWritting(l_ToWrite);
            }
 
            if (e.Button == MouseButtons.Middle)
            {
                if (e.Delta < 0)
                    l_ToWrite = "Mouse wheel, wheel down | ";
                else
                    l_ToWrite = "Mouse wheel, wheel up | ";
                    m_FileWriter.HookedMouseWritting(l_ToWrite);
            }
        }
 
        #endregion
 
        #region Filelistener events methods
 
        public void OnFileChanged(object sender, FileSystemEventArgs e)
        {
            string l_ToWrite = "";
            l_ToWrite = " Changed : " + e.FullPath + " was  " + e.ChangeType + " ";
            if (m_InfoChecker.Check_File_Names(e.FullPath))
            {
                m_FileWriter.FileListenerWritting(l_ToWrite);
            }
        }
 
        public void OnFileCreated(object sender, FileSystemEventArgs e)
        {
            string l_ToWrite = "";
            l_ToWrite = " Created : " + e.FullPath + " was  " + e.ChangeType + " ";
            if (m_InfoChecker.Check_File_Names(e.FullPath))
            {
                m_FileWriter.FileListenerWritting(l_ToWrite);
            }
        }
 
        public void OnFileDeleted(object sender, FileSystemEventArgs e)
        {
            string l_ToWrite = "";
            l_ToWrite = " Deleted : " + e.FullPath + " was  " + e.ChangeType + " ";
            if (m_InfoChecker.Check_File_Names(e.FullPath))
            {
                m_FileWriter.FileListenerWritting(l_ToWrite);
            }
        }
 
        public void OnFileRenamed(object sender, RenamedEventArgs e)
        {
            string l_ToWrite = "";
            l_ToWrite = " Renamed : " + e.OldFullPath + " to " + e.FullPath + " NEW NAME:" + e.Name + " ";
            if (m_InfoChecker.Check_File_Names(e.FullPath))
            {
                m_FileWriter.FileListenerWritting(l_ToWrite);
            }
        }
 
        #endregion
 
        #region ProcessCPUListener event method
 
        public void OnCPUTimerElapsed(object sender, ElapsedEventArgs e, ProcessCPUListener p_Process)
        {
            p_Process.GetProcess();
            var l_Counters = new List<PerformanceCounter>();
            int l_Indice =0;
            string l_ToWrite = "";
 
            foreach (Process l_Process in p_Process.Processes)
            {
                var l_Counter = new PerformanceCounter("Process", "% Processor Time", l_Process.ProcessName);
                l_Counter.NextValue();
                l_Counters.Add(l_Counter);
            }
            Thread.Sleep(1000);
 
            foreach (var l_Counter in l_Counters)
            {
                l_ToWrite = p_Process.Processes[l_Indice].ProcessName + "       | CPU% " + (Math.Round(l_Counter.NextValue(),1));
                l_Indice++;
                m_FileWriter.ProcessCPUListenerWritting(l_ToWrite);
            }
        }
 
        #endregion
    }
}

FileWritting.cs:

Code:

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
public class FileWriting
    {
 
        #region Attributs
 
        private string[] m_FilePath;
 
        #endregion
 
        #region Constructor
 
        public FileWriting()
        {
            m_FilePath = new string[] { @"Q:\OE100_Gruppenplatte\TEMP\WorkerRecorderTest\keyboard.txt",        //FilePath[0]: path to text file for keyboard recorder.
                                      @"Q:\OE100_Gruppenplatte\TEMP\WorkerRecorderTest\mouse.txt",             //FilePath[1]: path to text file for mouse recorder.
                                      @"Q:\OE100_Gruppenplatte\TEMP\WorkerRecorderTest\changes.txt",       //FilePath[2]: path to text file for file activity recorder.
                                      @"Q:\OE100_Gruppenplatte\TEMP\WorkerRecorderTest\processes.txt"
                                    };
        }
 
        #endregion
 
        #region Public methods
 
        public void HookedKeyWritting(string p_ToWrite)
        {
            DateTime l_D1 = DateTime.Now;
            using (StreamWriter file = new System.IO.StreamWriter(m_FilePath[0], true))
            {
                file.WriteLine(p_ToWrite + l_D1);
            }
        }
 
        public void HookedMouseWritting(string p_ToWrite)
        {
            DateTime l_D1 = DateTime.Now;
            using (StreamWriter file = new System.IO.StreamWriter(m_FilePath[1], true))
            {
                file.WriteLine(p_ToWrite + l_D1);
            }
        }
 
        public void FileListenerWritting(string p_ToWrite)
        {
            DateTime l_D1 = DateTime.Now;
            using (StreamWriter file = new System.IO.StreamWriter(m_FilePath[2], true))
            {
                file.WriteLine(p_ToWrite + l_D1);
            }
        }
 
        public void ProcessCPUListenerWritting(string p_ToWrite)
        {
            DateTime l_D1 = DateTime.Now;
            using (StreamWriter file = new StreamWriter(m_FilePath[3], true))
            {
                file.WriteLine(p_ToWrite + l_D1);
            }
        }
 
        #endregion
 
    }

ProcessCPUListener.cs :

Code:

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 class ProcessCPUListener
    {
 
        #region Attributs
 
        private System.Timers.Timer m_Timer;
        private Process[] m_Processes;
 
        #endregion
 
        #region Constructor
 
        public ProcessCPUListener()
        {
            m_Timer = new System.Timers.Timer();
            m_Timer.Interval = 8000;
        }
 
        #endregion
 
        #region Public methods
 
        public void GetProcess()
        {
            m_Processes = Process.GetProcesses();
        }
 
        #endregion
 
        #region Accessors
 
        public System.Timers.Timer Timer
        {
            get { return this.m_Timer;}
        }
 
        public Process[] Processes
        {
            get { return this.m_Processes; }
        }
        #endregion
 
    }

Les autres parties de l'application fonctionnaient bien au prealable. C'est lorsque j'ai integre le travail de ma comparse, c'est a dire la classe ProcessCPUListener.cs, les controller associes dans Controller.cs, la methode de traitement dans OnActionMethod.cs, et la methode decriture dans FileWriting.cs que j'ai eu des problemes. Ma comparse avait deja eu cette meme erreur ulterieurement lorsqu'elle avait code son programme en solo mais elle sen etait debarasse en augmentant l'intervalle du timer (chose que jai faite mais le probleme mais juste plus de temps a arriver).

Voila, si quelqu'un pouvait m'apporter un bout d'aide je serai preneur car je rame fortement la. Si je n'ai pas ete assez precis ou autres je peux fournir des precisions, je peux eventuellement filer la solution complete aussi.

Bonne journee et merci d'avance,

Vincent

EDIT: J'ai eu la meme erreur mais l'exception qui est genere est tjs la meme mais pas pour la meme instance. Ici un autre screenshot avec la meme exception mais pour une instance differente (GoogleUpdate alors que la premiere c'est SearchFilterHost) :
Pièce jointe 160220