public async Task Handle <TValue>(EffStateMachine <TValue> stateMachine) { List <TValue>?values = null; Exception? error = null; try { values = await NonDetEffectHandler.Run(stateMachine); } catch (Exception e) { error = e; } if (values != null) { foreach (var result in values) { stateMachine.SetResult(result); await ContinueStateMachine(clone : true); } } else { stateMachine.SetException(error !); await ContinueStateMachine(); } }
private static async Task <List <TResult> > Run <TResult>(EffStateMachine <TResult> stateMachine) { while (true) { stateMachine.MoveNext(); switch (stateMachine.Position) { case StateMachinePosition.Result: return(new List <TResult> { stateMachine.Result }); case StateMachinePosition.Exception: throw stateMachine.Exception !; case StateMachinePosition.TaskAwaiter: await stateMachine.TaskAwaiter !.Value; break; case StateMachinePosition.EffAwaiter: var awaiter = stateMachine.EffAwaiter !; var handler = new NonDetEffectHandlerImpl <TResult>(stateMachine); await awaiter.Accept(handler); return(handler.Results); default: throw new Exception($"Invalid state machine position {stateMachine.Position}."); } } }
/// <summary> /// Sets a Eff state machine instance. For use by the generated state machine. /// </summary> public void SetStateMachine(IAsyncStateMachine stateMachine) { // hijacks the IAsyncStateMachine.SetStateMachine mechanism // in order to pass the eff state machine instance to the builder // only used when evaluating async methods from release builds. _effStateMachine = (EffStateMachine <Unit>)stateMachine; }
void IEffMethodBuilder <TResult> .SetStateMachine(EffStateMachine <TResult> stateMachine) { // hijacks the IAsyncStateMachine.SetStateMachine mechanism, // in order to pass the state machine instance to the builder. // Only used when evaluating async methods from release builds. _effStateMachine = stateMachine; }
public override async Task Handle <TResult>(EffStateMachine <TResult> stateMachine) { await base.Handle(stateMachine); if (stateMachine.Exception is Exception ex) { await Log(ex, stateMachine); } }
public async Task Handle <TValue>(EffStateMachine <TValue> stateMachine) { var result = await MaybeEffectHandler.Run(stateMachine); if (result.HasValue) { await ContinueStateMachine(); } }
public override async ValueTask Handle <TResult>(EffStateMachine <TResult> stateMachine) { await base.Handle(stateMachine); if (stateMachine.HasResult) { Log(stateMachine.Result, stateMachine); } }
public override Task Handle <TResult>(EffStateMachine <TResult> stateMachine) { Token.ThrowIfCancellationRequested(); return(base.Handle(stateMachine)); }
public NonDetEffectHandlerImpl(EffStateMachine <TResult> stateMachine) { _stateMachine = stateMachine; }
public ResumableEffectHandler(Eff suspendableWorkflow) { _stateMachine = Eff.FromUntypedEff(suspendableWorkflow).GetStateMachine(); }
public MaybeEffectHandlerImpl(EffStateMachine <TResult> stateMachine) { _stateMachine = stateMachine; }
void IEffMethodBuilder <Unit> .SetStateMachine(EffStateMachine <Unit> stateMachine) { _effStateMachine = stateMachine; }
public void SetStateMachine(IAsyncStateMachine stateMachine) { _effStateMachine = (EffStateMachine <TResult>)stateMachine; }