public async Task <TResult> ExecuteTask <TResult>(string name, string version, params object[] parameters)
{
string serializedInput = dataConverter.Serialize(parameters);
TaskActivity activity = objectManager.GetObject(name, version);
Interlocked.Increment(ref pendingExecutions);
string serializedResult = await Task.Factory.StartNew(() =>
{
try
{
string result = activity.RunAsync(null, serializedInput).Result;
return(result);
}
catch (AggregateException e)
{
e = e.Flatten();
if (e.InnerException is TaskFailureException)
{
var taskFailureException = e.InnerException as TaskFailureException;
Exception cause = Utils.RetrieveCause(taskFailureException.Details, dataConverter);
throw new TaskFailedException(0, 0, name, version, taskFailureException.Message, cause);
}
throw new TaskFailedException(0, 0, name, version, e.Message, e);
}
finally
{
Interlocked.Decrement(ref pendingExecutions);
}
});
var r = dataConverter.Deserialize <TResult>(serializedResult);
return(r);
}
async Task <T> Execute <T>(FakeOrchestrationContext context, string name, string version, object input)
{
OrchestrationInstance instance = context.OrchestrationInstance;
SynchronizationContext prevCtx = SynchronizationContext.Current;
try
{
TaskOrchestration definition = orchestrationObjectManager.GetObject(name, version);
if (definition == null)
{
throw new OrchestrationFrameworkException("Orchestration not found");
}
string serializedInput = dataConverter.Serialize(input);
Task <string> serializedResultTask = definition.Execute(context, serializedInput);
currentExecutions.Add(instance.InstanceId, definition);
string serializedResult = null;
try
{
serializedResult = await serializedResultTask;
}
catch (OrchestrationFailureException e)
{
Exception cause = Utils.RetrieveCause(e.Details, dataConverter);
var subOrchestrationFailedException = new SubOrchestrationFailedException(0, 0, name, version,
e.Message, cause);
throw subOrchestrationFailedException;
}
catch (Exception e)
{
var subOrchestrationFailedException = new SubOrchestrationFailedException(0, 0, name, version,
e.Message, e);
throw subOrchestrationFailedException;
}
return(dataConverter.Deserialize <T>(serializedResult));
}
finally
{
SynchronizationContext.SetSynchronizationContext(prevCtx);
TaskOrchestration orchestration = null;
if (currentExecutions.TryGetValue(instance.InstanceId, out orchestration))
{
currentExecutions.Remove(instance.InstanceId);
completedExecutions.Add(instance, orchestration);
}
}
}
