Sto cercando di leggere su DDD, e sto faticando un po 'cercando di identificare le radici aggregate. Ho scritto un'app molto semplice per dividere i giocatori in squadre diverse all'interno di un gioco.
Quindi le mie entità sono qualcosa del genere:
Entità del gioco:
public class Game : DomainEntityBase, IDomainEntity
{
private List<Team> teams = new List<Team>();
private List<Player> players = new List<Player>();
private int teamSize;
public Game(
string gameName,
int teamSize,
IEnumerable<Player> players) : base(Guid.NewGuid())
{
this.teamSize = teamSize;
this.players = players.ToList();
}
public string GameName { get; private set; }
public ReadOnlyCollection<Team> Teams => teams.AsReadOnly();
public void SplitPlayersToTeams()
{
if (players.Count() % 2 != 0)
{
throw new NotSupportedException("Only equally dividable teams are supported");
}
var teamCount = players.Count / teamSize;
var playersPerTeam = players.Count / teamCount;
SetPlayersToTeam(teamCount, playersPerTeam);
}
private void SetPlayersToTeam(int teamCount, int playersPerTeam)
{
var rnd = new Random();
for (var i = 0; i < teamCount; i++)
{
var team = new Team(i.ToString());
while (team.Players.Count != playersPerTeam)
{
var randomIndex = rnd.Next(players.Count);
var player = players[randomIndex];
if (!team.Players.Contains(player))
{
player.SetTeam(team);
team.AddPlayer(player);
}
}
teams.Add(team);
}
}
}
Entità team:
public class Team : DomainEntityBase, IDomainEntity
{
private List<Player> players = new List<Player>();
public Team(
string teamIdentifier) : base(Guid.NewGuid())
{
TeamIdentifier = teamIdentifier;
}
public string TeamIdentifier { get; }
public ReadOnlyCollection<Player> Players => players.AsReadOnly();
public void AddPlayer(Player player)
{
players.Add(player);
}
}
Entità giocatore:
public class Player : DomainEntityBase, IDomainEntity
{
public Player(
string nickName) : base(Guid.NewGuid())
{
Nickname = nickName;
}
public string Nickname { get; private set; }
public Team Team { get; private set; }
public void SetTeam(Team team)
{
Team = team;
}
}
Ora pensavo che il gioco sarebbe stato una radice aggregata. Avrebbe senso in un modo. Ma poi ho iniziato a pensare che cosa succederebbe se volessi mantenere i giocatori separatamente in modo da non dover aggiungere nuovi giocatori per ogni partita? Cosa succede se si desidera mantenere le squadre separatamente se si dispone di squadre che possono essere riutilizzate in seguito? Il gioco in sé, sarebbe una radice aggregata, perché vorrei persistere nei giochi per esempio caricare una cronologia di giochi dalla persistenza.
Quindi la domanda è, è ogni oggetto che ho elencato sopra una radice aggregata, con i propri repository dato che ogni radice aggregata dovrebbe avere il proprio repository?
Grazie in anticipo.