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;
}
