Jaki jest wzór C# do wykonania akcji na serii wartości?

Question

mam ten kod:

if (PsionTeklogix.Keyboard.Keyboard.GetModifierKeyState(Key.Orange) == KeyState.Lock) 
    PsionTeklogix.Keyboard.Keyboard.InjectKeyboardCommand(Function.Orange, 0, 0); 

if (PsionTeklogix.Keyboard.Keyboard.GetModifierKeyState(Key.Blue) == KeyState.Lock) 
    PsionTeklogix.Keyboard.Keyboard.InjectKeyboardCommand(Function.Blue, 0, 0); 

if (PsionTeklogix.Keyboard.Keyboard.GetModifierKeyState(Key.Shift) == KeyState.Lock) 
    PsionTeklogix.Keyboard.Keyboard.InjectKeyboardCommand(Function.Shift, 0, 0); 

if (PsionTeklogix.Keyboard.Keyboard.GetModifierKeyState(Key.Control) == KeyState.Lock) 
    PsionTeklogix.Keyboard.Keyboard.InjectKeyboardCommand(Function.Control, 0, 0); 

... 

i chcę byłaby kodu oddzielającą definicję klucz/funkcji z działań. Key.xxx i Function.xxx nie są tego samego typu.

np: w Pythonie, może po prostu zrobić coś takiego:

keys = (
    (Key.Orange, Function.Orange), 
    (Key.Blue , Function.Blue), 
    (Key.Shift , Function.Shift), 
    ... 
    ) 

psi_key = PsionTeklogix.Keyboard.Keyboard 

for key, func in keys: 
    if psi_key.GetModifierKeyState(key) == KeyState.Lock): 
     psi_key.InjectKeyboardCommand(func, 0, 0) 

Co to jest "właściwy sposób", aby zrobić w C#?

Answer 1

Można zrobić coś bardzo podobnego:

Dictionary<Key, Function> keys = new Dictionary<Key, Function> 
{ 
    { Key.Orange, Function.Orange }, 
    { Key.Blue, Function.Blue } 
    ... 
}; 

foreach (var pair in keys) 
{ 
    if (Keyboard.GetModifierKeyState(pair.Key) == KeyState.Locked) 
    { 
     Keyboard.InjectKeyboardCommand(pair.Value, 0, 0); 
    } 
} 

Można nawet użyć LINQ jeśli chciał:

foreach (var pair in keys.Where(pair => 
       Keyboard.GetModifierKeyState(pair.Key) == KeyState.Locked) 
{ 
    Keyboard.InjectKeyboardCommand(pair.Value, 0, 0); 
} 

Teraz używając Dictionary jest nieco dziwne, zważywszy, że tutaj nie szukamy wszystko w górze. Jeśli używasz platformy .NET 4, możesz zamiast tego użyć listy krotek:

var keys = new List<Tuple<Key, Function>>() 
{ 
    Tuple.Of(Key.Orange, Function.Orange), 
    Tuple.Of(Key.Blue, Function.Blue), 
    ... 
}; 

i odpowiednio ustawić pętlę. Można użyć typ anonimowy, zbyt:

var keys = new[] 
{ 
    new { Key = Key.Orange, Function = Function.Orange }, 
    new { Key = Key.Blue, Function = Function.Blue }, 
    ... 
}; 

Oni wszyscy w zasadzie działa jako sposób przedstawiania głównych parach/funkcja :)

Answer 2

można użyć Dictionary do tego.

Dictionary<Key, Function> map = new Dictionary<Key, Function>(); 

map.Add(Key.Orange, Function.Orange); 
map.Add(Key.Blue, Function.Blue); 
map.Add(Key.Shift, Function.Shift); 
map.Add(Key.Control, Function.Control); 

foreach(var pair in map) 
{ 
    if (PsionTeklogix.Keyboard.Keyboard.GetModifierKeyState(map.Key) == KeyState.Lock) 
    { 
     PsionTeklogix.Keyboard.Keyboard.InjectKeyboardCommand(map.Value, 0, 0); 
    } 
} 

Answer 3

Zakładając klucz i funkcji są wyliczeń, można też spróbować:

foreach (Key key in Enum.GetValues(typeof(Key))) 
{ 
    if (PsionTeklogix.Keyboard.Keyboard.GetModifierKeyState(key) == KeyState.Lock) 
    { 
     PsionTeklogix.Keyboard.Keyboard.InjectKeyboardCommand((Function)Enum.Parse(typeof(Function), key.ToString()), 0, 0); 
    } 
} 

Answer 4

using PsionTeklogix.Keyboard; /* assuming that's a namespace, */ 
           /* otherwise, you can optionally do: */ 
/* using Keyboard = PsionTeklogix.Keyboard.Keyboard; */ 

class Foo{ 
    static readonly Key[] keys = {Key.Orange, Key.Blue, Key.Shift, ...}; 
    static readonly Function[] functions = {Function.Orange, Function.Blue, Function.Shift, ...}; 

    static void Main(){ 
     for(int i = 0; i < keys.Length; i++) 
      if(Keyboard.GetModifierKeyState(keys[i]) == KeyState.Lock) 
       Keyboard.InjectKeyboardCommand(func, 0, 0); 
    } 
} 

Alternatywnie, ponieważ wygląda zarówno Key i Function są teksty stałe, i użyć tego samego Function Nazwa wartości wyliczeniowej dla każdej wartości wyliczeniowej Key, możesz zrobić coś takiego, co jest nieco ładniejsze, jeśli nieco wolniej:

static readonly string[] values = {"Orange", "Blue", "Shift", ...}; 

static void Main(){ 
    foreach(string value in values) 
     if(Keyboard.GetModifierKeyState((Key)Enum.Parse(typeof(Key), value)) == KeyState.Lock); 
      Keyboard.InjectKeyboardCommand((Function)Enum.Parse(typeof(Function), value), 0, 0); 
} 

Dobra, może nie jest ładniejsza. Meh.

Ale jeśli wartości z Keysą również takie same jak wartości Function (czyli jeśli (int)Key.Orange == (int)Function.Orange, etc.), a następnie można zrobić coś takiego:

static readonly Key[] keys = {Key.Orange, Key.Blue, Key.Shift, ...}; 

static void Main(){ 
    foreach(Key key in keys) 
     if(Keyboard.GetModifierKeyState(key) == KeyState.Lock); 
      Keyboard.InjectKeyboardCommand((Function)key, 0, 0); 
} 

Żaden z tych jest bezpośredni odpowiednikiem kodu Pythona, który byłby bardziej tak:

class KeyFunction{ 
    readonly Key  key; 
    readonly Function function; 

    public Key  Key  {get{return key;}} 
    public Function Function{get{return function;}} 

    public KeyFunction(Key key, Function function){ 
     this.key  = key; 
     this.function = function; 
    } 
} 

static readonly KeyFunction[] keyFunctions = { 
    new KeyFunction(Key.Orange, Function.Orange), 
    new KeyFunction(Key.Blue, Key.Blue), 
    new KeyFunction(Key.Shift, Key.Shift), 
    ... 
}; 

static void Main(){ 
    foreach(KeyFunction kf in keyFunctions) 
     if(Keyboard.GetModifierKeyState(kf.Key) == KeyState.Lock) 
      Keyboard.InjectKeyboardCommand(kf.Function, 0, 0); 
} 

to najbardziej gadatliwy sol z wszystkich, ale jest najbardziej elastyczny.