Task Callback(object callbackState) { double value = GetAverageTemperature(); if (value > 100) { observers.Notify(x => x.HighTemperature(value, this.GetPrimaryKeyString(), temperatures.Count)); } return(TaskDone.Done); }
Task Callback(object callbackState) { if (_vehicleInfo != null) { _observers.Notify(x => x.ReportToVehicle(_vehicleInfo)); _vehicleInfo = null; } return(TaskDone.Done); }
/// <summary> /// Presense grain calls this method to update the game with its latest status /// </summary> public async Task UpdateGameStatus(GameStatus status) { this.status = status; // Check for new players that joined since last update foreach (Guid player in status.Players) { if (!players.Contains(player)) { try { // Here we call player grains serially, which is less efficient than a fan-out but simpler to express. await PlayerGrainFactory.GetGrain(player).JoinGame(this); players.Add(player); } catch (Exception) { // Ignore exceptions while telling player grains to join the game. // Since we didn't add the player to the list, this will be tried again with next update. } } } // Check for players that left the game since last update List <Task> promises = new List <Task>(); foreach (Guid player in players) { if (!status.Players.Contains(player)) { try { // Here we do a fan-out with multiple calls going out in parallel. We join the promisses later. // More code to write but we get lower latency when calling multiple player grains. promises.Add(PlayerGrainFactory.GetGrain(player).LeaveGame(this)); players.Remove(player); } catch (Exception) { // Ignore exceptions while telling player grains to leave the game. // Since we didn't remove the player from the list, this will be tried again with next update. } } } // Joining promises await Task.WhenAll(promises); // Notify subsribers about the latest game score subscribers.Notify((s) => s.UpdateGameScore(status.Score)); return; }
public Task SayHello() { string str_hello = "SayHello"; Console.WriteLine($"{str_hello}Send"); m_subsManager.Notify((IMainEntry_Obs imev) => { imev.Handle(str_hello); }); return(Task.CompletedTask); }
public Task Pong(IPongGrain @from, Message message) { pongs++; if (pings < repeats) { actor.Ping(this, msg); pings++; } else if (pongs >= repeats) { subscribers.Notify(x => x.Done(pings, pongs)); } return(TaskDone.Done); }
public Task Pong(IPongGrain pongGrain, Message message) { _batch--; if (_batch > 0) { return(TaskDone.Done); } if (!SendBatch(pongGrain)) { subscribers.Notify(s => s.BenchmarkFinished()); } return(TaskDone.Done); }
private void Lobby_OnReady(Lobby lobby) { var scavengerGrain = GrainFactory.GetGrain <IScavengerGrain>(lobby.ScavengerId.Value); scavengerGrain.SubscribeGuide(_guideObserver); scavengerGrain.SubscribeScavenger(_scavengerObserver); var guideGrain = GrainFactory.GetGrain <IGuideGrain>(lobby.GuideId.Value); guideGrain.SetScavenger(lobby.ScavengerId.Value); var lobbyManagerGrain = GrainFactory.GetGrain <ILobbyManagerGrain>(0); lobbyManagerGrain.RemoveLobby(this.GetPrimaryKey()); _observers.Notify(o => o.LobbyReady(lobby.ScavengerId.Value, lobby.GuideId.Value)); Console.WriteLine($"Lobby { this.GetPrimaryKey()} Ready!"); }
public async Task StartGame() { Guid newGame = await mgr.CreateProcess(); List <Task> promises = new List <Task>(); for (int i = 0; i < players.Count; i++) { promises.Add(mgr.AddPlayer(newGame, players[i])); } await Task.WhenAll(promises); players.Clear(); observers.Notify((o) => o.GameStart(newGame, 0)); observers.Clear(); await mgr.StartGame(newGame); }
public async Task Execute(CreateSalesOrderCommand command) { var message = new CreateSalesOrderMessage(command.SalesOrderKey, command.CustomerKey, command.WarehouseKey); var salesOrderGrain = GrainFactory.GetGrain <ISalesOrderGrain>(command.SalesOrderKey); // var referenceList = await SalesOrdersObserverFactory.CreateObjectReference(new SalesOrderListObserver()); // var referenceDashboard = await SalesOrdersObserverFactory.CreateObjectReference(new OrdersDashboardObserver()); // await salesOrderGrain.Subscribe(referenceList); // await salesOrderGrain.Subscribe(referenceDashboard); await salesOrderGrain.Create(message); var customerGrain = GrainFactory.GetGrain <ICustomerGrain>(command.CustomerKey); var tax = await customerGrain.GetSaleTax(); await salesOrderGrain.AssignTax(tax); // await salesOrderGrain.Unsubscribe(referenceDashboard); // await salesOrderGrain.Unsubscribe(referenceList); _subscribers.Notify(x => x.Notify(message.SalesOrderKey)); }
public Task Send(IOutPacket packet) { sessionObservers.Notify(receiver => receiver.ForwardPacket(packet)); return(Task.CompletedTask); }
public Task PushMessageForTest(string msg) { _subsManager.Notify(o => o.OnNext(msg)); return(Task.CompletedTask); }
public Task Move(Position position) { _scavenger.Move(position); _guideObservers.Notify(observer => observer.ScavengerMoved(position)); return(TaskDone.Done); }
public Task SendUpdateMessage(string message) { Console.WriteLine("BroadCast:" + message); _subsManager.Notify(s => s.ReceiveMessage(message)); return(Task.CompletedTask); }
public Task NotifyObserver(string message) { _subsManager.Notify(s => s.ReceiveMessage(message)); return(Task.CompletedTask); }
public Task SendUpdateMessage(string message) { _subsManager.Notify(s => s.ReceiveMessage(message)); return(Task.CompletedTask); }
private Task SendOutUpdates(object _) { subscribers.Notify(s => s.StuffUpdate(DateTime.Now.Millisecond)); return(TaskDone.Done); }
public Task Publish(string message) { _subsManager.Notify(s => s.Handle(message)); return(TaskDone.Done); }
public Task SendUpdateMessage(string message) { _subsManager.Notify(s => s.ReceiveMessage(message)); return(TaskDone.Done); }