Как вернуть возврат внутри анонимных методов?

К сожалению, нет.

Компилятор не позволяет комбинировать два «волшебных» фрагмента кода. Оба включают переписывание кода для поддержки того, что вы хотите сделать:

1. Анонимный метод выполняется путем перемещения кода в соответствующий метод и переноса локальных переменных в поля класса с помощью этого метода.
2. Метод итератора переписан как конечный автомат

Однако вы можете переписать код, чтобы вернуть коллекцию, поэтому в вашем конкретном случае я бы сделал это:

worker.DoWork += ( sender, e ) =>
{
    return GlobalGraph.Effects
        .Select(effect => image.Apply(effect));
};

хотя выглядит странным, когда событие (sender, e) вообще что-то возвращает. Вы уверены, что показываете нам реальный сценарий?

Редактировать Хорошо, думаю я понимаю, что вы здесь пытаетесь сделать.

У вас есть вызов статического метода, а затем вы хотите выполнить код в фоновом режиме, а затем вернуть данные из этого статического метода после завершения фонового вызова.

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

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

Возможно, просто верните выражение linq и отложите выполнение, например yield:

return GlobalGraph.Effects.Select(x => image.Apply(x));

Если я чего-то не упускаю, ты не можешь делать то, о чем просишь.

(У меня есть для вас ответ, поэтому сначала прочтите мое объяснение того, почему вы не можете делать то, что делаете, а затем читайте дальше.)

Полный метод будет выглядеть примерно так:

public static IEnumerable<EffectResult> GetSomeValues()
{
    // code to set up worker etc
    worker.DoWork += ( sender, e ) =>
    {
        foreach ( var effect in GlobalGraph.Effects )
        {
            // Returns EffectResult
            yield return image.Apply (effect);
        }
    };
}

Если мы предположим, что ваш код был "допустимым", то при вызове GetSomeValues, даже если обработчик DoWork добавлен в worker, лямбда-выражение не выполняется до тех пор, пока не будет запущено событие DoWork. Таким образом, вызов GetSomeValues завершается без возврата каких-либо результатов, и lamdba может или не может быть вызван на более позднем этапе, что в любом случае будет слишком поздно для вызывающего метода GetSomeValues.

Ваш лучший ответ - использовать Rx.

Rx переворачивает IEnumerable<T> с ног на голову. Вместо того, чтобы запрашивать значения из перечислимого, Rx имеет значения, переданные вам из IObservable<T>.

Поскольку вы используете фонового работника и отвечаете на событие, вы уже фактически получаете значения, отправленные вам. С Rx становится легко делать то, что вы пытаетесь сделать.

У вас есть несколько вариантов. Наверное, самое простое - это сделать так:

public static IObservable<IEnumerable<EffectResult>> GetSomeValues()
{
    // code to set up worker etc
    return from e in Observable.FromEvent<DoWorkEventArgs>(worker, "DoWork")
           select (
               from effect in GlobalGraph.Effects
               select image.Apply(effect)
           );
}

Теперь вызывающие ваш GetSomeValues метод будут делать это:

GetSomeValues().Subscribe(ers =>
{
    foreach (var er in ers)
    {
        // process each er
    }
});

Если вы знаете, что DoWork сработает только один раз, тогда этот подход может быть немного лучше:

public static IObservable<EffectResult> GetSomeValues()
{
    // code to set up worker etc
    return Observable
        .FromEvent<DoWorkEventArgs>(worker, "DoWork")
        .Take(1)
        .Select(effect => from effect in GlobalGraph.Effects.ToObservable()
                          select image.Apply(effect))
        .Switch();  
}

Этот код выглядит немного сложнее, но он просто превращает отдельное событие do work в поток EffectResult объектов.

Тогда вызывающий код выглядит так:

GetSomeValues().Subscribe(er =>
{
    // process each er
});

Rx можно даже использовать для замены фонового рабочего. Возможно, это лучший вариант для вас:

public static IObservable<EffectResult> GetSomeValues()
{
    // set up code etc
    return Observable
        .Start(() => from effect in GlobalGraph.Effects.ToObservable()
                     select image.Apply(effect), Scheduler.ThreadPool)
        .Switch();  
}

Вызывающий код такой же, как в предыдущем примере. Scheduler.ThreadPool сообщает Rx, как «запланировать» обработку подписок для наблюдателя.

Надеюсь, это поможет.

Для новых читателей: наиболее элегантный способ реализации «анонимных итераторов» (т.е. вложенных в другие методы) в C # 5, вероятно, выглядит примерно так: этот крутой трюк с async / await (не запутайтесь этими ключевыми словами, приведенный ниже код вычисляется абсолютно синхронно - подробности см. на связанной странице):

        public IEnumerable<int> Numbers()
        {
            return EnumeratorMonad.Build<int>(async Yield =>
            {
                await Yield(11);
                await Yield(22);
                await Yield(33);
            });
        }

        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethod]
        public void TestEnum()
        {
            var v = Numbers();
            var e = v.GetEnumerator();

            int[] expected = { 11, 22, 33 };

            Numbers().Should().ContainInOrder(expected);

        }

C # 7 (доступен в предварительной версии Visual Studio 15) поддерживает локальные функции, которые позволяют yield return:

public IEnumerable<T> Filter<T>(IEnumerable<T> source, Func<T, bool> filter)
{
    if (source == null) throw new ArgumentNullException(nameof(source));
    if (filter == null) throw new ArgumentNullException(nameof(filter));

    return Iterator();

    IEnumerable<T> Iterator()
    {
        foreach (var element in source) 
        {
            if (filter(element)) { yield return element; }
        }
    }
}

DoWork имеет тип DoWorkEventHandler, который ничего не возвращает ( void), так что в вашем случае это вообще невозможно.

Рабочий должен установить свойство Result для DoWorkEventArgs.

worker.DoWork += (s, e) => e.Result = GlobalGraph.Effects.Select(x => image.Apply(x));

Хорошо, я сделал что-то вроде этого, что делает то, что я хотел (некоторые переменные опущены):

public static void Run ( Action<float, EffectResult> action )
{
    worker.DoWork += ( sender, e ) =>
    {
        foreach ( var effect in GlobalGraph.Effects )
        {
            var result = image.Apply (effect);

            action (100 * ( index / count ), result );
        }
    }
};

а затем на сайте звонка:

GlobalGraph.Run ( ( p, r ) =>
    {
        this.Progress = p;
        this.EffectResults.Add ( r );
    } );