C# 对象设计中的多对多关系

我也有类似的问题：

---

然而，想象一下锦标赛将有一个映射到任何参与者的“最后玩的日期”属性（仅作为示例）。在这种情况下，该财产最终将流向何处？必须创建一个中间类吗？（我不想这么做）我有什么选择？谢谢

一种方法是，在每个对象上都有一个数组，其中包含指向其他对象的指针，可以通过将对象存储为键、日期存储为值的字典（或任何数量的属性的自定义属性类），也可以在对象周围使用包装类和普通列表，然后，这个包装器应该实现decorator模式，以允许直接访问对象以及任何唯一的属性

包装器对象可以使用内部对象作为两个不同对象的oposing包装器对象之间共享的属性，以便任何属性都是同步的

另一种方法是一个单独的对列表，其中一个像上面那样包装

后者可以轻松地在所有对象上循环

这里是一个代码示例，它可能不完全是您所需要的，但它可能会为您提供我的想法的基础

void Main()
{
    var p = new Player("David");
    var c = new Championship("Chess");
    p.LinkChampionship(c, DateTime.Now);

    p.Dump();
}

// Define other methods and classes here

class Player : Properties {
    public virtual String Name {get; set;}
    public List<ChampionshipWrapper> champs = new List<ChampionshipWrapper>();

    public Player() {
    }
    public Player(string name) {
        Name = name;
    }
    public void LinkChampionship(Championship champ, DateTime when) {
        var p = new Properties(when);
        champs.Add(new ChampionshipWrapper(champ, p));
        champ.players.Add(new PlayerWrapper(this, p));
    }
}

class Championship : Properties {
    public virtual String Name { get; set; }
    public List<PlayerWrapper> players = new List<PlayerWrapper>();

    public Championship(){}
    public Championship(string name) {
        Name = name;
    }

    public void LinkPlayer(Player play, DateTime when) {
        var p = new Properties(when);
        players.Add(new PlayerWrapper(play, p));
        play.champs.Add(new ChampionshipWrapper(this, p));
    }
}

class Properties {
    public virtual DateTime LastPlayed { get; set; }
    public Properties() {
    }
    public Properties(DateTime when) {
        LastPlayed = when;
    }
}

class PlayerWrapper : Player {
    private Player player;
    private Properties props;

    public PlayerWrapper(Player play, Properties prop) {
        this.player = play;
        this.props = prop;
    }

    public override String Name {
        get { return this.player.Name; }
        set { this.player.Name = value; }
    }

    public override DateTime LastPlayed { 
        get { return this.props.LastPlayed; }
        set { this.props.LastPlayed = value; }
    }
}

class ChampionshipWrapper : Championship {
    private Championship champ;
    private Properties props;

    public ChampionshipWrapper(Championship c, Properties prop) {
        this.champ = c;
        this.props = prop;
    }

    public override String Name {
        get { return this.champ.Name; }
        set { this.champ.Name = value; }
    }

    public override DateTime LastPlayed { 
        get { return this.props.LastPlayed; }
        set { this.props.LastPlayed = value; }
    }   
}

void Main（）
{
var p=新玩家（“大卫”）；
var c=新锦标赛（“国际象棋”）；
p、 LinkChampion（c，DateTime.Now）；
p、 Dump（）；
}
//在此处定义其他方法和类
玩家类别：属性{
公共虚拟字符串名称{get；set；}
公共列表champs=新列表（）；
公共玩家（）{
}
公共播放器（字符串名称）{
名称=名称；
}
公开锦标赛（锦标赛冠军，日期和时间）{
var p=新的房地产（何时）；
添加（新ChampionshipWrapper（champ，p））；
添加（新的演奏者说唱者（这个，p））；
}
}
班级冠军：物业{
公共虚拟字符串名称{get；set；}
公共列表玩家=新列表（）；
公开锦标赛（{}
公开锦标赛（字符串名称）{
名称=名称；
}
公共无效链接播放器（播放器播放，日期时间）{
var p=新的房地产（何时）；
添加（新玩家说唱者（play，p））；
play.champs.Add（新ChampionshipWrapper（this，p））；
}
}
类属性{
上次播放的公共虚拟日期时间{get；set；}
公共财产（）{
}
公共属性（日期时间和时间）{
LastPlayed=何时；
}
}
职业选手：选手{
私人玩家；
私人财产道具；
公共玩家说唱者（玩家游戏，属性道具）{
这个玩家=玩；
this.props=prop；
}
公共重写字符串名{
获取{返回this.player.Name；}
设置{this.player.Name=value；}
}
上次播放的公共覆盖日期时间{
获取{返回this.props.LastPlayed；}
设置{this.props.LastPlayed=value；}
}
}
职业冠军：冠军{
私人冠军；
私人财产道具；
公共ChampionshipWrapper（ChampionC，Properties道具）{
this.champ=c；
this.props=prop；
}
公共重写字符串名{
获取{返回this.champ.Name；}
设置{this.champ.Name=value；}
}
上次播放的公共覆盖日期时间{
获取{返回this.props.LastPlayed；}
设置{this.props.LastPlayed=value；}
}   
}

比赛日期是锦标赛的财产还是参与者的财产？所以：这是最后一次有人参加比赛，还是最后一次举行锦标赛（比如每年一次的比赛）让我们假设这是参与者的财产，但这与示例并不相关，财产可能在任何一边我会试试，只是先吃，所以给我15分钟左右。+1的字典。好主意，因为名单上只有独一无二的锦标赛。我们可以使用某种类型的propertystruct，也可以使用某种多维数组。我的示例在LinqPad中进行了测试，因此在main；）的末尾使用了.Dump（）这是我的一个建议，如果这不起作用，我可以试着在孩子们睡觉的时候做另一个例子。