Le stockage d'un procédé en tant que variable membre d'une classe

Question

J'ai ce que l'un de mes membres de la classe « KeyEvent »:

private delegate void eventmethod();

Et le constructeur:

public KeyEvent(eventmethod D) 
{
    D();
}

Ce que je veux faire est au lieu d'appeler D () là, je veux stocker cette méthode (D) en tant que variable membre de KeyEvent, donc quelque chose comme:

stored_method = D();

Et puis plus tard dans une autre méthode de KeyEvent, faire quelque chose comme:

stored_method();

Comment puis-je faire?

Answer 1

Vous avez à peu près le code déjà. Il suffit de créer un champ de membre du type délégué droit et enregistrer le paramètre juste comme vous le feriez avec tout autre type de données.

private eventmethod MySavedEvent;

public void KeyEvent(eventmethod D) {
    // Save the delegate
    MySavedEvent = D;
}

public void CallSavedEvent() {
    if (MySavedEvent != null) {
        MySavedEvent();
    }
}

Answer 2

Vous pouvez faire quelque chose comme:

private Action CallBackFunction {get; set;}

public KeyEvent(Action callback) {
   CallBackFunction = callback;
}

Ce qui peut être instancié par:

new KeyEvent(MyFunction);

Où MyFunction est le nom d'une fonction dans cette classe

La classe KeyEvent peut alors invoquer cette fonction avec:

CallBackFunction();

La classe d'action permet également des paramètres fortement typés à passer dans la classe et Func peut être utilisé pour des méthodes qui renvoient un résultat.

Answer 3

la chose que vous voulez est appelée « première fonction de la classe » http: //en.wikipedia .org / wiki / First-class_function

C #, depuis la version 3, prend en charge les fonctions anonymes et les expressions lambda.

Vous pouvez donc utiliser Func<A,R> qui représente une fonction qui prend un argument de type A et retourne une valeur de type R

de wiki

static Func<double, double> MakeDerivative(Func<double, double> f, double deltaX)
  {
    return (x) => (f(x + deltaX) - f(x - deltaX)) / (2 * deltaX);
  }

Answer 4

public class KeyEvent
{
  private eventmethod hurr;
  public KeyEvent(eventmethod D)
  {
    hurr = D;
  }
  public void SomeOtherMethod()
  {
    hurr();
  }
}

choses Couple ... types PascalCase / délégués / etc (MéthodeEvénement) et des arguments de camelCase (d, dIsMyMethod). Et réutiliser ce que le cadre vous donne: private Action hurr;