Comment transmettre des arguments aux délégués?

Question

J'ai le pseudo code suivant qui fonctionne:

KeyBindings[Keys.Right] += Method1; 
KeyBindings[Keys.Right] += Method2; 

Le problème que je suis en cours d'exécution en est que je voudrais être en mesure de le faire:

KeyBindings[Keys.Right] += Method1(argument); 
KeyBindings[Keys.Right] += Method2(argument1, argument 2); 

Est-ce possible? Si oui, comment réécrire mon code pour y parvenir?

---

KeyBindings est défini comme:

Dictionary<Keys, Action> KeyBindings = new Dictionary<Keys, Action>(); 

Answer 1

class Program { 
    public static void Main() { 
     Dictionary<ConsoleKey, Action> KeyBindings = new Dictionary<ConsoleKey, Action>(); 
     KeyBindings[ConsoleKey.A] = null; 
     KeyBindings[ConsoleKey.A] +=() => Method1(12); 
    } 

    static void Method1(int arg) { 
    } 
} 

Answer 2

Il ne fonctionne pas de cette façon. Vous n'appelez pas une méthode à ce stade ... vous lui dites simplement quelle méthode il devrait utiliser.

Lorsque vous créez un événement, vous spécifiez le type de méthode qui inclut les paramètres. Les paramètres sont passés à l'endroit où l'événement est déclenché.

Voici un tutoriel sur le sujet qui vous aidera à mieux comprendre: http://www.csharp-station.com/Tutorials/lesson14.aspx

En regardant le code ci-dessous peut également vous aider à mettre les morceaux ensemble un peu mieux.

public void SomeMethod() 
{ 
    //Assign the delegate 
    KeyBindings[Keys.Right] += Method1; 
} 

public PlaceWhereEventGetsRaised() 
{ 
    object argument1, argument2; 

    // set the arguments to something 

    if (KeyBindings[Keys.Right] != null) 
     KeyBindings[Keys.Right](argument1, argument2); 
} 

public void Method1(object argument1, object argument2) 
{ 
    // Do stuff 
} 

S'il semble que vous ne parvenez pas à accomplir ce que vous envie de faire la façon dont vous pensiez, alors laissez-nous savoir ce que vous essayez de faire et nous pouvons peut-être vous aider à trouver la bonne approche.

Answer 3

Eh bien, en général, si vous voulez créer un délégué qui prendrait une fonction existante et appliquer un ensemble prédéfini d'arguments, vous devez envelopper la fonction dans un autre.

par exemple,

Considérons la fonction Foo() qui prend un argument string et retourne un int (qui a la même signature que Func<string, int>):

int Foo(string str) 
{ 
    return str.Length + 8941; 
} 

Si vous voulez utiliser pour créer un délégué qui renvoie le résultat de l'appel Foo de la chaîne "bar", vous pouvez le faire:

Func<int> foobar =() => Foo("bar"); 

Notez donc que nous avons créé un nouveau délégué, l'expression lambda qui ne prend rien et (dans ce cas) renvoie le résultat de l'appel Foo("bar").

---

Vous pouvez appliquer la même chose dans votre code:

KeyBindings[Keys.Right] += new Action(() => Method1(argument)); 
KeyBindings[Keys.Right] += new Action(() => Method2(argument1, argument 2)); 

Answer 4

Pour faire une telle chose, vous devez créer une nouvelle méthode qui a les args fixes à l'intérieur. Ou méthode anonyme comme ceci:

event += (s, someEventArgs) => Method1(s, someEventArgs, someOtherArgs)