/// <summary>
/// Waits for all the input tasks to complete
/// </summary>
/// <param name="tasks">IEnumerable</param>
/// <returns>Task</returns>
public static Task WhenAll(IEnumerable <Task> tasks)
{
List <Task> taskList = new List <Task>(tasks);
if (taskList.Count == 0)
{
var resultTask = new ActorCompletionTask <object>();
Runtime.SendEvent(resultTask.ActorCompletionMachine, new ActorCompletionMachine.SetResultRequest(true));
return(resultTask);
}
if (taskList[0] is ActorCompletionTask <object> )
{
foreach (var task in taskList)
{
((ActorCompletionTask <object>)task).Wait();
}
var resultTask = new ActorCompletionTask <object>();
Runtime.SendEvent(resultTask.ActorCompletionMachine, new ActorCompletionMachine.SetResultRequest(true));
return(resultTask);
}
else
{
return(Task.WhenAll(tasks));
}
}
/// <summary>
/// Waits for all the input tasks to complete
/// </summary>
/// <typeparam name="TResult">TResult</typeparam>
/// <param name="tasks">params Task<TResult>[]</param>
/// <returns>Task</returns>
public static Task <TResult[]> WhenAll <TResult>(params Task <TResult>[] tasks)
{
List <TResult> resultList = new List <TResult>();
if (tasks.Length == 0)
{
var resultTask = new ActorCompletionTask <TResult[]>();
Runtime.SendEvent(resultTask.ActorCompletionMachine, new ActorCompletionMachine.SetResultRequest(resultList.ToArray()));
return(resultTask);
}
if (tasks[0] is ActorCompletionTask <TResult> )
{
foreach (var task in tasks)
{
resultList.Add(((ActorCompletionTask <TResult>)task).Result);
}
var resultTask = new ActorCompletionTask <TResult[]>();
Runtime.SendEvent(resultTask.ActorCompletionMachine, new ActorCompletionMachine.SetResultRequest(resultList.ToArray()));
return(resultTask);
}
else
{
return(Task.WhenAll(tasks));
}
}
/// <summary>
/// Waits for one of the tasks in the input list of tasks to complete.
/// </summary>
/// <typeparam name="TResult">TResult</typeparam>
/// <param name="tasks">IEnumerable</param>
/// <returns>Task</returns>
public static Task <Task <TResult> > WhenAny <TResult>(IEnumerable <Task <TResult> > tasks)
{
List <Task <TResult> > taskList = new List <Task <TResult> >(tasks);
if (taskList.Count == 0)
{
var resultTask = new ActorCompletionTask <Task <TResult> >();
Runtime.SendEvent(resultTask.ActorCompletionMachine, new ActorCompletionMachine.SetResultRequest(
new ActorCompletionTask <TResult>()));
return(resultTask);
}
if (taskList[0] is ActorCompletionTask <TResult> )
{
foreach (var task in taskList)
{
MachineId mc = Runtime.CreateMachine(typeof(WaitMachine <TResult>), new WaitMachine <TResult> .CompleteTask(
(ActorCompletionTask <TResult>)task, Runtime.GetCurrentMachineId(), timestamp));
}
var receivedEvent = Runtime.Receive(typeof(WaitMachine <TResult> .TaskCompleted), new Func <Event, bool>(
e => ((WaitMachine <TResult> .TaskCompleted)e).Timestamp == timestamp));
timestamp++;
var resultTask = new ActorCompletionTask <Task <TResult> >();
Runtime.SendEvent(resultTask.ActorCompletionMachine, new ActorCompletionMachine.SetResultRequest(
((WaitMachine <TResult> .TaskCompleted)receivedEvent).ResultTask));
return(resultTask);
}
else
{
return(Task.WhenAny(tasks));
}
}
/// <summary>
/// Waits for all the input tasks to complete
/// </summary>
/// <typeparam name="TResult">TResult</typeparam>
/// <param name="tasks">IEnumerable</param>
/// <returns>Task</returns>
public static Task <TResult[]> WhenAll <TResult>(IEnumerable <Task <TResult> > tasks)
{
List <Task <TResult> > taskList = new List <Task <TResult> >(tasks);
List <TResult> resultList = new List <TResult>();
if (taskList.Count == 0)
{
var resultTask = new ActorCompletionTask <TResult[]>();
Runtime.SendEvent(resultTask.ActorCompletionMachine, new ActorCompletionMachine.SetResultRequest(resultList.ToArray()));
return(resultTask);
}
if (taskList[0] is ActorCompletionTask <TResult> )
{
foreach (var task in taskList)
{
resultList.Add(((ActorCompletionTask <TResult>)task).Result);
}
var resultTask = new ActorCompletionTask <TResult[]>();
Runtime.SendEvent(resultTask.ActorCompletionMachine, new ActorCompletionMachine.SetResultRequest(resultList.ToArray()));
return(resultTask);
}
else
{
Console.WriteLine("CAUGHT!!!!!!!!");
return(Task.WhenAll(tasks));
}
}
public Task <StreamSubscriptionHandle <T> > SubscribeAsync(IAsyncObserver <T> observer)
{
ActorModel.Runtime.SendEvent(StreamMachineId, new StreamMachine.Subscribe(ActorModel.Runtime.GetCurrentMachineId(), observer));
ActorCompletionTask <StreamSubscriptionHandle <T> > returnTask = new ActorCompletionTask <StreamSubscriptionHandle <T> >();
ActorModel.Runtime.SendEvent(returnTask.ActorCompletionMachine, new ActorCompletionMachine.SetResultRequest(
new StreamSubscriptionHandleImpl <T>(new StreamIdentity(StreamGuid, StreamNamespace))));
return(returnTask);
}
public Task <int> Eat(int a, int b, string s)
{
object[] parameters = new object[] { a, b, s };
ActorCompletionTask <int> task = new ActorCompletionTask <int>();
ServiceFabricModel.FabricActorMachine.ActorEvent ev = new ServiceFabricModel.
FabricActorMachine.ActorEvent(typeof(IHuman), "Eat", obj, parameters, task.ActorCompletionMachine);
ActorModel.Runtime.SendEvent(id, ev);
return(task);
}
/// <summary>
/// Returns the reminder which has the name "reminderName"
/// </summary>
/// <param name="reminderName">string</param>
/// <returns>Task<IGrainReminder></returns>
protected virtual Task <IGrainReminder> GetReminder(string reminderName)
{
var reminders = ActorModel.GetReminders(ActorModel.Runtime.GetCurrentMachineId());
var reminder = reminders.SingleOrDefault(val => ((GrainReminder)val).ReminderName.Equals(reminderName));
var task = new ActorCompletionTask <IGrainReminder>();
var actorCompletionMachine = task.ActorCompletionMachine;
ActorModel.Runtime.SendEvent(actorCompletionMachine,
new ActorCompletionMachine.SetResultRequest(reminder));
return(task);
}
/// <summary>
/// Returns all the reminders of this grain
/// </summary>
/// <returns>Task<List<IGrainReminder>></returns>
protected virtual Task <List <IGrainReminder> > GetReminders()
{
var reminders = new List <IGrainReminder>();
foreach (var reminder in ActorModel.GetReminders(ActorModel.Runtime.GetCurrentMachineId()))
{
reminders.Add(reminder as IGrainReminder);
}
var task = new ActorCompletionTask <List <IGrainReminder> >();
var actorCompletionMachine = task.ActorCompletionMachine;
ActorModel.Runtime.SendEvent(actorCompletionMachine,
new ActorCompletionMachine.SetResultRequest(reminders));
return(task);
}
/// <summary>
/// Unregisters a reminder.
/// </summary>
/// <param name="reminder">IGrainReminder</param>
/// <returns>Task</returns>
protected virtual Task UnregisterReminder(IGrainReminder reminder)
{
var reminders = ActorModel.GetReminders(ActorModel.Runtime.GetCurrentMachineId());
var reminderToBeRemoved = reminders.SingleOrDefault(val
=> ((GrainReminder)val).ReminderName.Equals(reminder.ReminderName));
if (reminderToBeRemoved != null)
{
reminderToBeRemoved.Dispose();
}
var task = new ActorCompletionTask <object>();
var actorCompletionMachine = task.ActorCompletionMachine;
ActorModel.Runtime.SendEvent(actorCompletionMachine,
new ActorCompletionMachine.SetResultRequest(true));
return(task);
}
/// <summary>
/// Unregisters the specified reminder.
/// </summary>
/// <param name="reminder">IActorReminder</param>
/// <returns>Task</returns>
protected Task UnregisterReminderAsync(IActorReminder reminder)
{
ActorModel.Assert(reminder != null, "Cannot unregister a 'null' reminder.");
var reminders = ActorModel.GetReminders(ActorModel.Runtime.GetCurrentMachineId());
var reminderToBeRemoved = reminders.SingleOrDefault(val
=> ((ActorReminder)val).Name.Equals(reminder.Name));
if (reminderToBeRemoved != null)
{
reminderToBeRemoved.Dispose();
}
var task = new ActorCompletionTask <object>();
var actorCompletionMachine = task.ActorCompletionMachine;
ActorModel.Runtime.SendEvent(actorCompletionMachine,
new ActorCompletionMachine.SetResultRequest(true));
return(task);
}
/// <summary>
/// Registers the specified reminder.
/// </summary>
/// <param name="reminderName">Name of the reminder to register</param>
/// <param name="state">State associated with reminder</param>
/// <param name="dueTime">TimeSpan when actor timer is first due</param>
/// <param name="period">TimeSpan for subsequent actor timer invocation</param>
/// <returns>IActorReminder</returns>
protected Task <IActorReminder> RegisterReminderAsync(string reminderName, byte[] state, TimeSpan dueTime, TimeSpan period)
{
var reminders = ActorModel.GetReminders(ActorModel.Runtime.GetCurrentMachineId());
var reminder = reminders.SingleOrDefault(val => ((ActorReminder)val).Name.Equals(reminderName));
var task = new ActorCompletionTask <IActorReminder>();
var actorCompletionMachine = task.ActorCompletionMachine;
if (reminder != null)
{
ActorModel.Runtime.SendEvent(actorCompletionMachine,
new ActorCompletionMachine.SetResultRequest(reminder));
}
else
{
ActorModel.Runtime.CreateMachine(typeof(ActorReminderMachine), reminderName,
new ReminderMachine.InitEvent(ActorModel.Runtime.GetCurrentMachineId(),
actorCompletionMachine, reminderName, null));
}
return(task);
}
/// <summary>
/// Waits for all the input tasks to complete
/// </summary>
/// <param name="tasks">Task[]</param>
/// <returns>Task</returns>
public static Task WhenAll(params Task[] tasks)
{
if (tasks.Length == 0)
{
var resultTask = new ActorCompletionTask <object>();
Runtime.SendEvent(resultTask.ActorCompletionMachine, new ActorCompletionMachine.SetResultRequest(true));
return(resultTask);
}
if (tasks[0] is ActorCompletionTask <object> )
{
foreach (var task in tasks)
{
((ActorCompletionTask <object>)task).Wait();
}
var resultTask = new ActorCompletionTask <object>();
Runtime.SendEvent(resultTask.ActorCompletionMachine, new ActorCompletionMachine.SetResultRequest(true));
return(resultTask);
}
else
{
return(Task.WhenAll(tasks));
}
}
