Metoda Pass jako parametr za pomocą C#

Musisz użyć delegata. W tym przypadku wszystkie metody pobierają parametr string i zwracają int - jest to najprościej reprezentowane przez delegata Func<string, int> ¹. Tak więc Twój kod może stać się poprawny z tak prostą zmianą jak ta:

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

RunTheMethod(x => x.Length);

To stworzy funkcja anonimowa jak ta:

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

, a następnie przekazać ten delegat do metody RunTheMethod.

Możesz używać delegatów do subskrypcji zdarzeń, asynchronicznej realizacji, wywołań zwrotnych-wszelkiego rodzaju rzeczy. Warto o nich poczytać, szczególnie jeśli chcemy korzystać z LINQ. Mam Artykuł, który jest głównie o różnicach między delegatami i wydarzeniami, ale i tak może się okazać przydatny.

¹ jest to po prostu oparte na generic Func<T, TResult> typ delegata w frameworku; możesz łatwo zadeklarować swój własny:

public delegate int MyDelegateType(string value)

A następnie niech parametr będzie Typu MyDelegateType.

Możesz również spróbować Action Delegate!

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

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

 public bool RunTheMethod(Action myMethodName)
 {
      myMethodName();
      return true;
 }

A następnie wywołaj swoją metodę używając

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

Lub

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

Następnie po prostu wywołaj metodę

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

Użycie:

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

Powinieneś użyć delegata Func<string, int>, który reprezentuje funkcję przyjmującą string jako argument i zwracającą int:

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

Następnie użyj go:

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

Jeśli chcesz mieć możliwość zmiany, która metoda jest wywoływana w czasie wykonywania, polecam użycie delegata: http://www.codeproject.com/KB/cs/delegates_step1.aspx

Pozwoli Ci utworzyć obiekt do przechowywania metody do wywołania i możesz przekazać ją innym metodom, gdy jest to potrzebne.

Chociaż przyjęta odpowiedź jest absolutnie poprawna, chciałbym podać dodatkową metodę.

Wylądowałem tutaj po tym, jak sam szukałem rozwiązania podobnego pytania. Buduję framework oparty na wtyczkach, a w jego ramach chciałem, aby ludzie mogli dodawać elementy menu do menu aplikacji do ogólnej listy bez wystawiania rzeczywistego obiektu Menu, ponieważ framework może zostać wdrożony na innych platformach, które nie mają Menu obiektów UI. Dodawanie ogólnych informacji o menu jest wystarczająco łatwe, ale pozwalając twórcy plugin wystarczająco dużo swobody, aby utworzyć callback po kliknięciu menu okazało się być bólem. Dopóki nie dotarło do mnie, że próbowałem ponownie wynaleźć koło i normalne połączenia menu i wywołać oddzwanianie od zdarzeń!

Po prostu utwórz osobne klasy dla każdej z twoich obecnych metod, odziedziczonych po bazie, jeśli musisz, i po prostu dodaj Zdarzenie opiekun dla każdego.

Aby podzielić się jak najbardziej kompletnym rozwiązaniem, skończę z przedstawieniem trzech różnych sposobów działania, ale teraz zacznę od najbardziej podstawowej zasady.

Krótkie wprowadzenie

Delegat reprezentuje wskaźnik za metodę. Ponieważ (jak powiedziałem powyżej) metoda nie jest wartością, istnieje specjalna klasa w językach CLR: Delegate. Ta klasa otacza dowolną metodę i można ją w sposób niejawny przypisać dowolnej metodzie.

Spójrz na następujący przykład użycia:

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

Trzy sposoby:

• Sposób 1
  Użyj klasy specjalnej Delegate bezpośrednio jako przykład powyżej. Problem tego rozwiązania polega na tym, że Twój kod będzie odznaczony, gdy przekazujesz dynamicznie swój argumenty bez ograniczania ich do typów zawartych w deklaracji metody.

• Sposób 2/3 Oprócz specjalnej klasy Delegate, koncepcja delegatów rozprzestrzenia się na niestandardowe delegaty, które są deklaracjami metod poprzedzonych słowem kluczowym delegate i zachowują się jak normalna metoda. Są tak sprawdzone, a Ty znajdziesz kod" perfect ".

Spójrz na następujący przykład:

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

Druga opcja w ten sposób aby nie pisać własnego delegata niestandardowego, należy użyć jednego z nich zadeklarowanego w bibliotekach systemowych:

• Action owija void bez argumentów.
• Action<T1> owija void jednym argumentem.
• Action<T1, T2> owija void dwoma argumentami.
• i tak dalej...
• Func<TR> zawija funkcję z typem zwracanym TR bez argumentów.
• Func<TR, T1> zawija funkcję z typem zwracanym TR i z jednym argumentem.
• Func<TR, T1, T2> otacza funkcję z TR return type i z dwoma argumentami.
• i tak dalej...

(to ostatnie rozwiązanie polega na tym, że wiele osób opublikowało.)

Oto przykład, który pomoże Ci lepiej zrozumieć, jak przekazać funkcję jako parametr.

Załóżmy, że masz stronę rodzica i chcesz otworzyć wyskakujące okno dziecka. Na stronie nadrzędnej znajduje się pole tekstowe, które należy wypełnić w oparciu o pole tekstowe Popup potomne.

Tutaj musisz utworzyć delegata.

Teraz Utwórz funkcję, która wypełni twoje pole tekstowe i funkcja powinny mapować delegatów

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

Teraz po kliknięciu przycisku musisz otworzyć wyskakujące okno dziecka.

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

         p.Show();

    }

W Konstruktorze ChildPopUp musisz utworzyć parametr 'typ delegata' strony nadrzędnej //

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

Oto przykład bez parametru: http://en.csharp-online.net/CSharp_FAQ:_How_call_a_method_using_a_name_string

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

W zasadzie przekazujesz tablicę obiektów wraz z nazwą metody. następnie używasz obu z metodą Invoke.

Params obiekt [] parametry