Nhibernate 复制柱

Question

我想映射以下简单实体：

public class AnimalsOwner
{
    public AnimalsOwner()
    {
        Cats = new List<Cat>();
        Dogs = new List<Dog>();
    }

    public virtual int Id { get; set; }

    public virtual IList<Cat> Cats { get; set; }

    public virtual IList<Dog> Dogs { get; set; }
}

public abstract class Animal
{
    public virtual int Id { get; set; }

    public virtual AnimalsOwner AnimalsOwner { get; set; }
}

public class Dog : Animal
{
    public virtual string DogsProperty { get; set; }
}

public class Cat : Animal
{
    public virtual string CatsProperty { get; set; }
}

使用以下映射：

public OwnerMapping()
    {
        this.Table("Owners");
        Id(x => x.Id)
            .GeneratedBy.Native();

        HasMany(x => x.Cats).AsBag().Cascade.SaveUpdate();
        HasMany(x => x.Dogs).AsBag().Cascade.SaveUpdate();
    }
}

public class AnimalMapping : ClassMap<Animal>
{
    public AnimalMapping()
    {
        this.Table("Animals");
        Id(x => x.Id).GeneratedBy.Native();

        References(x => x.AnimalsOwner).Not.Nullable();
    }
}

public class DogMap : SubclassMap<Dog>
{
    public DogMap()
    {
        this.Table("Dogs");
        this.KeyColumn("AnimalId");
        Map(x => x.DogsProperty);
    }
}

public class CatMap : SubclassMap<Cat>
{
    public CatMap()
    {
        this.Table("Cats");
        this.KeyColumn("AnimalId");
        Map(x => x.CatsProperty);
    }
}

使用此类映射一切正常，但生成的架构如下所示：

此类代码：

 var owner = new AnimalsOwner();
                    owner.Cats.Add(new Cat()
                    {
                        AnimalsOwner = owner,
                        CatsProperty = "cat"
                    });

在 OwnderId 列的所有三个表（Animals、Cats、Dogs）中进行插入。但是仅将其放在 Animals 表中还不够吗？如果是的话如何实现呢？如果 NHibernate 的行为符合预期，那么他为什么要做这样的重复呢？

Answer 1

我将使用每类表策略来映射它，并按类型过滤公共集合。这种数据库结构更容易使用并且查询更高效。

public class AnimalMapping : ClassMap<Animal>
{
    public AnimalMapping()
    {
        Table("Animals");
        Id(x => x.Id).GeneratedBy.Native();    
        References(x => x.AnimalsOwner);
        DiscriminateSubClassesOnColumn("AnimalType");
    }
}

public class DogMap : SubclassMap<Dog>
{
    public DogMap()
    {
        DiscriminatorValue("DOG");
        Map(x => x.DogsProperty);
    }
}

public class CatMap : SubclassMap<Cat>
{
    public CatMap()
    {
        DiscriminatorValue("CAT");
        Map(x => x.CatsProperty);
    }
}

可以通过将 Animals 集合映射为私有成员并按类型过滤来公开 Dogs 和 Cats 集合：

public class AnimalsOwner
{
    private IList<Animal> _animals;

    public AnimalsOwner()
    {
        _animals = new List<Animal>();
    }

    public virtual int Id { get; set; }

    public virtual IEnumerable<Animal> Animals { get { return _animals; } }

    public virtual IEnumerable<Cat> Cats { get { return _animals.OfType<Cat>(); } }

    public virtual IEnumerable<Dog> Dogs { get { return _animals.OfType<Dog>(); } }

    public virtual void AddAnimal(Animal animal)
    {
        if (!_animals.Contains(animal))
        {
            animal.AnimalsOwner = this;
            _animals.Add(animal); 
        }
    }

    public virtual void RemoveAnimal(Animal animal)
    {
        if (_animals.Contains(animal))
        {
            animal.AnimalsOwner = null;
            _animals.Remove(animal);
        |
     }   
}

此类的映射为：

public OwnerMapping()
    {
        this.Table("Owners");
        Id(x => x.Id).GeneratedBy.Native();

        HasMany(x => x.Animals.AsBag.Cascade.AllDeleteOrphan()
            .Inverse().LazyLoad()
            .Access.CamelCaseField(Prefix.Underscore);
    }
}

添加猫的代码为：

var owner = new AnimalsOwner();
owner.AddAnimal(new Cat()
                {
                    CatsProperty = "cat"
                });

Answer 2

您会得到重复项，因为您在所有者映射中定义了 HasMany Cats 和 Dogs（以及 Owner 类中的 Cat 和 Dog 集合）。也许您真正想要的是所有者类中的一组动物（而不是单独的狗和猫），并且所有者映射中只有一个 HasMany 动物？