Lulus Metode sebagai Parameter menggunakan C #

Saya punya beberapa metode semua dengan tanda tangan yang sama (parameter dan nilai kembali) tetapi nama yang berbeda dan internal metode berbeda. Saya ingin meneruskan nama metode untuk menjalankan ke metode lain yang akan memanggil metode lewat.

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

Kode ini tidak berfungsi tetapi inilah yang saya coba lakukan. Yang tidak saya mengerti adalah bagaimana menulis kode RunTheMethod karena saya perlu mendefinisikan parameter.

Anda bisa menggunakan delegasi Func di .net 3.5 sebagai parameter dalam metode RunTheMethod Anda. Delegasi Func memungkinkan Anda untuk menentukan metode yang mengambil sejumlah parameter dari jenis tertentu dan mengembalikan argumen tunggal dari jenis tertentu. Ini adalah contoh yang bisa digunakan:

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

Anda perlu menggunakan delegasi . Dalam hal ini semua metode Anda mengambil stringparameter dan mengembalikan int- ini paling mudah diwakili oleh Func<string, int>delegasi ¹ . Jadi kode Anda dapat menjadi benar dengan perubahan sesederhana ini:

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

Para delegasi memiliki kekuatan lebih besar dari ini, harus diakui. Misalnya, dengan C # Anda dapat membuat delegasi dari ekspresi lambda , sehingga Anda dapat memanggil metode Anda dengan cara ini:

RunTheMethod(x => x.Length);

Itu akan membuat fungsi anonim seperti ini:

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

dan kemudian meneruskan delegasi itu ke RunTheMethodmetode.

Anda dapat menggunakan delegasi untuk berlangganan acara, eksekusi asinkron, callback - semua jenis hal. Sebaiknya baca di atasnya, terutama jika Anda ingin menggunakan LINQ. Saya memiliki artikel yang sebagian besar tentang perbedaan antara delegasi dan acara, tetapi Anda mungkin tetap menemukan manfaatnya.

¹ Ini hanya berdasarkan pada Func<T, TResult>jenis delegasi umum dalam kerangka kerja; Anda dapat dengan mudah mendeklarasikan sendiri:

public delegate int MyDelegateType(string value)

dan kemudian membuat parameter menjadi tipe MyDelegateTypegantinya.

Dari contoh OP:

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

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

Anda dapat mencoba Aksi Delegasi! Dan kemudian panggil metode Anda menggunakan

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

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

Atau

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

Maka cukup panggil metode

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

Pemakaian:

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

Untuk berbagi solusi selengkap mungkin, saya akan berakhir dengan menghadirkan tiga cara berbeda untuk melakukan, tetapi sekarang saya akan mulai dari prinsip paling dasar.

Perkenalan singkat

Semua bahasa yang berjalan di atas CLR ( Common Language Runtime ), seperti C #, F #, dan Visual Basic, bekerja di bawah VM, yang menjalankan kode pada tingkat yang lebih tinggi daripada bahasa asli seperti C dan C ++ (yang langsung dikompilasi ke mesin kode). Oleh karena itu metode tidak berupa blok terkompilasi, tetapi mereka hanya elemen terstruktur yang diakui CLR. Dengan demikian, Anda tidak dapat berpikir untuk meneruskan metode sebagai parameter, karena metode tidak menghasilkan nilai sendiri, karena mereka bukan ekspresi! Sebaliknya, itu adalah pernyataan, yang didefinisikan dalam kode CIL yang dihasilkan. Jadi, Anda akan menghadapi konsep delegasi.

Apa itu delegasi?

Delegasi mewakili pointer ke metode. Seperti yang saya katakan di atas, metode bukan nilai, maka ada kelas khusus dalam bahasa CLR Delegate, yang merangkum metode apa pun.

Lihatlah contoh berikut:

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

Tiga cara berbeda, konsep yang sama di belakang:

• Cara 1
  Gunakan Delegatekelas khusus secara langsung seperti contoh di atas. Masalah dari solusi ini adalah bahwa kode Anda akan tidak dicentang ketika Anda memberikan argumen Anda secara dinamis tanpa membatasi mereka ke jenis yang ada dalam definisi metode.

• Cara 2
  Selain Delegatekelas khusus, konsep delegasi menyebar ke delegasi khusus, yang merupakan definisi metode yang didahului olehdelegate kata kunci, dan mereka berperilaku sama seperti metode normal. Dengan demikian mereka diperiksa, sehingga Anda akan menemukan kode aman tanpa cacat.

  Ini sebuah contoh:

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

• Cara 3
  Atau, Anda dapat menggunakan delegasi yang telah ditentukan dalam .NET Standard:

  • Actionmembungkus voidtanpa argumen.
  • Action<T1>mengakhiri voiddengan satu argumen.
  • Action<T1, T2>membungkus voiddengan dua argumen.
  • Dan seterusnya...
  • Func<TR>membungkus fungsi dengan TRtipe kembali dan tanpa argumen.
  • Func<T1, TR>merangkai fungsi dengan TRtipe kembali dan dengan satu argumen.
  • Func<T1, T2, TR> mengakhiri fungsi dengan TR tipe kembali dan dengan dua argumen.
  • Dan seterusnya...

(Solusi terakhir adalah yang paling banyak diposting orang.)

Anda harus menggunakan Func<string, int>delegasi, yang mewakili fungsi mengambil stringargumen sebagai dan mengembalikan int:

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

Kemudian gunakan:

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

Jika Anda ingin kemampuan untuk mengubah metode mana yang dipanggil saat dijalankan saya akan merekomendasikan menggunakan delegasi: http://www.codeproject.com/KB/cs/delegates_step1.aspx

Ini akan memungkinkan Anda untuk membuat objek untuk menyimpan metode untuk memanggil dan Anda bisa meneruskannya ke metode lain ketika diperlukan.

Meskipun jawaban yang diterima benar-benar benar, saya ingin memberikan metode tambahan.

Saya berakhir di sini setelah melakukan pencarian sendiri untuk solusi untuk pertanyaan serupa. Saya sedang membangun kerangka kerja yang digerakkan oleh plugin, dan sebagai bagian dari itu saya ingin orang-orang dapat menambahkan item menu ke menu aplikasi ke daftar generik tanpa mengekspos Menuobjek yang sebenarnya karena kerangka kerja tersebut dapat digunakan pada platform lain yang tidak memiliki MenuUI benda. Menambahkan info umum tentang menu cukup mudah, tetapi memungkinkan pengembang plugin cukup bebas untuk membuat panggilan balik ketika menu diklik terbukti menyebalkan. Sampai saya sadar bahwa saya sedang mencoba untuk menemukan kembali roda dan panggilan menu normal dan memicu panggilan balik dari acara!

Jadi solusinya, sesederhana kedengarannya begitu Anda menyadarinya, menghindari saya sampai sekarang.

Cukup buat kelas terpisah untuk masing-masing metode Anda saat ini, diwarisi dari basis jika Anda harus, dan tambahkan saja pengendali acara ke masing-masing metode.

Berikut adalah contoh yang dapat membantu Anda lebih memahami cara melewatkan fungsi sebagai parameter.

Misalkan Anda memiliki halaman Induk dan Anda ingin membuka jendela sembulan anak. Di halaman induk ada kotak teks yang harus diisi berdasarkan kotak teks popup anak.

Di sini Anda perlu membuat delegasi.

Parent.cs // deklarasi delegasi delegasi publik batal FillName (String FirstName);

Sekarang buat fungsi yang akan mengisi kotak teks Anda dan fungsi harus memetakan delegasi

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

Sekarang pada tombol klik Anda perlu membuka jendela popup Anak.

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

         p.Show();

    }

DI konstruktor ChildPopUp Anda perlu membuat parameter 'tipe delegasi' dari halaman induk //

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

Jika Anda ingin meneruskan Metode sebagai parameter, gunakan:

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

Ini adalah contoh tanpa parameter: http://en.csharp-online.net/CSharp_FAQ:_How_call_a_method_using_a_name_string

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

Anda pada dasarnya mengirimkan array objek beserta nama metode. Anda kemudian menggunakan keduanya dengan metode Invoke.

parameter params Object []

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

Kelas kedua adalah Klien, yang akan menggunakan kelas penyimpanan. Ini memiliki metode Utama yang membuat instance dari PersonDB, dan ia memanggil metode Proses objek itu dengan metode yang didefinisikan dalam kelas Klien.

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