Warum kann eine anonyme Methode in C # keine yield-Anweisung enthalten?

Ich dachte, es wäre schön, so etwas zu tun (mit der lambda zu tun eine Rendite):

public IList<T> Find<T>(Expression<Func<T, bool>> expression) where T : class, new()
{
    IList<T> list = GetList<T>();
    var fun = expression.Compile();

    var items = () => {
        foreach (var item in list)
            if (fun.Invoke(item))
                yield return item; //This is not allowed by C#
    }

    return items.ToList();
}

Allerdings fand ich heraus, dass ich nicht verwenden können, die Ausbeute in der anonymen Methode. Ich Frage mich, warum. Die Ausbeute docs nur sagen, es ist nicht erlaubt.

Da war es nicht erlaubt ich gerade erstellten Liste Hinzugefügt und die Elemente.

InformationsquelleAutor der Frage Lance Fisher | 2009-08-01

  1. 92

    Eric Lippert schrieb vor kurzem eine Reihe von blog-posts über, warum die Ausbeute ist nicht erlaubt in einigen Fällen.

    EDIT2:

    • Teil 7 (dieser wurde später veröffentlicht und richtet sich speziell dieser Frage)

    Wahrscheinlich werden Sie dort die Antwort finden...

    EDIT1: dies wird erklärt in den Kommentaren von Teil 5, in der Eric 's Antwort auf Abhijeet Patel' s Kommentar:

    Q :

    Eric,

    Können Sie auch Einblick in
    warum "Erträge" sind nicht erlaubt im inneren eine
    anonyme Methode oder lambda-Ausdruck

    A :

    Gute Frage. Ich würde lieben, Sie zu haben
    anonyme iterator-Blöcke. Es wäre
    Total genial bauen zu können
    Sie sich ein wenig Sequenz-generator
    in-place, die geschlossen über lokale
    Variablen. Der Grund, warum nicht ist
    unkompliziert: die Vorteile nicht
    die Kosten überwiegen. Awesomeness
    die Herstellung Sequenz-Generatoren in-place ist
    eigentlich ziemlich klein, in der grand
    Schema der Dinge und der nominal-Methoden
    den job gut genug in den meisten
    - Szenarien. Also die Vorteile sind nicht
    das überzeugende.

    Die Kosten sind groß. Iterator
    rewriting ist die komplizierteste
    transformation in den compiler, und
    anonyme Methode ist das umschreiben der
    zweite komplizierteste. Anonym
    Methoden können innerhalb anderer anonym
    Methoden und anonyme Methoden
    im inneren iterator-Blöcke. Daher
    was wir tun, ist zunächst schreiben wir alle
    anonyme Methoden, so dass Sie zu
    Methoden der closure-Klasse. Dies ist
    die Letzte Sekunde, was der compiler
    vor dem ausstrahlen von IL für eine Methode.
    Sobald dieser Schritt erledigt ist, wird der iterator
    rewriter kann davon ausgehen, dass es keine
    anonyme Methoden in der "iterator"
    blockieren Sie; Sie haben alle umgeschrieben werden
    schon. Daher wird der iterator
    rewriter können, konzentrieren Sie sich nur auf
    das umschreiben der iterator, ohne
    besorgniserregend ist, dass es möglicherweise ein
    fehlende anonyme Methode.

    Auch, iterator-Blöcke nie "nest",
    im Gegensatz zu anonymen Methoden. Der iterator
    rewriter kann davon ausgehen, dass alle iterator
    Blöcke sind "top-level".

    Wenn anonyme Methoden sind erlaubt
    enthalten iterator-Blöcke, dann die beiden
    diese Annahmen gehen aus dem Fenster.
    Können Sie ein iterator-block,
    enthält eine anonyme Methode, die
    enthält eine anonyme Methode, die
    enthält ein iterator-block,
    enthält eine anonyme Methode, und...
    igitt. Jetzt haben wir zu schreiben, umzuschreiben
    pass verarbeiten kann verschachtelte iterator
    Blöcke und verschachtelte anonyme Methoden an
    die gleiche Zeit, das Zusammenführen unserer zwei wichtigsten
    komplizierte algorithmen in einer weit
    komplizierter Algorithmus. Es würde
    wirklich schwer sein zu entwerfen, zu implementieren,
    und zu testen. Wir sind clever genug zu tun
    so, da bin ich sicher. Wir haben eine smart-team
    hier. Aber wir wollen nicht zu nehmen
    dass große Belastung für ein "nice to have
    aber nicht notwendig" - Funktion. -- Eric

    InformationsquelleAutor der Antwort Thomas Levesque

  2. 19

    Eric Lippert hat geschrieben eine exzellente Serie von Artikeln über die Grenzen (und design-Entscheidungen beeinflussen die Entscheidungen) auf iterator-Blöcke

    Insbesondere iterator-Blöcke implementiert sind einige ausgefeilte compiler-code-Transformationen. Diese Veränderungen auswirken würden mit den Veränderungen, die passieren, inside anonyme Funktionen oder Lambda-Ausdrücke, so dass unter bestimmten Umständen würden Sie versuchen, sowohl auf 'konvertieren' den code in ein anderes Konstrukt, welches nicht kompatibel mit den anderen.

    Als Ergebnis sind Sie verboten von Interaktion.

    Wie iterator-Blöcke arbeiten unter der Haube ist behandelt mit gut hier.

    Als ein einfaches Beispiel für eine Unvereinbarkeit:

    public IList<T> GreaterThan<T>(T t)
{
    IList<T> list = GetList<T>();
    var items = () => {
        foreach (var item in list)
            if (fun.Invoke(item))
                yield return item; //This is not allowed by C#
    }

    return items.ToList();
}

    Ist der compiler gleichzeitig zu wollen, konvertieren Sie diese zu etwas wie:

    //inner class
private class Magic
{
    private T t;
    private IList<T> list;
    private Magic(List<T> list, T t) { this.list = list; this.t = t;}

    public IEnumerable<T> DoIt()
    {
        var items = () => {
            foreach (var item in list)
                if (fun.Invoke(item))
                    yield return item;
        }
    }
}

public IList<T> GreaterThan<T>(T t)
{
    var magic = new Magic(GetList<T>(), t)
    var items = magic.DoIt();
    return items.ToList();
}

    und gleichzeitig den iterator Aspekt ist versuchen zu tun, ist es Arbeit zu machen, eine kleine state-Maschine. Bestimmte einfache Beispiele könnten arbeiten mit einem fairen Betrag von sanity-Check (erste beschäftigt sich mit der (möglicherweise willkürlich nexted Verschlüsse) dann sehen, wenn die ganz unteren Ebene, die resultierenden Klassen transformiert werden kann in iterator-state-machines.

    Dies würde jedoch

    1. Sehr viel Arbeit.
    2. Gar nicht in allen Fällen funktionieren, ohne zumindest die iterator-block Aspekt Lage zu verhindern, dass die Schließung Aspekt von der Anwendung bestimmter Transformationen für die Effizienz (wie die Förderung von lokalen Variablen zu Instanz-Variablen anstatt einer vollwertigen Schließung Klasse).
      • Wenn es sogar eine geringfügige Möglichkeit der überlappung, wo es unmöglich war, oder ausreichend schwer, um nicht umgesetzt werden, dann werden die Anzahl der Supportprobleme resultierende, würde wohl zu hoch sein, da die subtile brechen ändern würde verloren gehen, für viele Benutzer.
    3. Es kann sehr leicht umgangen werden.

    In deinem Beispiel etwa so:

    public IList<T> Find<T>(Expression<Func<T, bool>> expression) 
    where T : class, new()
{
    return FindInner(expression).ToList();
}

private IEnumerable<T> FindInner<T>(Expression<Func<T, bool>> expression) 
    where T : class, new()
{
    IList<T> list = GetList<T>();
    var fun = expression.Compile();
    foreach (var item in list)
        if (fun.Invoke(item))
            yield return item;
}

    InformationsquelleAutor der Antwort ShuggyCoUk

  3. 2

    Leider weiß ich nicht, warum Sie nicht zulassen, denn natürlich ist es durchaus möglich, zu tun, sich vorstellen, wie das funktionieren würde.

    Jedoch, anonyme Methoden sind bereits ein Stück von "compiler-Magie" in dem Sinne, dass die Methode extrahiert werden, die entweder auf eine Methode in der vorhandenen Klasse, oder sogar eine ganz neue Klasse, je nachdem, ob es sich mit lokalen Variablen oder nicht.

    Darüber hinaus iterator-Methoden mit yield ist auch implementiert, mithilfe von compiler-magic.

    Meine Vermutung ist, dass einer der beiden macht den code un-identifizierbaren, um das andere Stück der Magie, und so wurde beschlossen, nicht verbringen Zeit auf diese Arbeit für die aktuellen Versionen der C# - compiler. Natürlich, es ist vielleicht nicht eine bewusste Wahl, und dass es einfach nicht funktioniert, weil niemand dachte, es zu implementieren.

    Für eine 100% genaue Frage, die ich schlage vor, Sie verwenden die Microsoft Connect Website und Bericht-eine Frage, ich bin sicher, Sie bekommen etwas Verwertbares zurück.

    InformationsquelleAutor der Antwort Lasse Vågsæther Karlsen

  4. 1

    Ich würde dies tun:

    IList<T> list = GetList<T>();
var fun = expression.Compile();

return list.Where(item => fun.Invoke(item)).ToList();

    Natürlich müssen Sie die System.Core.dll auf die dort verwiesen wird .NET 3.5, für Linq-Methode. Und beinhalten: 

    using System.Linq;

    Cheers,

    Sly

    InformationsquelleAutor der Antwort

Schreibe einen Kommentar