Func<> mit einer unbekannten Anzahl von Parametern

Betrachten Sie den folgenden pseudo-code:

TResult Foo<TResult>(Func<T1, T2,...,Tn, TResult> f, params object[] args)
{
    TResult result = f(args);
    return result;
}

Die Funktion akzeptiert Func<> mit unbekannter Anzahl der generischen Parameter, eine Liste der entsprechenden Argumente. Ist es möglich, dies in C# schreiben? Wie definieren und aufrufen Foo? Wie gebe ich args zu f?

  • Leider nicht möglich 🙁 Sie können es über Delegate und mit der spiegelung, aber ich bin sicher, das ist nicht, was Sie wollen.
InformationsquelleAutor user2341923 | 2014-04-03
  1. 14

    Nicht möglich ist. Am besten, Sie hätte einen Delegaten, der braucht auch eine variable Anzahl von Argumenten, und dann haben die Delegierten Parsen der Argumente

    TResult Foo<TResult>(Func<object[], TResult> f, params object[] args)
{
    TResult result = f(args);
    return result;
}

    Foo<int>(args =>
{
    var name = args[0] as string;
    var age = (int) args[1];

    //...

    return age;
}, arg1, arg2, arg3);
    InformationsquelleAutor dcastro
  2. 10

    Können Sie Delegate mit DynamicInvoke.

    Mit, dass Sie nicht brauchen, um Griff mit object[] im f.

    TResult Foo<TResult>(Delegate f, params object[] args)
{
    var result = f.DynamicInvoke(args);
    return (TResult)Convert.ChangeType(result, typeof(TResult));
}

    Verwendung:

    Func<string, int, bool, bool> f = (name, age, active) =>
{
    if (name == "Jon" && age == 40 && active)
    {
        return true;
    }
    return false;
}; 

Foo<bool>(f,"Jon", 40, true);

    Erstellte ich ein Turnschuh zeigt einige Beispiele: https://dotnetfiddle.net/LdmOqo

    Hinweis:

    Wenn Sie möchten, verwenden Sie eine method group, müssen Sie eine explizite Umwandlung in den Func:

    public static bool Method(string name, int age)
{
    ...
}
var method = (Func<string, int, bool>)Method;
Foo<bool>(method, "Jon", 40);

    Fiddle: https://dotnetfiddle.net/3ZPLsY

    • Hat das eigentlich funktioniert? Hat die DynamicInvoke reflektieren das Array durch Komma getrennte Parameter in den Methoden der Ausführung?
    • Ja @GoldBishop. DynamicInvoke macht genau das. In diese Geige zeige ich einige Beispiele. Überprüfen msdn-doc - DynamicInvoke für mehr Informationen.
    • hmmmm...das ist Blödsinn, der kann mit diesem wissen 🙂
    • würdest du einen Kommentar abgeben?
    • Das funktioniert, das ist cool. Leider kann man nicht direkt übergeben, eine Methode, die beliebige Argumente, erstellen Sie zuerst eine Func. So eine Methode bool F(string name, int age, bool active) {...} können nicht direkt übergeben werden, um Foo<bool>(F, "Jon",40,true).
    • Schöner Punkt @yoyo. Um diese Funktion zu nutzen mit der Methode Gruppe, die Sie verwenden müssen explizite casting. Erstellt habe ich eine andere Geige, die zeigen, wie Sie dies tun können: dotnetfiddle.net/qVlt47 ich werde zu aktualisieren meinem awnser, erklärt Sie. Danke für den Kommentar!
    • Vielen Dank für das update, und die Geige (dotNetFiddle ist toll!) Ich habe versucht, einen Weg zu finden, der Umgang mit beliebigem Parameter ohne Angabe der parameter-Typen in den call-Seite, aber ich habe beschlossen, einen anderen Weg finden um mein problem zu lösen. (BTW, Method("yoyo", 22) jeden Fall false zurückgibt! 😉
    • Ich bin froh, das zu hören. 🙂

    InformationsquelleAutor Renan Araújo
  3. 2

    Könnte dies einfach mit lambda-Ausdrücken:

    TResult Foo<Tresult>(Func<TResult> f)
{
  TResult result = f();
  return result;
}

    Dann Verwendung coul werden wie:

    var result = Foo<int>(() => method(arg1, arg2, arg3));

    Wo method kann beliebige Methode der Rückkehr int.

    Diese Weise können Sie eine beliebige Anzahl von erguments direkt über lambda.

    InformationsquelleAutor Michał Turczyn
  4. 1

    Könnten Sie versuchen, etwas ähnlich zu dem, was ich hier gepostet: https://stackoverflow.com/a/47556051/4681344

    Wird es ermöglichen, für eine beliebige Anzahl von Argumenten und erzwingt Ihre Typen.

    public delegate T ParamsAction<T>(params object[] args);

TResult Foo<TResult>(ParamsAction<TResult> f)
{
    TResult result = f();
    return result;
}

    nennen, es ist einfach......

    Foo(args => MethodToCallback("Bar", 123));
    • Ich denke, es sollte aufgerufen werden ParamsFunc<> statt, aber sonst kann ich Zustimmen. Ich würde es machen kovariante ("out") in T. Zum Beispiel public delegate TResult ParamsFunc<out TResult>(params object[] args);
    InformationsquelleAutor Bryan Clark
  5. 0

    In einigen Fällen können Sie in der Lage sein, um Weg mit einem trick, wie diese:

    public static class MyClass
{
    private static T CommonWorkMethod<T>(Func<T> wishMultipleArgsFunc)
    {
        //... do common preparation
        T returnValue = wishMultipleArgsFunc();
        //... do common cleanup
        return returnValue;
    }

    public static int DoCommonWorkNoParams() => CommonWorkMethod<int>(ProduceIntWithNoParams);
    public static long DoCommonWorkWithLong(long p1) => CommonWorkMethod<long>(() => ProcessOneLong(p1));
    public static string DoCommonWorkWith2Params(int p1, long p2) => CommonWorkMethod<string>(() => ConvertToCollatedString(p1, p2));

    private static int ProduceIntWithNoParams() { return 5; }
}
    InformationsquelleAutor DDRider62
Schreibe einen Kommentar