/// <summary>Invokes MoveNext under the provided context.</summary>
internal void Run()
{
if (m_context != null)
{
try
{
// Get the callback, lazily initializing it as necessary
Action <object> callback = s_invokeMoveNext;
if (callback == null)
{
s_invokeMoveNext = callback = InvokeMoveNext;
}
if (m_context == null)
{
callback(m_stateMachine);
}
else
{
// Use the context and callback to invoke m_stateMachine.MoveNext.
ExecutionContextLightup.Instance.Run(m_context, callback, m_stateMachine);
}
}
finally { if (m_context != null)
{
m_context.Dispose();
}
}
}
else
{
m_stateMachine.MoveNext();
}
}
internal void Run()
{
Contract.Assert(m_stateMachine != null, "The state machine must have been set before calling Run.");
if (m_context != null)
{
try
{
// Get the callback, lazily initializing it as necessary
ContextCallback callback = s_invokeMoveNext;
if (callback == null)
{
s_invokeMoveNext = callback = InvokeMoveNext;
}
// Use the context and callback to invoke m_stateMachine.MoveNext.
ExecutionContext.Run(m_context, callback, m_stateMachine);
}
finally { m_context.Dispose(); }
}
else
{
m_stateMachine.MoveNext();
}
}
internal void Run()
{
if (m_context != null)
{
try
{
Action <object> action = s_invokeMoveNext;
if (action == null)
{
action = (s_invokeMoveNext = new Action <object>(InvokeMoveNext));
}
if (m_context == null)
{
action.Invoke(m_stateMachine);
}
else
{
ExecutionContextLightup.Instance.Run(m_context, action, m_stateMachine);
}
return;
}
finally
{
if (m_context != null)
{
m_context.Dispose();
}
}
}
m_stateMachine.MoveNext();
}
/// <summary>Invokes <see cref="IAsyncStateMachine.MoveNext"/> under the provided context.</summary>
internal void Run()
{
if (_context != null)
{
try
{
Action <object> action = _invokeMoveNext;
if (action == null)
{
action = (_invokeMoveNext = InvokeMoveNext);
}
if (_context == null)
{
action.Invoke(_stateMachine);
}
else
{
ExecutionContext.Run(_context, x => action(x), _stateMachine);
}
return;
}
finally
{
}
}
_stateMachine.MoveNext();
}
public static void ContinueWith(this IAwaitable self, IAsyncStateMachine state)
{
if (self.Status == WaitableStatus.Running)
{
state.MoveNext();
}
}
internal void Start(IAsyncStateMachine stateMachine)
{
if (stateMachine == null)
{
throw new ArgumentNullException("stateMachine");
}
stateMachine.MoveNext();
}
public static Action GetActionForState(this IAsyncStateMachine stateMachine, int state)
{
return(() =>
{
stateMachine.SetState(state);
stateMachine.MoveNext();
});
}
public static void UnsafeContinueWith(this IAwaitable self, IAsyncStateMachine state)
{
self.Container.Manager.Enqueue(() =>
{
if (self.Status == WaitableStatus.Running)
{
state.MoveNext();
}
});
}
public void Run()
{
if (!scope.IsUnavailable)
{
machine.MoveNext();
}
else
{
scope.OnCompleted(Run);
}
}
public Task <bool> MoveNext(CancellationToken cancel)
{
_current = new TaskCompletionSource <T>();
_currentSm = clone(this);
_currentSm.MoveNext();
var tcs = new TaskCompletionSource <bool>();
_current.Task.ContinueWith(_ =>
{
tcs.SetResult(true);
});
return(tcs.Task);
}
/// <summary>Invokes <see cref="IAsyncStateMachine.MoveNext"/> under the provided context.</summary>
internal void Run()
{
if (_context != null)
{
try
{
Action <object> action = _invokeMoveNext;
if (action == null)
{
action = (_invokeMoveNext = InvokeMoveNext);
}
if (_context == null)
{
action.Invoke(_stateMachine);
}
else
{
var sync = SynchronizationContext.Current;
ExecutionContext.Run(_context,
x =>
{
if (sync == null)
{
var prevContext = SynchronizationContext.Current;
try
{
SynchronizationContext.SetSynchronizationContext(null);
action(x);
}
finally
{
SynchronizationContext.SetSynchronizationContext(prevContext);
}
}
else
{
sync.Post(y => action(y), x);
}
}, _stateMachine);
}
return;
}
finally
{
}
}
_stateMachine.MoveNext();
}
internal void Run()
{
if (_context == null)
{
StateMachine.MoveNext();
return;
}
var callback = _invokeMoveNext;
if (callback == null)
{
_invokeMoveNext = callback = InvokeMoveNext;
}
ExecutionContext.Run(_context, callback, StateMachine);
}
internal void Run()
{
if (m_context == null)
{
m_stateMachine.MoveNext();
return;
}
try
{
var callback = s_invokeMoveNext;
if (callback == null)
{
s_invokeMoveNext = callback = InvokeMoveNext;
}
ExecutionContext.Run(m_context, callback, m_stateMachine);
}
finally
{
// m_context.Dispose();
}
}
/// <summary>Invokes <see cref="IAsyncStateMachine.MoveNext"/> under the provided context.</summary>
internal void Run()
{
Debug.Assert(_stateMachine != null, "The state machine must have been set before calling Run.");
if (_context != null)
{
try
{
// Get the callback, lazily initializing it as necessary
Action<object> callback = _invokeMoveNext;
if (callback == null)
{
_invokeMoveNext = callback = InvokeMoveNext;
}
if (_context == null)
{
callback(_stateMachine);
}
else
{
// Use the context and callback to invoke _stateMachine.MoveNext.
ExecutionContextLightup.Instance.Run(_context, callback, _stateMachine);
}
}
finally
{
if (_context != null)
_context.Dispose();
}
}
else
{
_stateMachine.MoveNext();
}
}
internal void Run()
{
if (context == null)
{
StateMachine.MoveNext();
return;
}
try
{
var callback = invokeMoveNext;
if (callback == null)
{
invokeMoveNext = callback = InvokeMoveNext;
}
ExecutionContext.Run(context, callback, StateMachine);
}
finally
{
#if !NET35
context.Dispose();
#endif
}
}
public void Start(IAsyncStateMachine stateMachine)
{
stateMachine.MoveNext();
}
public void MoveNextSafe()
{
Console.WriteLine("In MoveNextSafe");
ExecutionContext.Run(_context, state => _stateMachine.MoveNext(), null);
}
private void AwaitOnCompleted(INotifyCompletion awaiter, IAsyncStateMachine stateMachine)
{
awaiter.OnCompleted(() => stateMachine.MoveNext());
}
public void Run()
{
StateMachine.MoveNext();
}
public void Start <TStateMachine>(ref TStateMachine stateMachine)
where TStateMachine : IAsyncStateMachine
{
StateMachine = stateMachine; //box state machine straight away
StateMachine.MoveNext();
}
public void Start <TStateMachine>(ref TStateMachine stateMachine)
where TStateMachine : IAsyncStateMachine
{
StateMachine = stateMachine; //box immediately
StateMachine.MoveNext();
}
public void Start(ref IAsyncStateMachine stateMachine)
{
// do the first bit of work syncronously
stateMachine.MoveNext();
}
