Passar método como parâmetro usando c #

Eu tenho vários métodos, todos com a mesma assinatura (parâmetros e valores de retorno), mas nomes diferentes e os elementos internos dos métodos são diferentes. Quero passar o nome do método para executar em outro método que invocará o método passado.

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

Este código não funciona, mas é isso que estou tentando fazer. O que não entendo é como escrever o código RunTheMethod, pois preciso definir o parâmetro.

Você pode usar o representante Func no .net 3.5 como o parâmetro no seu método RunTheMethod. O delegado Func permite especificar um método que utiliza vários parâmetros de um tipo específico e retorna um único argumento de um tipo específico. Aqui está um exemplo que deve funcionar:

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

Você precisa usar um delegado . Nesse caso, todos os seus métodos usam um stringparâmetro e retornam um int- isto é representado simplesmente pelo Func<string, int>delegado ¹ . Portanto, seu código pode se tornar correto com uma alteração tão simples quanto esta:

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

Os delegados têm muito mais poder do que isso, é certo. Por exemplo, com C #, você pode criar um delegado a partir de uma expressão lambda , para poder invocar seu método da seguinte maneira:

RunTheMethod(x => x.Length);

Isso criará uma função anônima como esta:

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

e depois passe esse delegado para o RunTheMethodmétodo

Você pode usar delegados para inscrições de eventos, execução assíncrona, retornos de chamada - todos os tipos de coisas. Vale a pena ler sobre eles, principalmente se você quiser usar o LINQ. Eu tenho um artigo que trata principalmente das diferenças entre delegados e eventos, mas você pode achar útil de qualquer maneira.

¹ Isso se baseia apenas no Func<T, TResult>tipo de delegado genérico na estrutura; você pode facilmente declarar o seu:

public delegate int MyDelegateType(string value)

e faça com que o parâmetro seja do tipo MyDelegateType.

Do exemplo do OP:

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

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

Você pode experimentar o Delegado de Ação! E então chame seu método usando

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

Em seguida, basta chamar o método

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

Uso:

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

Por compartilhar uma solução o mais completa possível, vou apresentar três maneiras diferentes de fazer, mas agora vou começar pelo princípio mais básico.

Uma breve introdução

Todos os idiomas executados no CLR ( Common Language Runtime ), como C #, F # e Visual Basic, funcionam em uma VM, que executa o código em um nível superior aos idiomas nativos como C e C ++ (que são compilados diretamente na máquina). código). Daqui resulta que os métodos não são nenhum tipo de bloco compilado, mas são apenas elementos estruturados que o CLR reconhece. Portanto, você não pode passar um método como parâmetro, porque os métodos não produzem nenhum valor, pois não são expressões! Em vez disso, são instruções definidas no código CIL gerado. Então, você enfrentará o conceito de delegado.

O que é um delegado?

Um delegado representa um ponteiro para um método. Como eu disse acima, um método não é um valor, portanto, há uma classe especial nas linguagens CLR Delegate, que agrupa qualquer método.

Veja o seguinte exemplo:

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

Três maneiras diferentes, o mesmo conceito por trás:

• Caminho 1
  Use a Delegateclasse especial diretamente como no exemplo acima. O problema desta solução é que seu código será desmarcado quando você passar dinamicamente seus argumentos sem restringi-los aos tipos daqueles na definição do método.

• Caminho 2
  Além doDelegate classe especial, o conceito de delegado se espalha para delegados personalizados, que são definições de métodos precedidos pela delegatepalavra - chave e se comportam da mesma forma que os métodos normais. Eles são verificados para que você tenha um código perfeitamente seguro.

  Aqui está um exemplo:

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

• Caminho 3
  Como alternativa, você pode usar um representante que já foi definido no .NET Standard:

  • Actionquebra um voidsem argumentos.
  • Action<T1>termina um voidcom um argumento.
  • Action<T1, T2> envolve um void com dois argumentos.
  • E assim por diante...
  • Func<TR>agrupa uma função com o TRtipo de retorno e sem argumentos.
  • Func<T1, TR>agrupa uma função com o TRtipo de retorno e com um argumento.
  • Func<T1, T2, TR> envolve uma função com TR tipo de retorno e com dois argumentos.
  • E assim por diante...

(A última solução é a que mais pessoas publicaram.)

Você deve usar um Func<string, int>delegado, que representa uma função que recebe um stringargumento as e retorna um int:

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

Então use-o:

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

Se você quiser alterar o método chamado em tempo de execução, recomendo o uso de um representante: http://www.codeproject.com/KB/cs/delegates_step1.aspx

Isso permitirá que você crie um objeto para armazenar o método a ser chamado e você poderá transmiti-lo aos outros métodos quando necessário.

Embora a resposta aceita esteja absolutamente correta, eu gostaria de fornecer um método adicional.

Acabei aqui depois de fazer minha própria busca de uma solução para uma pergunta semelhante. Estou criando uma estrutura orientada a plug-ins e, como parte dela, queria que as pessoas pudessem adicionar itens de menu ao menu de aplicativos em uma lista genérica sem expor um Menuobjeto real, porque a estrutura pode ser implantada em outras plataformas que não possuem Menuinterface do usuário objetos. A adição de informações gerais sobre o menu é bastante fácil, mas permitir ao desenvolvedor do plugin liberdade suficiente para criar o retorno de chamada para quando o menu é clicado estava provando ser um problema. Até que me dei conta de que estava tentando reinventar a chamada do volante e dos menus normais e acionar o retorno de chamada dos eventos!

Portanto, a solução, tão simples quanto parece depois que você a percebe, me escapou até agora.

Apenas crie classes separadas para cada um dos métodos atuais, herdadas de uma base, se necessário, e adicione um manipulador de eventos a cada uma.

Aqui está um exemplo que pode ajudá-lo a entender melhor como passar uma função como parâmetro.

Suponha que você tenha a página pai e deseje abrir uma janela pop-up filho. Na página pai, há uma caixa de texto que deve ser preenchida com base na caixa de texto pop-up filho.

Aqui você precisa criar um delegado.

Parent.cs // declaração dos delegados delegado público void FillName (String FirstName);

Agora crie uma função que preencha sua caixa de texto e a função deve mapear os delegados

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

Agora, clique no botão, você precisa abrir uma janela pop-up filho.

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

         p.Show();

    }

No construtor ChildPopUp, você precisa criar o parâmetro 'tipo delegado' da página pai //

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

Se você deseja passar o método como parâmetro, use:

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

Aqui está um exemplo sem um parâmetro: http://en.csharp-online.net/CSharp_FAQ:_How_call_a_method_using_a_name_string

com parâmetros: http://www.daniweb.com/forums/thread98148.html#

você basicamente passa uma matriz de objetos junto com o nome do método. você usa os dois com o método Invoke.

params Parâmetros do objeto []

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

A segunda classe é o cliente, que usará a classe de armazenamento. Ele possui um método Main que cria uma instância do PersonDB e chama o método Process desse objeto com um método definido na classe Client.

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