public override async Task <string> RunTask(OrchestrationContext context, int input)
{
IUserTasks userTasks = context.CreateClient <IUserTasks>();
await context.CreateTimer <object>(context.CurrentUtcDateTime.Add(TimeSpan.FromSeconds(input)), null);
return(await userTasks.GreetUserAsync("Gabbar"));
}
public override async Task <int> RunTask(OrchestrationContext context, RecurringOrchestrationInput input)
{
var testTasks = context.CreateClient <ITestTasks>();
if (targetOchestrationInvocationsCount == 0)
{
// First time, Reset Generation Count variable.
await testTasks.ResetGenerationCounter();
}
int result = await context.CreateSubOrchestrationInstance <int>(input.TargetOrchestrationType,
GetTargetOrchestrationVersion(),
input.TargetOrchestrationInstanceId,
input.TargetOrchestrationInput);
await context.CreateTimer(GetNextExecutionTime(context), true, CancellationToken.None);
if (ShouldRepeatTargetOrchestration())
{
context.ContinueAsNew(input);
}
else
{
// Finally, Reset Generation Count variable.
await testTasks.ResetGenerationCounter();
}
return(result);
}
public override async Task <string> RunTask(OrchestrationContext context, UtilitySignupOrchestrationInput input)
{
this.activityClient = context.CreateClient <IUtilitySignupActivities>();
bool[] results = null;
try
{
// start three tasks in parallel and wait for all of them to finish
results = await Task.WhenAll <bool>(
PerformAddressCheckAsync(input.Checks, input.Address),
PerformCreditCheckAsync(input.Name, input.NumberOfCreditAgencies),
PerformBankAccountCheckAsync(input.Checks, input.AccountNumber));
this.status.AppendStatus("All Checks Completed.");
}
catch
{
// Error handling if any of the tasks throws an exception.
// Just append it to instance status and rethrow to cause the orchestration instance to fail.
this.status.AppendStatus("Checks Failed.");
throw;
}
string customerId = "Rejected";
if (results != null && results.All(r => r))
{
// Check to see if all checks succeeded for the customer and then signup user for utility service
customerId = await this.activityClient.SignupCustomer(
input.Name, input.AccountNumber, input.Address, this.requiresManagerApproval);
}
return(customerId);
}
public override async Task <TResult> RunTask(OrchestrationContext context, TInput input)
{
var expiration = GetExpirationTime(input);
while (!IsCompleted(input))
{
if (expiration + MaximumClockSkew <= context.CurrentUtcDateTime)
{
return(GetTimeoutResult(input));
}
TimeSpan refreshInterval = GetRefreshInterval(input);
if (refreshInterval == TimeSpan.Zero)
{
refreshInterval = DefaulfReshInterval;
}
await context.CreateTimer <object>(context.CurrentUtcDateTime.Add(refreshInterval), null);
var activities = context.CreateClient <TActivities>();
input = await this.RefreshInput(activities, input);
}
return(GetResult(input));
}
public override async Task <int> RunTask(OrchestrationContext context, string input)
{
var testTasks = context.CreateClient <ITestTasks>();
int count = await testTasks.IncrementGenerationCount();
return(count);
}
public override async Task <string> RunTask(OrchestrationContext context, string input)
{
IUserTasks userTasks = context.CreateClient <IUserTasks>();
string user = await userTasks.GetUserAsync();
string greeting = await userTasks.GreetUserAsync(user);
return(greeting);
}
public override async Task <string> RunTask(OrchestrationContext context, string input)
{
IUserTasks userTasks = context.CreateClient <IUserTasks>();
var subOrch1 = context.CreateSubOrchestrationInstance <string>(typeof(SimpleOrchestrationWithTasks), input);
var subOrch2 = context.CreateSubOrchestrationInstance <string>(typeof(SimpleOrchestrationWithTasks), input);
var myTask = userTasks.GreetUserAsync("World");
await Task.WhenAll(subOrch1, subOrch2, myTask);
return($"TaskResult = {myTask.Result} , SubOrchestration1Result = {subOrch1.Result}, SubOrchestration2Result = {subOrch2.Result}");
}
public override async Task <string> RunTask(OrchestrationContext context, MoreParamsOrchestrationInput input)
{
var activitiesClient = context.CreateClient <IMoreParamsActivitiesClient>();
string a1 = await activitiesClient.Activity1(input.Str);
string a2 = await activitiesClient.Activity2(input.Str);
Result = a1 + a2;
return(Result);
}
public override async Task <string> RunTask(OrchestrationContext context, string input)
{
var client = context.CreateClient <IGreetings>(true);
var client2 = context.CreateClient <IGreetings2>(true);
string user = await client.GetUserAsync(input);
string greeting = await client.SendGreetingAsync(user);
string user2 = await client2.GetUserAsync(input);
string greeting2 = await client2.SendGreetingAsync(user2);
await client2.SendGreetingsAgainAsync(user2);
// This is a HACK to get unit test up and running. Should never be done in actual code.
Result = greeting;
Result2 = greeting2;
return(greeting);
}
public override async Task <string> RunTask(OrchestrationContext context, string input)
{
var client = context.CreateClient <GreetingsClient>();
string user = await client.GetUser();
string greeting = await client.SendGreeting(user);
// This is a HACK to get unit test up and running. Should never be done in actual code.
Result = greeting;
return(greeting);
}
public override async Task <int> RunTask(OrchestrationContext context, int numberOfGenerations)
{
var testTasks = context.CreateClient <ITestTasks>();
int count = await testTasks.IncrementGenerationCount();
numberOfGenerations--;
if (numberOfGenerations > 0)
{
context.ContinueAsNew(numberOfGenerations);
}
// This is a HACK to get unit test up and running. Should never be done in actual code.
Result = count;
return(count);
}
public override async Task <TResult> RunTask(OrchestrationContext context, TInput input)
{
var activities = context.CreateClient <TActivity>();
var intermediates = await FanOut(input, activities);
List <Task <TIntermediateOut> > intermediateTasks = new List <Task <TIntermediateOut> >();
foreach (var intermediate in intermediates)
{
intermediateTasks.Add(ExecuteSubTasks(intermediate, activities));
}
var intermediateResults = await Task.WhenAll(intermediateTasks);
return(Aggregate(intermediateResults));
}
public override async Task <double> RunTask(OrchestrationContext context, int[] input)
{
if (input == null || input.Length != 3)
{
throw new ArgumentException("input");
}
int start = input[0];
int end = input[1];
int step = input[2];
int total = end - start + 1;
var chunks = new List <Task <int> >();
int current;
while (start < end)
{
current = start + step - 1;
if (current > end)
{
current = end;
}
var client = context.CreateClient <AverageCalculatorClient>();
Task <int> chunk = client.ComputeSum(new[] { start, current });
chunks.Add(chunk);
start = current + 1;
}
int sum = 0;
int[] allChunks = await Task.WhenAll(chunks.ToArray());
foreach (int result in allChunks)
{
sum += result;
}
double r = sum / total;
Result = r;
return(r);
}
public override async Task <string> RunTask(OrchestrationContext context, GenericInterfaceOrchestrationInput input)
{
IGenericMethodInterface client = context.CreateClient <IGenericMethodInterface>();
IGenericMethodInterface retryableClient = context.CreateRetryableClient <IGenericMethodInterface>(new RetryOptions(TimeSpan.FromMilliseconds(1), 1));
Dictionary <int, List <string> > a = await client.GetWhenTIsInput <string>(input.Property.ToString(), new[] { "test" }, new List <string>());
Assert.IsNotNull(a);
Assert.AreEqual(2, a[1].Count);
GenericInterfaceOrchestrationInput[] c = await retryableClient.GetWhenMultipleGenericTypes <double, GenericInterfaceOrchestrationInput>(input.Property, input);
Assert.IsNotNull(c);
Assert.AreEqual(1, c.Length);
GenericInterfaceOrchestrationInput b = await client.GetWhenNoParams <GenericInterfaceOrchestrationInput>();
Assert.IsNull(b);
return(string.Empty);
}
public override async Task <string> RunTask(OrchestrationContext context, string value)
{
var client = context.CreateClient <IFailureClient>(false);
IEnumerable <string>[] completedTasks;
try
{
Task <IEnumerable <string> > t1 = client.GetValues(false);
// This is the task that gets thrown as a unhandled task exception when it gets created during replay (aka context.isReplaying = true)
Task <IEnumerable <string> > t2 = client.GetValues(true);
completedTasks = await Task.WhenAll(t1, t2);
}
catch (Exception ex)
{
return(ex.Message);
}
IEnumerable <string> allResults = completedTasks.SelectMany(t => t);
return(string.Join(",", allResults));
}
/// <inheritdoc/>
public override T CreateClient <T>()
{
PreUpdateProperties();
return(Wrap(_innerContext.CreateClient <T>()));
}
protected void Initialize(OrchestrationContext context)
{
this._activityProxy = context.CreateClient <IActivityFunction>(true);
}
public override async Task <string> RunTask(OrchestrationContext context,
PrimitiveTypeOrchestrationInput input)
{
var activitiesClient = context.CreateClient <IPrimitiveTypeActivitiesClient>();
Byte =
await
activitiesClient.ReturnByte(input.Byte, input.SByte, input.Integer, input.UInteger, input.Short,
input.UShort, input.Long, input.ULong, input.Float, input.Double, input.Char, input.Bool,
input.Str, input.Decimal);
SByte =
await
activitiesClient.ReturnSByte(input.Byte, input.SByte, input.Integer, input.UInteger, input.Short,
input.UShort, input.Long, input.ULong, input.Float, input.Double, input.Char, input.Bool,
input.Str, input.Decimal);
Integer =
await
activitiesClient.ReturnInteger(input.Byte, input.SByte, input.Integer, input.UInteger,
input.Short, input.UShort, input.Long, input.ULong, input.Float, input.Double, input.Char,
input.Bool, input.Str, input.Decimal);
UInteger =
await
activitiesClient.ReturnUInteger(input.Byte, input.SByte, input.Integer, input.UInteger,
input.Short, input.UShort, input.Long, input.ULong, input.Float, input.Double, input.Char,
input.Bool, input.Str, input.Decimal);
Short =
await
activitiesClient.ReturnShort(input.Byte, input.SByte, input.Integer, input.UInteger, input.Short,
input.UShort, input.Long, input.ULong, input.Float, input.Double, input.Char, input.Bool,
input.Str, input.Decimal);
UShort =
await
activitiesClient.ReturnUShort(input.Byte, input.SByte, input.Integer, input.UInteger,
input.Short, input.UShort, input.Long, input.ULong, input.Float, input.Double, input.Char,
input.Bool, input.Str, input.Decimal);
Long =
await
activitiesClient.ReturnLong(input.Byte, input.SByte, input.Integer, input.UInteger, input.Short,
input.UShort, input.Long, input.ULong, input.Float, input.Double, input.Char, input.Bool,
input.Str, input.Decimal);
ULong =
await
activitiesClient.ReturnULong(input.Byte, input.SByte, input.Integer, input.UInteger, input.Short,
input.UShort, input.Long, input.ULong, input.Float, input.Double, input.Char, input.Bool,
input.Str, input.Decimal);
Float =
await
activitiesClient.ReturnFloat(input.Byte, input.SByte, input.Integer, input.UInteger, input.Short,
input.UShort, input.Long, input.ULong, input.Float, input.Double, input.Char, input.Bool,
input.Str, input.Decimal);
Double =
await
activitiesClient.ReturnDouble(input.Byte, input.SByte, input.Integer, input.UInteger,
input.Short, input.UShort, input.Long, input.ULong, input.Float, input.Double, input.Char,
input.Bool, input.Str, input.Decimal);
Char =
await
activitiesClient.ReturnChar(input.Byte, input.SByte, input.Integer, input.UInteger, input.Short,
input.UShort, input.Long, input.ULong, input.Float, input.Double, input.Char, input.Bool,
input.Str, input.Decimal);
Bool =
await
activitiesClient.ReturnBool(input.Byte, input.SByte, input.Integer, input.UInteger, input.Short,
input.UShort, input.Long, input.ULong, input.Float, input.Double, input.Char, input.Bool,
input.Str, input.Decimal);
Str =
await
activitiesClient.ReturnString(input.Byte, input.SByte, input.Integer, input.UInteger,
input.Short, input.UShort, input.Long, input.ULong, input.Float, input.Double, input.Char,
input.Bool, input.Str, input.Decimal);
Decimal =
await
activitiesClient.ReturnDecimal(input.Byte, input.SByte, input.Integer, input.UInteger,
input.Short, input.UShort, input.Long, input.ULong, input.Float, input.Double, input.Char,
input.Bool, input.Str, input.Decimal);
DateTime = await activitiesClient.ReturnDateTime(input.DateTime);
TimeSpan = await activitiesClient.ReturnTimeSpan(input.TimeSpan);
MyEnum = await activitiesClient.ReturnEnum(input.Enum);
ByteArray = await activitiesClient.ReturnByteArray(new[] { input.Byte, input.Byte });
SByteArray = await activitiesClient.ReturnSByteArray(new[] { input.SByte, input.SByte });
IntegerArray = await activitiesClient.ReturnIntegerArray(new[] { input.Integer, input.Integer });
UIntegerArray = await activitiesClient.ReturnUIntegerArray(new[] { input.UInteger, input.UInteger });
ShortArray = await activitiesClient.ReturnShortArray(new[] { input.Short, input.Short });
UShortArray = await activitiesClient.ReturnUShortArray(new[] { input.UShort, input.UShort });
LongArray = await activitiesClient.ReturnLongArray(new[] { input.Long, input.Long });
ULongArray = await activitiesClient.ReturnULongArray(new[] { input.ULong, input.ULong });
FloatArray = await activitiesClient.ReturnFloatArray(new[] { input.Float, input.Float });
DoubleArray = await activitiesClient.ReturnDoubleArray(new[] { input.Double, input.Double });
CharArray = await activitiesClient.ReturnCharArray(new[] { input.Char, input.Char });
BoolArray = await activitiesClient.ReturnBoolArray(new[] { input.Bool, input.Bool });
StrArray = await activitiesClient.ReturnStrArray(new[] { input.Str, input.Str });
DecimalArray = await activitiesClient.ReturnDecimalArray(new[] { input.Decimal, input.Decimal });
DateTimeArray = await activitiesClient.ReturnDateTimeArray(new[] { input.DateTime, input.DateTime });
TimeSpanArray = await activitiesClient.ReturnTimeSpanArray(new[] { input.TimeSpan, input.TimeSpan });
MyEnumArray = await activitiesClient.ReturnEnumArray(new[] { input.Enum, input.Enum });
return("Done");
}
