Unity协程(Coroutine)管理类——TaskManager工具分享(转)

尊重他人的劳动，支持原创，转载请注明出处：http.dsqiu.iteye.com

在分享vp_Timer 中提到，没有继承的MonoBehaviour，没有Update，InVoke 和StartCoroutine的机制，vp_Timer就是提供了InVoke的机制，而且还可以统一管理。本篇D.S.Qiu要分享的TaskManager就是一个协程 管理类。 TaskManager —— Unity3D Managed Coroutines with Start, Stop, Resume ，看着就觉得很强大，当然是对于我这种对协程理解不深的来说。下面贴出 The Motivation of the author：

/// The motivation for this is twofold:

///

/// 1. The existing coroutine API provides no means of stopping specific

///    coroutines; StopCoroutine only takes a string argument, and it stops

///    all coroutines started with that same string; there is no way to stop

///    coroutines which were started directly from an enumerator.  This is

///    not robust enough and is also probably pretty inefficient.

///

/// 2. StartCoroutine and friends are MonoBehaviour methods.  This means

///    that in order to start a coroutine, a user typically must have some

///    component reference handy.  There are legitimate cases where such a

///    constraint is inconvenient.  This implementation hides that

///    constraint from the user.

代码很简单，但却很解渴，Unity官方只听过了StopCoroutine(string methodName)或StopAllCoroutine() 这两个停止方法，从api就会觉得Unity的整体方法论还不完善，所以才会觉得TaskManager的难能可贵。由于源码简单，就不做解释了，See source for document ：

C#代码  

1. /// Simple, really.  There is no need to initialize or even refer to TaskManager.
2. /// When the first Task is created in an application, a "TaskManager" GameObject
3. /// will automatically be added to the scene root with the TaskManager component
4. /// attached.  This component will be responsible for dispatching all coroutines
5. /// behind the scenes.
6. ///
7. /// Task also provides an event that is triggered when the coroutine exits.
8. using UnityEngine;
9. using System.Collections;
10. /// A Task object represents a coroutine.  Tasks can be started, paused, and stopped.
11. /// It is an error to attempt to start a task that has been stopped or which has
12. /// naturally terminated.
13. public class Task
14. {
15. /// Returns true if and only if the coroutine is running.  Paused tasks
16. /// are considered to be running.
17. public bool Running {
18. get {
19. return task.Running;
20. }
21. }
22. /// Returns true if and only if the coroutine is currently paused.
23. public bool Paused {
24. get {
25. return task.Paused;
26. }
27. }
28. /// Delegate for termination subscribers.  manual is true if and only if
29. /// the coroutine was stopped with an explicit call to Stop().
30. public delegate void FinishedHandler(bool manual);
31. /// Termination event.  Triggered when the coroutine completes execution.
32. public event FinishedHandler Finished;
33. /// Creates a new Task object for the given coroutine.
34. ///
35. /// If autoStart is true (default) the task is automatically started
36. /// upon construction.
37. public Task(IEnumerator c, bool autoStart = true)
38. {
39. task = TaskManager.CreateTask(c);
40. task.Finished += TaskFinished;
41. if(autoStart)
42. Start();
43. }
44. /// Begins execution of the coroutine
45. public void Start()
46. {
47. task.Start();
48. }
49. /// Discontinues execution of the coroutine at its next yield.
50. public void Stop()
51. {
52. task.Stop();
53. }
54. public void Pause()
55. {
56. task.Pause();
57. }
58. public void Unpause()
59. {
60. task.Unpause();
61. }
62. void TaskFinished(bool manual)
63. {
64. FinishedHandler handler = Finished;
65. if(handler != null)
66. handler(manual);
67. }
68. TaskManager.TaskState task;
69. }
70. class TaskManager : MonoBehaviour
71. {
72. public class TaskState
73. {
74. public bool Running {
75. get {
76. return running;
77. }
78. }
79. public bool Paused  {
80. get {
81. return paused;
82. }
83. }
84. public delegate void FinishedHandler(bool manual);
85. public event FinishedHandler Finished;
86. IEnumerator coroutine;
87. bool running;
88. bool paused;
89. bool stopped;
90. public TaskState(IEnumerator c)
91. {
92. coroutine = c;
93. }
94. public void Pause()
95. {
96. paused = true;
97. }
98. public void Unpause()
99. {
100. paused = false;
101. }
102. public void Start()
103. {
104. running = true;
105. singleton.StartCoroutine(CallWrapper());
106. }
107. public void Stop()
108. {
109. stopped = true;
110. running = false;
111. }
112. IEnumerator CallWrapper()
113. {
114. yield return null;
115. IEnumerator e = coroutine;
116. while(running) {
117. if(paused)
118. yield return null;
119. else {
120. if(e != null && e.MoveNext()) {
121. yield return e.Current;
122. }
123. else {
124. running = false;
125. }
126. }
127. }
128. FinishedHandler handler = Finished;
129. if(handler != null)
130. handler(stopped);
131. }
132. }
133. static TaskManager singleton;
134. public static TaskState CreateTask(IEnumerator coroutine)
135. {
136. if(singleton == null) {
137. GameObject go = new GameObject("TaskManager");
138. singleton = go.AddComponent<TaskManager>();
139. }
140. return new TaskState(coroutine);
141. }
142. }

Usage Example:

C#代码  

1. /// Example usage:
2. ///
3. /// ----------------------------------------------------------------------------
4. /// IEnumerator MyAwesomeTask()
5. /// {
6. ///     while(true) {
7. ///         Debug.Log("Logcat iz in ur consolez, spammin u wif messagez.");
8. ///         yield return null;
9. ////    }
10. /// }
11. ///
12. /// IEnumerator TaskKiller(float delay, Task t)
13. /// {
14. ///     yield return new WaitForSeconds(delay);
15. ///     t.Stop();
16. /// }
17. ///
18. /// void SomeCodeThatCouldBeAnywhereInTheUniverse()
19. /// {
20. ///     Task spam = new Task(MyAwesomeTask());
21. ///     new Task(TaskKiller(5, spam));
22. /// }
23. /// ----------------------------------------------------------------------------

小结：

本文主要是分享我的收藏的一些“干货”，TaskManager 和 vp_Timer 在项目中发挥了很大的作用，D.S.Qiu 一再觉得强大的东西不都是复杂的，能够使用最简单的本质方法解决问题才是代码设计的追求。 文末附上了相关的链接以及TaskManager的代码。

如果您对D.S.Qiu有任何建议或意见可以在文章后面评论，或者发邮件（[email protected])交流，您的鼓励和支持是我前进的动力，希望能有更多更好的分享。

转载请在文首注明出处：http://dsqiu.iteye.com/blog/2022992

更多精彩请关注D.S.Qiu的博客和微博（ID：静水逐风）