如何在代码中建模多对多关系？

Question

假设我的数据库中有 2 个表。 例如：狗和 老板 这是多对多的关系，因为一个老板可以拥有不止 1 只狗，而一只狗可以有不止 1 个主人。 我是鲍比的主人，我的妻子也是。

但多对多是不允许的，所以有一个帮助表： DogsPerBoss

如何在代码中对此进行建模？

班级老板可以拥有一批狗。 狗类可以拥有一系列 Boss。 --> 至少，我是这么认为的。 也许有更好的解决方案？

辅助表中的额外数据怎么样？ 应该是de Boss级还是Dog级？ 例如：昵称 （我称这只狗为“好孩子”，我的妻子称他为“小狗”）

我希望我的问题有点清楚？ 是否有实现这一目标的最佳方法的最佳实践？ 你能给我一些参考吗？

ORM（如 NHibernate）不是一个选择。

Answer 1

你为什么谈论桌子？ 您要创建对象模型还是数据库模型？

对于对象模型，Dog 没有理由不能拥有 List 并且所有者也可以拥有 List。 仅当关系上有属性时，才需要中间类（UML 称为关联类）。 这时您将拥有一个具有额外属性的 DogOwnership 类，并且每个 Owner 都会有一个 List，每个 Dog 也是如此。 DogOwner 将有一只狗、一个主人和额外的财产。

Answer 2

public class Boss
{
   private string name;
   private List<Hashtable> dogs;
   private int limit;

   public Boss(string name, int dogLimit)
   {
      this.name = name;
      this.dogs = new List<Hashtable>();
      this.limit = dogLimit; 
   }

   public string Name { get { return this.name; } }

   public void AddDog(string nickname, Dog dog)
   {
      if (!this.dogs.Contains(nickname) && !this.dogs.Count == limit)
      {
         this.dogs.Add(nickname, dog);
         dog.AddBoss(this);
      } 
   }

   public void RemoveDog(string nickname)
   {
       this.dogs.Remove(nickname);
       dog.RemoveBoss(this);
   }

   public void Hashtable Dogs { get { return this.dogs; } }
}

public class Dog
{
   private string name;
   private List<Boss> bosses;

   public Dog(string name)
   {
      this.name = name;
      this.bosses = new List<Boss>();
   }

   public string Name { get { return this.name; } }

   public void AddBoss(Boss boss)
   {
      if (!this.bosses.Contains(boss))
      {
          this.bosses.Add(boss);
      }
   }

   public void RemoveBoss(Boss boss)
   {
      this.bosses.Remove(boss);
   }  

   public ReadOnlyCollection<Boss> Bosses { get { return new ReadOnlyCollection<Boss>(this.bosses); } }
}

上面维护了 Boss 可以有多个狗（有限制）和狗有多个 Boss 的关系。 这也意味着当老板添加狗时，他们可以为狗指定一个昵称，该昵称仅对该老板而言是唯一的。 这意味着其他老板可以添加同一只狗，但昵称不同。

至于限制，我可能会将其作为您在实例化 boss 对象之前读取的 App.Config 值。 所以一个小例子是：

var james = new Boss("James", ConfigurationManager.AppSettings["DogsPerBoss"]);
var joe = new Boss("Joe", ConfigurationManager.AppSettings["DogsPerBoss"]);

var benji = new Dog("Benji");
var pooch = new Dog("Pooch");

james.AddDog("Good boy", benji);
joe.AddDog("Doggy", benji);

james.AddDog("Rover", pooch);
joe.AddDog("Buddy", pooch);  // won't add as the preset limit has been reached.

您显然可以根据需要调整它，但是，我认为您正在寻找的基本原理就在那里。

• 老板可以拥有多只狗，但有限制
• 狗可以有多个老板
• 老板可以对同一条狗有不同的昵称。

Answer 3

像这样的东西；
不过，它仍然需要一些微调（将集合设为私有并为其添加一个只读公共访问器，例如返回一个只读集合，但您会明白其中的含义。

public class Dog
{
    public List<Boss> Bosses;

    public void AddBoss( Boss b )  
    {
        if( b != null && Bosses.Contains (b) == false )
        {
            Bosses.Add (b);
            b.AddDog (this);
        }
    }

    public void RemoveBoss( Boss b )
    {
         if( b !=null && Bosses.Contains (b) )
         {
             Bosses.Remove (b);
             b.RemoveDog (this);
         }
    }
}

public class Boss
{
    public List<Dog> Dogs;

    public void AddDog( Dog d )
    {
         if( d != null && Dogs.Contains (d) == false )
         {
              Dogs.Add(d);
              d.AddBoss(this);
         }
    }

    public void RemoveDog( Dog d )
    {
        if( d != null && Dogs.Contains(d) )
        {
            Dogs.Remove (d);
            d.RemoveBoss(this);
        }
    }
}

通过这种方式，您可以在代码中建模多对多每个狗都认识他的老板，每个老板也认识他的狗。
当您需要辅助表中的额外数据时，您还需要创建另一个类。

Answer 4

传统的多对多关系在匹配表上没有额外的字段。

因为确实有包含独特信息的字段，所以我倾向于不再将这些关系视为多对多。

一旦您将信息添加到匹配表中，我认为您已经将该表本身变成了一个实体，因此需要它自己的对象来表示它。

此时，您可以开始使用 DogsName 类来连接人和狗 - 两者都将包含对此对象的引用作为集合的一部分。

然而，无论你给狗起一个名字来称呼它还是拥有它，都是独立的。

除了根据不同的人对狗的名字关系进行建模之外，您还需要对所有权关系进行建模。 在内存中，这意味着两个对象都包含其他对象的列表。

Answer 5

这是数据库和对象世界之间的一个典型问题，多对多不起作用，因此你的帮助表和多对多工作正常的对象世界。 一旦关系具有属性，您就应该创建一个新类来保存该信息。 然而，如果您查看对象关系映射（ORM），您将为自己节省大量时间，整个领域的发展就是为了解决数据库和对象之间的这个（以及许多其他）问题。

Answer 6

如果您有一个简单的多对多链接表，其中包含关系中每个表的外键，那么您将按照您的建议对其进行建模：Boss 有一个 Dogs 集合，而 Dog 有一个 Bosses 集合。

如果您与额外数据（例如昵称）存在多对多关系，那么您可以将其建模为两个一对多关系。 创建一个实体，例如 DogBoss，以便 Boss 拥有 DogBoss 的集合，Dog 拥有 DogBoss 的集合。

Answer 7

我是否遗漏了某些内容，或者是您需要的唯一代码，如下所示：

List<Bosses> BossList;

class Dog {}
class Boss { Dog[] Dogs; }

您不需要显式建模双向关系。 它隐含在代码结构中。 这样做可能还有其他原因，但一般来说，有一个单向引用和一种遍历引用对象集的方法就足够了。

Answer 8

如果您不需要记录昵称，那么 Dog 应该有 Bosses 列表，Boss 应该有 Dogs 列表。

如果 Dog 和 Boss 之间的关系具有属性（在本例中为昵称），那么您应该创建一个类来表示该关系，并让 Dog 和 Boss 都保存该类型的列表。

我已经使用 NHibernate 一段时间了，发现它对于缓解这种非常有用="http://en.wikipedia.org/wiki/Object-relational_impedance_mismatch" rel="nofollow noreferrer">对象关系阻抗不匹配。

Answer 9

我想缺少一些东西。 为什么不允许多对多？

public class Boss
{
    Dog[] dogs;
}

public class Dog
{
    Boss[] bosses;
}

Answer 10

在关系模型中，建模多对多关系的最佳方法（使用狗/老板的示例）是拥有三个单独的表。

一张表用于 DOGS，一张表用于 BOSSES（每个表都有一个唯一的键），第三个表通常是“连接表”。

该表通常至少有两个字段，一个字段用于 Dog 的外键，另一个字段用于 Boss 的外键。
这样每只狗可以有很多个Boss，每个Boss也可以有很多只狗。

现在，当以更面向对象的方式在代码中对此进行建模时，通常通过使用 Dog 类和 Boss 类来实现。
除了这些对象中的每一个都具有通常的原子属性之外，每个对象还将
还公开一个属性，该属性是另一个属性的集合。

因此，例如，Dog 对象将具有一个名为“Bosses”的属性。 此属性将公开分配给特定 Dog 对象（如联结表中定义）的 Boss 对象集合，而另一方面，每个 Boss 对象将公开一个名为 Dogs 的属性，该属性将是分配的 Dog 对象的集合到该特定的 Boss 对象（由联结表定义）。

请注意，这些对象中很可能存在一些“重叠”（即，一个“狗”对象可能具有另一个“狗”对象具有的“老板”对象），但是，这是转换三表多表的传统机制。将多对多关系模型转变为面向对象的关系模型。

Answer 11

每次我们都需要思考现实生活和我们的需求。 在这种情况下，关键在于哪一个应该有另一个。

在现实生活中，狗和老板可能没有彼此。 但您的软件需求应该会影响这种关系。

• 例如，如果您正在开发兽医患者管理软件，对于治疗流浪狗的兽医来说，患者（狗）-监护人（老板）的关系应该是这样的：
  老板必须至少有一只狗，而狗可能没有任何老板（然后老板 id 是这种关系的外键），这意味着在您的设计中，狗类必须保存老板的集合。 为什么，因为没有狗就无法创建任何 Boss 实例。 我们也可以通过数据逻辑做出这个决定。 让我们考虑一下当您尝试在数据库中保存您的狗和老板类别时。 如果像上面的关系条件，在保存boss的同时，你应该在连接表中插入一个连接记录。

• 如果您正在开发该软件，并且您是一名不治疗流浪狗的兽医，那么患者 - 家长关系需要是这样的：
  一只狗必须至少有一个老板，老板也必须至少有一只狗，我们需要考虑这种特殊的关系情况。 这意味着这些类实例中的任何一个都不能在没有彼此的情况下创建。 所以我们需要在面向对象设计中定义这个专业。 这意味着我们需要一个代表这种依赖关系的类。 当然，这种依赖关系将存储在联结表中。

-如果你的软件是为治疗流浪狗的兽医开发的，而这些狗被老板收养，你的设计应该是这样的：
任何狗都可能没有老板，并且任何老板在收养之前都可能没有任何狗。 在这种情况下，我们的面向对象设计需要关心这种特殊情况。 这个案例与第一个案例有点相似。 因此我们可以将任何类的集合添加到其他类中。 但是，任何这样的软件需求都会影响其他需求。 就像报道一样。 如果兽医担心老板收养的狗，他迟早会要求报告哪只狗被谁收养。 就像句子中的那样，（老板收养的狗）如果狗类包含老板类的集合，那就更好了。

我希望我能够对你的问题做出正确的回答。

Answer 12

不确定你的要求是什么。 但这是你想要的表结构：

Dog Table

DOG_ID int PK
DOG_Name varchar(50)

DogsPerBoss

ID int
DOG_ID 整数
BOSS_ID 整数
DogNickName varchar(15)

Boss

BOSS_ID int PK
BOSS_名称 varchar(50)