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