Détecter si une touche est enfoncée en C # (pas A, B, mais tout)

[EDIT 3]
J'ai une sorte de "résolu" par à l'aide de la "étrange" de la version. Au moins pour les touches les plus importantes. Il est suffisants pour permettre mon cas, où je veux vérifier que la touche ALT et ALT+ne sont pas les mêmes (assurant ainsi Un n'est pas pressé). Pas parfait, mais déjà beaucoup de temps pour un petit problème. Merci à tous pour les réponses en tout cas...
[EDIT 3]

[EDIT 4] Résolu beaucoup plus propre grâce à 280Z28 [/EDIT 4]

Je sais comment faire pour vérifier les touches de modification et la façon de tester pour une touche unique.
Le problème est, je veux vérifier si une touche est enfoncée. L'approche suivante semble "étrange" 🙂

WPF Application écrite en C#

if (Keyboard.IsKeyDown(Key.A)) return true;
if (Keyboard.IsKeyDown(Key.B)) return true;
if (Keyboard.IsKeyDown(Key.C)) return true;

Je sais que c'est un enum, alors j'ai pensé à une boucle, mais qu'est-ce que le "plus grand nombre" à utiliser. Et est-ce possible? btw, c'est un cas très spécial, normalement, je voudrais utiliser un événement, mais dans ce cas je dois le faire de cette façon. Unfortunatily, il n'existe pas de "liste" du Clavier.CurrentlyDownKeys. Au moins je n'ai pas la voir.

Grâce,
Chris

EDIT: Ok, parce qu'il semble être un gros deal, voici la raison pour cela:
J'ai défini un "Clavier", qui sert de DictionaryKey pour des fonctions personnalisées. Si quelqu'un clique sur un élément, le wrapper parcourt le dictionnaire et vérifie si les prédéfinis "Claviers" est active.

Cela me permet de définir simple déclencheurs, comme par exemple Exécuter cette fonction si les touches ALT+A+B est maintenu enfoncé. Une autre option est par exemple Exécuter cette fonction si les touches ALT+CTRL+A est enfoncé (lors d'un clic de souris sur un WPF élément).

Le seul "problème" avec l'implémentation actuelle, si je définis un jeu de clés qui ne contiennent PAS de vraies touches, comme s'exécuter si la touche ALT est enfoncée, il est également déclenchée si les touches ALT+A est enfoncé. Oh, tout en écrivant cela, je me rends compte qu'il y a un autre problème. ALT+A+B serait actuellement également déclencher si les touches ALT+A+B+C est pressé.

Peut-être que mon approche est erronée, et je doit créer une "clé statique tracker" et de comparer le jeu de clés à ses valeurs (acquis par l'entremise d'événements).. je vais donner à ceci un essai.

EDIT 2
Cela ne fonctionne pas, du moins pas de façon simple. J'ai besoin d'un FrameworkElement à joindre à KeyDown, mais je ne l'ai pas dans un constructeur statique. Et je ne suis pas intéressé par KeyDownEvents d'un certain élément, mais "globalement"...je crois que j'avance reporter ce problème, n'est pas si important. Encore, si quelqu'un connait une meilleure approche différente...

Si longtemps, pour quelqu'un qui se soucie, voici un peu de code:

    public class KeyModifierSet
{
internal readonly HashSet<Key> Keys = new HashSet<Key>();
internal readonly HashSet<ModifierKeys> MKeys = new HashSet<ModifierKeys>();
public override int GetHashCode()
{
int hash = Keys.Count + MKeys.Count;
foreach (var t in Keys)
{
hash *= 17;
hash = hash + t.GetHashCode();
}
foreach (var t in MKeys)
{
hash *= 19;
hash = hash + t.GetHashCode();
}
return hash;
}
public override bool Equals(object obj)
{
return Equals(obj as KeyModifierSet);
}
public bool Equals(KeyModifierSet other)
{
//Check for null
if (ReferenceEquals(other, null))
return false;
//Check for same reference
if (ReferenceEquals(this, other))
return true;
//Check for same Id and same Values
return Keys.SetEquals(other.Keys) && MKeys.SetEquals(other.MKeys);
}
public bool IsActive()
{
foreach (var k in Keys)
if (Keyboard.IsKeyUp(k)) return false;
if ((Keys.Count == 0) && !Keyboard.IsKeyDown(Key.None)) return false;
foreach (var k in MKeys)
if ((Keyboard.Modifiers & k) == 0) return false;
if ((MKeys.Count == 0) && Keyboard.Modifiers > 0) return false;
return true;
}
public KeyModifierSet(ModifierKeys mKey)
{
MKeys.Add(mKey);
}
public KeyModifierSet()
{
}
public KeyModifierSet(Key key)
{
Keys.Add(key);
}
public KeyModifierSet(Key key, ModifierKeys mKey)
{
Keys.Add(key);
MKeys.Add(mKey);
}
public KeyModifierSet Add(Key key)
{
Keys.Add(key);
return this;
}
public KeyModifierSet Add(ModifierKeys key)
{
MKeys.Add(key);
return this;
}
}

source d'informationauteur Christian Ruppert