private async Task <InvokeRoutineResult> RunRoutineAsync(
ITransitionCarrier transitionCarrier,
TransitionDescriptor transitionDescriptor,
CancellationToken ct)
{
var invocationResult = new InvokeRoutineResult();
using (_transitionScope.Enter(transitionDescriptor))
{
var transitionMonitor = _transitionScope.CurrentMonitor;
var serviceId = await transitionCarrier.GetServiceIdAsync(ct);
var methodId = await transitionCarrier.GetRoutineDescriptorAsync(ct);
var serviceReference = _serviceResolver.Resolve(serviceId);
var methodReference = _methodResolver.Resolve(serviceReference.Definition, methodId);
object serviceInstance = serviceReference.GetInstance();
//var serviceStateContainer = _serviceStateValueContainerProvider.CreateContainer(serviceInstance);
//var isStatefullService = serviceStateContainer.GetCount() > 0;
//if (isStatefullService)
// await transitionCarrier.ReadServiceStateAsync(serviceStateContainer, ct);
Type taskResultType =
methodReference.Definition.MethodInfo.ReturnType == typeof(void)
? TaskAccessor.VoidTaskResultType
: TaskAccessor.GetTaskResultType(methodReference.Definition.MethodInfo.ReturnType);
Task completionTask;
IValueContainer asmValueContainer = null;
if (TryCreateAsyncStateMachine(methodReference.Definition.MethodInfo, methodId.IntentId, out var asmInstance, out var asmMetadata))
{
var isContinuation = transitionDescriptor.Type == TransitionType.ContinueRoutine;
asmValueContainer = await LoadRoutineStateAsync(transitionCarrier, asmInstance, asmMetadata, isContinuation, ct);
asmMetadata.Owner.FieldInfo?.SetValue(asmInstance, serviceInstance);
transitionMonitor.OnRoutineStart(
serviceReference,
methodReference,
methodId,
serviceInstance,
asmInstance,
(transitionCarrier as TransitionCarrier)?.Caller);
try
{
asmInstance.MoveNext();
completionTask = GetCompletionTask(asmInstance, asmMetadata);
}
catch (Exception ex)
{
// The MoveNext() must not throw, but instead complete the task with an error.
// try-catch is added just in case for a non-compiler-generated state machine.
completionTask = TaskAccessor.FromException(taskResultType, ex);
}
}
private async Task RunRoutineAsync(
ITransitionCarrier transitionCarrier,
TransitionDescriptor transitionDescriptor,
CancellationToken ct)
{
using (_transitionScope.Enter(transitionDescriptor))
{
var transitionMonitor = _transitionScope.CurrentMonitor;
var serviceId = await transitionCarrier.GetServiceIdAsync(ct);
var routineDescriptor = await transitionCarrier.GetRoutineDescriptorAsync(ct);
object serviceInstance;
IServiceDefinition serviceDefinition;
#warning IntrinsicRoutines must be registered in the service registry, but it needs the engine IoC to resolve.
if (serviceId.ProxyName == nameof(IntrinsicRoutines))
{
serviceInstance = _intrinsicRoutines;
serviceDefinition = IntrinsicCommunicationModel.IntrinsicRoutinesServiceDefinition;
}
else
{
serviceInstance = _serviceProxyBuilder.Build(serviceId);
serviceDefinition = ((ServiceProxyContext)((IProxy)serviceInstance).Context).Definition;
}
var routineMethod = _routineMethodResolver.Resolve(serviceDefinition, routineDescriptor.MethodId);
//var serviceStateContainer = _serviceStateValueContainerProvider.CreateContainer(serviceInstance);
//var isStatefullService = serviceStateContainer.GetCount() > 0;
//if (isStatefullService)
// await transitionCarrier.ReadServiceStateAsync(serviceStateContainer, ct);
Task completionTask;
IValueContainer asmValueContainer = null;
if (TryCreateAsyncStateMachine(routineMethod, out var asmInstance, out var asmMetadata))
{
var isContinuation = transitionDescriptor.Type == TransitionType.ContinueRoutine;
asmValueContainer = await LoadRoutineStateAsync(transitionCarrier, asmInstance, asmMetadata, isContinuation, ct);
asmMetadata.Owner.FieldInfo?.SetValue(asmInstance, serviceInstance);
transitionMonitor.OnRoutineStart(
serviceId,
routineDescriptor,
serviceInstance,
routineMethod,
asmInstance);
try
{
#warning possibly need to create a proxy? on a sealed ASM class? How to capture Task.Delay if it's not immediate after first MoveNext?
asmInstance.MoveNext();
completionTask = GetCompletionTask(asmInstance, asmMetadata);
}
catch (Exception ex)
{
// The MoveNext() must not throw, but instead complete the task with an error.
// try-catch is added just in case for a non-compiler-generated state machine.
var taskResultType = TaskAccessor.GetTaskResultType(routineMethod.ReturnType);
completionTask = TaskAccessor.FromException(taskResultType, ex);
}
}
private async Task RunRoutineAsync(
ITransitionCarrier transitionCarrier,
ITransitionData transitionData,
TransitionDescriptor transitionDescriptor,
CancellationToken ct)
{
using (_transitionScope.Enter(transitionDescriptor))
{
var transitionMonitor = _transitionScope.CurrentMonitor;
var serviceId = await transitionData.GetServiceIdAsync(ct);
var routineDescriptor = await transitionData.GetRoutineDescriptorAsync(ct);
var serviceInstance =
#warning IntrinsicRoutines must be registered in the service registry, but it needs the engine IoC to resolve.
serviceId.ProxyName == nameof(IntrinsicRoutines)
? _intrinsicRoutines
: _serviceProxyBuilder.Build(serviceId);
#warning check if the serviceInstance proxy is an actual non-abstract class with implementation
// Need exact underlying type of the service implementation type to call
// the routine method directly without using the virtual method table.
var serviceType = (serviceInstance as IProxy)?.ObjectType ?? serviceInstance.GetType();
var routineMethod = _routineMethodResolver.Resolve(serviceType, routineDescriptor.MethodId);
var serviceStateContainer = _serviceStateValueContainerProvider.CreateContainer(serviceInstance);
var isStatefullService = serviceStateContainer.GetCount() > 0;
if (isStatefullService)
{
await transitionData.ReadServiceStateAsync(serviceStateContainer, ct);
}
Task completionTask;
IValueContainer asmValueContainer = null;
if (TryCreateAsyncStateMachine(routineMethod, out var asmInstance, out var asmMetadata, out completionTask))
{
var isContinuation = transitionDescriptor.Type == TransitionType.ContinueRoutine;
asmValueContainer = await LoadRoutineStateAsync(transitionData, asmInstance, asmMetadata, isContinuation, ct);
asmMetadata.Owner.FieldInfo?.SetValue(asmInstance, serviceInstance);
transitionMonitor.OnRoutineStart(
serviceId,
routineDescriptor,
serviceInstance,
routineMethod,
asmInstance);
try
{
#warning possibly need to create a proxy? on a sealed ASM class? How to capture Task.Delay if it's not immediate after first MoveNext?
asmInstance.MoveNext();
}
catch (Exception ex)
{
// The MoveNext() must not throw, but instead complete the task with an error.
// try-catch is added just in case for a non-compiler-generated state machine.
var taskResultType = TaskAccessor.GetTaskResultType(routineMethod.ReturnType);
completionTask = TaskAccessor.FromException(taskResultType, ex);
}
}