var taskOne = await TaskOne();
Console.WriteLine(taskOne);

Console.ReadLine();
   
static async Task<string> TaskOne()
{
    var httpResponse = await ClassFactory.Client.GetAsync("https://www.cnblogs.com");
    var content = await httpResponse.Content.ReadAsStringAsync();
    return content;
}

public class ClassFactory
{
    public static HttpClient Client = new HttpClient();
}

//因?yàn)槲覀兩厦娲avar taskOne = await TaskOne()
//使用了await語(yǔ)法糖，所以被替換成了狀態(tài)機(jī)調(diào)用
[AsyncStateMachine(typeof(<<Main>$>d__0))]
[DebuggerStepThrough]
private static Task <Main>$(string[] args)
{
	//創(chuàng)建狀態(tài)機(jī)實(shí)例
	<<Main>$>d__0 stateMachine = new <<Main>$>d__0();
	stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
	stateMachine.args = args;
	//設(shè)置狀態(tài)-1
	stateMachine.<>1__state = -1;
	//啟動(dòng)狀態(tài)機(jī)
	stateMachine.<>t__builder.Start(ref stateMachine);
	return stateMachine.<>t__builder.Task;
}

//這是系統(tǒng)默認(rèn)幫我們生成的static void Main的入口方法
[SpecialName]
[DebuggerStepThrough]
private static void <Main>(string[] args)
{
	//同步調(diào)用<Main>$方法
	<Main>$(args).GetAwaiter().GetResult();
}

[CompilerGenerated]
private sealed class <<Main>$>d__0 : IAsyncStateMachine
{
	public int <>1__state;
	public AsyncTaskMethodBuilder <>t__builder;
	public string[] args;
	private string <taskOne>5__1;
	private string <>s__2;

	[System.Runtime.CompilerServices.Nullable(new byte[] { 0, 1 })]
	private TaskAwaiter<string> <>u__1;

	private void MoveNext()
	{
		int num = <>1__state;
		try
		{
			TaskAwaiter<string> awaiter;
			//num的值來(lái)自<>1__state，由于在創(chuàng)建狀態(tài)機(jī)的時(shí)候傳遞的是-1所以一定會(huì)走到這個(gè)邏輯
			if (num != 0)
			{
				//調(diào)用TaskOne方法，也就是上面我們寫的業(yè)務(wù)方法
				//這個(gè)方法返回的是TaskAwaiter<>實(shí)例，以為我們TaskOne方法是異步方法
				awaiter = <<Main>$>g__TaskOne|0_0().GetAwaiter();
				//判斷任務(wù)是否執(zhí)行完成
				if (!awaiter.IsCompleted)
				{
					num = (<>1__state = 0);
					<>u__1 = awaiter;
					<<Main>$>d__0 stateMachine = this;
					<>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
					return;
				}
			}
			else
			{
				awaiter = <>u__1;
				<>u__1 = default(TaskAwaiter<string>);
				num = (<>1__state = -1);
			}
			//調(diào)用GetResult()方法獲取異步執(zhí)行結(jié)果
			<>s__2 = awaiter.GetResult();
			<taskOne>5__1 = <>s__2;
			<>s__2 = null;
			//這里對(duì)應(yīng)我們上面的輸出調(diào)用TaskOne方法的結(jié)果
			Console.WriteLine(<taskOne>5__1);
			Console.ReadLine();
		}
		catch (Exception exception)
		{
			<>1__state = -2;
			<taskOne>5__1 = null;
			<>t__builder.SetException(exception);
			return;
		}
		<>1__state = -2;
		<taskOne>5__1 = null;
		<>t__builder.SetResult();
	}

	void IAsyncStateMachine.MoveNext()
	{
		this.MoveNext();
	}

	[DebuggerHidden]
	private void SetStateMachine([System.Runtime.CompilerServices.Nullable(1)] IAsyncStateMachine stateMachine)
	{
	}

	void IAsyncStateMachine.SetStateMachine([System.Runtime.CompilerServices.Nullable(1)] IAsyncStateMachine stateMachine)
	{
		this.SetStateMachine(stateMachine);
	}
}

var taskOne = await TaskOne();
Console.WriteLine(taskOne);
Console.ReadLine();

//TaskOne方法編譯時(shí)生成的代碼
[CompilerGenerated]
private sealed class <<<Main>$>g__TaskOne|0_0>d : IAsyncStateMachine
{
	public int <>1__state;
	public AsyncTaskMethodBuilder<string> <>t__builder;
	private HttpResponseMessage <httpResponse>5__1;
	private string <content>5__2;
	private HttpResponseMessage <>s__3;
	private string <>s__4;

	[System.Runtime.CompilerServices.Nullable(new byte[] { 0, 1 })]
	private TaskAwaiter<HttpResponseMessage> <>u__1;

	[System.Runtime.CompilerServices.Nullable(new byte[] { 0, 1 })]
	private TaskAwaiter<string> <>u__2;

	private void MoveNext()
	{
		int num = <>1__state;
		string result;
		try
		{
			//因?yàn)槲覀兪褂昧藘纱蝍wait所以這里會(huì)有兩個(gè)TaskAwaiter<>實(shí)例
			//var httpResponse = await ClassFactory.Client.GetAsync("https://www.cnblogs.com");
                        //var content = await httpResponse.Content.ReadAsStringAsync();
			TaskAwaiter<string> awaiter;
			TaskAwaiter<HttpResponseMessage> awaiter2;
			if (num != 0)
			{
				if (num == 1)
				{
					awaiter = <>u__2;
					<>u__2 = default(TaskAwaiter<string>);
					num = (<>1__state = -1);
					goto IL_0100;
				}
				//這段邏輯針對(duì)的是我們手寫的這段代碼
				//await ClassFactory.Client.GetAsync("https://www.cnblogs.com")
				awaiter2 = ClassFactory.Client.GetAsync("https://www.cnblogs.com").GetAwaiter();
                                //判斷任務(wù)是否完成
				if (!awaiter2.IsCompleted)
				{
					num = (<>1__state = 0);
					<>u__1 = awaiter2;
					<<<Main>$>g__TaskOne|0_0>d stateMachine = this;
					<>t__builder.AwaitUnsafeOnCompleted(ref awaiter2, ref stateMachine);
					return;
				}
			}
			else
			{
				awaiter2 = <>u__1;
				<>u__1 = default(TaskAwaiter<HttpResponseMessage>);
				num = (<>1__state = -1);
			}
			//同步獲取HttpResponseMessage結(jié)果實(shí)例
			<>s__3 = awaiter2.GetResult();
			<httpResponse>5__1 = <>s__3;
			<>s__3 = null;
			//這段代碼對(duì)應(yīng)生成的則是await httpResponse.Content.ReadAsStringAsync()
			awaiter = <httpResponse>5__1.Content.ReadAsStringAsync().GetAwaiter();
			if (!awaiter.IsCompleted)
			{
				num = (<>1__state = 1);
				<>u__2 = awaiter;
				<<<Main>$>g__TaskOne|0_0>d stateMachine = this;
				<>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
				return;
			}
			goto IL_0100;
			IL_0100:
			//同步獲取httpResponse.Content.ReadAsStringAsync()放的結(jié)果
			<>s__4 = awaiter.GetResult();
			<content>5__2 = <>s__4;
			<>s__4 = null;
			result = <content>5__2;
		}
		catch (Exception exception)
		{
			<>1__state = -2;
			<httpResponse>5__1 = null;
			<content>5__2 = null;
			<>t__builder.SetException(exception);
			return;
		}
		<>1__state = -2;
		<httpResponse>5__1 = null;
		<content>5__2 = null;
		//調(diào)用AsyncTaskMethodBuilder<>方法放置httpResponse.Content.ReadAsStringAsync()結(jié)果
		<>t__builder.SetResult(result);
	}

	void IAsyncStateMachine.MoveNext()
	{
		this.MoveNext();
	}

	[DebuggerHidden]
	private void SetStateMachine([System.Runtime.CompilerServices.Nullable(1)] IAsyncStateMachine stateMachine)
	{
	}

	void IAsyncStateMachine.SetStateMachine([System.Runtime.CompilerServices.Nullable(1)] IAsyncStateMachine stateMachine)
	{
		this.SetStateMachine(stateMachine);
	}
}

[MethodImpl(MethodImplOptions.AggressiveInlining)]
[DebuggerStepThrough]
public void Start<[Nullable(0)] TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
{
	//調(diào)用了AsyncMethodBuilderCore的Start方法并傳遞狀態(tài)機(jī)實(shí)例
	//即<<Main>$>d__0 stateMachine = new <<Main>$>d__0()實(shí)例
	AsyncMethodBuilderCore.Start(ref stateMachine);
}

//AsyncMethodBuilderCore的Start方法
[DebuggerStepThrough]
public static void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
{
	if (stateMachine == null)
	{
		ThrowHelper.ThrowArgumentNullException(ExceptionArgument.stateMachine);
	}
	//獲取當(dāng)前線程實(shí)例
	Thread currentThread = Thread.CurrentThread;
	//獲取當(dāng)前執(zhí)行上下文
	ExecutionContext executionContext = currentThread._executionContext;
	//獲取當(dāng)前同步上下文
	SynchronizationContext synchronizationContext = currentThread._synchronizationContext;
	try
	{
		//調(diào)用狀態(tài)機(jī)的MoveNext方法
		stateMachine.MoveNext();
	}
	finally
	{
		//執(zhí)行完MoveNext之后
		//還原SynchronizationContext同步上下文到當(dāng)前實(shí)例
		if (synchronizationContext != currentThread._synchronizationContext)
		{
			currentThread._synchronizationContext = synchronizationContext;
		}
		//還原ExecutionContext執(zhí)行上下文到當(dāng)前實(shí)例
		ExecutionContext executionContext2 = currentThread._executionContext;
		if (executionContext != executionContext2)
		{
                        //執(zhí)行完成之后把執(zhí)行上下文裝載到當(dāng)前線程
			ExecutionContext.RestoreChangedContextToThread(currentThread, executionContext, executionContext2);
		}
	}
}

void IAsyncStateMachine.MoveNext()
{
	this.MoveNext();
}

AsyncTaskMethodBuilder<string> <>t__builder;
TaskAwaiter<HttpResponseMessage> awaiter2;
if (num != 0)
{
	if (num == 1)
	{}

        //ClassFactory.Client.GetAsyn()方法生成的邏輯
	awaiter2 = ClassFactory.Client.GetAsync("https://www.cnblogs.com").GetAwaiter();
	if (!awaiter2.IsCompleted)
	{
		num = (<>1__state = 0);
		<>u__1 = awaiter2;
		<<<Main>$>g__TaskOne|0_0>d stateMachine = this;
		<>t__builder.AwaitUnsafeOnCompleted(ref awaiter2, ref stateMachine);
		return;
	}
	//同步獲取異步結(jié)果
	<>s__4 = awaiter.GetResult();
}
else
{}

TaskAwaiter<string> awaiter;
//httpResponse.Content.ReadAsStringAsync()方法生成的邏輯
awaiter = <httpResponse>5__1.Content.ReadAsStringAsync().GetAwaiter();
//判斷任務(wù)是否完成
if (!awaiter.IsCompleted)
{
	num = (<>1__state = 1);
	<>u__2 = awaiter;
	<<<Main>$>g__TaskOne|0_0>d stateMachine = this;
	<>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
	return;
}
//同步獲取異步結(jié)果，并將返回值裝載
result= awaiter.GetResult();
<>t__builder.SetResult(result);

public void AwaitUnsafeOnCompleted<[Nullable(0)] TAwaiter, [Nullable(0)] TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
{
	//調(diào)用AwaitUnsafeOnCompleted方法
	AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine, ref m_task);
}

internal static void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine, [NotNull] ref Task<TResult> taskField) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
{
	//創(chuàng)建IAsyncStateMachineBox實(shí)例
	IAsyncStateMachineBox stateMachineBox = GetStateMachineBox(ref stateMachine, ref taskField);
	//調(diào)用AwaitUnsafeOnCompleted()方法
	AwaitUnsafeOnCompleted(ref awaiter, stateMachineBox);
}

internal static void AwaitUnsafeOnCompleted<TAwaiter>(ref TAwaiter awaiter, IAsyncStateMachineBox box) where TAwaiter : ICriticalNotifyCompletion
{
	//判斷awaiter實(shí)例類型
	if (default(TAwaiter) != null && awaiter is ITaskAwaiter)
	{
		//獲取TaskAwaiter實(shí)例的m_task屬性即Task類型
		TaskAwaiter.UnsafeOnCompletedInternal(Unsafe.As<TAwaiter, TaskAwaiter>(ref awaiter).m_task, box, true);
		return;
	}
	if (default(TAwaiter) != null && awaiter is IConfiguredTaskAwaiter)
	{
		//與上面邏輯一致m_task屬性即Task類型本質(zhì)他們都在操作Task
		ref ConfiguredTaskAwaitable.ConfiguredTaskAwaiter reference = ref Unsafe.As<TAwaiter, ConfiguredTaskAwaitable.ConfiguredTaskAwaiter>(ref awaiter);
		TaskAwaiter.UnsafeOnCompletedInternal(reference.m_task, box, reference.m_continueOnCapturedContext);
		return;
	}
	if (default(TAwaiter) != null && awaiter is IStateMachineBoxAwareAwaiter)
	{
		try
		{
			//調(diào)用IStateMachineBoxAwareAwaiter實(shí)例的AwaitUnsafeOnCompleted方法
			((IStateMachineBoxAwareAwaiter)(object)awaiter).AwaitUnsafeOnCompleted(box);
			return;
		}
		catch (Exception exception)
		{
			System.Threading.Tasks.Task.ThrowAsync(exception, null);
			return;
		}
	}
	try
	{
		//調(diào)用ICriticalNotifyCompletion實(shí)例的UnsafeOnCompleted方法
		awaiter.UnsafeOnCompleted(box.MoveNextAction);
	}
	catch (Exception exception2)
	{
		System.Threading.Tasks.Task.ThrowAsync(exception2, null);
	}
}

void IStateMachineBoxAwareAwaiter.AwaitUnsafeOnCompleted(IAsyncStateMachineBox box)
{
	object? obj = _value._obj;
	Debug.Assert(obj == null || obj is Task || obj is IValueTaskSource);

	if (obj is Task t)
	{
		//如果是Task類型的話會(huì)調(diào)用TaskAwaiter.UnsafeOnCompletedInternal方法，也是上面咱們多次提到的
		TaskAwaiter.UnsafeOnCompletedInternal(t, box, _value._continueOnCapturedContext);
	}
	else if (obj != null)
	{
		Unsafe.As<IValueTaskSource>(obj).OnCompleted(ThreadPool.s_invokeAsyncStateMachineBox, box, _value._token,
			_value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);
	}
	else
	{
		//兜底的方法也是TaskAwaiter.UnsafeOnCompletedInternal
		TaskAwaiter.UnsafeOnCompletedInternal(Task.CompletedTask, box, _value._continueOnCapturedContext);
	}
}

public void UnsafeOnCompleted(Action continuation)
{
	TaskAwaiter.OnCompletedInternal(m_task, continuation, true, false);
}
//TaskAwaiter的OnCompletedInternal方法
internal static void OnCompletedInternal(Task task, Action continuation, bool continueOnCapturedContext, bool flowExecutionContext)
{
	ArgumentNullException.ThrowIfNull(continuation, "continuation");
	if (TplEventSource.Log.IsEnabled() || Task.s_asyncDebuggingEnabled)
	{
		continuation = OutputWaitEtwEvents(task, continuation);
	}
	//這里調(diào)用了Task的SetContinuationForAwait方法
	task.SetContinuationForAwait(continuation, continueOnCapturedContext, flowExecutionContext);
}

internal static void UnsafeOnCompletedInternal(Task task, IAsyncStateMachineBox stateMachineBox, bool continueOnCapturedContext)
{
	if (TplEventSource.Log.IsEnabled() || Task.s_asyncDebuggingEnabled)
	{
		//默認(rèn)情況下我們是沒有去監(jiān)聽EventSource發(fā)布的時(shí)間消息
		//如果你開啟了EventSource日志的監(jiān)聽則會(huì)走到這里
		task.SetContinuationForAwait(OutputWaitEtwEvents(task, stateMachineBox.MoveNextAction), continueOnCapturedContext, false);
	}
	else
	{
		task.UnsafeSetContinuationForAwait(stateMachineBox, continueOnCapturedContext);
	}
}

internal void UnsafeSetContinuationForAwait(IAsyncStateMachineBox stateMachineBox, bool continueOnCapturedContext)
{
	if (continueOnCapturedContext)
	{
	    //winform wpf等ui線程包含同步上下文SynchronizationContext相關(guān)的信息
		//如果存在則直接在SynchronizationContext同步上線文中的Post方法把異步結(jié)果在ui線程中完成回調(diào)執(zhí)行
		SynchronizationContext current = SynchronizationContext.Current;
		if (current != null && current.GetType() != typeof(SynchronizationContext))
		{
			SynchronizationContextAwaitTaskContinuation synchronizationContextAwaitTaskContinuation = new SynchronizationContextAwaitTaskContinuation(current, stateMachineBox.MoveNextAction, false);
			if (!AddTaskContinuation(synchronizationContextAwaitTaskContinuation, false))
			{
				synchronizationContextAwaitTaskContinuation.Run(this, false);
			}
			return;
		}
		//判斷是否包含內(nèi)部任務(wù)調(diào)度器，如果不是默認(rèn)的TaskScheduler.Default調(diào)度策略，也就是ThreadPoolTaskScheduler的方式執(zhí)行MoveNext
		//則使用TaskSchedulerAwaitTaskContinuation的Run方法執(zhí)行MoveNext
		TaskScheduler internalCurrent = TaskScheduler.InternalCurrent;
		if (internalCurrent != null && internalCurrent != TaskScheduler.Default)
		{
			TaskSchedulerAwaitTaskContinuation taskSchedulerAwaitTaskContinuation = new TaskSchedulerAwaitTaskContinuation(internalCurrent, stateMachineBox.MoveNextAction, false);
			if (!AddTaskContinuation(taskSchedulerAwaitTaskContinuation, false))
			{
				taskSchedulerAwaitTaskContinuation.Run(this, false);
			}
			return;
		}
	}
	//執(zhí)行兜底邏輯使用線程池執(zhí)行
	if (!AddTaskContinuation(stateMachineBox, false))
	{
		ThreadPool.UnsafeQueueUserWorkItemInternal(stateMachineBox, true);
	}
}

internal sealed override void Run(Task task, bool canInlineContinuationTask)
{
	//判斷當(dāng)前線程同步上下文是否和傳遞的同步上下文一致，則直接執(zhí)行，說明當(dāng)前線程可以直接使用異步結(jié)果
	if (canInlineContinuationTask && m_syncContext == SynchronizationContext.Current)
	{
		RunCallback(AwaitTaskContinuation.GetInvokeActionCallback(), m_action, ref Task.t_currentTask);
		return;
	}
    //如果不是同一個(gè)同步上下文則執(zhí)行PostAction委托
	RunCallback(PostAction, this, ref Task.t_currentTask);
}

private static void PostAction(object state)
{
	//通過傳遞的state來(lái)捕獲執(zhí)行回調(diào)的同步上下文，這里使用的SynchronizationContext的非阻塞的Post方法來(lái)執(zhí)行后續(xù)邏輯
	SynchronizationContextAwaitTaskContinuation synchronizationContextAwaitTaskContinuation = (SynchronizationContextAwaitTaskContinuation)state;
	synchronizationContextAwaitTaskContinuation.m_syncContext.Post(s_postCallback, synchronizationContextAwaitTaskContinuation.m_action);
}

protected void RunCallback(ContextCallback callback, object state, ref Task currentTask)
{
        //捕獲執(zhí)行上下文，異步執(zhí)行完成之后在執(zhí)行上下文中執(zhí)行后續(xù)邏輯
	ExecutionContext capturedContext = m_capturedContext;
	if (capturedContext == null)
	{
		//核心邏輯就是再行上面的委托即AwaitTaskContinuation.GetInvokeActionCallback方法或PostAction方法
		callback(state);
	}
	else
	{
		ExecutionContext.RunInternal(capturedContext, callback, state);
	}
}

internal sealed override void Run(Task ignored, bool canInlineContinuationTask)
{
	//如果當(dāng)前的scheduler策略是TaskScheduler.Default即默認(rèn)的ThreadPoolTaskScheduler
	//則直接使用默認(rèn)策略調(diào)度任務(wù)
	if (m_scheduler == TaskScheduler.Default)
	{
		base.Run(ignored, canInlineContinuationTask);
		return;
	}
	//如果不是默認(rèn)策略則使用，我們定義的TaskScheduler
	Task task = CreateTask(delegate(object state)
	{
		try
		{
			((Action)state)();
		}
		catch (Exception exception)
		{
			Task.ThrowAsync(exception, null);
		}
	}, m_action, m_scheduler);//這里的m_scheduler指的是自定義的TaskScheduler
    bool flag = canInlineContinuationTask && (TaskScheduler.InternalCurrent == m_scheduler || Thread.CurrentThread.IsThreadPoolThread);
	//或者是task其他形式的策略執(zhí)行
	if (flag)
	{
		TaskContinuation.InlineIfPossibleOrElseQueue(task, false);
		return;
	}
	try
	{
		task.ScheduleAndStart(false);
	}
	catch (TaskSchedulerException)
	{
	}
}

private static void DispatchWorkItem(object workItem, Thread currentThread)
{
	//判斷在線程池中自行的任務(wù)書否是Task任務(wù)
	Task task = workItem as Task;
	if (task != null)
	{
		task.ExecuteFromThreadPool(currentThread);
	}
	else
	{
		Unsafe.As<IThreadPoolWorkItem>(workItem).Execute();
	}
}

private void MoveNext()
{
	int num = <>1__state;
	try
	{
		TaskAwaiter<string> awaiter;
		if (num != 0)
		{
			awaiter = Task.FromResult("Hello World").GetAwaiter();
			//這里的IsCompleted會(huì)為true不會(huì)執(zhí)行相關(guān)的執(zhí)行策略
			if (!awaiter.IsCompleted)
			{
				<>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
				return;
			}
		}
		else
		{
		}
		<>s__2 = awaiter.GetResult();
	}
	catch (Exception exception)
	{
	}
	<>t__builder.SetResult();
}