C# Action und Func-parameter überlast

Brauche ich eine Methode, die eine Aktion (oder eine Func), aber die Aktion hat eine gemischte Anzahl von Parametern. Was ist die geradlinig und kompakt zu implementieren, diese überlastungen:

public void Execute<T>(Action<T> action, T param) {
    //TODO: Implement something like:
    //Execute(action, param, null);
}

public void Execute<T1,T2>(Action<T1,T2> action, T1 param1, T2 param2) {
    //TODO: Implement something like:
    //Execute(action, param1, param2, null);
}

public void Execute<T1,T2,T3>(Action<T1,T2,T3> action, T1 param1, T2 param2, T3 param3) {
    DoStuff();
    action(param1, param2, param3)
    DoMoreStuff();
}

//OR any other type of higher order function-solution
public void Execute(Action action, params object[] parameters) { ... } //???

Den Inhalt, die Methoden sind genau die gleichen, außer für die Ausführung der Aktion und deren Parameter.

Wenn möglich, verwenden Sie keine C# - 4.0-spezifische Funktionen, um dieses Problem zu lösen.

InformationsquelleAutor Seb Nilsson | 2010-08-18
  1. 8

    Den Inhalt, die Methoden sind genau
    die gleichen, außer für die Ausführung von
    die Aktion und deren Parameter.

    Dass Schreie für die Verwendung einer höhere Ordnung-Funktion, aber da Sie bereits parametrisierte alle die bits, die geändert werden können (Durchführung der Maßnahme und deren Parameter) Sie sind schon da. Sorry, sieht aus wie Sie haben zu implementieren, diese überlastungen manuell.

    Nur die Verkettung durch die Verwendung von null-Werten wird nicht funktionieren, da die Delegierten bestanden nicht übereinstimmen. Was Sie tun können, ist wickeln die übergebene action/func innerhalb eines lambda zu schälen zusätzliche Argumente:

    public void Execute(Action<T> action, T param) {
     Execute( (a, _) => action(a) , param, null);
}

public void Execute(Action<T1, T2> action, T1 param1, T2 param2) {
    Execute( (a, b, _) => action(a, b) , param1, param2,  null);
}

public void Execute(Action<T1, T2, T3> action, T1 param1, T2 param2, T3 param3) {
    DoStuff();
    action(param1, param2, param3)
    DoMoreStuff();
}
    • Bitte fühlen Sie sich frei, um auch eine höhere Ordnung, Funktion-Lösung.
    • Was die höhere Ordnung Funktion: Sie sind bereits dort durch parametrisierte Aktionen.
    InformationsquelleAutor Johannes Rudolph
  2. 5

    Dies ist eigentlich die besten Ansatz (halten Sie im Verstand Johannes der Punkt, dass Sie haben könnte auch eine Funktion höherer Ordnung), wie es die meisten Typ-freundlich (Teilnehmer wird automatisch abgeglichen werden mit der richtigen Anzahl und Typen von Argumente) und erfordert keine lästige DynamicInvoke Anrufe.

    Ihre Letzte Methode definition ist problematisch. Ein Action durch seine Natur akzeptiert keine Parameter, so dass es nicht zu spielen schön mit einem params object[] argument. Wenn Sie möchten, eine endgültige überlastung, übernimmt eine variable Anzahl von Argumenten, würde ich gehen mit DynamicInvoke nachdem alle, nur für diese Methode nennen:

    public void Execute(Delegate action, params object[] parameters)
{
    DoStuff();
    action.DynamicInvoke(parameters);
    DoMoreStuff();
}

    Aber zu erweitern auf das, was Johannes sagen wollte, ich glaube, er war im Grunde immer sowas wie das hier:

    public Action<T1, T2, T3> CreateAction<T1, T2, T3>(Action action)
{
    return (T1 x, T2 y, T3 z) => action();
}

public Action<T1, T2, T3> CreateAction<T1, T2, T3>(Action<T1> action, T1 arg)
{
    return (T1 x, T2 y, T3 z) => action(arg);
}

    Und so weiter-in anderen Worten, was Sie bereits getan habe, aber in einem Allgemeinen Kontext, so dass der code ist wiederverwendbar an anderen stellen.

    InformationsquelleAutor Dan Tao
Schreibe einen Kommentar