Passer la méthode comme paramètre à l'aide de C #

J'ai plusieurs méthodes toutes avec la même signature (paramètres et valeurs de retour) mais des noms différents et les internes des méthodes sont différents. Je veux transmettre le nom de la méthode à exécuter à une autre méthode qui invoquera la méthode passée.

public int Method1(string)
{
    ... do something
    return myInt;
}

public int Method2(string)
{
    ... do something different
    return myInt;
}

public bool RunTheMethod([Method Name passed in here] myMethodName)
{
    ... do stuff
    int i = myMethodName("My String");
    ... do more stuff
    return true;
}

public bool Test()
{
    return RunTheMethod(Method1);
}

Ce code ne fonctionne pas mais c'est ce que j'essaie de faire. Ce que je ne comprends pas, c'est comment écrire le code RunTheMethod car j'ai besoin de définir le paramètre.

Vous pouvez utiliser le délégué Func dans .net 3.5 comme paramètre dans votre méthode RunTheMethod. Le délégué Func vous permet de spécifier une méthode qui prend un certain nombre de paramètres d'un type spécifique et renvoie un seul argument d'un type spécifique. Voici un exemple qui devrait fonctionner:

public class Class1
{
    public int Method1(string input)
    {
        //... do something
        return 0;
    }

    public int Method2(string input)
    {
        //... do something different
        return 1;
    }

    public bool RunTheMethod(Func<string, int> myMethodName)
    {
        //... do stuff
        int i = myMethodName("My String");
        //... do more stuff
        return true;
    }

    public bool Test()
    {
        return RunTheMethod(Method1);
    }
}

Vous devez utiliser un délégué . Dans ce cas, toutes vos méthodes prennent un stringparamètre et renvoient un int- celui-ci est le plus simplement représenté par le Func<string, int>délégué ¹ . Ainsi, votre code peut devenir correct avec un changement aussi simple que celui-ci:

public bool RunTheMethod(Func<string, int> myMethodName)
{
    // ... do stuff
    int i = myMethodName("My String");
    // ... do more stuff
    return true;
}

Certes, les délégués ont beaucoup plus de pouvoir que cela. Par exemple, avec C #, vous pouvez créer un délégué à partir d'une expression lambda , vous pouvez donc invoquer votre méthode de cette façon:

RunTheMethod(x => x.Length);

Cela créera une fonction anonyme comme celle-ci:

// The <> in the name make it "unspeakable" - you can't refer to this method directly
// in your own code.
private static int <>_HiddenMethod_<>(string x)
{
    return x.Length;
}

puis passez ce délégué à la RunTheMethodméthode.

Vous pouvez utiliser des délégués pour les abonnements aux événements, l'exécution asynchrone, les rappels - toutes sortes de choses. Cela vaut la peine de les lire, surtout si vous souhaitez utiliser LINQ. J'ai un article qui traite principalement des différences entre les délégués et les événements, mais vous pouvez quand même le trouver utile.

¹ Ceci est simplement basé sur le Func<T, TResult>type de délégué générique dans le cadre; vous pouvez facilement déclarer le vôtre:

public delegate int MyDelegateType(string value)

puis définissez le paramètre de type à la MyDelegateTypeplace.

De l'exemple d'OP:

 public static int Method1(string mystring)
 {
      return 1;
 }

 public static int Method2(string mystring)
 {
     return 2;
 }

Vous pouvez essayer Action Delegate! Et puis appelez votre méthode en utilisant

 public bool RunTheMethod(Action myMethodName)
 {
      myMethodName();   // note: the return value got discarded
      return true;
 }

RunTheMethod(() => Method1("MyString1"));

Ou

public static object InvokeMethod(Delegate method, params object[] args)
{
     return method.DynamicInvoke(args);
}

Appelez ensuite simplement method

Console.WriteLine(InvokeMethod(new Func<string,int>(Method1), "MyString1"));

Console.WriteLine(InvokeMethod(new Func<string, int>(Method2), "MyString2"));

public static T Runner<T>(Func<T> funcToRun)
{
    //Do stuff before running function as normal
    return funcToRun();
}

Usage:

var ReturnValue = Runner(() => GetUser(99));

Pour partager une solution aussi complète que possible, je vais finir par présenter trois façons différentes de faire, mais maintenant je vais partir du principe le plus élémentaire.

Une brève introduction

Toutes les langues qui s'exécutent au-dessus de CLR ( Common Language Runtime ), telles que C #, F # et Visual Basic, fonctionnent sous une machine virtuelle, qui exécute le code à un niveau plus élevé que les langues natives comme C et C ++ (qui se compilent directement sur la machine code). Il s'ensuit que les méthodes ne sont pas une sorte de bloc compilé, mais ce ne sont que des éléments structurés que CLR reconnaît. Ainsi, vous ne pouvez pas penser à passer une méthode en tant que paramètre, car les méthodes ne produisent aucune valeur elles-mêmes, car ce ne sont pas des expressions! Ce sont plutôt des instructions, qui sont définies dans le code CIL généré. Ainsi, vous ferez face au concept de délégué.

Qu'est-ce qu'un délégué?

Un délégué représente un pointeur sur une méthode. Comme je l'ai dit ci-dessus, une méthode n'est pas une valeur, donc il y a une classe spéciale dans les langages CLR Delegate, qui enveloppe n'importe quelle méthode.

Regardez l'exemple suivant:

static void MyMethod()
{
    Console.WriteLine("I was called by the Delegate special class!");
}

static void CallAnyMethod(Delegate yourMethod)
{
    yourMethod.DynamicInvoke(new object[] { /*Array of arguments to pass*/ });
}

static void Main()
{
    CallAnyMethod(MyMethod);
}

Trois façons différentes, le même concept derrière:

• Méthode 1
  Utilisez la Delegateclasse spéciale directement comme l'exemple ci-dessus. Le problème de cette solution est que votre code ne sera pas contrôlé lorsque vous passerez dynamiquement vos arguments sans les restreindre aux types de ceux de la définition de méthode.

• Way 2
  Outre la Delegateclasse spéciale, le concept de délégué se propage aux délégués personnalisés, qui sont des définitions de méthodes précédées par ledelegate mot clé, et ils se comportent de la même manière que les méthodes normales. Ils sont ainsi vérifiés, vous obtiendrez donc un code parfaitement sûr.

  Voici un exemple:

  delegate void PrintDelegate(string prompt);
  
  static void PrintSomewhere(PrintDelegate print, string prompt)
  {
      print(prompt);
  }
  
  static void PrintOnConsole(string prompt)
  {
      Console.WriteLine(prompt);
  }
  
  static void PrintOnScreen(string prompt)
  {
      MessageBox.Show(prompt);
  }
  
  static void Main()
  {
      PrintSomewhere(PrintOnConsole, "Press a key to get a message");
      Console.Read();
      PrintSomewhere(PrintOnScreen, "Hello world");
  }

• Méthode 3
  Vous pouvez également utiliser un délégué qui a déjà été défini dans la norme .NET:

  • Actiontermine un voidsans arguments.
  • Action<T1>termine un voidavec un argument.
  • Action<T1, T2>termine un voidavec deux arguments.
  • Etc...
  • Func<TR>encapsule une fonction avec un TRtype de retour et sans arguments.
  • Func<T1, TR>encapsule une fonction avec le TRtype de retour et avec un argument.
  • Func<T1, T2, TR> termine une fonction avec TR type de retour et avec deux arguments.
  • Etc...

(Cette dernière solution est celle que la plupart des gens ont publiée.)

Vous devez utiliser un Func<string, int>délégué, qui représente une fonction prenant un stringargument as et retournant un int:

public bool RunTheMethod(Func<string, int> myMethod) {
    // do stuff
    myMethod.Invoke("My String");
    // do stuff
    return true;
}

Ensuite, utilisez-le:

public bool Test() {
    return RunTheMethod(Method1);
}

Si vous voulez pouvoir modifier la méthode qui est appelée au moment de l'exécution, je recommanderais d'utiliser un délégué: http://www.codeproject.com/KB/cs/delegates_step1.aspx

Il vous permettra de créer un objet pour stocker la méthode à appeler et vous pouvez le transmettre à vos autres méthodes lorsque cela est nécessaire.

Bien que la réponse acceptée soit absolument correcte, je voudrais fournir une méthode supplémentaire.

Je me suis retrouvé ici après avoir fait ma propre recherche d'une solution à une question similaire. Je construis un framework piloté par plugin, et dans le cadre de celui-ci, je voulais que les gens puissent ajouter des éléments de menu au menu des applications à une liste générique sans exposer un Menuobjet réel car le framework peut se déployer sur d'autres plateformes qui n'ont pasMenu interface utilisateur objets. Ajouter des informations générales sur le menu est assez facile, mais donner au développeur du plugin suffisamment de liberté pour créer le rappel lorsque le menu est cliqué s'est avéré être une douleur. Jusqu'à ce que je me rende compte que j'essayais de réinventer la roue et l'appel des menus normaux et déclencher le rappel des événements!

Donc, la solution, aussi simple que cela puisse paraître une fois que vous vous en rendez compte, m'a échappé jusqu'à présent.

Créez simplement des classes distinctes pour chacune de vos méthodes actuelles, héritées d'une base si vous le souhaitez, et ajoutez simplement un gestionnaire d'événements à chacune.

Voici un exemple qui peut vous aider à mieux comprendre comment passer une fonction en paramètre.

Supposons que vous ayez la page Parent et que vous souhaitiez ouvrir une fenêtre contextuelle enfant. Dans la page parent, il y a une zone de texte qui doit être remplie en fonction de la zone de texte contextuelle enfant.

Ici, vous devez créer un délégué.

Parent.cs // déclaration des délégués délégué public void FillName (String FirstName);

Créez maintenant une fonction qui remplira votre zone de texte et la fonction devrait mapper les délégués

//parameters
public void Getname(String ThisName)
{
     txtname.Text=ThisName;
}

Maintenant, cliquez sur le bouton, vous devez ouvrir une fenêtre contextuelle enfant.

  private void button1_Click(object sender, RoutedEventArgs e)
  {
        ChildPopUp p = new ChildPopUp (Getname) //pass function name in its constructor

         p.Show();

    }

Dans le constructeur ChildPopUp, vous devez créer un paramètre de «type délégué» de la page parent //

ChildPopUp.cs

    public  Parent.FillName obj;
    public PopUp(Parent.FillName objTMP)//parameter as deligate type
    {
        obj = objTMP;
        InitializeComponent();
    }



   private void OKButton_Click(object sender, RoutedEventArgs e)
    {


        obj(txtFirstName.Text); 
        // Getname() function will call automatically here
        this.DialogResult = true;
    }

Si vous souhaitez passer la méthode comme paramètre, utilisez:

using System;

public void Method1()
{
    CallingMethod(CalledMethod);
}

public void CallingMethod(Action method)
{
    method();   // This will call the method that has been passed as parameter
}

public void CalledMethod()
{
    Console.WriteLine("This method is called by passing parameter");
}

Voici un exemple sans paramètre: http://en.csharp-online.net/CSharp_FAQ:_How_call_a_method_using_a_name_string

avec params: http://www.daniweb.com/forums/thread98148.html#

vous passez essentiellement un tableau d'objets avec le nom de la méthode. vous utilisez ensuite les deux avec la méthode Invoke.

params Paramètres Object []

class PersonDB
{
  string[] list = { "John", "Sam", "Dave" };
  public void Process(ProcessPersonDelegate f)
  {
    foreach(string s in list) f(s);
  }
}

La deuxième classe est Client, qui utilisera la classe de stockage. Il a une méthode Main qui crée une instance de PersonDB, et il appelle la méthode Process de cet objet avec une méthode définie dans la classe Client.

class Client
{
  static void Main()
  {
    PersonDB p = new PersonDB();
    p.Process(PrintName);
  }
  static void PrintName(string name)
  {
    System.Console.WriteLine(name);
  }
}