Aufrufen einer Funktion aus einer Zeichenfolge in C #

Ich weiß, dass Sie in PHP einen Anruf tätigen können wie:

$function_name = 'hello';
$function_name();

function hello() { echo 'hello'; }

Ist das in .Net möglich?

Ja. Sie können Reflexion verwenden. Etwas wie das:

Type thisType = this.GetType();
MethodInfo theMethod = thisType.GetMethod(TheCommandString);
theMethod.Invoke(this, userParameters);

Sie können Methoden einer Klasseninstanz mithilfe von Reflection aufrufen und dabei einen dynamischen Methodenaufruf ausführen:

Angenommen, Sie haben eine Methode namens "Hallo" in einer tatsächlichen Instanz (dies):

string methodName = "hello";

//Get the method information using the method info class
 MethodInfo mi = this.GetType().GetMethod(methodName);

//Invoke the method
// (null- no parameter for the method call
// or you can pass the array of parameters...)
mi.Invoke(this, null);

class Program
    {
        static void Main(string[] args)
        {
            Type type = typeof(MyReflectionClass);
            MethodInfo method = type.GetMethod("MyMethod");
            MyReflectionClass c = new MyReflectionClass();
            string result = (string)method.Invoke(c, null);
            Console.WriteLine(result);

        }
    }

    public class MyReflectionClass
    {
        public string MyMethod()
        {
            return DateTime.Now.ToString();
        }
    }

Eine leichte Tangente - Wenn Sie eine gesamte Ausdruckszeichenfolge analysieren und auswerten möchten, die (verschachtelte!) Funktionen enthält, ziehen Sie NCalc ( http://ncalc.codeplex.com/ und nuget) in Betracht.

Ex. leicht modifiziert aus der Projektdokumentation:

// the expression to evaluate, e.g. from user input (like a calculator program, hint hint college students)
var exprStr = "10 + MyFunction(3, 6)";
Expression e = new Expression(exprString);

// tell it how to handle your custom function
e.EvaluateFunction += delegate(string name, FunctionArgs args) {
        if (name == "MyFunction")
            args.Result = (int)args.Parameters[0].Evaluate() + (int)args.Parameters[1].Evaluate();
    };

// confirm it worked
Debug.Assert(19 == e.Evaluate());

Und innerhalb des EvaluateFunctionDelegaten würden Sie Ihre vorhandene Funktion aufrufen.

Tatsächlich arbeite ich an Windows Workflow 4.5 und muss einen Weg finden, einen Delegaten von einer Statemachine an eine Methode ohne Erfolg zu übergeben. Die einzige Möglichkeit, die ich finden konnte, bestand darin, eine Zeichenfolge mit dem Namen der Methode zu übergeben, die ich als Delegat übergeben wollte, und die Zeichenfolge in einen Delegaten innerhalb der Methode zu konvertieren. Sehr schöne Antwort. Vielen Dank. Überprüfen Sie diesen Link https://msdn.microsoft.com/en-us/library/53cz7sc6(v=vs.110).aspx

class Program
{
    static void Main(string[] args)
    {
        string method = args[0]; // get name method
        CallMethod(method);
    }
    
    public static void CallMethod(string method)
    {
        try
        {
            Type type = typeof(Program);
            MethodInfo methodInfo = type.GetMethod(method);
            methodInfo.Invoke(method, null);
        }
        catch(Exception ex)
        {
            Console.WriteLine("Error: " + ex.Message);
            Console.ReadKey();
        }
    }
    
    public static void Hello()
    {
        string a = "hello world!";
        Console.WriteLine(a);
        Console.ReadKey();
    }
}

In C # können Sie Delegaten als Funktionszeiger erstellen. Weitere Informationen zur Verwendung finden Sie im folgenden MSDN-Artikel:http://msdn.microsoft.com/en-us/library/ms173171(VS.80).aspx

    public static void hello()
    {
        Console.Write("hello world");
    }

   /* code snipped */

    public delegate void functionPointer();

    functionPointer foo = hello;
    foo();  // Writes hello world to the console.