Inline hot path methods

Author: muckSponge

UnityAsync/Assets/UnityAsync/Await/Await.cs

@@ -1,73 +1,90 @@
 using System;
+using System.Runtime.CompilerServices;
 using System.Threading;
 
 namespace UnityAsync
 {
 	public static partial class Await
 	{
+		static readonly Continuation<WaitForFrames> nextUpdate = new Continuation<WaitForFrames>(new WaitForFrames(1));
+		static readonly Continuation<WaitForFrames> nextLateUpdate = new Continuation<WaitForFrames>(new WaitForFrames(1), FrameScheduler.LateUpdate);
+		static readonly Continuation<WaitForFrames> nextFixedUpdate = new Continuation<WaitForFrames>(new WaitForFrames(1), FrameScheduler.FixedUpdate);
+		
 		/// <summary>
 		/// Quick access to Unity's <see cref="System.Threading.SynchronizationContext"/>.
 		/// </summary>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static SynchronizationContext UnitySyncContext() => AsyncManager.UnitySyncContext;
 
 		/// <summary>
 		/// Quick access to the background <see cref="System.Threading.SynchronizationContext"/>.
 		/// </summary>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static SynchronizationContext BackgroundSyncContext() => AsyncManager.BackgroundSyncContext;
 
 		/// <summary>
 		/// Convenience function to skip a single frame, equivalent to Unity's <c>yield return null</c>.
 		/// </summary>
-		public static WaitForFrames NextUpdate() => new WaitForFrames(1);
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public static Continuation<WaitForFrames> NextUpdate() => nextUpdate;
 
 		/// <summary>
 		/// Convenience function to skip a number of frames, equivalent to multiple <c>yield return null</c>s.
 		/// </summary>
-		public static WaitForFrames Updates(int count) => new WaitForFrames(count);
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public static Continuation<WaitForFrames> Updates(int count) => new Continuation<WaitForFrames>(new WaitForFrames(count));
 
 		/// <summary>
 		/// Convenience function to skip a single frame and continue in the LateUpdate loop.
 		/// </summary>
-		public static Continuation<WaitForFrames> NextLateUpdate() => new WaitForFrames(1).ConfigureAwait(FrameScheduler.LateUpdate);
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public static Continuation<WaitForFrames> NextLateUpdate() => nextLateUpdate;
 
 		/// <summary>
 		/// Convenience function to skip multiple frames and continue in the LateUpdate loop.
 		/// </summary>
-		public static Continuation<WaitForFrames> LateUpdates(int count) => new WaitForFrames(count).ConfigureAwait(FrameScheduler.LateUpdate);
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public static Continuation<WaitForFrames> LateUpdates(int count) => new Continuation<WaitForFrames>(new WaitForFrames(count), FrameScheduler.LateUpdate);
 
 		/// <summary>
 		/// Convenience function to skip a single FixedUpdate frame and continue in the FixedUpdate loop. Equivalent to
 		/// Unity's <see cref="UnityEngine.WaitForFixedUpdate"/>.
 		/// </summary>
-		public static Continuation<WaitForFrames> NextFixedUpdate() => new WaitForFrames(1).ConfigureAwait(FrameScheduler.FixedUpdate);
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public static Continuation<WaitForFrames> NextFixedUpdate() => nextFixedUpdate;
 
 		/// <summary>
 		/// Convenience function to skip multiple FixedUpdate frames and continue in the FixedUpdate loop.
 		/// </summary>
-		public static Continuation<WaitForFrames> FixedUpdates(int count) => new WaitForFrames(count).ConfigureAwait(FrameScheduler.FixedUpdate);
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		public static Continuation<WaitForFrames> FixedUpdates(int count) => new Continuation<WaitForFrames>(new WaitForFrames(count), FrameScheduler.FixedUpdate);
 
 		/// <summary>
 		/// Convenience function to wait for a number of in-game seconds before continuing, equivalent to Unity's
 		/// <see cref="UnityEngine.WaitForSeconds"/>.
 		/// </summary>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static WaitForSeconds Seconds(float duration) => new WaitForSeconds(duration);
 
 		/// <summary>
 		/// Convenience function to wait for a number of unscaled seconds before continuing. Equivalent to Unity's
 		/// <see cref="UnityEngine.WaitForSecondsRealtime"/>.
 		/// </summary>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static WaitForSecondsRealtime SecondsRealtime(float duration) => new WaitForSecondsRealtime(duration);
 
 		/// <summary>
 		/// Convenience function to wait for a condition to return true. Equivalent to Unity's
 		/// <see cref="UnityEngine.WaitUntil"/>.
 		/// </summary>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static WaitUntil Until(Func<bool> condition) => new WaitUntil(condition);
 
 		/// <summary>
 		/// Convenience function to wait for a condition to return false. Equivalent to Unity's
 		/// <see cref="UnityEngine.WaitWhile"/>.
 		/// </summary>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static WaitWhile While(Func<bool> condition) => new WaitWhile(condition);
 	}
 }

UnityAsync/Assets/UnityAsync/Continuation.cs

@@ -51,6 +51,31 @@ public Continuation(T inst)
 			Scheduler = FrameScheduler.Update;
 		}
 
+		public Continuation(T inst, FrameScheduler scheduler)
+		{
+			instruction = inst;
+			continuation = null;
+			owner = AsyncManager.Instance;
+			Scheduler = scheduler;
+		}
+		
+		public Continuation(T inst, CancellationToken cancellationToken, FrameScheduler scheduler)
+		{
+			instruction = inst;
+			continuation = null;
+			owner = AsyncManager.Instance;
+			this.cancellationToken = cancellationToken;
+			Scheduler = scheduler;
+		}
+		
+		public Continuation(T inst, Object owner, FrameScheduler scheduler)
+		{
+			instruction = inst;
+			continuation = null;
+			this.owner = owner;
+			Scheduler = scheduler;
+		}
+
 		public bool IsCompleted => false;
 
 		public void OnCompleted(Action continuation)
@@ -64,6 +89,7 @@ public void OnCompleted(Action continuation)
 		/// cycle it should be evaluated on.
 		/// </summary>
 		/// <returns>A new continuation with updated params.</returns>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public Continuation<T> ConfigureAwait(Object owner, FrameScheduler scheduler)
 		{
 			this.owner = owner;
@@ -75,6 +101,7 @@ public Continuation<T> ConfigureAwait(Object owner, FrameScheduler scheduler)
 		/// Link the continuation's lifespan to a <see cref="UnityEngine.Object"/>.
 		/// </summary>
 		/// <returns>A new continuation with updated params.</returns>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public Continuation<T> ConfigureAwait(Object owner)
 		{
 			this.owner = owner;
@@ -85,6 +112,7 @@ public Continuation<T> ConfigureAwait(Object owner)
 		/// Configure the type of update cycle it should be evaluated on.
 		/// </summary>
 		/// <returns>A new continuation with updated params.</returns>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public Continuation<T> ConfigureAwait(FrameScheduler scheduler)
 		{
 			Scheduler = scheduler;
@@ -96,6 +124,7 @@ public Continuation<T> ConfigureAwait(FrameScheduler scheduler)
 		/// type of update cycle it should be evaluated on.
 		/// </summary>
 		/// <returns>A new continuation with updated params.</returns>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public Continuation<T> ConfigureAwait(CancellationToken cancellationToken, FrameScheduler scheduler)
 		{
 			this.cancellationToken = cancellationToken;
@@ -107,13 +136,16 @@ public Continuation<T> ConfigureAwait(CancellationToken cancellationToken, Frame
 		/// Link the continuation's lifespan to a <see cref="System.Threading.CancellationToken"/>.
 		/// </summary>
 		/// <returns>A new continuation with updated params.</returns>
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public Continuation<T> ConfigureAwait(CancellationToken cancellationToken)
 		{
 			this.cancellationToken = cancellationToken;
 			return this;
 		}
 
 		public void GetResult() { }
+		
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public Continuation<T> GetAwaiter() => this;
 	}
 }