我理解协程的原理。我知道如何在Unity中使用C#获取标准的StartCoroutine / yield return模式，例如通过StartCoroutine调用返回IEnumerator的方法，在该方法中执行某些操作，使用yield return new WaitForSeconds(1);等待一秒钟，然后执行其他操作。
我的问题是：背后到底发生了什么？StartCoroutine具体是做什么的？WaitForSeconds返回的IEnumerator是什么？StartCoroutine如何将控制权返回给被调用方法中的“其他操作”部分？所有这些是如何与Unity的并发模型交互的（其中许多事情同时进行，而不使用协程）？
经常提到的Unity3D协程详解链接已经失效。由于它在评论和答案中被提及，我将在此发布文章内容。这篇文章内容来自这个镜像。
function LongComputation()
{
while(someCondition)
{
/* Do a chunk of work */
// Pause here and carry on next frame
yield;
}
}
IEnumerator LongComputation()
{
while(someCondition)
{
/* Do a chunk of work */
// Pause here and carry on next frame
yield return null;
}
}
IEnumerator TellMeASecret()
{
PlayAnimation("LeanInConspiratorially");
while(playingAnimation)
yield return null;
Say("I stole the cookie from the cookie jar!");
while(speaking)
yield return null;
PlayAnimation("LeanOutRelieved");
while(playingAnimation)
yield return null;
}
IEnumerator e = TellMeASecret();
while(e.MoveNext()) { }
IEnumerator e = TellMeASecret();
while(e.MoveNext())
{
// If they press 'Escape', skip the cutscene
if(Input.GetKeyDown(KeyCode.Escape)) { break; }
}
List<IEnumerator> unblockedCoroutines;
List<IEnumerator> shouldRunNextFrame;
List<IEnumerator> shouldRunAtEndOfFrame;
SortedList<float, IEnumerator> shouldRunAfterTimes;
foreach(IEnumerator coroutine in unblockedCoroutines)
{
if(!coroutine.MoveNext())
// This coroutine has finished
continue;
if(!coroutine.Current is YieldInstruction)
{
// This coroutine yielded null, or some other value we don't understand; run it next frame.
shouldRunNextFrame.Add(coroutine);
continue;
}
if(coroutine.Current is WaitForSeconds)
{
WaitForSeconds wait = (WaitForSeconds)coroutine.Current;
shouldRunAfterTimes.Add(Time.time + wait.duration, coroutine);
}
else if(coroutine.Current is WaitForEndOfFrame)
{
shouldRunAtEndOfFrame.Add(coroutine);
}
else /* similar stuff for other YieldInstruction subtypes */
}
unblockedCoroutines = shouldRunNextFrame;
YieldInstruction y;
if(something)
y = null;
else if(somethingElse)
y = new WaitForEndOfFrame();
else
y = new WaitForSeconds(1.0f);
yield return y;
具体的代码行yield return new WaitForSeconds()、yield return new WaitForEndOfFrame()等是常见的，但它们并不是特殊形式。
其次，因为这些协程只是迭代器块，如果需要你可以手动进行迭代，而不一定要由引擎自动操作。我曾经在协程中添加中断条件时使用过这种方法：
IEnumerator DoSomething()
{
/* ... */
}
IEnumerator DoSomethingUnlessInterrupted()
{
IEnumerator e = DoSomething();
bool interrupted = false;
while(!interrupted)
{
e.MoveNext();
yield return e.Current;
interrupted = HasBeenInterrupted();
}
}
第三，你可以在其他协程上使用yield，这样就可以实现自己的YieldInstructions，尽管其性能不如引擎实现的好。例如：
IEnumerator UntilTrueCoroutine(Func fn)
{
while(!fn()) yield return null;
}
Coroutine UntilTrue(Func fn)
{
return StartCoroutine(UntilTrueCoroutine(fn));
}
IEnumerator SomeTask()
{
/* ... */
yield return UntilTrue(() => _lives < 3);
/* ... */
}
然而，我不太建议这样做——启动协程的成本有点高，不符合我的喜好。
结论 我希望这能澄清一些当你在Unity中使用协程时实际上正在发生的事情。C#的迭代器块是一个很棒的构造，即使你不使用Unity，也可能会发现以同样的方式利用它们很有用。
IEnumerator SomeTask() { yield return UntilTrueCoroutine(() => _lives < 3); }，尽管你可能不会将该方法命名为“UntilTrueCoroutine”，而是使用“UntilTrue”来代替你当前命名为“UntilTrueCoroutine”的方法。 - matthias_buehlmann下面的第一个标题是对问题的直接回答。接下来的两个标题对于日常编程人员更有用。
协程在维基百科和其他地方有解释。在这里，我将从实际角度提供一些细节。 IEnumerator，yield等是C#语言特性，在Unity中用于不同的目的。
IEnumerator 声明拥有一组值，你可以一个接一个地请求这些值，有点像 List。在 C# 中，一个带有返回类型为 IEnumerator 的函数不需要实际创建并返回一个 IEnumerator，而是可以让 C# 提供一个隐式的 IEnumerator。然后，该函数可以通过 yield return 语句以延迟的方式提供将要返回的 IEnumerator 的内容。每当调用方从该隐式的 IEnumerator 请求另一个值时，该函数执行到下一个 yield return 语句，即提供下一个值。作为副产品，该函数暂停直到请求下一个值。IEnumerator与任何东西有什么关系？yield是什么？为什么要使用new WaitForSeconds(3)等）。在“幕后”，你通过IEnumerator提供的值被StartCoroutine()用于决定何时请求下一个值，从而确定你的协程何时会再次暂停。
while(true);来验证这一点。它会冻结整个东西，甚至连Unity编辑器也会冻结。这证明了所有内容都在一个主线程中运行。Kay在上面评论中提到的链接也是一个很好的资源。基本上，当你调用StartCoroutine(MyCoroutine())时，它就像对MyCoroutine()的普通函数调用一样，直到第一个yield return X，其中X是像null、new WaitForSeconds(3)、StartCoroutine(AnotherCoroutine())、break等东西。这时它开始与一个函数不同。Unity在那个yield return X行暂停该函数，继续其他业务并经过一些帧，再次到达时间时，Unity恢复该函数，恢复在该行后面的所有局部变量的值。这样，您就可以拥有一个每两秒循环一次的for循环，例如。
Unity会根据你在yield return X中使用的X来决定何时恢复你的协程。例如，如果你使用了yield return new WaitForSeconds(3);，它会在3秒后恢复。如果你使用了yield return StartCoroutine(AnotherCoroutine())，它会在AnotherCoroutine()完成后恢复，这使你可以嵌套行为和时间。如果你只是使用了yield return null;，它会在下一帧立即恢复。
Unity（以及所有游戏引擎）是基于帧进行处理的。
整个Unity的意义和目的就在于它是基于帧的。 引擎会在每一帧为您完成各种任务。 （动画制作、渲染对象、物理运算等等。）
你可能会问，“哦，太好了。如果我想让引擎在每一帧为我做点什么，我该如何告诉引擎执行某些操作？”
这正是“协程”的用途。
就是这么简单。
简而言之，您放入“更新”中的任何内容都会在每一帧上执行。 这与协程-暂停语法完全相同，没有任何区别。
void Update()
{
this happens every frame,
you want Unity to do something of "yours" in each of the frame,
put it in here
}
...in a coroutine...
while(true)
{
this happens every frame.
you want Unity to do something of "yours" in each of the frame,
put it in here
yield return null;
}
完全没有区别。
游戏引擎中的帧与线程完全没有关系，两者是完全、彻底、绝对无关的问题。
(你经常听到“Unity是单线程的！”请注意，即使这种说法也非常混乱。 帧/协程与线程根本就没有任何关系。如果Unity是多线程的、超线程的或在量子计算机上运行的！！！ ……它与帧/协程完全没有关系。 这是一个完全、彻底、绝对无关的问题。)
如果Unity是多线程的、超线程的或在量子计算机上运行的！！！ ……它与帧/协程完全没有关系。 这是一个完全、彻底、绝对无关的问题。
因此，协程/yield只是访问Unity中帧的方式。就是这样。
(实际上，它与Unity提供的Update()函数完全相同。)
就是这些，很简单。
再简单不过了：IEnumerator返回“一遍又一遍”的东西。
(那些东西的列表可以有一个特定的长度，比如“10个东西”，或者列表可以永远继续下去。)
因此，显然，IEnumerator就是你要使用的。
在.Net中，任何想要“一遍遍地返回”的地方都可以使用IEnumerator。
当然，所有基于帧的计算都使用IEnumerator来返回每个帧。还能用什么？
(如果您是C#的新手，请注意，IEnumerator也用于逐个返回“普通”的东西，例如数组中的项等。)
Update()这样的精确工作实现呢？我的意思是这两种实现和它们的用例之间应该至少存在一些微小的差异，这是相当明显的。 - MamiBeIEnumerator接口，以及如何将其用于协程。
对我来说，仍然觉得使用集合枚举器有点奇怪。这与枚举器旨在设计的相反。枚举器的重点是每次访问返回的值，但是协程的重点是值之间的代码。在此情况下，实际返回的值是无意义的。
async/await关键字来实现异步代码，但是在那之前，C#没有本地方法来实现异步代码。假设您有以下代码：
IEnumerable SomeNumbers() {
yield return 3;
yield return 5;
yield return 8;
}
3 5 8:// Output: 3 5 8
foreach (int number in SomeNumbers()) {
Console.Write(number);
}
IEnumerable DownloadAsync(string URL) {
WebRequest req = HttpWebRequest.Create(url);
WebResponse response = req.GetResponseAsync();
yield return response;
Stream resp = response.Result.GetResponseStream();
string html = resp.ReadToEndAsync().ExecuteAsync();
yield return html;
Console.WriteLine(html.Result);
}
PS：上面的代码来自于这篇优秀但有点陈旧的文章，介绍了使用迭代器进行异步编程：http://tomasp.net/blog/csharp-async.aspx/
async还是StartCoroutine？截至2021年，官方Unity文档在示例中使用协程而不是async。
此外，社区似乎更倾向于使用协程而不是async：
我推荐观看2019年的Unity讲座，标题为"最佳实践：Async vs. coroutines - Unite Copenhagen 2019"：https://youtu.be/7eKi6NKri6I
PS: 这是一个2012年的旧问题，但我回答它是因为在2021年仍然相关。
StartCoroutine是一种调用IEnumerator函数的方法。它类似于调用简单的void函数，只是不同之处在于您将其用于IEnumerator函数。这种类型的函数是独特的，因为它可以允许您使用特殊的yield函数，注意您必须返回一些东西。就我所知，就这些了。 这里我在Unity中编写了一个简单的闪烁游戏结束文本方法。
public IEnumerator GameOver()
{
while (true)
{
_gameOver.text = "GAME OVER";
yield return new WaitForSeconds(Random.Range(1.0f, 3.5f));
_gameOver.text = "";
yield return new WaitForSeconds(Random.Range(0.1f, 0.8f));
}
}
然后我从IEnumerator本身调用它
public void UpdateLives(int currentlives)
{
if (currentlives < 1)
{
_gameOver.gameObject.SetActive(true);
StartCoroutine(GameOver());
}
}
正如你所看到的，我是如何使用StartCoroutine()方法的。 希望我能在某种程度上帮助到你。我自己也是一个初学者，如果你能纠正我或者赞赏我，任何形式的反馈都将不胜感激。
void func()
你写
IEnumerator func()
关于协程。 同样的方式，您可以使用代码行来控制普通函数中的时间，例如
Time.deltaTime
yield return new WaitForSeconds();
IEnumerator/IEnumerable(或其泛型版本)且包含yield关键字的方法。请查询迭代器相关内容。 - Damien_The_Unbeliever