Creazione di riferimenti a oggetti bidirezionali e mantenimento dell'integrità dei dati

Prima di tutto, determina cosa è più comune nel tuo sistema - per elencare gruppi di un giocatore specifico o per elencare i giocatori di un gruppo specifico. A seconda di quale caso è più comune, implementarlo di conseguenza. Se si tenta di implementare entrambi allo stesso modo, si verificherà un calo di prestazioni per entrambi.

Quindi, l'ipotesi va Giocatore appartiene a un gruppo, quindi:

public class Group {
    public void AddPlayer(Player player) {

    }

    public void AddPlayers(IEnumerable<Player> player) {

    }
}

Ora che lo abbiamo tolto di mezzo.

public class Player {
    public Ienumerable<Group> GetRelevantGroups() {
        // Assuming you have some groups provider in this class. You should anyways.
        return this._groupsService.GetGroupsWithPlayer(this.Id);
    }
}

Usando entrambi:

// Adding a bunch of players to a group.
myGroup.Add(players);

// Getting all groups for specific player.
var playerGroups = player.GetRelevantGroups();

This works, but also introduces some side consequences of modifying the Group you pass, which you might not expect. But maybe this is the best (and relatively simple) way to do it?

Dal punto di vista del design, per mantenere entrambi gli elenchi sincronizzati ( se vuoi gestirlo in questo modo ) non è né la responsabilità di player né la% codice%. Puoi progettarlo con un mediatore (qui nella forma più semplice):

public class Group {

    List<Person> members;


    void addMember(Person p){
        members.add(p);
    }

}

public class Person {

    List<Group> groups;

    void addGroupMembership(Group g){
        groups.add(g);
    }
}

public class GroupingService {

    public void joinPersonToGroup(Person p, Group g){
        p.addGroupMembership(g);
        g.addMember(p);
    }

}

Ma oltre: c'è qualche ragione per implementarlo in questo modo?

Ho risolto questo problema una volta con qualcosa di simile:

class RelationshipManager {
    void addRelation(RelatableObject a, RelateableObject b);
    void removeRelation(RelatableObject a, RelatableObject b);

    List<C> getRelated(RelatableObject obj, Class<C> c);
}

Il RelationshipManager tiene traccia di quali oggetti sono correlati ad altri oggetti. Posso quindi effettuare richieste come:

relationshipManager.getRelated(player, Group.class);

Per ottenere tutti i gruppi per un determinato giocatore.

Puoi fare un ulteriore passo avanti e aggiungere metodi alla tua classe che chiamano questo:

class Player {

    List<Group> getGroups() {
       return relationshipManager.getRelated(this, Group.class);
    }
    void addGroup(Group group) {
       relationshipManager.addRelation(this, group);
    }
}

Nel mio caso, ero in Python, quindi in realtà ho fatto qualcosa del tipo:

class Player:
    groups = HasMany(Group)

e HasMany ha sovraccaricato il comportamento getter / setter predefinito di python per chiamare nel relationship manager. Ho anche un BelongsTo che trattava di singoli elementi invece di liste.

Il tuo problema più grande è che stai creando riferimenti circolari che possono portare a un mondo di problemi, da loop infiniti a perdite di memoria.
In un database devi creare un'entità separata (tabella) per contenere i riferimenti, tradotta in codice che è una classe con un riferimento sia a un giocatore che a un gruppo.
L'iterazione su una raccolta di quelli ti darà quindi tutti i giocatori in un gruppo o in tutti i gruppi a cui appartiene un giocatore, ma può diventare un'operazione costosa.