/// <summary> Checks a given condition whenever the given other actor changes state; if /// the condition passes, a given action is invoked, but all of this only while in the /// current state (or given super-state). </summary> /// <remarks> If the condition is already met, the callback is invoked immediately (but not in this call) with null transition information. </remarks> protected void WatchOtherWhileInState <OA, OS, OT>(IStatefulActor <OA, OS, OT> other, WatchOtherCondition <OS, OT> condition, Action action, TState?whileIn = null) where OS : struct { var inState = whileIn ?? State; if (InState(inState)) { void changedHandler(OS oldState, StateMachine <OS, OT> .Transition transition) { Act(() => { if (InState(inState) && condition(transition.Target, transition)) { action(); } } ); } other.Atomically(_ => { var otherState = other.State; other.StateChanged += changedHandler; Act(() => { if (InState(inState) && condition(otherState, null)) { action(); } }); }); WatchState(inState, () => { other.StateChanged -= changedHandler; }); } }
public int GetStatefulPositionCount() { var actorId = new ActorId(11111); var actorAddress = new Uri("fabric:/DartShooting/StatefulActorService"); IStatefulActor proxy = ActorProxy.Create <IStatefulActor>(actorId, actorAddress); return(proxy.GetCountAsync().Result); }
public StatefulActor.Interfaces.Models.Location GetStatefulPosition() { var actorId = new ActorId(11111); var actorAddress = new Uri("fabric:/DartShooting/StatefulActorService"); IStatefulActor proxy = ActorProxy.Create <IStatefulActor>(actorId, actorAddress); return(proxy.GetRandomPosition().Result); }
/// <summary> Checks to see if the current states transition's conditions are satisfied /// in response to any state change in the given other actor, but only while in the /// current state (or optionally given super-state). If the other actor goes to any given /// fault state, an exception is thrown for this actor. </summary> protected void WatchOtherAndUpdate <OA, OS, OT>(IStatefulActor <OA, OS, OT> other, OS[] errorStates, TState?whileIn = null) where OS : struct => WatchOtherWhileInState ( other, (s, t) => true, () => { if (errorStates.Any(es => other.InState(es))) { throw new FrameworkWatchedStateException(other.GetType().Name + " unexpectedly went to state " + other.State, other); } else { UpdateStates(); } }, whileIn );
public static void WaitForState <TActor, TState, TTrigger>(this IStatefulActor <TActor, TState, TTrigger> actor, TState desired, int timeout) where TState : struct { var completionSource = new System.Threading.Tasks.TaskCompletionSource <bool>(); void waitForUnstarted(TState oldState, StateMachine <TState, TTrigger> .Transition transition) { if (actor.InState(desired)) { completionSource.TrySetResult(true); } }; actor.StateChanged += waitForUnstarted; // Check for synchronous completion if (actor.InState(desired)) { completionSource.TrySetResult(true); } completionSource.Task.Wait(timeout); actor.StateChanged -= waitForUnstarted; }
/// <summary> Checks to see if the current states transition's conditions are satisfied /// in response to any state change in the given other actor, but only while in the /// current state (or optionally given super-state). If the other actor goes to a given /// fault state, an exception is thrown for this actor. </summary> protected void WatchOtherAndUpdate <OA, OS, OT>(IStatefulActor <OA, OS, OT> other, OS errorState, TState?whileIn = null) where OS : struct => WatchOtherAndUpdate(other, new OS[] { errorState }, whileIn);
/// <summary> Checks to see if the current states transition's conditions are satisfied /// in response to any state change in the given other actor, but only while in the /// current state (or optionally given super-state). </summary> protected void WatchOtherAndUpdate <OA, OS, OT>(IStatefulActor <OA, OS, OT> other, TState?whileIn = null) where OS : struct => WatchOtherWhileInState(other, (s, t) => true, UpdateStates, whileIn);