NHibernate 3.2映射选择、关系和POV？

我正在努力学习NH（3.2版），在理解一些映射选择时遇到了问题。Scott Findlater已经发布了他为性感的唠叨NH的完整工作框架，我关于映射的问题将基于他的样本。 以下是域模型（pic不是其示例的一部分，但为了清晰起见，此处包含）：

他的分类类如下所示：

public class Category : Entity
    {
        public Category()
        {
            Products = new List<Product>();
            SubCategories = new List<Category>();
        }

        public virtual string Name { get; set; }
        public virtual string Description { get; set; }
        public virtual Category Parent { get; set; }
        public virtual IEnumerable<Category> SubCategories { get; set; }
        public virtual IList<Product> Products { get; set; }
    }

class CategoryMap : ClassMapping<Category>
    {
        public CategoryMap()
        {
            // **************************************************
            // Mapping of Id here will take precedence over the 
            // global conventions configured in the ModelMapper.
            // **************************************************
            //Id(x => x.Id, map =>
            //{
            //    map.Column("Id");
            //    map.Generator(Generators.GuidComb);
            //});

            Property(x => x.Name, m => m.Length(450));
            Property(x => x.Description, m => m.Length(2000));

            Set(x => x.SubCategories, set =>
                                          {
                                              set.Key(k => k.Column("ParentCategoryId"));
                                              set.Inverse(true);
                                          } ,
                                       ce => ce.OneToMany());

            ManyToOne(x => x.Parent, manyToOne =>
                                         {
                                             manyToOne.Column("ParentCategoryId");
                                             manyToOne.Lazy(LazyRelation.NoLazy);
                                             manyToOne.NotNullable(false);
                                         });


            Set(x => x.Products, set =>
                                    {
                                        set.Key(key =>
                                        {
                                            key.Column("ProductId");
                                            key.ForeignKey("FK_Product_Category_ProductId");
                                        });
                                        set.Table("Product_Category");
                                    },
                                    ce => ce.ManyToMany(m => m.Column("CategoryId")));
        }
    }

公共类类别：实体
{
公共类别（）
{
产品=新列表（）；
子类别=新列表（）；
}
公共虚拟字符串名称{get；set；}
公共虚拟字符串描述{get；set；}
公共虚拟类别父项{get；set；}
公共虚拟IEnumerable子类别{get；set；}
公共虚拟IList产品{get；set；}
}

他的映射类是这样的：

public class Category : Entity
    {
        public Category()
        {
            Products = new List<Product>();
            SubCategories = new List<Category>();
        }

        public virtual string Name { get; set; }
        public virtual string Description { get; set; }
        public virtual Category Parent { get; set; }
        public virtual IEnumerable<Category> SubCategories { get; set; }
        public virtual IList<Product> Products { get; set; }
    }

class CategoryMap : ClassMapping<Category>
    {
        public CategoryMap()
        {
            // **************************************************
            // Mapping of Id here will take precedence over the 
            // global conventions configured in the ModelMapper.
            // **************************************************
            //Id(x => x.Id, map =>
            //{
            //    map.Column("Id");
            //    map.Generator(Generators.GuidComb);
            //});

            Property(x => x.Name, m => m.Length(450));
            Property(x => x.Description, m => m.Length(2000));

            Set(x => x.SubCategories, set =>
                                          {
                                              set.Key(k => k.Column("ParentCategoryId"));
                                              set.Inverse(true);
                                          } ,
                                       ce => ce.OneToMany());

            ManyToOne(x => x.Parent, manyToOne =>
                                         {
                                             manyToOne.Column("ParentCategoryId");
                                             manyToOne.Lazy(LazyRelation.NoLazy);
                                             manyToOne.NotNullable(false);
                                         });


            Set(x => x.Products, set =>
                                    {
                                        set.Key(key =>
                                        {
                                            key.Column("ProductId");
                                            key.ForeignKey("FK_Product_Category_ProductId");
                                        });
                                        set.Table("Product_Category");
                                    },
                                    ce => ce.ManyToMany(m => m.Column("CategoryId")));
        }
    }

类类别映射：类映射
{
公共类别映射（）
{
// **************************************************
//此处Id的映射将优先于
//在ModelMapper中配置的全局约定。
// **************************************************
//Id（x=>x.Id，map=>
//{
//地图栏（“Id”）；
//map.Generator（Generators.GuidComb）；
//});
属性（x=>x.Name，m=>m.Length（450））；
属性（x=>x.描述，m=>m.长度（2000））；
集合（x=>x.子类别，集合=>
{
set.Key（k=>k.Column（“ParentCategoryId”）；
set.Inverse（真）；
} ,
ce=>ce.OneToMany（））；
多通（x=>x.父，多通=>
{
manytone.列（“父类别ID”）；
懒惰的（懒散的关系）；
manyToOne.NotNullable（false）；
});
集合（x=>x.产品，集合=>
{
set.Key（Key=>
{
关键字栏（“ProductId”）；
key.ForeignKey（“FK_产品_类别_产品ID”）；
});
集合表格（“产品类别”）；
},
ce=>ce.ManyToMany（m=>m.Column（“CategoryId”））；
}
}

现在，关于问题：

1） 为什么他选择将父属性映射/建模为多通关系？这难道不意味着类别可以属于多个父类别，也就是说，任何给定的类别（我想不是根类别）都可以分布在许多其他父类别中吗？如果是这样的话，那么从模型本身来看这不是很清楚，因为对我来说父对象（正如我在类定义中看到的）看起来像是Category类型的属性，我会这样映射它。您什么时候会选择此解决方案中的方法v.s.将其映射为简单属性

2） 当我映射文件时，我应该从谁（或哪个）的角度看？在我看来，这是从你试图绘制的类的内部开始的。所以，在本例中，当我尝试映射Category类时，我只关心映射出的“箭头”，对吗

3） 创建映射文件的人必须了解仅仅通过查看一个类就可以了解的内容之外的知识。查看产品属性是如何映射的（多个关系）。从类本身可以清楚地看出，类别可能属于许多产品，但类别不知道它可能包含在许多产品中。这一事实对于产品类来说是显而易见的。现在我已经说过，在我看来，当我创建映射文件时，我应该从类和模型的角度来看

4） 一般来说：何时使用.Inverse（）、.Cascade（）和.Lazy（）

5） 使用ModelMapper与ConventionModelMapper进行映射有什么区别？我没有研究过同一个项目中包含的使用后一种方法的文件，但我想知道，除了偏好之外，使用一种方法是否比使用另一种方法更有优势。

• 对于1。这并不意味着每个类别都有多个父类别，而是意味着许多类别可以在同一父类别中表达，每个类别都可以有一个子类别列表。如果是一对一的话，那就意味着每个类别只有一个类别，我想你不是有意的

• 对于4。

  Inverse（）

  用于指定关联的所有者，因此您可以在一对多关系中使用它，其中子实体不是关系的所有者，或者子实体不负责该关系，并且不了解该关系，因此如果将其设置为true，NHibernate不会尝试插入或更新联接定义的属性

• Cascade（）

  指定将从父实体级联到关联实体的操作

• lazy

  用于延迟加载其他实体引用的实体

• 两个人。三,。我不能理解你的意思，你是什么意思，但是我认为当你在映射一个实体时，你应该从你所映射的类的角度来看，当你在映射时，关系的另一边是同一事物，从它的视角看，同时考虑RelAT的两个方面。