/// <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)); } }