我有一个匿名方法，用于我的BackgroundWorker：
worker.DoWork += ( sender, e ) =>
{
foreach ( var effect in GlobalGraph.Effects )
{
// Returns EffectResult
yield return image.Apply (effect);
}
};
当我这样做时，编译器告诉我：
"在匿名方法或lambda表达式中不能使用yield语句"
那么，在这种情况下，最优雅的方法是什么？顺便说一句，如果解决方案需要，DoWork方法位于静态方法内。
很遗憾，你不能这样做。
编译器不允许将两个“神奇”的代码片段结合在一起。这两种方法都需要重写你的代码来支持你想要做的事情：
但是，你可以将代码重写为返回集合的形式，在你的特定情况下，我会这样做：
worker.DoWork += ( sender, e ) =>
{
return GlobalGraph.Effects
.Select(effect => image.Apply(effect));
};
虽然在事件 (sender, e) 中返回任何内容看起来很奇怪。您确定您向我们展示的是真实场景吗？
编辑：好的，我认为我知道你在这里想要做什么了。
您调用了一个静态方法，然后想要在后台执行代码，并在后台调用完成后从该静态方法返回数据。
虽然这是可能的，但并不是一个好的解决方案，因为您实际上正在暂停一个线程等待另一个线程，而后一个线程是在您暂停线程之前直接启动的。换句话说，您正在增加上下文切换的开销。
相反，您需要启动后台工作，然后在该工作完成时处理生成的数据。
return 关键字来返回其所在方法。在 lambda 表达式中使用的 return 关键字只会导致从该 lambda 表达式本身返回。 - Enigmativity或许只需返回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中，lambda表达式也不会在DoWork事件触发之前执行。因此，对GetSomeValues的调用完成后没有返回任何结果，lamdba可能会在以后的某个阶段被调用-这对于GetSomeValues方法的调用者来说已经太晚了。IEnumerable<T>的方式。Rx不是从可枚举对象中请求值，而是从IObservable<T>中推送值给你。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 如何 "调度" 处理对观察者的订阅。
希望这可以帮到你。
IEnumerable<EffectResult>，而它必须在BW执行其任务时进行阻塞。因此，你最好完全避免使用BW。你需要使用类似Rx或TPL的东西。 - EnigmativityIEnumerable<EffectResult>的原因。 - Joan VengeIEnumerable<T> 都是阻塞调用。使用 yield return 不会使其异步化。您的 BW 应在后台执行所有数据处理，然后一次性将处理后的数据交给 UI。您正在尝试分多个步骤（即使用可枚举对象）交付它，这是行不通的。尝试使用 TPL。如果您使用的是 .NET 3.5 SP1，则可以通过安装 Rx 来获取 TPL。它已经捆绑在其中了。 - Enigmativity对于新读者：在C#5中实现“匿名迭代器”（即嵌套在其他方法中）最优雅的方法可能是像this cool trick with 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 Preview中可用）支持本地函数，允许使用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; }
}
}
}
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 );
} );
我想要补充user1414213562的答案，并提供一个ForEachMonad的实现。
static class ForEachMonad
{
public static IEnumerable<A> Lift<A>(A a) { yield return a; }
// Unfortunately, this doesn't compile
// public static Func<IEnumerable<A>, IEnumerable<B>> Lift<A, B>(Func<A, IEnumerable<B>> f) =>
// (IEnumerable<A> ea) => { foreach (var a in ea) { foreach (var b in f(a)) { yield return b; } } }
// Fortunately, this does :)
public static Func<IEnumerable<A>, IEnumerable<B>> Lift<A, B>(Func<A, IEnumerable<B>> f)
{
IEnumerable<B> lift(IEnumerable<A> ea)
{
foreach (var a in ea) { foreach (var b in f(a)) { yield return b; } }
}
return lift;
}
public static void Demo()
{
var f = (int x) => (IEnumerable<int>)new int[] { x + 1, x + 2, x + 3 };
var g = (int x) => (IEnumerable<double>)new double[] { Math.Sqrt(x), x*x };
var log = (double d) => { Console.WriteLine(d); return Lift(d); };
var e1 = Lift(0);
var e2 = Lift(f)(e1);
var e3 = Lift(g)(e2);
// we call ToArray in order to materialize the IEnumerable
Lift(log)(e3).ToArray();
}
}
运行 ForEachMonad.Demo() 会产生以下输出：
1
1
1,4142135623730951
4
1,7320508075688772
9