public void MoveNext()
{
if (state == 0)
{
awaiter = Task.Delay(5000).GetAwaiter();
if (awaiter.IsCompleted)
{
state = 1;
goto state1;
}
else
{
state = 1;
mb.AwaitUnsafeOnCompleted(ref awaiter, ref this);
}
return;
}
state1:
if (state == 1)
{
awaiter.GetResult();
mb.SetResult("asdasd");
return;
}
}
void IAsyncStateMachine.MoveNext()
{
string result = null;
try
{
int num = this.state;
if (num != -3)
{
TaskAwaiter<string> taskAwaiter;
if (num != 0)
{
this.httpClient = new HttpClient();
this.task = this.httpClient.GetStringAsync("http://web.myresource.org/angular/current/version.txt");
Console.WriteLine("hello, asynchronous!");
taskAwaiter = this.task.GetAwaiter();
if (!taskAwaiter.IsCompleted)
{
this.state = 0;
this.outerAwaiter = taskAwaiter;
this.builder.AwaitUnsafeOnCompleted<TaskAwaiter<string>, AsyncAndAwaitImplement.StateMachine>(ref taskAwaiter, ref this);
return;
}
}
else
{
taskAwaiter = this.outerAwaiter;
this.outerAwaiter = default(TaskAwaiter<string>);
this.state = -1;
}
string arg_B3_0 = taskAwaiter.GetResult();
taskAwaiter = default(TaskAwaiter<string>);
string text = arg_B3_0;
this.result = text;
Console.WriteLine("{0}", this.result);
result = this.result;
}
}
catch (Exception exception)
{
this.state = -2;
this.builder.SetException(exception);
return;
}
this.state = -2;
this.builder.SetResult(result);
}
public void MoveNext()
{
int result;
try
{
#pragma warning disable 0219 // doFinallyBodies is never used
bool doFinallyBodies = true;
#pragma warning restore
if (state != 1)
{
if (state != -1)
{
task = Task<int>.Factory.StartNew(() => 5);
awaiter = task.GetAwaiter();
if (awaiter.IsCompleted)
{
goto Label_GetResult;
}
state = 1;
doFinallyBodies = false;
awaiter.OnCompleted(moveNextDelegate);
}
return;
}
state = 0;
Label_GetResult: // target of state=1
int awaitResult = awaiter.GetResult();
awaiter = default(TaskAwaiter<int>);
result = awaitResult;
}
catch (Exception e)
{
state = -1;
builder.SetException(e);
return;
}
state = -1;
builder.SetResult(result);
}
public async Task RunLoop()
{
await Task.Delay(WintermintUpdateDaemon.InitialUpdateDelay);
TaskAwaiter awaiter;
while (true)
{
LaunchData.TryLaunch("wintermint-update", (string) null);
awaiter = Task.Delay(WintermintUpdateDaemon.UpdateDelay).GetAwaiter();
if (awaiter.IsCompleted)
{
awaiter.GetResult();
awaiter = new TaskAwaiter();
}
else
break;
}
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^this).\u003C\u003E1__state = 1;
TaskAwaiter taskAwaiter = awaiter;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted<TaskAwaiter, WintermintUpdateDaemon.\u003CRunLoop\u003Ed__0>(ref awaiter, this);
}
public void MoveNext()
{
string str;
int num = this._state;
try
{
ConfiguredTaskAwaitable <Stream> .ConfiguredTaskAwaiter awaiter;
switch (num)
{
case 0:
break;
case 1:
goto Label_00C3;
default:
this._path = null;
this._streamVideoSource = this.source as StreamVideoSource;
if (this._streamVideoSource?.Stream == null)
{
goto Label_01FB;
}
awaiter = this._streamVideoSource.GetStreamAsync(this.cancellationToken).ConfigureAwait(false).GetAwaiter();
if (awaiter.IsCompleted)
{
goto Label_00AC;
}
this._state = num = 0;
this._configuredAwaiter = awaiter;
this._builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
return;
}
awaiter = this._configuredAwaiter;
this._configuredAwaiter = new ConfiguredTaskAwaitable <Stream> .ConfiguredTaskAwaiter();
this._state = num = -1;
Label_00AC:
Stream introduced9 = awaiter.GetResult();
awaiter = new ConfiguredTaskAwaitable <Stream> .ConfiguredTaskAwaiter();
Stream stream = introduced9;
this._stream = stream;
Label_00C3 :;
try
{
if (num != 1)
{
if (this._stream == null)
{
goto Label_01F4;
}
string fileName = this._this.GetFileName(this._stream, this._streamVideoSource.Format);
string str3 = Path.Combine(Path.GetTempPath(), "MediaCache");
this._path = Path.Combine(str3, fileName);
if (File.Exists(this._path))
{
goto Label_01F4;
}
if (!Directory.Exists(str3))
{
Directory.CreateDirectory(str3);
}
this._tempFile = File.Create(this._path);
}
try
{
TaskAwaiter awaiter2;
if (num != 1)
{
awaiter2 = this._stream.CopyToAsync(this._tempFile).GetAwaiter();
if (!awaiter2.IsCompleted)
{
this._state = num = 1;
this._awaiter = awaiter2;
this._builder.AwaitUnsafeOnCompleted(ref awaiter2, ref this);
return;
}
}
else
{
awaiter2 = this._awaiter;
this._awaiter = new TaskAwaiter();
this._state = num = -1;
}
awaiter2.GetResult();
awaiter2 = new TaskAwaiter();
}
finally
{
if ((num < 0) && (this._tempFile != null))
{
this._tempFile.Dispose();
}
}
this._tempFile = null;
}
finally
{
if ((num < 0) && (this._stream != null))
{
this._stream.Dispose();
}
}
Label_01F4:
this._stream = null;
Label_01FB:
str = this._path;
}
catch (Exception exception)
{
this._state = -2;
this._builder.SetException(exception);
return;
}
this._state = -2;
this._builder.SetResult(str);
}
public TaskOperation(Task <T> task)
{
Task = task;
TaskAwaiter = Task.GetAwaiter();
}
public WcfContextAwaiter(Task task)
{
Validate(task);
m_Awaiter = task.GetAwaiter();
}
void IAsyncStateMachine.MoveNext()
{
int num = this.state;
try
{
TaskAwaiter awaiter1;
switch (num)
{
default:
goto MethodStart;
case 0:
goto FirstAwaitContinuation;
case 1:
goto SecondAwaitContinuation;
}
MethodStart:
Console.WriteLine("Before first delay");
awaiter1 = Task.Delay(this.delay).GetAwaiter();
if (awaiter1.IsCompleted)
{
goto GetFirstAwaitResult;
}
this.state = num = 0;
this.awaiter = awaiter1;
this.builder.AwaitUnsafeOnCompleted(ref awaiter1, ref this);
return;
FirstAwaitContinuation:
awaiter1 = this.awaiter;
this.awaiter = default(TaskAwaiter);
this.state = num = -1;
GetFirstAwaitResult:
awaiter1.GetResult();
for (int i = 0; i < 3; i++)
{
Console.WriteLine("Between delays");
}
TaskAwaiter awaiter2 = Task.Delay(this.delay).GetAwaiter();
if (awaiter2.IsCompleted)
{
goto GetSecondAwaitResult;
}
this.state = num = 1;
this.awaiter = awaiter2;
this.builder.AwaitUnsafeOnCompleted(ref awaiter2, ref this);
return;
SecondAwaitContinuation:
awaiter2 = this.awaiter;
this.awaiter = default(TaskAwaiter);
this.state = num = -1;
GetSecondAwaitResult:
awaiter2.GetResult();
Console.WriteLine("After second delay");
}
catch (Exception exception)
{
this.state = -2;
this.builder.SetException(exception);
return;
}
this.state = -2;
this.builder.SetResult();
}
private async Task RunLoop()
{
await Task.Delay(RiotUpdateDaemon.InitialUpdateDelay);
TaskAwaiter awaiter1;
TaskAwaiter awaiter2;
while (true)
{
awaiter1 = this.TryUpdate().GetAwaiter();
if (awaiter1.IsCompleted)
{
awaiter1.GetResult();
awaiter1 = new TaskAwaiter();
awaiter2 = Task.Delay(RiotUpdateDaemon.UpdateDelay).GetAwaiter();
if (awaiter2.IsCompleted)
{
awaiter2.GetResult();
awaiter2 = new TaskAwaiter();
}
else
goto label_6;
}
else
break;
}
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
state = 1;
TaskAwaiter taskAwaiter = awaiter1;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted<TaskAwaiter, RiotUpdateDaemon.\u003CRunLoop\u003Ed__1f>(ref awaiter1, this);
return;
label_6:
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^this).\u003C\u003E1__state = 2;
taskAwaiter = awaiter2;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted<TaskAwaiter, RiotUpdateDaemon.\u003CRunLoop\u003Ed__1f>(ref awaiter2, this);
}
private void MoveNextSingleYield()
{
int num = state;
int result;
try
{
TaskAwaiter <int> awaiter;
YieldAwaitable.YieldAwaiter awaiter2;
if (num != 0)
{
if (num == 1)
{
awaiter = u__2;
u__2 = default(TaskAwaiter <int>);
num = (state = -1);
goto IL_00fb;
}
awaiter2 = Task.Yield().GetAwaiter();
if (!awaiter2.IsCompleted)
{
num = (state = 0);
u__1 = awaiter2;
//CountRecursivelyAsyncd__1 stateMachine = this;
t__builder.AwaitUnsafeOnCompleted(ref awaiter2, ref this);
return;
}
}
else
{
awaiter2 = u__1;
u__1 = default(YieldAwaitable.YieldAwaiter);
num = (state = -1);
}
awaiter2.GetResult();
if (count > 0)
{
awaiter = CountRecursivelyAsync(count - 1).GetAwaiter();
if (!awaiter.IsCompleted)
{
num = (state = 1);
u__2 = awaiter;
//CountRecursivelyAsyncd__1 stateMachine = this;
t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
return;
}
goto IL_00fb;
}
result = count;
goto end_IL_0007;
IL_00fb:
s__1 = awaiter.GetResult();
result = 1 + s__1;
end_IL_0007 :;
}
catch (Exception exception)
{
state = -2;
t__builder.SetException(exception);
return;
}
state = -2;
t__builder.SetResult(result);
}
public void MoveNext()
{
int result;
try
{
bool doFinallyBodies = true;
int tmpState = state;
// Effectively a three way switch: 1, -1, 0
if (tmpState != 1)
{
if (state == -1)
{
return;
}
this.writer = File.CreateText("output.txt");
}
try
{
tmpState = state;
if (tmpState == 1)
{
goto Label_ResumePoint;
}
sum = 0;
i = 0;
Label_ResumePoint: // This shouldn't quite be here... see below
while (i < loopCount)
{
// Not in generated code:
if (state == 1)
{
goto Label_ResumePoint2;
}
// Back to generated code
valueFetcher = Task.Factory.StartNew(() => 1);
j = 0;
// Still not in the generated code, and still not quite right... we don't want the j test here
Label_ResumePoint2:
// Back to generated code again...
while (j < 3)
{
try
{
// We want Label_ResumePoint to be here really
tmpState = state;
if (tmpState != 1)
{
Console.WriteLine("Awaiting...");
awaiter = valueFetcher.GetAwaiter();
if (!awaiter.IsCompleted)
{
state = 1;
doFinallyBodies = false;
awaiter.OnCompleted(moveNextDelegate);
return;
}
}
else
{
state = 0;
}
int awaitResult = awaiter.GetResult();
awaiter = new TaskAwaiter<int>();
value = awaitResult;
writer.WriteLine("Got value {0}", value);
sum += value;
break;
}
catch (Exception)
{
Console.WriteLine("Oops... retrying");
}
j++;
}
i++;
}
result = sum;
}
finally
{
if (doFinallyBodies && writer != null)
{
writer.Dispose();
}
}
}
catch (Exception e)
{
state = -1;
builder.SetException(e);
return;
}
state = -1;
builder.SetResult(result);
}
public void Toggle(bool open, int durationMs)
{
var animationFn = AnimationFunction(Settings.Instance.ToggleAnimationType);
var frameTimeMs = Settings.Instance.ToggleAnimationFrameTimeMs;
Log.Information(open?"Open":"Close");
if (open)
{
FocusTracker.FocusGained(_process);
}
var screen = GetScreenWithCursor();
User32.ShowWindow(_process.MainWindowHandle, NCmdShow.RESTORE);
User32.SetForegroundWindow(_process.MainWindowHandle);
// Used to accurately measure how far we are in the animation
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
TimeSpan ts = stopWatch.Elapsed;
var curMs = ts.TotalMilliseconds;
// Run the open/close animation
while (curMs < durationMs)
{
// Asynchronously start the timer for this frame (unless frameTimeMs is 0)
TaskAwaiter frameTimer = (frameTimeMs == 0)? new TaskAwaiter(): Task.Delay(TimeSpan.FromMilliseconds(frameTimeMs)).GetAwaiter();
// Render the next frame of animation
var animationX = open ? (curMs / durationMs) : (1.0 - (curMs / durationMs));
var bounds = GetBounds(screen, animationFn(animationX));
User32.MoveWindow(_process.MainWindowHandle, bounds.X, bounds.Y, bounds.Width, bounds.Height, true);
User32.ThrowIfError();
ts = stopWatch.Elapsed;
curMs = (double)ts.TotalMilliseconds;
if (frameTimeMs != 0)
{
frameTimer.GetResult(); // Wait for the timer to end
}
}
stopWatch.Stop();
// To ensure sure we end up in exactly the correct final position
var finalBounds = GetBounds(screen, open?1.0:0.0);
User32.MoveWindow(_process.MainWindowHandle, finalBounds.X, finalBounds.Y, finalBounds.Width, finalBounds.Height, true);
User32.ThrowIfError();
if (open)
{
if (Settings.Instance.VerticalScreenCoverage >= 100 && Settings.Instance.HorizontalScreenCoverage >= 100)
{
User32.ShowWindow(_process.MainWindowHandle, NCmdShow.MAXIMIZE);
}
}
else
{
// Minimize, so the last window gets focus
User32.ShowWindow(_process.MainWindowHandle, NCmdShow.MINIMIZE);
// Hide, so the terminal windows doesn't linger on the desktop
User32.ShowWindow(_process.MainWindowHandle, NCmdShow.HIDE);
}
}
public TaskAwaiterWrapper(TaskAwaiter taskAwaiter)
{
this.taskAwaiter = taskAwaiter;
}
internal GremlinQueryAwaiter(TaskAwaiter <TElement[]> valueTaskAwaiter)
{
_valueTaskAwaiter = valueTaskAwaiter;
}
public ContextAwaiter(Task task, Control control, bool alwaysAsync)
{
_awaiter = task.GetAwaiter();
_control = control;
_alwaysAsync = alwaysAsync;
}
public ClientesRepository()
{
getAwaiter = new TaskAwaiter();
}
private async Task TrackProgressAsync()
{
StreamReader stream = this.Process.StandardError;
TaskAwaiter<string> awaiter;
while (true)
{
awaiter = stream.ReadLineAsync().GetAwaiter();
if (awaiter.IsCompleted)
{
string result = awaiter.GetResult();
awaiter = new TaskAwaiter<string>();
string line;
if ((line = result) != null)
{
GroupCollection groups = RiotUpdateDaemon.RiotUpdaterProgressParser.Match(line).Groups;
string s1 = groups["position"].Value;
string s2 = groups["length"].Value;
this.Status = groups["status"].Value;
long.TryParse(s1, out this.Position);
long.TryParse(s2, out this.Length);
this.notifyChange();
}
else
break;
}
else
goto label_5;
}
this.SetCompleted();
label_5:
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^this).\u003C\u003E1__state = 0;
TaskAwaiter<string> taskAwaiter = awaiter;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted<TaskAwaiter<string>, RiotUpdateDaemon.UpdaterState.\u003CTrackProgressAsync\u003Ed__27>(ref awaiter, this);
}
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 async Task HomeWorkDoneChanged(bool done)
{
HomeWorkDetailViewModel workDetailViewModel = this;
try
{
TaskAwaiter taskAwaiter;
int num;
if (done != workDetailViewModel.HomeWorkDone)
{
try
{
if (workDetailViewModel.ActiveProfile.IsTutelary)
{
TaskAwaiter awaiter = ((MvxNotifyPropertyChanged)workDetailViewModel).RaisePropertyChanged("HomeWorkDone").GetAwaiter();
if (!awaiter.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 0;
taskAwaiter = awaiter;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter, HomeWorkDetailViewModel.\u003CHomeWorkDoneChanged\u003Ed__39>(ref awaiter, this);
return;
}
awaiter.GetResult();
awaiter = workDetailViewModel._modalDialog.DisplayAlertByResourceKeysAsync("HomeWorkDetail_Update_IsTutelary", "Common_NoInternet_Title").GetAwaiter();
if (!awaiter.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 1;
taskAwaiter = awaiter;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter, HomeWorkDetailViewModel.\u003CHomeWorkDoneChanged\u003Ed__39>(ref awaiter, this);
return;
}
awaiter.GetResult();
}
else if (!workDetailViewModel.HasInternetConnection)
{
TaskAwaiter awaiter = ((MvxNotifyPropertyChanged)workDetailViewModel).RaisePropertyChanged("HomeWorkDone").GetAwaiter();
if (!awaiter.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 2;
taskAwaiter = awaiter;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter, HomeWorkDetailViewModel.\u003CHomeWorkDoneChanged\u003Ed__39>(ref awaiter, this);
return;
}
awaiter.GetResult();
awaiter = workDetailViewModel._modalDialog.DisplayAlertByResourceKeysAsync("HomeWorkStudentDetail_Update_NoInternet", "Common_NoInternet_Title").GetAwaiter();
if (!awaiter.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 3;
taskAwaiter = awaiter;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter, HomeWorkDetailViewModel.\u003CHomeWorkDoneChanged\u003Ed__39>(ref awaiter, this);
return;
}
awaiter.GetResult();
}
else
{
TaskAwaiter awaiter1 = workDetailViewModel._mobileApi.SaveTeacherHomeWorkDoneStatusAsync(workDetailViewModel.ActiveProfile, workDetailViewModel._teacherHomeWork.Id, done).GetAwaiter();
if (!awaiter1.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 4;
taskAwaiter = awaiter1;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter, HomeWorkDetailViewModel.\u003CHomeWorkDoneChanged\u003Ed__39>(ref awaiter1, this);
return;
}
awaiter1.GetResult();
workDetailViewModel._teacherHomeWorkDbDataService.AddOrUpdate(workDetailViewModel.TeacherHomeWork, (Action <TeacherHomeWorkRealm>)(_teacherHomeWork => _teacherHomeWork.Done = done));
workDetailViewModel._lessonDataService.AddOrUpdate(workDetailViewModel.Lesson, (Action <LessonRealm>)(lesson => lesson.IsHomeworkDone = done));
TaskAwaiter awaiter2 = ((MvxNotifyPropertyChanged)workDetailViewModel).RaisePropertyChanged("HomeWorkDone").GetAwaiter();
if (!awaiter2.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 5;
taskAwaiter = awaiter2;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter, HomeWorkDetailViewModel.\u003CHomeWorkDoneChanged\u003Ed__39>(ref awaiter2, this);
return;
}
awaiter2.GetResult();
}
}
catch (Exception ex)
{
ErrorHandler.Current.HandleError(ex);
TaskAwaiter awaiter = ((MvxNotifyPropertyChanged)workDetailViewModel).RaisePropertyChanged("HomeWorkDone").GetAwaiter();
if (!awaiter.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 6;
taskAwaiter = awaiter;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter, HomeWorkDetailViewModel.\u003CHomeWorkDoneChanged\u003Ed__39>(ref awaiter, this);
return;
}
awaiter.GetResult();
}
}
}
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();
}
/// <summary>
/// Initializes a new instance of the <see cref="TaskDynamicListAwaiter"/> struct.
/// </summary>
/// <param name="awaiter">Awaiter for <see cref="TaskDynamicListAwaitable.Wait"/> method result.</param>
internal TaskDynamicListAwaiter(TaskAwaiter awaiter)
{
_awaiter = awaiter;
}
void IAsyncStateMachine.MoveNext()
{
int result = default(int);
try
{
bool doFinallyBodies = true;
switch (state)
{
case -3:
goto Done;
case 0:
goto FirstAwaitContinuation;
case 1:
goto SecondAwaitContinuation;
}
// Default case - first call (state is -1)
total = 0;
iterator = text.GetEnumerator();
// We really want to jump straight to FirstAwaitRealContinuation, but we can't
// goto a label inside a try block...
FirstAwaitContinuation:
// foreach loop
try
{
// for/foreach loops typically have the condition at the end of the generated code.
// We want to go there *unless* we're trying to reach the first continuation.
if (state != 0)
{
goto LoopCondition;
}
goto FirstAwaitRealContinuation;
LoopBody:
ch = iterator.Current;
unicode = ch;
TaskAwaiter localTaskAwaiter = Task.Delay(unicode).GetAwaiter();
if (localTaskAwaiter.IsCompleted)
{
goto FirstAwaitCompletion;
}
state = 0;
taskAwaiter = localTaskAwaiter;
builder.AwaitUnsafeOnCompleted(ref localTaskAwaiter, ref this);
doFinallyBodies = false;
return;
FirstAwaitRealContinuation:
localTaskAwaiter = taskAwaiter;
taskAwaiter = default(TaskAwaiter);
state = -1;
FirstAwaitCompletion:
localTaskAwaiter.GetResult();
localTaskAwaiter = default(TaskAwaiter);
total += unicode;
LoopCondition:
if (iterator.MoveNext())
{
goto LoopBody;
}
}
finally
{
if (doFinallyBodies && iterator != null)
{
iterator.Dispose();
}
}
// After the loop
YieldAwaitable.YieldAwaiter localYieldAwaiter = Task.Yield().GetAwaiter();
if (localYieldAwaiter.IsCompleted)
{
goto SecondAwaitCompletion;
}
state = 1;
yieldAwaiter = localYieldAwaiter;
builder.AwaitUnsafeOnCompleted(ref localYieldAwaiter, ref this);
doFinallyBodies = false;
return;
SecondAwaitContinuation:
localYieldAwaiter = yieldAwaiter;
yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
state = -1;
SecondAwaitCompletion:
localYieldAwaiter.GetResult();
localYieldAwaiter = default(YieldAwaitable.YieldAwaiter);
result = total;
}
catch (Exception ex)
{
state = -2;
builder.SetException(ex);
return;
}
Done:
state = -2;
builder.SetResult(result);
}
public EventReceiverAwaiter(TaskAwaiter <T> task)
{
this.task = task;
}
private async Task <HttpRequestMessage> CloneRequest(
HttpRequestMessage request,
TokenData tokenData = null)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
int num1 = (^ this).\u003C\u003E1__state;
HttpRequestMessage result;
HttpRequestMessage result1;
try
{
result = new HttpRequestMessage(request.Method, request.RequestUri);
IEnumerator <KeyValuePair <string, IEnumerable <string> > > enumerator1 = request.Headers.GetEnumerator();
try
{
while (enumerator1.MoveNext())
{
KeyValuePair <string, IEnumerable <string> > current = enumerator1.Current;
if (tokenData != null && current.Key == "Authorization")
{
result.Headers.Add(current.Key, string.Format("Bearer " + tokenData.AccessToken));
}
else
{
result.Headers.Add(current.Key, current.Value);
}
}
}
finally
{
if (num1 < 0 && enumerator1 != null)
{
enumerator1.Dispose();
}
}
if (request.Content?.Headers.ContentType != null)
{
TaskAwaiter <string> awaiter = request.Content.ReadAsStringAsync().GetAwaiter();
if (!awaiter.IsCompleted)
{
int num2;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num2 = 0;
TaskAwaiter <string> taskAwaiter = awaiter;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter <string>, AuthDbMessageHandler.\u003CCloneRequest\u003Ed__7>(ref awaiter, this);
return;
}
result.Content = (HttpContent) new StringContent(awaiter.GetResult(), Encoding.UTF8, request.Content.Headers.ContentType.MediaType);
IEnumerator <KeyValuePair <string, IEnumerable <string> > > enumerator2 = request.Content.Headers.GetEnumerator();
try
{
while (enumerator2.MoveNext())
{
KeyValuePair <string, IEnumerable <string> > current = enumerator2.Current;
if (!current.Key.Equals("Content-Type", StringComparison.OrdinalIgnoreCase))
{
result.Content.Headers.Add(current.Key, current.Value);
}
}
}
finally
{
if (num1 < 0 && enumerator2 != null)
{
enumerator2.Dispose();
}
}
}
result1 = result;
}
catch (Exception ex)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = -2;
result = (HttpRequestMessage)null;
// 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;
result = (HttpRequestMessage)null;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.SetResult(result1);
}
public WithinCancellableCallbackTaskAwaitable(HttpContext context, TaskAwaiter innerAwaiter) {
_awaiter = new WithinCancellableCallbackTaskAwaiter(context, innerAwaiter);
}
void IAsyncStateMachine.MoveNext()
{
string result = null;
try
{
bool executeFinally = true;
if (m_state == -1)
{
m_local = m_argument;
}
try
{
TaskAwaiter <Type1> awaiterType1;
TaskAwaiter <Type2> awaiterType2;
switch (m_state)
{
case -1:
awaiterType1 = Method1Async().GetAwaiter();
if (!awaiterType1.IsCompleted)
{
m_state = 0;
m_awaiterType1 = awaiterType1;
//把Method1Async的continue方法设置为调用this.movenext
m_builder.AwaitUnsafeOnCompleted(ref awaiterType1, ref this);
executeFinally = false;
return;
}
break;
case 0:
awaiterType1 = m_awaiterType1;
break;
case 1:
awaiterType2 = m_awaiterType2;
goto ForLoopEpilog;
}
m_result1 = awaiterType1.GetResult();
m_i = 0;
goto ForLoopBody;
ForLoopEpilog:
m_result2 = awaiterType2.GetResult();
m_i++;
ForLoopBody:
if (m_i < 3)
{
awaiterType2 = Method2Async().GetAwaiter();
if (!awaiterType2.IsCompleted)
{
m_state = 1;
m_awaiterType2 = awaiterType2;
m_builder.AwaitUnsafeOnCompleted(ref awaiterType2, ref this);
executeFinally = false;
return;
}
goto ForLoopEpilog;
}
}
catch (Exception)
{
Console.WriteLine("Catch");
}
finally
{
if (executeFinally)
{
Console.WriteLine("Finally");
}
}
}
catch (Exception exception)
{
// Unhandled exception: complete state machine's Task with exception
m_builder.SetException(exception);
return;
}
m_builder.SetResult(result);
}
protected override async Task <HttpResponseMessage> SendAsync(
HttpRequestMessage request,
CancellationToken cancellationToken)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
int num = (^ this).\u003C\u003E1__state;
HttpResponseMessage response;
HttpResponseMessage result1;
try
{
response = (HttpResponseMessage)null;
try
{
TaskAwaiter awaiter1 = this._semaphore.WaitAsync().GetAwaiter();
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, AuthDbMessageHandler.\u003CSendAsync\u003Ed__6>(ref awaiter1, this);
return;
}
awaiter1.GetResult();
TaskAwaiter <HttpRequestMessage> taskAwaiter1;
HttpRequestMessage result2;
if (this._secureStore.GetTokenData(this._profile.Id).ExpiresAt <= DateTime.Now)
{
TaskAwaiter <TokenData> awaiter2 = ((IAuthDbDataService)Mvx.get_IoCProvider().Resolve <IAuthDbDataService>()).RefreshToken(this._profile).GetAwaiter();
if (!awaiter2.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 1;
TaskAwaiter <TokenData> taskAwaiter2 = awaiter2;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter <TokenData>, AuthDbMessageHandler.\u003CSendAsync\u003Ed__6>(ref awaiter2, this);
return;
}
TokenData result3 = awaiter2.GetResult();
if (result3 == null)
{
result1 = (HttpResponseMessage)null;
goto label_26;
}
else
{
this._tokenInfoRepository.AddOrUpdate(new TokenInfoRealmMapper().To((Ekreta.Mobile.Core.Models.TokenInfo)JsonConvert.DeserializeObject <Ekreta.Mobile.Core.Models.TokenInfo>(TokenDecoder.Decode(result3.AccessToken))), (Action <TokenInfoRealm>)null);
TaskAwaiter <HttpRequestMessage> awaiter3 = this.CloneRequest(request, result3).GetAwaiter();
if (!awaiter3.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 2;
taskAwaiter1 = awaiter3;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter <HttpRequestMessage>, AuthDbMessageHandler.\u003CSendAsync\u003Ed__6>(ref awaiter3, this);
return;
}
result2 = awaiter3.GetResult();
}
}
else
{
TaskAwaiter <HttpRequestMessage> awaiter2 = this.CloneRequest(request, (TokenData)null).GetAwaiter();
if (!awaiter2.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 3;
taskAwaiter1 = awaiter2;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter <HttpRequestMessage>, AuthDbMessageHandler.\u003CSendAsync\u003Ed__6>(ref awaiter2, this);
return;
}
result2 = awaiter2.GetResult();
}
TaskAwaiter <HttpResponseMessage> awaiter4 = base.SendAsync(result2, cancellationToken).GetAwaiter();
if (!awaiter4.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 4;
TaskAwaiter <HttpResponseMessage> taskAwaiter2 = awaiter4;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter <HttpResponseMessage>, AuthDbMessageHandler.\u003CSendAsync\u003Ed__6>(ref awaiter4, this);
return;
}
response = awaiter4.GetResult();
result1 = response;
}
catch (InvalidOperationException ex)
{
result1 = response;
}
catch (HttpRequestException ex)
{
if (!((IConnectivity)Mvx.get_IoCProvider().Resolve <IConnectivity>()).get_IsConnected())
{
throw new NoInternetConnectionException().SetErrorCode <NoInternetConnectionException>("/Users/admin/myagent/macMiniBlack3/_work/2/s/eKreta.Mobile/eKreta.Mobile.Core.Standard/Services/Handlers/AuthDbMessageHandler.cs", 99);
}
throw;
}
finally
{
if (num < 0)
{
this._semaphore.Release();
}
}
}
catch (Exception ex)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = -2;
response = (HttpResponseMessage)null;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.SetException(ex);
return;
}
label_26:
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = -2;
response = (HttpResponseMessage)null;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.SetResult(result1);
}
internal WithinCancellableCallbackTaskAwaiter(HttpContext context, TaskAwaiter innerAwaiter) {
_context = context;
_innerAwaiter = innerAwaiter;
}
public SilentAwaiter(Task <T> task)
{
_task = task;
_inner = task.GetAwaiter();
}
static void Main(string[] args)
{
//Tasks erzeugen, grundsätzlich Threads aus dem Threadpool, somit Background-Tasks
Task t1 = new Task(() => { Console.WriteLine("Hallo aus neuem Task"); });
t1.Start();
Task t2 = Task.Factory.StartNew(() => { Console.WriteLine("Hallo über Factory!"); }, TaskCreationOptions.LongRunning); //Kein Threadpool Thread
Task t3 = Task.Run(() => { Console.WriteLine("Hallo über Task.Run!"); Thread.Sleep(3000); }); // ab .NET 4.5
Console.WriteLine("Task 3 läuft!");
t3.Wait(); //Blockiert weitere Ausführung bis Task 3 beendet ist.
Console.WriteLine("Task 3 beendet!");
//Wertrückgabe
Task <string> t4 = Task.Run(() => { Console.WriteLine("Methode mit Rückgabe"); Thread.Sleep(3000); return("drei"); });
//t4.Wait(); //Bei Zugriff auf Result-Property wird auf das Beenden des Tasks gewartet! Somit ist Wait() nicht notwendig
Console.WriteLine("Ergebnis ist: " + t4.Result);
Task <int> t5 = Task.Run <int>(Berechne);
Console.WriteLine("t5 Ergebnis: " + t5.Result);
goto weiter; // nur Demonstration
//Ausnahme im Task abfangen
Task <int> t6 = Task.Run(MethodeMitException);
try
{
t6.Wait();
}catch (AggregateException ex)
{
Console.WriteLine("Fehler: " + ex.Message + "\n" + ex.GetType());
Console.WriteLine("InnerException: " + ex.InnerException.Message);
if (ex.InnerException is NullReferenceException)
{
Console.WriteLine("Erwartete Null Reference Exception");
}
}catch (Exception)
{
Console.WriteLine("Exception aufgetreten!! (nicht im Task)");
}
weiter: //Goto Sprungmarke (nur zur Demonstration!!!)
// Methoden mit Übergabeparameter in neuem Task aufrufen
Task <int> t7 = Task.Factory.StartNew(BerechneSinn, 13);
Console.WriteLine("t7: " + t7.Result);
Task <int> t8 = Task.Run(() => { return(BerechneMitIntUebergabe(100)); });
Console.WriteLine("t8: " + t8.Result);
Task t9 = Task.Run(() => MethodeMitVielenParametern(12, 2.3, "Hallo", 'c'));
//Task abbrechen
cts = new CancellationTokenSource(); //Instanz erstellen
Task t10 = Task.Factory.StartNew(SchreibeX, cts.Token);
Thread.Sleep(1500);
cts.Cancel();
//Continuations
//Nach Fertigstellung eines Task, eine weitere Aufgabe ausführen
// 1. Möglichkeit
Console.WriteLine("Starte t11");
Task <int> t11 = Task.Run(() => { Thread.Sleep(2000); return(42); });
TaskAwaiter <int> awaiter = t11.GetAwaiter();
awaiter.OnCompleted(() =>
{
int ergebnis = awaiter.GetResult();
Console.WriteLine("Ergebnis von t11: " + ergebnis);
});
Console.WriteLine("Nach Aufruf der OnCompleted-Methode.");
//2. Möglichkeit
Console.WriteLine("Starte t12");
Task <int> t12 = Task.Run(() => { Thread.Sleep(2000); return(42); });
t12.ContinueWith(vorrigerTask =>
{
int ergebnis = vorrigerTask.Result;
Console.WriteLine("Ergebnis von t12: {0}", ergebnis);
});
Console.WriteLine("Nach Aufruf der ContinueWith-Methode");
//Erzeugen eines Task aus einem Abhandlungstrangs
var tcs = new TaskCompletionSource <int>();
new Thread(() => { Thread.Sleep(2000); tcs.SetResult(42); })
{
IsBackground = true
}.Start();
Task <int> t13 = tcs.Task;
Console.WriteLine("Ergebnis von t13: " + t13.Result);
Task <int> t14 = Run <int>(() => { Thread.Sleep(1000); return(42); });
Console.WriteLine("Starten des Delays");
Task.Delay(5000).GetAwaiter().OnCompleted(() => Console.WriteLine("5 Sekunden abgelaufen!!!!"));
Console.WriteLine("Ende des Delays");
Task.Delay(1000).ContinueWith(delay => Console.WriteLine("1 Sekunde abgelaufen"));
Console.ReadLine();
}
private async Task LoadMessages()
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
int num1 = (^ this).\u003C\u003E1__state;
MessagesViewModel messagesViewModel1 = this;
IEnumerable <PostaladaElem> tempPostaladaElemek;
try
{
tempPostaladaElemek = (IEnumerable <PostaladaElem>)null;
messagesViewModel1.IsLoading = true;
TaskAwaiter <IEnumerable <PostaladaElem> > taskAwaiter;
try
{
if (messagesViewModel1.ActiveProfile == null)
{
messagesViewModel1.ActiveProfile = messagesViewModel1._profileDataService.GetActiveProfile();
}
IEnumerable <PostaladaElem> postaladaElemek = messagesViewModel1._uzenetDataService.GetPostaladaElemek(messagesViewModel1.ActiveProfile);
IOrderedEnumerable <PostaladaElem> orderedEnumerable;
if (postaladaElemek == null)
{
orderedEnumerable = (IOrderedEnumerable <PostaladaElem>)null;
}
else
{
IEnumerable <PostaladaElem> source = postaladaElemek.Where <PostaladaElem>((Func <PostaladaElem, bool>)(x => x.Uzenet != null));
orderedEnumerable = source != null?source.OrderByDescending <PostaladaElem, DateTimeOffset>((Func <PostaladaElem, DateTimeOffset>)(x => x.Uzenet.KuldesDatum)) : (IOrderedEnumerable <PostaladaElem>)null;
}
IEnumerable <PostaladaElem> postaladaElems = (IEnumerable <PostaladaElem>)orderedEnumerable;
tempPostaladaElemek = postaladaElems;
if (!messagesViewModel1.HasInternetConnection)
{
if (postaladaElems == null)
{
messagesViewModel1.ShowError();
}
}
else
{
TaskAwaiter <IEnumerable <PostaladaElem> > awaiter = messagesViewModel1._uzenetDataService.FetchPostaladaElemek(messagesViewModel1.ActiveProfile).GetAwaiter();
if (!awaiter.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num1 = 0;
taskAwaiter = awaiter;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter <IEnumerable <PostaladaElem> >, MessagesViewModel.\u003CLoadMessages\u003Ed__32>(ref awaiter, this);
return;
}
IEnumerable <PostaladaElem> result = awaiter.GetResult();
tempPostaladaElemek = (IEnumerable <PostaladaElem>)messagesViewModel1._uzenetDataService.OverridePostaladaElemek(messagesViewModel1.ActiveProfile, result).OrderByDescending <PostaladaElem, DateTimeOffset>((Func <PostaladaElem, DateTimeOffset>)(x => x.Uzenet.KuldesDatum));
messagesViewModel1._messenger.Publish <ActiveProfileChangedMessage>((M0) new ActiveProfileChangedMessage((object)messagesViewModel1, messagesViewModel1.ActiveProfile));
}
}
catch (Exception ex1)
{
IEnumerable <PostaladaElem> postaladaElemek = messagesViewModel1._uzenetDataService.GetPostaladaElemek(messagesViewModel1.ActiveProfile);
if (postaladaElemek == null)
{
messagesViewModel1.ShowError();
}
else if (!postaladaElemek.Any <PostaladaElem>())
{
try
{
TaskAwaiter <IEnumerable <PostaladaElem> > awaiter = messagesViewModel1._uzenetDataService.FetchPostaladaElemek(messagesViewModel1.ActiveProfile).GetAwaiter();
if (!awaiter.IsCompleted)
{
int num2;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num2 = 1;
taskAwaiter = awaiter;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter <IEnumerable <PostaladaElem> >, MessagesViewModel.\u003CLoadMessages\u003Ed__32>(ref awaiter, this);
return;
}
IEnumerable <PostaladaElem> result = awaiter.GetResult();
tempPostaladaElemek = (IEnumerable <PostaladaElem>)messagesViewModel1._uzenetDataService.OverridePostaladaElemek(messagesViewModel1.ActiveProfile, result).OrderByDescending <PostaladaElem, DateTimeOffset>((Func <PostaladaElem, DateTimeOffset>)(x => x.Uzenet.KuldesDatum));
messagesViewModel1._messenger.Publish <ActiveProfileChangedMessage>((M0) new ActiveProfileChangedMessage((object)messagesViewModel1, messagesViewModel1.ActiveProfile));
}
catch (Exception ex2)
{
CrossMobileAnalytics.Current.TrackException(ex2, (IDictionary <string, string>)null, nameof(LoadMessages), "/Users/admin/myagent/macMiniBlack3/_work/2/s/eKreta.Mobile/eKreta.Mobile.Core.Standard/ViewModels/MessagesViewModel.cs", 151);
}
}
else
{
messagesViewModel1.PostaladaElemek = tempPostaladaElemek;
}
CrossMobileAnalytics.Current.TrackException(ex1, (IDictionary <string, string>)null, nameof(LoadMessages), "/Users/admin/myagent/macMiniBlack3/_work/2/s/eKreta.Mobile/eKreta.Mobile.Core.Standard/ViewModels/MessagesViewModel.cs", 161);
}
MessagesViewModel messagesViewModel2 = messagesViewModel1;
IEnumerable <PostaladaElem> source1 = tempPostaladaElemek;
List <PostaladaElem> postaladaElemList = source1 != null?source1.OrderByDescending <PostaladaElem, DateTimeOffset>((Func <PostaladaElem, DateTimeOffset>)(x => x.Uzenet.KuldesDatum)).ToList <PostaladaElem>() : (List <PostaladaElem>)null;
messagesViewModel2.PostaladaElemek = (IEnumerable <PostaladaElem>)postaladaElemList;
messagesViewModel1.IsLoading = false;
}
catch (Exception ex)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = -2;
tempPostaladaElemek = (IEnumerable <PostaladaElem>)null;
// 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;
tempPostaladaElemek = (IEnumerable <PostaladaElem>)null;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.SetResult();
}
public Awaiter(TaskAwaiter awaiter)
{
this.awaiter = awaiter;
}
protected async Task <string> DownloadFile(
string relativeUri,
Profile profile,
string accessToken,
Csatolmany csatolmany)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
int num = (^ this).\u003C\u003E1__state;
string filePath;
string name;
try
{
Uri requestUri = new Uri(new Uri(ConfigurationRepository.EnvironmentSetting.EugyintezesAPIUrl ?? ""), "/integration-kretamobile-api/v1" + relativeUri);
filePath = this._dataViewer.FilePath(csatolmany.FajlNev);
HttpClient httpClient = this.BuildHttpClient(profile);
try
{
HttpRequestMessage httpMessage = new HttpRequestMessage(HttpMethod.Get, requestUri);
try
{
httpMessage.Headers.Add("Accept", "application/json");
httpMessage.Headers.Add(this._deviceSpecification.AgentName, this._userAgentData.UserAgentText);
httpMessage.Headers.Add("Authorization", string.Format("Bearer " + accessToken));
TaskAwaiter <HttpResponseMessage> awaiter1 = httpClient.SendAsync(httpMessage, HttpCompletionOption.ResponseHeadersRead).GetAwaiter();
if (!awaiter1.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 0;
TaskAwaiter <HttpResponseMessage> taskAwaiter = awaiter1;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter <HttpResponseMessage>, EugyintezesApi.\u003CDownloadFile\u003Ed__12>(ref awaiter1, this);
return;
}
HttpResponseMessage response = awaiter1.GetResult();
try
{
FileStream fs = new FileStream(filePath, FileMode.CreateNew);
try
{
TaskAwaiter awaiter2 = response.Content.CopyToAsync((Stream)fs).GetAwaiter();
if (!awaiter2.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 1;
TaskAwaiter taskAwaiter = awaiter2;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter, EugyintezesApi.\u003CDownloadFile\u003Ed__12>(ref awaiter2, this);
return;
}
awaiter2.GetResult();
name = fs.Name;
}
finally
{
if (num < 0 && fs != null)
{
fs.Dispose();
}
}
}
finally
{
if (num < 0 && response != null)
{
response.Dispose();
}
}
}
finally
{
if (num < 0 && httpMessage != null)
{
httpMessage.Dispose();
}
}
}
finally
{
if (num < 0 && httpClient != null)
{
httpClient.Dispose();
}
}
}
catch (Exception ex)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = -2;
filePath = (string)null;
// 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;
filePath = (string)null;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.SetResult(name);
}
public TaskAwaiterAdapter(TaskAwaiter <object[]> awaiter, string description) : base(description)
{
this.awaiter = awaiter;
}
// This is the state machine method itself
void IAsyncStateMachine.MoveNext() {
String result = null; // Task's result value
// Compiler-inserted try block ensures the state machine's task completes
try {
Boolean executeFinally = true; // Assume we're logically leaving the 'try' block
if (m_state == -1) { // If 1st time in state machine method,
m_local = m_argument; // execute start of original method
}
// Try block that we had in our original code
try {
TaskAwaiter<Type1> awaiterType1;
TaskAwaiter<Type2> awaiterType2;
switch (m_state) {
case -1: // Start execution of code in 'try'
// Call Method1Async and get its awaiter
awaiterType1 = Method1Async().GetAwaiter();
if (!awaiterType1.IsCompleted) {
m_state = 0; // 'Method1Async' is completing
// asynchronously
m_awaiterType1 = awaiterType1; // Save the awaiter for when we come back
// Tell awaiter to call MoveNext when operation completes
m_builder.AwaitUnsafeOnCompleted(ref awaiterType1, ref this);
// The line above invokes awaiterType1's OnCompleted which approximately
// calls ContinueWith(t => MoveNext()) on the Task being awaited.
// When the Task completes, the ContinueWith task calls MoveNext
executeFinally = false; // We're not logically leaving the 'try'
// block
return; // Thread returns to caller
}
// 'Method1Async' completed synchronously
break;
case 0: // 'Method1Async' completed asynchronously
awaiterType1 = m_awaiterType1; // Restore most-recent awaiter
break;
case 1: // 'Method2Async' completed asynchronously
awaiterType2 = m_awaiterType2; // Restore most-recent awaiter
goto ForLoopEpilog;
}
// After the first await, we capture the result & start the 'for' loop
m_resultType1 = awaiterType1.GetResult(); // Get awaiter's result
ForLoopPrologue:
m_x = 0; // 'for' loop initialization
goto ForLoopBody; // Skip to 'for' loop body
ForLoopEpilog:
m_resultType2 = awaiterType2.GetResult();
m_x++; // Increment x after each loop iteration
// Fall into the 'for' loop's body
ForLoopBody:
if (m_x < 3) { // 'for' loop test
// Call Method2Async and get its awaiter
awaiterType2 = Method2Async().GetAwaiter();
if (!awaiterType2.IsCompleted) {
m_state = 1; // 'Method2Async' is completing asynchronously
m_awaiterType2 = awaiterType2; // Save the awaiter for when we come back
// Tell awaiter to call MoveNext when operation completes
m_builder.AwaitUnsafeOnCompleted(ref awaiterType2, ref this);
executeFinally = false; // We're not logically leaving the 'try' block
return; // Thread returns to caller
}
// 'Method2Async' completed synchronously
goto ForLoopEpilog; // Completed synchronously, loop around
}
}
catch (Exception) {
Console.WriteLine("Catch");
}
finally {
// Whenever a thread physically leaves a 'try', the 'finally' executes
// We only want to execute this code when the thread logically leaves the 'try
'
if (executeFinally) {
Console.WriteLine("Finally");
}
}
result = "Done"; // What we ultimately want to return from the async function
}
catch (Exception exception) {
// Unhandled exception: complete state machine's Task with exception
m_builder.SetException(exception);
return;
}
// No exception: complete state machine's Task with result
m_builder.SetResult(result);
}
public async Task <Institute> GetInstituteAsync(Institute savedInstitute)
{
Institute downloadedInstitute;
Institute result;
try
{
downloadedInstitute = (Institute)null;
int num;
try
{
TaskAwaiter <Institute> awaiter = this.SendAsync <Institute>(HttpMethod.Get, "Institute/" + savedInstitute.InstituteId, (Dictionary <string, string>)null, false, (string)null).GetAwaiter();
if (!awaiter.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 0;
TaskAwaiter <Institute> taskAwaiter = awaiter;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter <Institute>, GlobalMobileApi.\u003CGetInstituteAsync\u003Ed__8>(ref awaiter, this);
return;
}
downloadedInstitute = awaiter.GetResult();
}
catch (KeyNotFoundException ex)
{
CrossMobileAnalytics.Current.TrackException((Exception)ex, (IDictionary <string, string>)null, nameof(GetInstituteAsync), "/Users/admin/myagent/macMiniBlack3/_work/2/s/eKreta.Mobile/eKreta.Mobile.Core.Standard/Services/GlobalMobileApi.cs", 70);
}
finally
{
if (downloadedInstitute == null || downloadedInstitute.InstituteCode != savedInstitute.InstituteCode || downloadedInstitute.InstituteId != savedInstitute.InstituteId)
{
TaskAwaiter <IEnumerable <Institute> > awaiter = this.GetInstitutesAsync().GetAwaiter();
if (!awaiter.IsCompleted)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 1;
TaskAwaiter <IEnumerable <Institute> > taskAwaiter = awaiter;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter <IEnumerable <Institute> >, GlobalMobileApi.\u003CGetInstituteAsync\u003Ed__8>(ref awaiter, this);
return;
}
downloadedInstitute = awaiter.GetResult().Where <Institute>((Func <Institute, bool>)(i => i.InstituteCode == savedInstitute.InstituteCode)).FirstOrDefault <Institute>();
}
}
result = downloadedInstitute ?? savedInstitute;
}
catch (Exception ex)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = -2;
downloadedInstitute = (Institute)null;
// 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;
downloadedInstitute = (Institute)null;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.SetResult(result);
}
internal Awaiter(TaskAwaiter <TResult> awaiter)
{
_awaiter = awaiter;
}
private async Task <TeacherHomeWorkRealm> FetchTeacherHomeWork()
{
HomeWorkDetailViewModel workDetailViewModel = this;
TeacherHomeWorkRealm teacherHomeWork;
TeacherHomeWorkRealm result;
try
{
teacherHomeWork = (TeacherHomeWorkRealm)null;
try
{
workDetailViewModel.IsOffline = false;
if (!workDetailViewModel._connectivity.get_IsConnected())
{
throw new NoInternetConnectionException().SetErrorCode <NoInternetConnectionException>("/Users/admin/myagent/macMiniBlack3/_work/2/s/eKreta.Mobile/eKreta.Mobile.Core.Standard/ViewModels/HomeWorkDetailViewModel.cs", 155);
}
if (workDetailViewModel.Lesson.TeacherHomeWorkId.HasValue)
{
TaskAwaiter <TeacherHomeWorkRealm> awaiter = workDetailViewModel._teacherHomeWorkDbDataService.FetchTeacherHomeWorkAsync(workDetailViewModel.ActiveProfileRealm, workDetailViewModel.Lesson.TeacherHomeWorkId.Value, true).GetAwaiter();
if (!awaiter.IsCompleted)
{
int num;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = num = 0;
TaskAwaiter <TeacherHomeWorkRealm> taskAwaiter = awaiter;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.AwaitUnsafeOnCompleted <TaskAwaiter <TeacherHomeWorkRealm>, HomeWorkDetailViewModel.\u003CFetchTeacherHomeWork\u003Ed__36>(ref awaiter, this);
return;
}
teacherHomeWork = awaiter.GetResult();
workDetailViewModel._teacherHomeWorkDbDataService.SaveTeacherHomeWork(workDetailViewModel.ActiveProfileRealm.RolelessId, teacherHomeWork);
}
if (teacherHomeWork == null)
{
workDetailViewModel.CreateTanarHaziFeladatFromLesson();
}
}
catch (Exception ex)
{
ex.SetErrorCode <Exception>("/Users/admin/myagent/macMiniBlack3/_work/2/s/eKreta.Mobile/eKreta.Mobile.Core.Standard/ViewModels/HomeWorkDetailViewModel.cs", 171);
switch (ex)
{
case NoInternetConnectionException _:
case ServerUnreachableException _:
workDetailViewModel.IsOffline = true;
result = workDetailViewModel._teacherHomeWorkDbDataService.GetTeacherHomeWork(workDetailViewModel.Lesson);
goto label_14;
}
}
result = teacherHomeWork;
}
catch (Exception ex)
{
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = -2;
teacherHomeWork = (TeacherHomeWorkRealm)null;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.SetException(ex);
return;
}
label_14:
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003E1__state = -2;
teacherHomeWork = (TeacherHomeWorkRealm)null;
// ISSUE: explicit reference operation
// ISSUE: reference to a compiler-generated field
(^ this).\u003C\u003Et__builder.SetResult(result);
}
// Token: 0x060004FD RID: 1277
public async void method_7(object sender, EventArgs e)
{
for (;;)
{
try
{
string a;
if (this.string_1 == null)
{
if (GClass0.string_2 != null && GClass0.string_2.Length > 5)
{
this.method_5("Authenticating license", "white");
TaskAwaiter <string> taskAwaiter = Licenser.smethod_11(GClass0.string_2, true, false).GetAwaiter();
bool isCompleted = taskAwaiter.IsCompleted;
a = taskAwaiter.GetResult();
}
else
{
this.method_5("Starting", "white");
a = "none";
}
}
else
{
a = this.string_1;
}
if (a == "valid")
{
this.method_6();
Thread.Sleep(500);
this.method_5(string.Format("Welcome back {0}", Licenser.string_0.Split(new char[]
{
'#'
})[0]), "white");
MainWindow.smethod_0(new EventHandler(this.method_3));
new MainWindow().Show();
}
else
{
if (a == "error")
{
this.method_5(string.Format("Retrying in {0} seconds", Array.Empty <object>()), "white");
Thread.Sleep(1000);
continue;
}
MainWindow.smethod_0(new EventHandler(this.method_3));
new MainWindow().Show();
}
}
catch
{
for (int i = 10; i > 0; i--)
{
this.method_5(string.Format("Retrying in {0} seconds", i), "white");
Thread.Sleep(1000);
}
continue;
}
break;
}
}
public override async Task Handle<TResult>(TaskAwaiter<TResult> effect)
{
var result = await effect.Task;
effect.SetResult(result);
await Log(result, effect);
}
public NonGenericAdapter(Task task)
{
_awaiter = task.GetAwaiter();
}
public Awaiter(TaskAwaiter<bool> taskAwaiter)
{
this._taskAwaiter = taskAwaiter;
}
public GenericAdapter(Task <T> task)
{
_awaiter = task.GetAwaiter();
}
public RecursiveLockAwaitable(Task<IDisposable> key, RecursiveAsyncLock mutex)
{
_key = key;
_awaiter = key.GetAwaiter();
_mutex = mutex;
}
void IAsyncStateMachine.MoveNext()
{
try
{
bool doFinallyBodies = true;
TaskAwaiter<int> localAwaiter;
int localLhs;
switch (state)
{
case -3:
goto Done;
case 0:
goto FirstAwaitContinuation;
case 1:
goto SecondAwaitContinuation;
}
// Default case - first call (state = -1)
y = 10;
z = Task.FromResult(10);
localAwaiter = z.GetAwaiter();
localLhs = y;
if (localAwaiter.IsCompleted)
{
goto FirstAwaitCompletion;
}
stack = localLhs;
state = 0;
awaiter = localAwaiter;
builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
doFinallyBodies = false;
return;
FirstAwaitContinuation:
localLhs = (int) stack;
stack = null;
localAwaiter = awaiter;
awaiter = default(TaskAwaiter<int>);
state = -1;
FirstAwaitCompletion:
int localRhs = localAwaiter.GetResult();
x = localLhs * localRhs;
// Second section of code...
task = Task.FromResult(20);
string localArg0 = "{0} {1}";
int localArg1 = x;
localAwaiter = task.GetAwaiter();
if (localAwaiter.IsCompleted)
{
goto SecondAwaitCompletion;
}
var localTuple = new Tuple<string, int>(localArg0, localArg1);
stack = localTuple;
state = 1;
awaiter = localAwaiter;
builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
doFinallyBodies = false;
return;
SecondAwaitContinuation:
localTuple = (Tuple<string, int>) stack;
localArg0 = localTuple.Item1;
localArg1 = localTuple.Item2;
stack = null;
localAwaiter = awaiter;
awaiter = default(TaskAwaiter<int>);
state = -1;
SecondAwaitCompletion:
int localArg2 = localAwaiter.GetResult();
Console.WriteLine(localArg0, localArg1, localArg2);
}
catch (Exception ex)
{
state = -2;
builder.SetException(ex);
return;
}
Done:
state = -2;
builder.SetResult();
}
/// <summary>
/// Submits the http put request to the specified uri.
/// </summary>
/// <param name="uri">The uri to which the put request will be issued.</param>
/// <param name="body">The HTTP content comprising the body of the request.</param>
/// <param name="allowRetry">Allow the Post to be retried after issuing a Get call. Currently used for CSRF failures.</param>
/// <returns>Task tracking the PUT completion.</returns>
#pragma warning disable 1998
private async Task <Stream> Put(
Uri uri,
IHttpContent body = null,
bool allowRetry = true)
{
IBuffer dataBuffer = null;
HttpBaseProtocolFilter httpFilter = new HttpBaseProtocolFilter();
httpFilter.AllowUI = false;
if (this.deviceConnection.Credentials != null)
{
httpFilter.ServerCredential = new PasswordCredential();
httpFilter.ServerCredential.UserName = this.deviceConnection.Credentials.UserName;
httpFilter.ServerCredential.Password = this.deviceConnection.Credentials.Password;
}
using (HttpClient client = new HttpClient(httpFilter))
{
this.ApplyHttpHeaders(client, HttpMethods.Put);
// Send the request
IAsyncOperationWithProgress <HttpResponseMessage, HttpProgress> responseOperation = client.PutAsync(uri, null);
TaskAwaiter <HttpResponseMessage> responseAwaiter = responseOperation.GetAwaiter();
while (!responseAwaiter.IsCompleted)
{
}
using (HttpResponseMessage response = responseOperation.GetResults())
{
if (!response.IsSuccessStatusCode)
{
// If this isn't a retry and it failed due to a bad CSRF
// token, issue a GET to refresh the token and then retry.
if (allowRetry && this.IsBadCsrfToken(response))
{
await this.RefreshCsrfToken();
return(await this.Put(uri, body, false));
}
throw new DevicePortalException(response);
}
this.RetrieveCsrfToken(response);
if (response.Content != null)
{
using (IHttpContent messageContent = response.Content)
{
IAsyncOperationWithProgress <IBuffer, ulong> bufferOperation = messageContent.ReadAsBufferAsync();
while (bufferOperation.Status != AsyncStatus.Completed)
{
}
dataBuffer = bufferOperation.GetResults();
}
}
}
}
return((dataBuffer != null) ? dataBuffer.AsStream() : null);
}
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);
}