Orlens入門コンセプト(2)Grainsの作成

PM> Install-Package Microsoft.Orleans.OrleansCodeGenerator.Build

//an example of a Grain Interface
public interface IPlayerGrain : IGrainWithGuidKey
{
  Task GetCurrentGame();
  Task JoinGame(IGameGrain game);
  Task LeaveGame(IGameGrain game);
}

//an example of a Grain class implementing a Grain Interface
public class PlayerGrain : Grain, IPlayerGrain
{
    private IGameGrain currentGame;

    // Game the player is currently in. May be null.
    public Task GetCurrentGame()
    {
       return Task.FromResult(currentGame);
    }

    // Game grain calls this method to notify that the player has joined the game.
    public Task JoinGame(IGameGrain game)
    {
       currentGame = game;
       Console.WriteLine(
           "Player {0} joined game {1}", 
           this.GetPrimaryKey(),
           game.GetPrimaryKey());

       return Task.CompletedTask;
    }

   // Game grain calls this method to notify that the player has left the game.
   public Task LeaveGame(IGameGrain game)
   {
       currentGame = null;
       Console.WriteLine(
           "Player {0} left game {1}",
           this.GetPrimaryKey(),
           game.GetPrimaryKey());

       return Task.CompletedTask;
   }
}

public Task GrainMethod1()
{
    ...
    return Task.FromResult();
}

public Task GrainMethod2()
{
    ...
    return Task.CompletedTask;
}

public async Task GrainMethod3()
{
    ...
    return ;
}

public async Task GrainMethod4()
{
    ...
    return;
}

public Task GrainMethod5()
{
    ...
    Task task = CallToAnotherGrain();
    return task;
}

public Task GrainMethod6()
{
    ...
    Task task = CallToAsyncAPI();
    return task;
}

    //construct the grain reference of a specific player
    IPlayerGrain player = GrainFactory.GetGrain(playerId);

    IPlayerGrain player = GrainClient.GrainFactory.GetGrain(playerId);

    IPlayerGrain player = client.GetGrain(playerId);

//Invoking a grain method asynchronously
Task joinGameTask = player.JoinGame(this);
//The await keyword effectively makes the remainder of the method execute asynchronously at a later point (upon completion of the Task being awaited) without blocking the thread.
await joinGameTask;
//The next line will execute later, after joinGameTask is completed.
players.Add(playerId);

List tasks = new List();
Message notification = CreateNewMessage(text);

foreach (ISubscriber subscriber in subscribers)
{
   tasks.Add(subscriber.Notify(notification));
}

// WhenAll joins a collection of tasks, and returns a joined Task that will be resolved when all of the individual notification Tasks are resolved.
Task joinedTask = Task.WhenAll(tasks);
await joinedTask;

// Execution of the rest of the method will continue asynchronously after joinedTask is resolve.