Discussion :

[BleudeBromothymol]

Salut tlm

Peut on gérer les signaux dans une application console C#?

j'ai lu que c'était faisable en C++, en faisant un peu de prog systeme
mais qu'en est il en .NET?


merci pour vos réponses
k

[telynor]

si tu fais une application windows form et si tu creer un mainmenu tu peux facilement rajouter un shortcut via le clavier, je pense que tu devrai regarder par la pour voir si cette tecnique peut etre utiliser autrement que via un mainmenu

[Thomas Lebrun]

Qu'est-ce que tu appelles les signaux ?

[abelman]

oui cela peut se faire avec les API win32
Cherche SetConsoleCtrlHandler sur google.
Ensuite il suffit de savoir appeler les fonctions win32 en C#

[BleudeBromothymol]

C'est bien la le problème...
l'Api Win32 est en C++
ca utilise des headers genre <windows.h>
et je ne sais absolument pas comment les appeller depuis un code C#
peut etre en appellant des DLL système...

j'ai cherché sur les msdn, mais je n'ai rien trouvé d'équivalent en C# ...

merci pour vos réponses
je continue mes recherches et je vous tiens au courant

bonne journée
k

PS : je voudrais gérer les Ctrl-C / Ctrl-X pour stopper le Main proprement dans une application Console C#

[abelman]

Je te donnerai un exemple entre midi et 14h

[Thomas Lebrun]

Il est 14h

[abelman]

Il est 14h

Je peux même plus prendre mon café ? non Mais ...

Bon c'est un peu long car je poste des classes que j'ai écrit il y a un moment ...

D'abord j'ai une classe Win32 ou je mets toutes mes déclarations API windows

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
 
using System;
using System.Runtime.InteropServices;
 
public sealed class Win32
{
	#region "Constantes Win32"
 
	/// <summary>
	/// Constante Win32 INVALID_HANDLE = -1
	/// </summary>
	public const int INVALID_HANDLE = -1;
 
	/// <summary>
	/// Constante Win32 CTRL_BREAK_EVENT = 1
	/// </summary>
	public const int CTRL_BREAK_EVENT = 1;
 
	/// <summary>
	/// Constante Win32 CTRL_C_EVENT = 0
	/// </summary>
	public const int CTRL_C_EVENT = 0;
 
	/// <summary>
	/// Constante Win32 CTRL_LOGOFF_EVENT = 2
	/// </summary>
	public const int CTRL_CLOSE_EVENT = 2;
 
	/// <summary>
	/// Constante Win32 CTRL_LOGOFF_EVENT = 5
	/// </summary>
	public const int CTRL_LOGOFF_EVENT = 5;
 
 
	#endregion
 
	#region "Pointeurs de fonctions Win32"
 
	/// <summary>
	/// Pointeur de fonctions gérant des évènement pour la console
	/// Utilisé par la fonction SetConsoleCtrlHandler
	/// </summary>
	/// <param name="CtrlType">Signal reçu par le handler</param>
	/// <returns>La fonction doit retourner 1 si le signal est traité. 0 sinon.</returns>
	/// <remarks>Voir HandlerRoutine dans MSDN pour plus d'informations</remarks>
	public delegate int ConsoleHandlerRoutine(int CtrlType);
 
	#endregion
 
	#region "Fonctions Win32"
 
	/// <summary>
	/// Ajoute un Callback ayant ConsoleHandlerRoutine comme prototype au gestionaire
	/// d'évenement d'une console. Voir MSDN
	/// </summary>
	/// <returns>Zero si l'appel échoue. Appeler Marshal.GetLastWin32Error() pour avoir le numéro de l'erreur.
	/// Renvoie une valeur différente de zéro si l'appel reussie.
	/// </returns>
	[DllImport("Kernel32.dll", SetLastError=true)]
	public static extern int SetConsoleCtrlHandler(ConsoleHandlerRoutine handler, int Add);
 
 
	#endregion
 
	/// <summary>
	/// Constructeur privé pour empêcher la construction.
	/// </summary>
	private Win32() {}
}

Ensuite j'ai la classe ConsoleCtrHandler (je sais plus pourquoi je l'ai appelé comme ça lol)

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
 
using System;
using System.Runtime.InteropServices;
using System.Threading;
using System.Diagnostics;
 
/// <summary>
/// La classe ConsoleCtrlHandler permet d'associer une routine systeme à une console.
/// Cette routine met la console en attente des évenements de sortie (CTRL+C, CTRL+BREAK, Arrêt de windows, ...).
/// Une fois qu'un de ces évènements se produit, le programme peut se terminer
/// </summary>
public sealed class ConsoleCtrlHandler : IDisposable
{
	/// <summary>
	/// 
	/// </summary>
	private static ConsoleCtrlHandler _instance;
 
	/// <summary>
	/// 
	/// </summary>
	private bool _disposed;
 
	/// <summary>
	/// Evénement d'attente.
	/// </summary>
	private static ManualResetEvent _endEvent;
 
	/// <summary>
	/// Routine Système qui intercepte la sortie de la console.
	/// </summary>
	private Win32.ConsoleHandlerRoutine _handlerRoutine;
 
	/// <summary>
	/// Constructeur privé
	/// </summary>
	private ConsoleCtrlHandler()
	{
 
	}
 
	/// <summary>
	/// Handler d'evenement de fin de programme console
	/// </summary>
	/// <param name="CtrlType">Type de l'évènement (CTRL+C, CTRL+BREAK, Logoff, CLOSE)</param>
	/// <returns>1 si l'evenement est pris en compte. 0 sinon.</returns>
	private static int HandlerRoutine(int CtrlType)
	{
		switch (CtrlType)
		{
			case Win32.CTRL_BREAK_EVENT :
				_endEvent.Set();
				return 1;
			case Win32.CTRL_C_EVENT :
				_endEvent.Set();
				return 1;
			case Win32.CTRL_CLOSE_EVENT :
				_endEvent.Set();
				return 1;
			case Win32.CTRL_LOGOFF_EVENT :
				_endEvent.Set();
				return 1;
			default :
				return 0;
		}
	}
 
	/// <summary>
	/// Attente d'evenement de fin de programme. (CTRL+C, CTRL+BREAK, etc ...)
	/// </summary>
	public void WaitForCloseInputEvent()
	{
		Debug.Assert(_endEvent != null);
		_endEvent.WaitOne();
	}
 
	/// <summary>
	/// 
	/// </summary>
	/// <exception cref="Ateo.Sys.Win32Exception">
	/// Cette Exception est levée si l'appel à la fonction Win32 SetConsoleCtrlHandler échoue.
	/// </exception>
	/// <returns>Une instance de CCConsoleCtrlHandler.</returns>
	public static ConsoleCtrlHandler GetInstance()
	{
		if (_instance == null)
		{
			_instance = new ConsoleCtrlHandler();
			// TODO : Lancer une exception si l'application n'a pas de console
			_instance._disposed = false;
			ConsoleCtrlHandler._endEvent = new ManualResetEvent(false);
			_instance._handlerRoutine = new Win32.ConsoleHandlerRoutine(HandlerRoutine);
			if (Win32.SetConsoleCtrlHandler(_instance._handlerRoutine, 1) == 0)
				throw new Win32Exception((uint)Marshal.GetLastWin32Error());
			return _instance;
		}
		else
			return _instance;
	}
 
	#region Membres de IDisposable
 
	/// <summary>
	/// Suppression des ressources non managées
	/// </summary>
	public void Dispose()
	{
		if (!_disposed)
		{
			_endEvent.Close();
			Win32.SetConsoleCtrlHandler(_handlerRoutine, 0);
			_disposed = true;
			GC.SuppressFinalize(this);
		}
	}
 
	#endregion
}

Et enfin ta fonction Main tu fais :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
static void Main(string[] args)
{
	ConsoleCtrlHandler consCtrlHandler = ConsoleCtrlHandler.GetInstance();
 
		using (consCtrlHandler)
		{
			// To code ici ...
 
			// Attente de Ctrl+C, Ctrl+Break, etc ...
			consCtrlHandler.WaitForCloseInputEvent();
		}
	}
}

Si le code n'est pas assez commenté n'hésite pas à poser des questions.
J'ai fais des copier coller et si ça ne marche pas du premier coup ...

[BleudeBromothymol]

Merci pour le code!

je le teste dans l'aprem

bonne journée
k