Passer de la Méthode en Paramètre à l'aide de C#

Vous pouvez utiliser la touche Func délégué .net 3.5 en tant que paramètre dans votre RunTheMethod méthode. Le délégué Func 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);
    }
}

De l'OP de l'exemple:

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

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

Vous pouvez essayer Délégué Action! Et appeler la méthode à l'aide de

 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);
}

Puis il suffit d'appeler la méthode

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

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

Vous devez utiliser un Func<string, int> délégué, qui représente une fonction prenant un string comme argument et retourne un int:

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

Puis l'utiliser:

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

Pour le partage d'une aussi complète que possible de la solution, je vais terminer avec la présentation de trois façons différentes de le faire, mais maintenant, je vais commencer à partir du principe le plus fondamental.

---

Brève introduction

Tous CLR (Common Language Runtime) langages (comme C# et Visual Basic) travaillent sous une machine virtuelle appelée CLI (Langage Commun Interprète) qui exécute le code sur un niveau plus élevé que les langages comme le C et le C++ (qui directement compiler en code machine). Il en résulte que les méthodes ne sont pas n'importe quel type de compilé bloc, mais ils sont juste des éléments structurés qui CLR reconnaître et d'utiliser de sortir de leur corps et rewing à la ligne d'instructions de la machine code. Ainsi, vous ne pouvez pas penser à passer d'une méthode en tant que paramètre, parce qu'une méthode ne produit pas de valeur par lui-même: ce n'est pas une expression valide! De sorte que, vous allez tomber le délégué concept.

---

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

Un délégué représente un pointeur sur une méthode. Car (comme je l'ai dit ci-dessus), une méthode n'est pas une valeur, il y a une classe spéciale dans le CLR langues: Delegate. Cette classe encapsule la méthode, et vous pouvez implicitement convertie en une méthode pour cela.

Voici une exemple d'utilisation:

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);
}

---

Les trois façons:

• Voie 1
  
  Utiliser le Delegate classe spéciale directement comme dans l'exemple ci-dessus. Le problème de cette solution est que votre code sera décochée que vous passez dynamiquement vos arguments sans les restreindre les types de personnes dans la déclaration de la méthode.

• Façon 2/3
  En plus de la Delegate classe spéciale, les délégués concept se propage à la coutume des délégués, qui sont des déclarations de méthodes précédé par la delegate mot-clé et ils se comportent comme une méthode normale. Ils sont donc vérifié, et vous arriverez à un "parfait" du code.

Regardez l'exemple suivant:

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");
}

Une deuxième option, par ce moyen, de ne pas écrire vos propres délégué est l'aide de l'un d'eux a déclaré à l'intérieur du système des bibliothèques:

• Action enroule une void sans arguments.
• Action<T1> enroule une void avec un argument.
• Action<T1, T2> enroule une void avec deux arguments.
• Et ainsi de suite...
• Func<TR> enroule une fonction avec TR type de retour et sans arguments.
• Func<T1, TR> enroule une fonction avec TR type de retour et avec un argument.
• Func<T1, T2, TR> enroule une fonction avec TR type de retour et avec deux arguments.
• Et ainsi de suite...

(Cette dernière solution est que beaucoup de gens affiché.)

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

Supposons que vous avez Parent page et vous souhaitez ouvrir un enfant de la fenêtre popup. Dans le parent de la page, il y a une zone de texte qui doit être rempli en se basant sur les enfants popup zone de texte.

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

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

Maintenant créer une fonction qui va remplir la zone de texte et en fonction de la carte délégués

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

Maintenant sur le bouton cliquez sur vous avez besoin pour ouvrir une Enfant de la fenêtre popup.

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

         p.Show();

    }

DANS ChildPopUp constructeur, vous devez créer un paramètre de "délégué" de parent //page

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;
    }