/// <summary>
/// Captures a completed Eff awaiter instance into a serialized PersistedEffect value.
/// </summary>
public static PersistedEffect FromCompletedAwaiter <TResult>(EffAwaiter <TResult> awaiter)
{
if (!awaiter.IsCompleted)
{
throw new ArgumentException("EffAwaiter is not in completed state.", nameof(awaiter));
}
bool isException;
string value;
if (awaiter.Exception is Exception e)
{
isException = true;
value = JsonConvert.SerializeObject(e);
}
else
{
isException = false;
value = JsonConvert.SerializeObject(awaiter.Result);
}
return(new PersistedEffect()
{
IsException = isException, Value = value
});
}
public async Task Log(Exception ex, EffAwaiter awaiter)
{
var stateMachine = awaiter.AwaitingStateMachine?.GetAsyncStateMachine();
if (stateMachine is null)
{
return;
}
var log =
new ExceptionLog
{
CallerFilePath = awaiter.CallerFilePath,
CallerLineNumber = awaiter.CallerLineNumber,
CallerMemberName = awaiter.CallerMemberName,
Exception = ex,
Parameters = stateMachine.GetParameterValues(),
LocalVariables = stateMachine.GetLocalVariableValues(),
};
if (!ex.Data.Contains("StackTraceLog"))
{
var queue = new Queue <ExceptionLog>();
queue.Enqueue(log);
ex.Data["StackTraceLog"] = queue;
return;
}
((Queue <ExceptionLog>)ex.Data["StackTraceLog"] !).Enqueue(log);
}
public async override Task Handle <TValue>(EffAwaiter <TValue> awaiter)
{
var result = MaybeEffectHandler.Run(awaiter.Eff);
if (result.HasValue)
{
awaiter.SetResult(result.Value);
var next = _continuation.MoveNext();
Result = MaybeEffectHandler.Run(next);
}
}
public void ToAwaiter <TResult>(EffAwaiter <TResult> awaiter)
{
if (Exception is Exception e)
{
awaiter.SetException(e);
}
else
{
awaiter.SetResult((TResult)Value !);
}
}
public static RecordedResult FromAwaiter <TResult>(EffAwaiter <TResult> awaiter)
{
return((awaiter.Exception is Exception e) ?
new RecordedResult()
{
Exception = e
} :
new RecordedResult()
{
Value = awaiter.Result
});
}
public override async Task Handle <TResult>(EffAwaiter <TResult> effect)
{
try
{
var result = await effect.Eff.Run(this);
effect.SetResult(result);
}
catch (Exception ex)
{
await Log(ex, effect);
throw;
}
}
///<summary>
/// Hydrates an incomplete awaiter instance with the persisted result.
///</summary>
public void WriteToAwaiter <TResult>(EffAwaiter <TResult> awaiter)
{
if (awaiter.IsCompleted)
{
throw new ArgumentException("EffAwaiter is in completed state.", nameof(awaiter));
}
if (IsException)
{
var exn = JsonConvert.DeserializeObject <Exception>(Value);
awaiter.SetException(exn);
}
else
{
var value = JsonConvert.DeserializeObject <TResult>(Value);
awaiter.SetResult(value !);
}
}
public void Log(object?result, EffAwaiter awaiter)
{
var stateMachine = awaiter.AwaitingStateMachine?.GetAsyncStateMachine();
if (stateMachine is null)
{
return;
}
var log = new ResultLog
{
Result = result,
CallerFilePath = awaiter.CallerFilePath,
CallerLineNumber = awaiter.CallerLineNumber,
CallerMemberName = awaiter.CallerMemberName,
Parameters = stateMachine.GetParameterValues(),
LocalVariables = stateMachine.GetLocalVariableValues(),
};
TraceLogs.Add(log);
}
public override async Task Handle<TResult>(EffAwaiter<TResult> effect)
{
var result = await effect.Eff.Run(this);
effect.SetResult(result);
await Log(result, effect);
}
