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

спасибо,

хитрый