public void GetResult()
{
#if NET45
var t = Thread.CurrentThread;
if (culture != null)
{
t.CurrentCulture = culture;
}
if (uiCulture != null)
{
t.CurrentUICulture = uiCulture;
}
waiter.GetResult();
#else
if (culture != null)
{
CultureInfo.CurrentCulture = culture;
}
if (uiCulture != null)
{
CultureInfo.CurrentUICulture = uiCulture;
}
waiter.GetResult();
#endif
}
// Token: 0x0600009A RID: 154 RVA: 0x00009C58 File Offset: 0x00007E58
private async Task <HttpResponseMessage> method_1(string string_0, Task <HttpResponseMessage> task_0)
{
TaskAwaiter <HttpResponseMessage> taskAwaiter = task_0.GetAwaiter();
TaskAwaiter <HttpResponseMessage> taskAwaiter2;
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
taskAwaiter = taskAwaiter2;
taskAwaiter2 = default(TaskAwaiter <HttpResponseMessage>);
}
HttpResponseMessage result = taskAwaiter.GetResult();
while (result.StatusCode >= HttpStatusCode.MultipleChoices && result.StatusCode <= (HttpStatusCode)399)
{
Uri uri = result.Headers.Location;
if (!uri.IsAbsoluteUri)
{
uri = new Uri(new Uri(string_0).GetLeftPart(UriPartial.Authority) + uri);
}
taskAwaiter = this.httpClient_0.GetAsync(uri).GetAwaiter();
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
taskAwaiter = taskAwaiter2;
taskAwaiter2 = default(TaskAwaiter <HttpResponseMessage>);
}
result = taskAwaiter.GetResult();
}
return(result);
}
public Disposition GetResult()
{
try
{
awaiter.GetResult();
return(Disposition.Completed);
}
catch (DeferRemainderException)
{
return(Disposition.Deferred);
}
}
private static Task PrintAnswerToLife()
{
var tcs = new TaskCompletionSource <object>();
TaskAwaiter awaiter = Task.Delay(5000).GetAwaiter();
awaiter.OnCompleted(() =>
{
try
{
//Generate an exception again
awaiter.GetResult();
int answer = 21 * 2;
Console.WriteLine(answer);
tcs.SetResult(null);
}
catch (Exception e)
{
tcs.SetException(e);
}
});
return(tcs.Task);
}
// Token: 0x060002C9 RID: 713 RVA: 0x00017684 File Offset: 0x00015884
public async Task <HttpResponseMessage> method_8(string string_0, Dictionary <string, string> dictionary_0, bool bool_1)
{
this.method_4(string_0, "POST");
HttpResponseMessage result;
if (bool_1)
{
string string_ = string_0;
TaskAwaiter <HttpResponseMessage> taskAwaiter = this.httpClient_0.PostAsync(string_0, Class70.smethod_2(dictionary_0)).GetAwaiter();
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter <HttpResponseMessage> taskAwaiter2;
taskAwaiter = taskAwaiter2;
taskAwaiter2 = default(TaskAwaiter <HttpResponseMessage>);
}
result = await this.method_2(string_, taskAwaiter.GetResult());
string_ = null;
}
else
{
TaskAwaiter <HttpResponseMessage> taskAwaiter = this.httpClient_0.PostAsync(string_0, Class70.smethod_2(dictionary_0)).GetAwaiter();
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter <HttpResponseMessage> taskAwaiter2;
taskAwaiter = taskAwaiter2;
taskAwaiter2 = default(TaskAwaiter <HttpResponseMessage>);
}
result = taskAwaiter.GetResult();
}
return(result);
}
// Token: 0x060002C7 RID: 711 RVA: 0x000175D4 File Offset: 0x000157D4
public async Task <HttpResponseMessage> method_6(string string_0, bool bool_1)
{
this.method_4(string_0, "GET");
HttpResponseMessage result;
if (bool_1)
{
string string_ = string_0;
TaskAwaiter <HttpResponseMessage> taskAwaiter = this.httpClient_0.GetAsync(string_0).GetAwaiter();
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter <HttpResponseMessage> taskAwaiter2;
taskAwaiter = taskAwaiter2;
taskAwaiter2 = default(TaskAwaiter <HttpResponseMessage>);
}
result = await this.method_2(string_, taskAwaiter.GetResult());
string_ = null;
}
else
{
TaskAwaiter <HttpResponseMessage> taskAwaiter = this.httpClient_0.GetAsync(string_0).GetAwaiter();
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter <HttpResponseMessage> taskAwaiter2;
taskAwaiter = taskAwaiter2;
taskAwaiter2 = default(TaskAwaiter <HttpResponseMessage>);
}
result = taskAwaiter.GetResult();
}
return(result);
}
void WrongWay()
{
// this will be a deadlock, there's actually only one thread. The async methods run on the same thread!
Task <Sandwich> sandwichTask = MakeBLT();
TaskAwaiter <Sandwich> awaiter = sandwichTask.GetAwaiter();
Sandwich result = awaiter.GetResult();
}
private void OnButtonClick(object sender, RoutedEventArgs e)
{
DialogButton[] buttons = new DialogButton[]
{
new DialogButton("Red", Colors.Red),
new DialogButton("Green", Colors.Green),
new DialogButton("Blue", Colors.Blue),
};
MessageDialog m = new MessageDialog("Choose a color", "How To Async #2", buttons);
Task <Object> messageTask = m.ShowAsync();
TaskAwaiter <object> messageAwaiter = messageTask.GetAwaiter();
messageAwaiter.OnCompleted(() =>
{
object ret = messageAwaiter.GetResult();
if (ret == null)
{
return;
}
clr = (Color)ret;
contentGrid.Background = new SolidColorBrush(clr);
});
}
public void MoveNext()
{
if (state == 0)
{
awaiter = Task.Delay(10000).GetAwaiter();
if (awaiter.IsCompleted)
{
state = 1;
goto state1;
}
else
{
state = 1;
// ref moves state machine to heap
methodBuilder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
}
return;
}
state1:
if (state == 1)
{
// Task is done so no blocking call
awaiter.GetResult();
methodBuilder.SetResult(10);
}
}
private R RunOnEmptyStackCore <R>(Func <object, R> action, object state)
{
_executionStackCount++;
try
{
// Using default scheduler rather than picking up the current scheduler.
Task <R> task = Task.Factory.StartNew(action, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
TaskAwaiter <R> awaiter = task.GetAwaiter();
// Avoid AsyncWaitHandle lazy allocation of ManualResetEvent in the rare case we finish quickly.
if (!awaiter.IsCompleted)
{
// Task.Wait has the potential of inlining the task's execution on the current thread; avoid this.
((IAsyncResult)task).AsyncWaitHandle.WaitOne();
}
// Using awaiter here to unwrap AggregateException.
return(awaiter.GetResult());
}
finally
{
_executionStackCount--;
}
}
public void MoveNext()
{
// State machine
if (state == 0)
{
awaiter = Task.Delay(5000).GetAwaiter();
if (awaiter.IsCompleted)
{
state = 1;
goto state1;
}
else
{
state = 1;
MethodBuilder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
}
return;
}
state1:
if (state == 1)
{
awaiter.GetResult();
MethodBuilder.SetResult(42);
return;
}
}
public static void Await(Task task, CancellationToken cancellationToken = default(CancellationToken))
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
SynchronizationContext previousContext = SynchronizationContext.Current;
try
{
SingleThreadSynchronizationContext syncContext = new SingleThreadSynchronizationContext(cancellationToken);
SynchronizationContext.SetSynchronizationContext(syncContext);
TaskAwaiter awaiter = task.GetAwaiter();
while (!awaiter.IsCompleted)
{
if (cancellationToken.IsCancellationRequested)
{
throw new OperationCanceledException("The task was not completed before being cancelled");
}
syncContext.RunOnCurrentThread(cancellationToken);
}
syncContext.SetComplete();
awaiter.GetResult();
}
finally
{
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
static void CreateFaultedAwaiter(out TaskAwaiter <object> awaiter)
{
var faultedSource = new TaskCompletionSource <object>();
faultedSource.SetException(new Exception());
awaiter = faultedSource.Task.GetAwaiter();
try {
awaiter.GetResult();
} catch {
}
try {
awaiter.GetResult();
} catch {
}
}
void IAsyncStateMachine.MoveNext()
{
try
{
if (_state != 0)
{
goto afterSetup;
}
_fileName = GenerateFileName();
_reader = File.OpenText(_fileName);
TaskAwaiter <string> awaiter = _reader.ReadToEndAsync().GetAwaiter();
_state = -1;
if (!awaiter.IsCompleted)
{
_awaiter = awaiter;
_builder.AwaitUnsafeOnCompleted <TaskAwaiter <string>, ReadFileAsyncStateMachine>(ref awaiter, ref this);
return;
}
afterSetup:
awaiter = _awaiter;
string result = awaiter.GetResult();
_state = -2;
_builder.SetResult(result);
_reader.Dispose();
}
catch (Exception exception)
{
_state = -2;
_builder.SetException(exception);
_reader?.Dispose();
return;
}
}
public void MoveNext()
{
try
{
if (state == 0)
{
Console.WriteLine("Before Await");
awaiter = AsyncOperation(5000).GetAwaiter();
if (awaiter.IsCompleted)
{
state = 1;
}
else
{
state = 1;
methodBuilder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
return;
}
}
if (state == 1)
{
int result = awaiter.GetResult();
methodBuilder.SetResult(result + 1);
}
}
catch (Exception ex)
{
methodBuilder.SetException(ex);
}
}
// Token: 0x06000014 RID: 20 RVA: 0x00003314 File Offset: 0x00001514
public async Task <T> DequeueAsync()
{
T result;
for (;;)
{
TaskAwaiter taskAwaiter = this.semaphoreSlim.WaitAsync().GetAwaiter();
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter taskAwaiter2;
taskAwaiter = taskAwaiter2;
taskAwaiter2 = default(TaskAwaiter);
}
taskAwaiter.GetResult();
if (this.concurrentQueue.IsEmpty)
{
break;
}
if (this.concurrentQueue.TryDequeue(out result))
{
goto IL_77;
}
}
throw new InvalidOperationException("Queue empty.");
IL_77:
return(result);
}
/// <summary>
/// hdt
/// </summary>
/// <returns></returns>
public static Task <ProcessorArchitecture> GetProcessorArchitectureAsync()
{
TaskAwaiter <PnpObject> awaiter = SystemInfoEstimate.GetHalDevice(new string[] { "System.ItemNameDisplay" }).GetAwaiter();
PnpObject halDevice = awaiter.GetResult();
ProcessorArchitecture arm;
if (halDevice != null && halDevice.Properties["System.ItemNameDisplay"] != null)
{
string str = halDevice.Properties["System.ItemNameDisplay"].ToString();
if (str.Contains("x64"))
{
arm = ProcessorArchitecture.X64;
}
else if (str.Contains("ARM"))
{
arm = ProcessorArchitecture.Arm;
}
else
{
arm = ProcessorArchitecture.X86;
}
}
else
{
arm = ProcessorArchitecture.Unknown;
}
return(Task.FromResult <ProcessorArchitecture>(arm));
}
public TResult GetResult()
{
var result = _awaiter.GetResult();
_restoreState(result.Item2);
return(result.Item1());
}
// Token: 0x06000020 RID: 32 RVA: 0x0000718C File Offset: 0x0000538C
public static async void smethod_13(object object_0, JSExtInvokeArgs jsextInvokeArgs_0)
{
MainWindow.webView_0.QueueScriptCall("swal('Resetting key...','Please wait...','info',{buttons:false})");
TaskAwaiter <bool> taskAwaiter = Licenser.smethod_4().GetAwaiter();
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter <bool> taskAwaiter2;
taskAwaiter = taskAwaiter2;
taskAwaiter2 = default(TaskAwaiter <bool>);
}
if (taskAwaiter.GetResult())
{
MainWindow.webView_0.QueueScriptCall("swal('Success','Successfully reset your license key!','success')");
TaskAwaiter taskAwaiter3 = Task.Delay(1000).GetAwaiter();
if (!taskAwaiter3.IsCompleted)
{
await taskAwaiter3;
TaskAwaiter taskAwaiter4;
taskAwaiter3 = taskAwaiter4;
taskAwaiter4 = default(TaskAwaiter);
}
taskAwaiter3.GetResult();
MainWindow.mainWindow_0.method_4(null, null);
}
else
{
MainWindow.webView_0.QueueScriptCall("swal('Error','There was an error resetting your key, please try again later...','error')");
}
}
public void Iterate(RecordDirectory currentDirectory)
{
TaskAwaiter awaiter = currentDirectory.EnsureFullyLoaded().GetAwaiter();
awaiter.GetResult();
foreach (Record record in (IEnumerable <Record>)currentDirectory.Records)
{
//Debug.Log(record.Name);
Debug.Log(currentDirectory.Path);
string output = JsonConvert.SerializeObject(record);
if (is_fist_time)
{
file.Write(output);
is_fist_time = false;
}
else
{
file.Write("," + output);
}
//Debug.Log(output);
}
foreach (RecordDirectory subdirectory in (IEnumerable <RecordDirectory>)currentDirectory.Subdirectories)
{
//this._currentItems.TryGetValue(
//inventory._currentPath.Value = directory.GetRelativePath(false);
//if (this.World == Userspace.UserspaceWorld && this != InventoryBrowser.CurrentUserspaceInventory && InventoryBrowser.CurrentUserspaceInventory != null)
//{
// InventoryBrowser.CurrentUserspaceInventory._changePath = this._currentPath.Value;
// InventoryBrowser.CurrentUserspaceInventory._changeOwnerId = this._currentOwnerId.Value;
//}
//this.StartTask((Func<Task>)(async () => await this.OpenDirectory(directory, slide).ConfigureAwait(false)));
//inventory.OpenDirectory(directory, slide).ConfigureAwait(false));
//inventory.Open(subdirectory, SlideSwapRegion.Slide.None);
//MethodInfo openDirectoryMethod = inventory.GetType().GetMethod("OpenDirectory", BindingFlags.NonPublic | BindingFlags.Instance);
//Task task = this.StartTask((Func<Task>)(async () => await ((Task)openDirectoryMethod.Invoke(inventory, new object[] { subdirectory, SlideSwapRegion.Slide.None })).ConfigureAwait(false)));
//task.Wait();
//string previousDir = inventory.CurrentDirectory.Path;
//while(true)
//{
// if (inventory.CurrentDirectory.Path != previousDir)
// {
// break;
// }
//}
//string folderId = subdirectory.OwnerId+":"+subdirectory.Path;
string folderId = subdirectory.OwnerId + ":" + subdirectory.Name;
folderId = subdirectory.IsLink ? subdirectory.LinkRecord.RecordId : folderId;
//if (subdirectory.Path.Split('\\').Length < 1 && !folderIds.Contains(folderId))
//if (!folders.Contains(subdirectory))
if (!folderIds.Contains(folderId))
{
//this.Iterate(i + 1);
folderIds.Add(folderId);
//folders.Add(subdirectory);
Thread.Sleep(100);
Iterate(subdirectory);
}
}
}
/// <summary>
/// 프로그램의 진입점
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
Program cProgram = new Program();
Task cBotTask = cProgram.BotMain();
TaskAwaiter taskAwaiter = cBotTask.GetAwaiter();
taskAwaiter.GetResult(); //봇의 진입점 실행
}
public T GetResult()
{
if (_IsImmediate)
{
return(_Result);
}
return(_Task.GetResult());
}
public void GetResult()
{
if (m_AsyncContext != null)
{
m_AsyncContext.Restore();
}
m_Awaiter.GetResult();
}
public virtual async void OnMessageReceived(RemoteMessage message)
{
FirebaseMessageService firebaseMessageService = this;
try
{
TaskAwaiter awaiter1 = firebaseMessageService.Init().GetAwaiter();
int num;
if (!awaiter1.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 0;
TaskAwaiter taskAwaiter = awaiter1;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter, FirebaseMessageService.\u003COnMessageReceived\u003Ed__2>(ref awaiter1, this);
return;
}
awaiter1.GetResult();
PushMessage pushMessage = firebaseMessageService.CreateNotificationObject(message);
if (pushMessage != null)
{
TaskAwaiter <bool> awaiter2 = firebaseMessageService._queue.Enqueue <bool>((Func <Task <bool> >)(() => this._pushNotificationService.HandleNotification(pushMessage))).GetAwaiter();
if (!awaiter2.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 1;
TaskAwaiter <bool> taskAwaiter = awaiter2;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter <bool>, FirebaseMessageService.\u003COnMessageReceived\u003Ed__2>(ref awaiter2, this);
return;
}
if (awaiter2.GetResult())
{
NotificationFactory.CreateNotification((Context)firebaseMessageService, Build.VERSION.get_SdkInt(), pushMessage).ShowNotification();
}
}
}
catch (Exception ex)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = -2;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.SetException(ex);
return;
}
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = -2;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.SetResult();
}
// Token: 0x060001D1 RID: 465 RVA: 0x00011430 File Offset: 0x0000F630
public async void method_0(string string_7, string string_8, bool bool_3, GEnum1 genum1_0)
{
try
{
this.bool_1 = true;
if (bool_3 && !this.bool_2)
{
this.bool_2 = bool_3;
this.method_5(string_7, string_8, true, true);
if (genum1_0 != (GEnum1)5)
{
if (genum1_0 == (GEnum1)6)
{
this.method_1();
TaskAwaiter taskAwaiter = this.method_8(true).GetAwaiter();
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter taskAwaiter2;
taskAwaiter = taskAwaiter2;
taskAwaiter2 = default(TaskAwaiter);
}
taskAwaiter.GetResult();
}
}
else
{
TaskAwaiter taskAwaiter = this.method_8(false).GetAwaiter();
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter taskAwaiter2;
taskAwaiter = taskAwaiter2;
taskAwaiter2 = default(TaskAwaiter);
}
taskAwaiter.GetResult();
}
if (this.class14_0 != null)
{
this.class14_0.httpClient_0.Dispose();
}
this.cancellationTokenSource_0.Dispose();
Class130.dictionary_0.Remove((int)this.jtoken_0["id"]);
MainWindow.webView_0.QueueScriptCall(string.Format("updateButton({0},false)", this.jtoken_0["id"]));
}
else if (!bool_3)
{
this.bool_2 = bool_3;
this.method_5("Stopping...", "orange", true, true);
this.cancellationTokenSource_0.Cancel();
this.class14_0.httpClient_0.CancelPendingRequests();
}
}
catch
{
}
}
static void Main(string[] args)
{
LightWebClient lwc = new LightWebClient("server", "pasword");
Boolean testXml = true;
Boolean testList = false;
try
{
if (testXml)
{
if (testList)
{
TaskAwaiter <Stream> tat = lwc.GetStreamAsync(@"https://xldeploy.toto.com/deployit/repository/query?type=udm.DeployedApplication&resultsPerPage=-1", "XML").GetAwaiter();
Stream st = tat.GetResult();
ListOfCi loci = SerializerXml <XLDeployNamespace.ListOfCi> .GetInstance().Deserialize(st);
Console.WriteLine(loci.lstCi[0].reference + " " + loci.lstCi[0].type);
}
else
{
TaskAwaiter <Stream> tat = lwc.GetStreamAsync(@"https://xldeploy.toto.com/deployit/repository/ci/Environments/DEV/project/environment/deployments/product_deployment", "XML").GetAwaiter();
Stream st = tat.GetResult();
XElement elem = XDocument.Load(st).Root;
Console.WriteLine(elem.Name.LocalName);
st.Seek(0, 0);
XLDeployNamespace.Dictionary dict = SerializerXml <XLDeployNamespace.Dictionary> .GetInstance().Deserialize(st);
}
}
else
{
TaskAwaiter <Stream> tat = lwc.GetStreamAsync(@"https://xldeploy.toto.com/deployit/repository/query?type=udm.DeployedApplication&resultsPerPage=-1", "JSON").GetAwaiter();
Stream st = tat.GetResult();
//StreamReader reader = new StreamReader(st);
//string text = reader.ReadToEnd();
//Console.Write(text);
//ListOfCi loci = new ListOfCi();
List <CiListElement> loci = new List <CiListElement>();
//var serializer = new XmlSerializer(typeof(ListOfCi));
//Application di = new Application();
//var serializer = new DataContractJsonSerializer(typeof(Application));
//var serializer = new DataContractJsonSerializer(typeof(ListOfCi));
var serializer = new DataContractJsonSerializer(typeof(List <CiListElement>));
loci = (List <CiListElement>)serializer.ReadObject(st);
//di = (Application)serializer.ReadObject(st);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.ReadKey();
}
private static void CallerWithAwaiter() // Объекты ожидания
{
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
TaskAwaiter <string> awaiter = GreetingAsync("Matthias").GetAwaiter();
awaiter.OnCompleted(() => Console.WriteLine("Await is finished"));
string result = awaiter.GetResult();
Console.WriteLine(result);
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
}
void IAsyncStateMachine.MoveNext()
{
int num = this.state;
try
{
switch (num)
{
default:
goto MethodStart;
case 0:
goto AwaitContinuation;
}
MethodStart:
Console.WriteLine("Before loop");
this.i = 0;
goto ForLoopCondition;
ForLoopBody:
Console.WriteLine("Before await in loop");
TaskAwaiter awaiter = Task.Delay(this.delay).GetAwaiter();
if (awaiter.IsCompleted)
{
goto GetAwaitResult;
}
this.state = num = 0;
this.awaiter = awaiter;
this.builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
return;
AwaitContinuation:
awaiter = this.awaiter;
this.awaiter = default(TaskAwaiter);
this.state = num = -1;
GetAwaitResult:
awaiter.GetResult();
Console.WriteLine("After await in loop");
this.i++;
ForLoopCondition:
if (this.i < 3)
{
goto ForLoopBody;
}
Console.WriteLine("After loop delay");
}
catch (Exception exception)
{
this.state = -2;
this.builder.SetException(exception);
return;
}
this.state = -2;
this.builder.SetResult();
}
private static void CallerWithAwaiter()
{
TraceThreadAndTask($"starting {nameof(CallerWithAwaiter)}");
TaskAwaiter <string> awaiter = GreetingAsync("Manpreet").GetAwaiter();
awaiter.OnCompleted(() =>
{
Console.WriteLine(awaiter.GetResult());
TraceThreadAndTask($"ended {nameof(CallerWithAwaiter)}");
});
}
private void Print2Async()
{
TaskAwaiter <int> awaiter = WorkAsync().GetAwaiter();
awaiter.OnCompleted(() =>
{
int result = awaiter.GetResult();
Console.WriteLine($"Print结果：{result} {DateTime.Now.ToLongTimeString()}");
Thread.Sleep(3000);
});
}
static void CreateFaultedAwaiter (out TaskAwaiter<object> awaiter)
{
var faultedSource = new TaskCompletionSource<object>();
faultedSource.SetException(new Exception());
awaiter = faultedSource.Task.GetAwaiter ();
try {
awaiter.GetResult ();
} catch {
}
try {
awaiter.GetResult ();
} catch {
}
}
public void MoveNext()
{
int result;
try
{
#pragma warning disable 0219 // doFinallyBodies is never used
bool doFinallyBodies = true;
#pragma warning restore
switch (state)
{
case 1:
break;
case 2:
goto Label_Awaiter2Continuation;
case 3:
goto Label_Awaiter3Continuation;
default:
if (state != -1)
{
task1 = Task.Factory.StartNew(() => 1);
task2 = Task.Factory.StartNew(() => 2);
task3 = Task.Factory.StartNew(() => 3);
awaiter1 = task1.GetAwaiter();
if (awaiter1.IsCompleted)
{
goto Label_GetAwaiter1Result;
}
state = 1;
doFinallyBodies = false;
awaiter1.OnCompleted(moveNextDelegate);
}
return;
}
state = 0;
Label_GetAwaiter1Result:
int awaitResult1 = awaiter1.GetResult();
awaiter1 = new TaskAwaiter<int>();
value1 = awaitResult1;
awaiter2 = task2.GetAwaiter();
if (awaiter2.IsCompleted)
{
goto Label_GetAwaiter2Result;
}
state = 2;
doFinallyBodies = false;
awaiter2.OnCompleted(moveNextDelegate);
return;
Label_Awaiter2Continuation:
state = 0;
Label_GetAwaiter2Result:
int awaitResult2 = awaiter2.GetResult();
awaiter2 = new TaskAwaiter<int>();
value2 = awaitResult2;
awaiter3 = task3.GetAwaiter();
if (awaiter3.IsCompleted)
{
goto Label_GetAwaiter3Result;
}
state = 3;
doFinallyBodies = false;
awaiter3.OnCompleted(moveNextDelegate);
return;
Label_Awaiter3Continuation:
state = 0;
Label_GetAwaiter3Result:
int awaitResult3 = awaiter3.GetResult();
awaiter3 = new TaskAwaiter<int>();
value3 = awaitResult3;
result = value1 + value2 + value3;
}
catch (Exception e)
{
state = -1;
builder.SetException(e);
return;
}
state = -1;
builder.SetResult(result);
}
