ensure coroutine handler instance thread safety

Coroutine/CoroutineHandlerInstance.cs

@@ -16,15 +16,26 @@ namespace Coroutine {
         private readonly HashSet<ActiveCoroutine> outstandingEventCoroutines = new HashSet<ActiveCoroutine>();
         private readonly HashSet<ActiveCoroutine> outstandingTickingCoroutines = new HashSet<ActiveCoroutine>();
         private readonly Stopwatch stopwatch = new Stopwatch();
+        private readonly object lockObject = new object();
 
         /// <summary>
         /// The amount of <see cref="ActiveCoroutine"/> instances that are currently waiting for a tick (waiting for time to pass)
         /// </summary>
-        public int TickingCount => this.tickingCoroutines.Count;
+        public int TickingCount {
+            get {
+                lock (this.lockObject)
+                    return this.tickingCoroutines.Count;
+            }
+        }
         /// <summary>
         /// The amount of <see cref="ActiveCoroutine"/> instances that are currently waiting for an <see cref="Event"/>
         /// </summary>
-        public int EventCount => this.eventCoroutines.Sum(c => c.Value.Count);
+        public int EventCount {
+            get {
+                lock (this.lockObject)
+                    return this.eventCoroutines.Sum(c => c.Value.Count);
+            }
+        }
 
         /// <summary>
         /// Starts the given coroutine, returning a <see cref="ActiveCoroutine"/> object for management.
@@ -47,8 +58,10 @@ namespace Coroutine {
         /// <returns>An active coroutine object representing this coroutine</returns>
         public ActiveCoroutine Start(IEnumerator<Wait> coroutine, string name = "", int priority = 0) {
             var inst = new ActiveCoroutine(coroutine, name, priority, this.stopwatch);
-            if (inst.MoveNext())
+            if (inst.MoveNext()) {
+                lock (this.lockObject)
                     this.GetOutstandingCoroutines(inst.IsWaitingForEvent).Add(inst);
+            }
             return inst;
         }
 
@@ -70,6 +83,7 @@ namespace Coroutine {
         /// </summary>
         /// <param name="deltaSeconds">The amount of seconds that have passed since the last time this method was invoked</param>
         public void Tick(double deltaSeconds) {
+            lock (this.lockObject) {
                 this.MoveOutstandingCoroutines(false);
                 this.tickingCoroutines.RemoveAll(c => {
                     if (c.Tick(deltaSeconds)) {
@@ -81,6 +95,7 @@ namespace Coroutine {
                     return false;
                 });
             }
+        }
 
         /// <summary>
         /// Ticks this coroutine handler, causing all time-based <see cref="Wait"/>s to be ticked.
@@ -96,6 +111,7 @@ namespace Coroutine {
         /// </summary>
         /// <param name="evt">The event to raise</param>
         public void RaiseEvent(Event evt) {
+            lock (this.lockObject) {
                 this.MoveOutstandingCoroutines(true);
                 var coroutines = this.GetEventCoroutines(evt, false);
                 if (coroutines != null) {
@@ -113,12 +129,14 @@ namespace Coroutine {
                     }
                 }
             }
+        }
 
         /// <summary>
         /// Returns a list of all currently active <see cref="ActiveCoroutine"/> objects under this handler.
         /// </summary>
         /// <returns>All active coroutines</returns>
         public IEnumerable<ActiveCoroutine> GetActiveCoroutines() {
+            lock (this.lockObject)
                 return this.tickingCoroutines.Concat(this.eventCoroutines.Values.SelectMany(c => c));
         }