Messing around with Async

Messing around with Async.cs (after compiling)

using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
namespace Messing_around_with_Async
{
	internal class Program
	{
		[CompilerGenerated]
		[StructLayout(LayoutKind.Auto)]
		private struct <ReturnWithoutClosure>d__0 : IAsyncStateMachine
		{
			public int <>1__state;
			public AsyncTaskMethodBuilder<bool> <>t__builder;
			private YieldAwaitable.YieldAwaiter <>u__$awaiter1;
			private object <>t__stack;
			void IAsyncStateMachine.MoveNext()
			{
				bool result;
				try
				{
					YieldAwaitable.YieldAwaiter yieldAwaiter;
					switch (this.<>1__state)
					{
					case -3:
						goto IL_28E;
					case 0:
						yieldAwaiter = this.<>u__$awaiter1;
						this.<>u__$awaiter1 = default(YieldAwaitable.YieldAwaiter);
						this.<>1__state = -1;
						goto IL_AF;
					case 1:
						yieldAwaiter = this.<>u__$awaiter1;
						this.<>u__$awaiter1 = default(YieldAwaitable.YieldAwaiter);
						this.<>1__state = -1;
						goto IL_11C;
					case 2:
						yieldAwaiter = this.<>u__$awaiter1;
						this.<>u__$awaiter1 = default(YieldAwaitable.YieldAwaiter);
						this.<>1__state = -1;
						goto IL_189;
					case 3:
						yieldAwaiter = this.<>u__$awaiter1;
						this.<>u__$awaiter1 = default(YieldAwaitable.YieldAwaiter);
						this.<>1__state = -1;
						goto IL_1F6;
					case 4:
						yieldAwaiter = this.<>u__$awaiter1;
						this.<>u__$awaiter1 = default(YieldAwaitable.YieldAwaiter);
						this.<>1__state = -1;
						goto IL_260;
					}
					yieldAwaiter = Task.Yield().GetAwaiter();
					if (!yieldAwaiter.IsCompleted)
					{
						this.<>1__state = 0;
						this.<>u__$awaiter1 = yieldAwaiter;
						this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Program.<ReturnWithoutClosure>d__0>(ref yieldAwaiter, ref this);
						return;
					}
					IL_AF:
					yieldAwaiter.GetResult();
					yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
					yieldAwaiter = Task.Yield().GetAwaiter();
					if (!yieldAwaiter.IsCompleted)
					{
						this.<>1__state = 1;
						this.<>u__$awaiter1 = yieldAwaiter;
						this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Program.<ReturnWithoutClosure>d__0>(ref yieldAwaiter, ref this);
						return;
					}
					IL_11C:
					yieldAwaiter.GetResult();
					yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
					yieldAwaiter = Task.Yield().GetAwaiter();
					if (!yieldAwaiter.IsCompleted)
					{
						this.<>1__state = 2;
						this.<>u__$awaiter1 = yieldAwaiter;
						this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Program.<ReturnWithoutClosure>d__0>(ref yieldAwaiter, ref this);
						return;
					}
					IL_189:
					yieldAwaiter.GetResult();
					yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
					yieldAwaiter = Task.Yield().GetAwaiter();
					if (!yieldAwaiter.IsCompleted)
					{
						this.<>1__state = 3;
						this.<>u__$awaiter1 = yieldAwaiter;
						this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Program.<ReturnWithoutClosure>d__0>(ref yieldAwaiter, ref this);
						return;
					}
					IL_1F6:
					yieldAwaiter.GetResult();
					yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
					yieldAwaiter = Task.Yield().GetAwaiter();
					if (!yieldAwaiter.IsCompleted)
					{
						this.<>1__state = 4;
						this.<>u__$awaiter1 = yieldAwaiter;
						this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Program.<ReturnWithoutClosure>d__0>(ref yieldAwaiter, ref this);
						return;
					}
					IL_260:
					yieldAwaiter.GetResult();
					yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
					result = true;
				}
				catch (Exception exception)
				{
					this.<>1__state = -2;
					this.<>t__builder.SetException(exception);
					return;
				}
				IL_28E:
				this.<>1__state = -2;
				this.<>t__builder.SetResult(result);
			}
			[DebuggerHidden]
			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine param0)
			{
				this.<>t__builder.SetStateMachine(param0);
			}
		}
		[CompilerGenerated]
		[StructLayout(LayoutKind.Auto)]
		private struct <Void>d__3 : IAsyncStateMachine
		{
			public int <>1__state;
			public AsyncTaskMethodBuilder <>t__builder;
			private YieldAwaitable.YieldAwaiter <>u__$awaiter4;
			private object <>t__stack;
			void IAsyncStateMachine.MoveNext()
			{
				try
				{
					YieldAwaitable.YieldAwaiter yieldAwaiter;
					switch (this.<>1__state)
					{
					case -3:
						goto IL_26B;
					case 0:
						yieldAwaiter = this.<>u__$awaiter4;
						this.<>u__$awaiter4 = default(YieldAwaitable.YieldAwaiter);
						this.<>1__state = -1;
						goto IL_AE;
					case 1:
						yieldAwaiter = this.<>u__$awaiter4;
						this.<>u__$awaiter4 = default(YieldAwaitable.YieldAwaiter);
						this.<>1__state = -1;
						goto IL_11A;
					case 2:
						yieldAwaiter = this.<>u__$awaiter4;
						this.<>u__$awaiter4 = default(YieldAwaitable.YieldAwaiter);
						this.<>1__state = -1;
						goto IL_186;
					case 3:
						yieldAwaiter = this.<>u__$awaiter4;
						this.<>u__$awaiter4 = default(YieldAwaitable.YieldAwaiter);
						this.<>1__state = -1;
						goto IL_1F2;
					case 4:
						yieldAwaiter = this.<>u__$awaiter4;
						this.<>u__$awaiter4 = default(YieldAwaitable.YieldAwaiter);
						this.<>1__state = -1;
						goto IL_25B;
					}
					yieldAwaiter = Task.Yield().GetAwaiter();
					if (!yieldAwaiter.IsCompleted)
					{
						this.<>1__state = 0;
						this.<>u__$awaiter4 = yieldAwaiter;
						this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Program.<Void>d__3>(ref yieldAwaiter, ref this);
						return;
					}
					IL_AE:
					yieldAwaiter.GetResult();
					yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
					yieldAwaiter = Task.Yield().GetAwaiter();
					if (!yieldAwaiter.IsCompleted)
					{
						this.<>1__state = 1;
						this.<>u__$awaiter4 = yieldAwaiter;
						this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Program.<Void>d__3>(ref yieldAwaiter, ref this);
						return;
					}
					IL_11A:
					yieldAwaiter.GetResult();
					yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
					yieldAwaiter = Task.Yield().GetAwaiter();
					if (!yieldAwaiter.IsCompleted)
					{
						this.<>1__state = 2;
						this.<>u__$awaiter4 = yieldAwaiter;
						this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Program.<Void>d__3>(ref yieldAwaiter, ref this);
						return;
					}
					IL_186:
					yieldAwaiter.GetResult();
					yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
					yieldAwaiter = Task.Yield().GetAwaiter();
					if (!yieldAwaiter.IsCompleted)
					{
						this.<>1__state = 3;
						this.<>u__$awaiter4 = yieldAwaiter;
						this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Program.<Void>d__3>(ref yieldAwaiter, ref this);
						return;
					}
					IL_1F2:
					yieldAwaiter.GetResult();
					yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
					yieldAwaiter = Task.Yield().GetAwaiter();
					if (!yieldAwaiter.IsCompleted)
					{
						this.<>1__state = 4;
						this.<>u__$awaiter4 = yieldAwaiter;
						this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Program.<Void>d__3>(ref yieldAwaiter, ref this);
						return;
					}
					IL_25B:
					yieldAwaiter.GetResult();
					yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
					IL_26B:;
				}
				catch (Exception exception)
				{
					this.<>1__state = -2;
					this.<>t__builder.SetException(exception);
					return;
				}
				this.<>1__state = -2;
				this.<>t__builder.SetResult();
			}
			[DebuggerHidden]
			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine param0)
			{
				this.<>t__builder.SetStateMachine(param0);
			}
		}
		[CompilerGenerated]
		[StructLayout(LayoutKind.Auto)]
		private struct <ReturnCaptured>d__6<T> : IAsyncStateMachine
		{
			public int <>1__state;
			public AsyncTaskMethodBuilder<T> <>t__builder;
			public T x;
			private YieldAwaitable.YieldAwaiter <>u__$awaiter7;
			private object <>t__stack;
			void IAsyncStateMachine.MoveNext()
			{
				T result;
				try
				{
					YieldAwaitable.YieldAwaiter yieldAwaiter;
					switch (this.<>1__state)
					{
					case -3:
						goto IL_293;
					case 0:
						yieldAwaiter = this.<>u__$awaiter7;
						this.<>u__$awaiter7 = default(YieldAwaitable.YieldAwaiter);
						this.<>1__state = -1;
						goto IL_AF;
					case 1:
						yieldAwaiter = this.<>u__$awaiter7;
						this.<>u__$awaiter7 = default(YieldAwaitable.YieldAwaiter);
						this.<>1__state = -1;
						goto IL_11C;
					case 2:
						yieldAwaiter = this.<>u__$awaiter7;
						this.<>u__$awaiter7 = default(YieldAwaitable.YieldAwaiter);
						this.<>1__state = -1;
						goto IL_189;
					case 3:
						yieldAwaiter = this.<>u__$awaiter7;
						this.<>u__$awaiter7 = default(YieldAwaitable.YieldAwaiter);
						this.<>1__state = -1;
						goto IL_1F6;
					case 4:
						yieldAwaiter = this.<>u__$awaiter7;
						this.<>u__$awaiter7 = default(YieldAwaitable.YieldAwaiter);
						this.<>1__state = -1;
						goto IL_260;
					}
					yieldAwaiter = Task.Yield().GetAwaiter();
					if (!yieldAwaiter.IsCompleted)
					{
						this.<>1__state = 0;
						this.<>u__$awaiter7 = yieldAwaiter;
						this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Program.<ReturnCaptured>d__6<T>>(ref yieldAwaiter, ref this);
						return;
					}
					IL_AF:
					yieldAwaiter.GetResult();
					yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
					yieldAwaiter = Task.Yield().GetAwaiter();
					if (!yieldAwaiter.IsCompleted)
					{
						this.<>1__state = 1;
						this.<>u__$awaiter7 = yieldAwaiter;
						this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Program.<ReturnCaptured>d__6<T>>(ref yieldAwaiter, ref this);
						return;
					}
					IL_11C:
					yieldAwaiter.GetResult();
					yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
					yieldAwaiter = Task.Yield().GetAwaiter();
					if (!yieldAwaiter.IsCompleted)
					{
						this.<>1__state = 2;
						this.<>u__$awaiter7 = yieldAwaiter;
						this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Program.<ReturnCaptured>d__6<T>>(ref yieldAwaiter, ref this);
						return;
					}
					IL_189:
					yieldAwaiter.GetResult();
					yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
					yieldAwaiter = Task.Yield().GetAwaiter();
					if (!yieldAwaiter.IsCompleted)
					{
						this.<>1__state = 3;
						this.<>u__$awaiter7 = yieldAwaiter;
						this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Program.<ReturnCaptured>d__6<T>>(ref yieldAwaiter, ref this);
						return;
					}
					IL_1F6:
					yieldAwaiter.GetResult();
					yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
					yieldAwaiter = Task.Yield().GetAwaiter();
					if (!yieldAwaiter.IsCompleted)
					{
						this.<>1__state = 4;
						this.<>u__$awaiter7 = yieldAwaiter;
						this.<>t__builder.AwaitUnsafeOnCompleted<YieldAwaitable.YieldAwaiter, Program.<ReturnCaptured>d__6<T>>(ref yieldAwaiter, ref this);
						return;
					}
					IL_260:
					yieldAwaiter.GetResult();
					yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
					result = this.x;
				}
				catch (Exception exception)
				{
					this.<>1__state = -2;
					this.<>t__builder.SetException(exception);
					return;
				}
				IL_293:
				this.<>1__state = -2;
				this.<>t__builder.SetResult(result);
			}
			[DebuggerHidden]
			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine param0)
			{
				this.<>t__builder.SetStateMachine(param0);
			}
		}
		private static void Main(string[] args)
		{
			Program.Void().Wait();
			bool x = Program.ReturnWithoutClosure().Result;
			Task<string> y = Program.ReturnCaptured<string>("test");
		}
		[DebuggerStepThrough, AsyncStateMachine(typeof(Program.<ReturnWithoutClosure>d__0))]
		private static Task<bool> ReturnWithoutClosure()
		{
			Program.<ReturnWithoutClosure>d__0 <ReturnWithoutClosure>d__;
			<ReturnWithoutClosure>d__.<>t__builder = AsyncTaskMethodBuilder<bool>.Create();
			<ReturnWithoutClosure>d__.<>1__state = -1;
			AsyncTaskMethodBuilder<bool> <>t__builder = <ReturnWithoutClosure>d__.<>t__builder;
			<>t__builder.Start<Program.<ReturnWithoutClosure>d__0>(ref <ReturnWithoutClosure>d__);
			return <ReturnWithoutClosure>d__.<>t__builder.Task;
		}
		[DebuggerStepThrough, AsyncStateMachine(typeof(Program.<Void>d__3))]
		private static Task Void()
		{
			Program.<Void>d__3 <Void>d__;
			<Void>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
			<Void>d__.<>1__state = -1;
			AsyncTaskMethodBuilder <>t__builder = <Void>d__.<>t__builder;
			<>t__builder.Start<Program.<Void>d__3>(ref <Void>d__);
			return <Void>d__.<>t__builder.Task;
		}
		[DebuggerStepThrough, AsyncStateMachine(typeof(Program.<ReturnCaptured>d__6<>))]
		private static Task<T> ReturnCaptured<T>(T x)
		{
			Program.<ReturnCaptured>d__6<T> <ReturnCaptured>d__;
			<ReturnCaptured>d__.x = x;
			<ReturnCaptured>d__.<>t__builder = AsyncTaskMethodBuilder<T>.Create();
			<ReturnCaptured>d__.<>1__state = -1;
			AsyncTaskMethodBuilder<T> <>t__builder = <ReturnCaptured>d__.<>t__builder;
			<>t__builder.Start<Program.<ReturnCaptured>d__6<T>>(ref <ReturnCaptured>d__);
			return <ReturnCaptured>d__.<>t__builder.Task;
		}
	}
}

Messing around with Async.cs (original)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Messing_around_with_Async
{
    class Program
    {
        static void Main(string[] args)
        {
            Void().Wait();
            var x = ReturnWithoutClosure().Result;
            var y = ReturnCaptured("test");
        }

        static async Task<bool> ReturnWithoutClosure()
        {
            await Task.Yield();
            await Task.Yield();
            await Task.Yield();
            await Task.Yield();
            await Task.Yield();
            return true;
        }

        static async Task Void()
        {
            await Task.Yield();
            await Task.Yield();
            await Task.Yield();
            await Task.Yield();
            await Task.Yield();
        }

        static async Task<T> ReturnCaptured<T>(T x)
        {
            await Task.Yield();
            await Task.Yield();
            await Task.Yield();
            await Task.Yield();
            await Task.Yield();
            return x;
        }
    }
}