Wie Delegate als Argument in Funktion mit Reflektion verwenden

Question

Ich habe eine Klasse, die Methode zum Abrufen von Wert von bestimmten Funktion (sin (x)) und Methode zum Abrufen von Wert von jeder Funktion mit Delegate.

namespace ValueFunctionFinder { 

public delegate double SomeFunction(double arg); 

public class ValueFunctionFinderClass 
{ 
    public double GetValue(double x) 
    { 
     double y = Math.Sin(x); 
     return y; 
    } 

    public double GetValueDel(double x, SomeFunction function) 
    { 
     double y = function(x); 
     return y; 
    } 

} 

Ich benutze diese Klasse in meinem Haupt:

static void Main(string[] args) 
{ 
    ValueFunctionFinderClass finder = new ValueFunctionFinderClass(); 

    double x = Math.Sin(Math.PI/6); 
    // find value from specific function 
    double y = finder.GetValue(x); 
    Console.WriteLine($"Sin(PI/6) = {y}"); 

    // find value from any function 
    SomeFunction function = Math.Sin; 
    y = finder.GetValueDel(x, function); 
    Console.WriteLine($"Sin(PI/6) = {y}"); 

    Console.ReadLine(); 
} 

In einem anderen Projekt, das ich möchte es mit Reflexion wieder verwenden:

static void Main(string[] args) 
{ 
    Assembly assembly = Assembly.Load("ValueFunctionFinder"); 
    Type functionFinderType = assembly.GetType("ValueFunctionFinder.ValueFunctionFinderClass"); 
    object functionFinderObj = Activator.CreateInstance(functionFinderType); 

    // find value from specific function using Reflection 
    MethodInfo getValueMethodInfo = functionFinderType.GetMethod("GetValue"); 
    double x = Math.Sin(Math.PI/6); 
    object y = getValueMethodInfo.Invoke(functionFinderObj, new object[] { x }); 
    Console.WriteLine($"Sin(PI/6) = {y}"); // it works OK 

    // find value from any function with Reflection 
    Type someFunctionType = assembly.GetType("ValueFunctionFinder.SomeFunction"); 

    // I should use smth like this: 
    // ********************************************** 
    // dynamic creation of delegate 
    //Delegate del = Delegate.CreateDelegate(someFunctionType, someMethodInfo); // what kind of methodInfo shoul I use? 
    // dynamic use of delegate 
    //object function = del.DynamicInvoke(arguments); // what kind of arguments? Math.Sin? 
    // ********************************************** 
    MethodInfo getValueDelMethodInfo = functionFinderType.GetMethod("GetValueDel"); 
    //y = getValueDelMethodInfo.Invoke(functionFinderObj, new object[] {x, function}); 
    Console.WriteLine($"Sin(PI/6) = {y}"); // how do this? 
    Console.ReadLine(); 
} 

I MSDN und diese Ressource gelesen haben, aber Ich konnte nicht verstehen, wie man Delegate als Argument in der Funktion verwendet, indem man Reflexion verwendet.

Answer 1

SomeFunction function = Math.Sin; 

ist eine Abkürzung für

SomeFunction function = new SomeFunction(Math.Sin); 

und Reflexion kann mit dem MethodInfo.CreateDelegate method für uns tun:

var getValueDelMethod = functionFinderType.GetMethod("GetValueDel"); 

// create a delegate to the target method of the desired type 
var delegateType = typeof(SomeFunction); 
var sinMethod = typeof(Math).GetMethod(nameof(Math.Sin)); 
var delegateObj = sinMethod.CreateDelegate(delegateType); 

var result = getValueDelMethod.Invoke(functionFinderObj, new object[] {x, delegateObj});