(Wie) ist es möglich, bind/rebind Methode zu arbeiten, mit ein Delegat, der eine andere Signatur?

Ich bin ein c++ Entwickler, die verwendeten Signale & Ablagefächer in c++, das auf mich scheint, Analog zum Delegaten in c#. Ich habe festgestellt, mich an einem Verlust bei der Suche nach den Funktionen "binden", und das Gefühl, ich muss etwas fehlen.

Ich das Gefühl, dass so etwas wie die folgenden, die möglich ist, in c++ möglich sein sollte, in c# mit den Delegaten. Hier einige psudo-code für das, was ich tun würde, in c++:

Slot<void> someCallback;

int foo(int i)
{
    std::cout << "Value: " << i << "\n";
    return i;
}

int main()
{
    int i = 0;
    Slot<int> someCallback = bind( fun_ptr(foo), i );
    ++i; //added to show that late evaluation would be a non-trivial difference
    int result = someCallback();
    assert( result == 0 );
    return 0;
}

Leider habe ich nicht in der Lage gewesen zu finden, jede Bezugnahme auf die Bindung/neubindung mit Bezug auf c# - Delegaten. Bin ich etwas fehlt? Gibt es eine radikal andere Weise, dies zu tun in c#?

InformationsquelleAutor Catskul | 2010-01-20

c#callback currying delegates signals-slots

15

In C# - wir tun so etwas wie dieses:
```
class Program {
    static Action Curry<T>(Action<T> action, T parameter) {
        return () => action(parameter);
    }

    static void Foo(int i) {
        Console.WriteLine("Value: {0}", i);
    }
    static void Main(string[] args) {
        Action curried = Curry(Foo, 5);
        curried();
    }
}
```
Klar die Methode Foo entspricht Ihre Methode Foo nur mit den entsprechenden Aufrufe Console.WriteLine statt std::cout.

Nächstes deklarieren wir eine Methode Curry nimmt eine Action<T> und zurück Action. Im Allgemeinen, eine Action<T> ist ein Delegat, der akzeptiert einen einzelnen parameter vom Typ T und zurück void. Insbesondere Foo ist ein Action<int> weil es akzeptiert einen parameter vom Typ int und zurück void. Als für den Rückgabetyp der Curry wird deklariert als Action. Ein Action ist ein Delegat, der hat keine Parameter und gibt void.

Die definition von Curry ist ziemlich interessant. Wir definieren eine Aktion mit einem lambda-Ausdruck ist eine sehr spezielle form von einem anonymen Delegaten. Effektiv
```
() => action(parameter)
```
sagt, dass die void parameter zugeordnet ist action bewertet parameter.

Schließlich in Main wir deklarieren eine Instanz von Action namens curried das ist das Ergebnis der Anwendung Curry zu Foo mit dem parameter 5. Das spielt die gleiche Rolle wie bind(fun_ptr(foo), 5) im C++ - Beispiel.

Schließlich rufen wir die neu gebildeten delegieren curried über die syntax curried(). Das ist wie someCallback() in deinem Beispiel.

Fancy Begriff für diese ist currying.

Als noch interessanter ist Folgendes zu berücksichtigen:
```
class Program {
    static Func<TArg, TResult> Curry<TArg, TResult>(
        Func<TArg, TArg, TResult> func,
        TArg arg1
    ) {
        return arg => func(arg1, arg);
    }

    static int Add(int x, int y) {
        return x + y;
    }

    static void Main(string[] args) {
        Func<int, int> addFive = Curry<int, int>(Add, 5);
        Console.WriteLine(addFive(7));
    }
}
```
Hier sind wir deklarieren eine Methode Curry akzeptiert Delegierter (Func<TArg, TArg, TResult> akzeptiert zwei Parameter des gleichen Typs TArg und gibt einen Wert von etwas anderer Art TResult und einen parameter vom Typ TArg und gibt ein Delegat, der akzeptiert einen einzelnen parameter vom Typ TArg und gibt einen Wert vom Typ TResult (Func<TArg, TResult>).

Dann, als test deklarieren wir eine Methode Add akzeptiert zwei Parameter vom Typ int und gibt einen parameter vom Typ int (a Func<int, int, int>). Dann in Main instanzieren wir eine neue Stellvertretung benannt addFive das wirkt wie eine Methode fügt hinzu, dass fünf seiner input-parameter. So
```
Console.WriteLine(addFive(7));
```
Drucke 12 auf der Konsole.
- Danke für deine ausführliche Antwort. Ich kenn die andere als die akzeptierten Antworten, denn es ist eher prägnant, aber es fehlen einige wichtige details, die Ihnen enthalten.
- Sicher. Ich hoffe nur, dass die zusätzliche Farbe hilft. 🙂
- Extrem nützlich, Antwort, in dieser. Eingeführt ein geniales Konzept, currying, in einer leicht verständlichen Art und Weise. Wird auf jeden Fall fügen Sie diese zu meiner mentalen toolbox.
InformationsquelleAutor jason
4

Versuchen Sie die folgenden
```
class Example {
  static void foo(int i) {
    Console.WriteLine(i);
  }
  public static void Main() {
    Action someCallback = () => foo(5);
    someCallback();
  }
}
```
Oder für etwas noch näher an das C++ Gegenstück
```
class Example {
  static void foo(int i) {
    Console.WriteLine(i);
  }
  static Action bind<T>(Action<T> action, T value) {
    return () => action(value);
  }
  public static void Main() {
    Action someCallback = bind(foo, 5);
    someCallback();
  }
}
```
Erklärung. Was hier passiert ist, das ich erschaffe eine neue Stellvertretung durch einen lambda-Ausdruck. Der lambda-Ausdruck beginnend mit () =>. In diesem Fall erstellt er einen Delegat akzeptiert keine Argumente und produzieren keinen Wert. Es ist kompatibel mit dem Typ Action.
- Woah. Interessant. Was sehe ich hier?
- Er ist erstellen Sie einen neuen Delegaten mit einem lambda-Ausdruck. Der Delegat ruft "foo(5)". Es ist wie eine neue Methode on-the-fly Aufruf von foo(5) für Sie, dann die Zuordnung zu den someCallback delegieren.
- Action<T> ist eine Stellvertretung zur Verfügung gestellt durch das framework. Es ist eine Funktion, die einen parameter (vom Typ T) und gibt nichts zurück (void). Er ist die Zuweisung einer anonymen Funktion, die Delegierten (die er genannt hat someCallback). Die leeren Klammern zeigen an, dass es keine Argumente entgegennimmt, wird der Ausdruck nach der => ist der Körper der Funktion.
- Danke. Das ist genau das, was ich suchte. Bedenkt man diese Beispiel, ich glaube nicht, dass gibt es eine generische binden verfügbar, ermittelt automatisch den Rückgabetyp?
- Nein, es ist nicht in C#
- Nach der Verwendung dieses mehr intensiv es scheint, dass es eine sehr große Einschränkung, um das erste Beispiel, das macht es unbrauchbar wird: verzögerte Auswertung. Wenn ich "Action someCallback = () => foo(i);" es nimmt das "ich" zur Zeit der Rückruf als vielmehr der Zeitpunkt der Zuordnung. Das zweite Beispiel hingegen funktioniert, aber hat die unglückliche Nebenwirkung, die dafür eine bestimmte "binden" erklärt werden, die für jede Art von rebinding durchgeführt werden.
InformationsquelleAutor JaredPar

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.