В C#, почему анонимный метод не может содержать оператор yield?

Эрик Липперт написал отличную серию статей об ограничениях (и дизайнерских решений, влияющих на этот выбор) на итератор блоков

в частности, блоки итераторов реализуются некоторыми сложными преобразованиями кода компилятора. Эти преобразования будут влиять на преобразования, которые происходят внутри анонимных функций или лямбд, так что в определенных обстоятельствах они оба попытаются "преобразовать" код в какой - то другой конструкция, которая была несовместима с другой.

в результате, они запрещены от взаимодействия.

как блоки итератора работают под капотом хорошо справляется здесь.

как простой пример несовместимости:

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();
}

компилятор одновременно хочет преобразовать это в нечто вроде:

// 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();
}

и в то же время аспект итератора пытается сделать свою работу, чтобы сделать небольшое состояние машина. Некоторые простые примеры могут работать с изрядным количеством проверки здравомыслия (сначала имея дело с (возможно, произвольно) вложенными замыканиями), а затем видя, могут ли результирующие классы самого нижнего уровня быть преобразованы в итераторы.

однако это будет

1. довольно много работы.
2. не может работать во всех случаях, если по крайней мере аспект блока итератора не может предотвратить аспект закрытия применение определенных преобразований для повышения эффективности (например, продвижение локальных переменных к переменным экземпляра, а не к полноценному классу закрытия).
   • если бы была даже небольшая вероятность перекрытия там, где это было невозможно или достаточно трудно не быть реализованным, то количество проблем поддержки в результате, вероятно, будет высоким, так как тонкое нарушение изменения будут потеряны для многих пользователей.
3. его можно очень легко обойти.

в вашем примере вот так:

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;
}

к сожалению, я не знаю, почему они не позволили этого, так как, конечно, вполне можно представить, как это будет работать.

кроме того, методы итератора используют yield также реализуется через магия компилятора.

Я предполагаю, что один из этих двух делает код неидентифицируемым для другой части магии, и что было решено не тратить время на эту работу для текущих версий компилятора C#. Конечно, это может быть сознательный выбор, и что он просто не работает, потому что никто не думал его выполнять.

для 100% точного вопроса я бы предложил вам использовать Microsoft Connect сайт и сообщить вопрос, я конечно, вы получите что-то полезное взамен.

Я бы сделал так:

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

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

конечно, вам нужна система.Ядро.DLL-файл ссылается .Net 3.5, для метод в LINQ. И включают в себя:

using System.Linq;

спасибо,

хитрый