Funktionszeiger in C#

Ich nehme an, in gewisser Weise eine (oder beide) Delegate oder MethodInfo qualifizieren Sie sich für diese Titel. Jedoch, weder die syntaktische Nettigkeit, die ich Suche. Also, kurz gesagt, Ist es eine Möglichkeit, dass ich schreiben kann, die folgenden:

FunctionPointer foo = //whatever, create the function pointer using mechanisms
foo();

Kann ich nicht verwenden, eine solide Delegierten (also die Verwendung der delegate Schlüsselwort deklarieren Sie einen Delegaten-Typ), weil es keine Möglichkeit zu wissen, bis Laufzeit die genauen parameter Liste. Als Referenz, hier ist, was ich schon immer liebäugelt mit in LINQPad derzeit, wo B werden (meist) vom Benutzer generierten code, und so wird Main, und damit für die Feinheit meiner user, ich bin versucht zu entfernen, die .Call:

void Main()
{
    A foo = new B();
    foo["SomeFuntion"].Call();
}

//Define other methods and classes here
interface IFunction {
    void Call();
    void Call(params object[] parameters);
}

class A {
    private class Function : IFunction {
        private MethodInfo _mi;
        private A _this;
        public Function(A @this, MethodInfo mi) {
            _mi = mi;
            _this = @this;
        }

        public void Call() { Call(null); }
        public void Call(params object[] parameters) {
            _mi.Invoke(_this, parameters);
        }
    }

    Dictionary<string, MethodInfo> functions = new Dictionary<string, MethodInfo>();

    public A() {
        List<MethodInfo> ml = new List<MethodInfo>(this.GetType().GetMethods());
        foreach (MethodInfo mi in typeof(Object).GetMethods())
        {
            for (int i = 0; i < ml.Count; i++)
            {
                if (ml[i].Name == mi.Name)
                    ml.RemoveAt(i);
            }
        }

        foreach (MethodInfo mi in ml)
        {
            functions[mi.Name] = mi;
        }
    }

    public IFunction this[string function] {
        get { 
            if (!functions.ContainsKey(function))
                throw new ArgumentException();

            return new Function(this, functions[function]);
        }
    }
}

sealed class B : A {
    public void SomeFuntion() {
        Console.WriteLine("SomeFunction called.");
    }
}

InformationsquelleAutor Matthew Scharley | 2009-07-26

c#delegates reflection

29

Sagen Sie, Sie wollen, halten Sie die Anzahl und Art der Parameter geöffnet, aber Sie können tun, dass mit einem delgate:
```
public delegate object DynamicFunc(params object[] parameters);
```
Dies ist genau die gleiche Sache, die Sie derzeit haben. Versuchen Sie dies:
```
class Program
{
    static void Main(string[] args)
    {
        DynamicFunc f = par =>
                        {
                            foreach (var p in par)
                                Console.WriteLine(p);

                            return null;
                        };

        f(1, 4, "Hi");
    }
}
```
Können Sie denken, eine Instanz-Methode delegieren als sehr ähnlich zu Ihrem Function - Klasse: ein Objekt einer MethodInfo. So gibt es keine Notwendigkeit, neu zu schreiben.

Auch Funktionszeiger in C und C++ sind nicht näher, was Sie brauchen: Sie können nicht an ein Objekt gebunden Instanz und Funktion, und auch Sie sind statisch typisiert, nicht dynamisch typisiert.

Wenn Sie wollen, "wrap", eine andere Methode in einer DynamicFunc delegieren, versuchen Sie dies:
```
public static DynamicFunc MakeDynamicFunc(object target, MethodInfo method)
{
    return par => method.Invoke(target, par);
}

public static void Foo(string s, int n)    
{
    Console.WriteLine(s);
    Console.WriteLine(n);
}
```
dann:
```
DynamicFunc f2 = MakeDynamicFunc(null, typeof(Program).GetMethod("Foo"));

f2("test", 100);
```
Hinweis, dass ich mit einer statischen Methode Foo also ich pass null für das Beispiel, aber wenn es eine Instanz-Methode, ich würde mich übergeben das Objekt zu binden. Program passiert zu sein, die Klasse die statische Methoden definiert sind.

Natürlich, wenn Sie das falsche argument-Typen, dann bekommst du Fehler zur Laufzeit. Ich würde wohl nach einem Weg suchen, um Ihr Programm entwerfen, damit Sie so viel Art von Informationen erfasst wird zur compile-Zeit wie möglich.

Während ich denken, dass Sie ein Genie, daran zu denken, ich bin immer bind-Fehler, wenn ich versuche zu erstellen, die die Delegierten mit: return (DynamicFunction)Delegieren.CreateDelegate(typeof(DynamicFunction), dieser, Funktionen, die[Funktion]);
Das ist viel komplexer... hängen.
Okay, vielleicht nicht so Komplex... siehe update.
Compile-Zeit für die B Klasse runtime, wie ich schon sagte, es ist user-generiert, so dass leider keine Fehler es wird behandelt, indem Ihnen (und es gibt gute Bestimmungen, Fehler-reporting, etc., zu tun).
Fair genug - in Anlehnung an Einstein, ein Programm sollte so statisch typisierte wie möglich-aber nicht statisch-typisierte-er.

InformationsquelleAutor Daniel Earwicker

Hier ist ein weiteres Stück code, den Sie nutzen könnten; Reflexion ist eher langsam, also, wenn Sie erwarten, dass Ihre Dynamischen Funktionsaufrufen werden Häufig aufgerufen, Sie nicht wollen-Methode.Aufrufen innerhalb des Delegaten:

public delegate void DynamicAction(params object[] parameters);
static class DynamicActionBuilder
{
    public static void PerformAction0(Action a, object[] pars) { a(); }
    public static void PerformAction1<T1>(Action<T1> a, object[] p) {
        a((T1)p[0]);
    }
    public static void PerformAction2<T1, T2>(Action<T1, T2> a, object[] p) {
        a((T1)p[0], (T2)p[1]);
    }
    //etc...

    public static DynamicAction MakeAction(object target, MethodInfo mi) {
        Type[] typeArgs =
            mi.GetParameters().Select(pi => pi.ParameterType).ToArray();
        string perfActName = "PerformAction" + typeArgs.Length;
        MethodInfo performAction =
            typeof(DynamicActionBuilder).GetMethod(perfActName);
        if (typeArgs.Length != 0)
            performAction = performAction.MakeGenericMethod(typeArgs);
        Type actionType = performAction.GetParameters()[0].ParameterType;
        Delegate action = Delegate.CreateDelegate(actionType, target, mi);
        return (DynamicAction)Delegate.CreateDelegate(
            typeof(DynamicAction), action, performAction);
    }
}

Und Sie können es verwenden, wie diese:

static class TestDab
{
    public static void PrintTwo(int a, int b) {
        Console.WriteLine("{0} {1}", a, b);
        Trace.WriteLine(string.Format("{0} {1}", a, b));//for immediate window.
    }
    public static void PrintHelloWorld() {
        Console.WriteLine("Hello World!");
        Trace.WriteLine("Hello World!");//for immediate window.
    }

    public static void TestIt() {
        var dynFunc = DynamicActionBuilder.MakeAction(null,
            typeof(TestDab).GetMethod("PrintTwo"));
        dynFunc(3, 4);
        var dynFunc2 = DynamicActionBuilder.MakeAction(null,
            typeof(TestDab).GetMethod("PrintHelloWorld"));
        dynFunc2("extraneous","params","allowed"); //you may want to check this.
    }
}

Dieser wird etwas schneller sein; jeder dynamische Aufruf beinhaltet 1 typecheck pro param, 2 Anrufe und eine array-Konstruktion aufgrund der params-Stil vorbei.

Ich scheinen zu erinnern, etwas über Aufrufen zu langsam und zu verwenden CreateDelegate statt, das ist der Grund, warum ich sprang auf, die Lösung mit zu beginnen, da ist es durchaus möglich, diese Funktionen aufgerufen werden, ein großes viele Male pro Sekunde... ich werde über die details dieses, wenn ich nicht im Halbschlaf jedoch (liest: 8 Stunden oder so)
Aus Neugier habe ich zeitlich diese Technik (mit zwei Parametern) gegen meins, und festgestellt, dass meine Methode hat einen overhead von drei und eine halbe Millionstel Sekunde pro Anruf. Also ich vermute, der Aufwand ist unwahrscheinlich, dass ein Problem in einer echten Anwendung; hängt davon ab, welche Art von Dingen, die Ihre Benutzer werden dabei in Ihren Funktionen.

InformationsquelleAutor Eamon Nerbonne

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.