Fluent Nhibernate映射-值对象中的一对多？

嗨，我正在努力优化/重构一个域模型，并试图将逻辑从应用程序服务转移到我的域模型中。现在我陷入了一个NHibernate的问题

该模型是一个WorkEvaluation类，它包含一个带有问题的问卷模板，还包含一组问卷权重类。问题是WorkEvaluation类还有一个重要属性HitInterval，它属于WorkEvaluation中的问题权重集合。其概念是通过回答大量问题（本例中不包括Anserw）进行评估，最后应用一些权重（百分比权重）修改答案分数。这意味着你可以让一些问题变得更重要，而另一些问题则不那么重要。命中间隔也是一个调整参数，当您计算总的WorkEvaluation分数（包括权重修改）时，您可以使用该参数，结果例如：Totalscore=100，命中间隔比我们得到的totalinterval 95-105高5%，并且可以用于匹配其他评估

足够的背景知识。 我想将QuestionWeights列表和HitInterval封装在一个值对象QuestionScoreTuning中，因为它们属于一起，应该同时应用。 我还想在QuestionScoreTuning中添加一些不属于workEvaluation的业务逻辑。 如何映射具有一对多集合和HitInterval以及回引用的值对象（组件）？这是我当前的代码：

public class WorkEvaluation : DomainBase<long>, IAggregateRoot
{
 public void ApplyTuning(QuestionScoreTuning tuning)
        {
            QuestionScoreTuning = tuning;
            //TODO Raise Domain Event WorkEvaluationCompleted - 
            // which should recalculate all group scores
        }
 public QuestionScoreTuning QuestionScoreTuning { get; protected set; }
}

public class QuestionScoreTuning : ValueObject
    {
        private IList<QuestionWeight> _questionWeights;

        public QuestionScoreTuning(IList<QuestionWeight> listOfWeights, long hitInterval)
        {
            _questionWeights = listOfWeights;
            HitInterval = hitInterval;
        }

        public long HitInterval { get; protected set; }

        protected override IEnumerable<object> GetAtomicValues()
        {
            return _questionWeights.Cast<object>();
        }

        /// <summary>
        /// A list of all added QuestionWeights for this WorkEvaluation
        /// </summary>
        public IList<QuestionWeight> QuestionWeights
        {
            get { return new List<QuestionWeight>(_questionWeights); }
            protected set { _questionWeights = value; }
        }

        protected QuestionScoreTuning()
        {}
    }

public class QuestionWeight : DomainBase<long>, IAggregateRoot
{
    public QuestionWeight(Question question, WorkEvaluation evaluation)
    {
        Question = question;
        WorkEvaluation = evaluation;
    }

    public Weight Weight { get; set; }
    public Question Question { get; protected set; }
    public WorkEvaluation WorkEvaluation { get; protected set; }

    public override int GetHashCode()
    {
        return (Question.GetHashCode() + "|" + Weight).GetHashCode();
    }

    protected QuestionWeight()
    {}
}

public类WorkEvaluation:DomainBase，IAggregateRoot
{
public void ApplyTuning（调整）
{
调谐=调谐；
//TODO引发域事件工作评估已完成-
//这将重新计算所有组的分数
}
公共QuestionScoreTuning QuestionScoreTuning{get；protected set；}
}
公共类：ValueObject
{
私人IList_；
公共问题评分调整（IList列表权重，长命中间隔）
{
_问题权重=权重列表；
HitInterval=HitInterval；
}
公共长命中间隔{get；protected set；}
受保护的重写IEnumerable GetAtomicValues（）
{
return _questionWeights.Cast（）；
}
/// 
///此工作评估添加的所有问题权重的列表
/// 
公营机构
{
获取{返回新列表（_）；}
受保护集{u questionWeights=value；}
}
受保护的优化（）
{}
}
公共类问题权重：DomainBase，IAggregateRoot
{
公共问题权重（问题、工作评价）
{
问题=问题；
工作评价=评价；
}
公共权重{get；set；}
公共问题问题{get；protected set；}
公共工作评估工作评估{get；protected set；}
公共覆盖int GetHashCode（）
{
return（Question.GetHashCode（）+“|”+权重）.GetHashCode（）；
}
受保护的问题权重（）
{}
}

流畅的映射：

public class WorkEvaluationMapping : ClassMap<WorkEvaluation>
    {
        public WorkEvaluationMapping()
        {
            Id(x => x.ID).GeneratedBy.Identity();
            References(x => x.SalaryReview).Not.Nullable();
            References(x => x.WorkEvaluationTemplate).Column("WorkEvaluationTemplate_Id").Not.Nullable();
            Component(x => x.QuestionScoreTuning, m =>
                                                      {
                                                          m.Map(x => x.HitInterval, "HitInterval");
                                                          m.HasMany(x => x.QuestionWeights).KeyColumn("WorkEvaluation_id").Cascade.All();
                                                      });

            }
    }

public class QuestionWeightMapping : ClassMap<QuestionWeight>
    {
        public QuestionWeightMapping()
        {
            Not.LazyLoad();
            Id(x => x.ID).GeneratedBy.Identity();
            Component(x => x.Weight, m =>
                                         {
                                             m.Map(x => x.Value, "WeightValue");
                                             m.Map(x => x.TypeOfWeight, "WeightType");
                                         });
            References(x => x.Question).Column("Question_id").Not.Nullable().UniqueKey(
                "One_Weight_Per_Question_And_WorkEvaluation");
            References(x => x.WorkEvaluation).Column("WorkEvaluation_id").Not.Nullable().UniqueKey(
                "One_Weight_Per_Question_And_WorkEvaluation");
        }
    }

公共类WorkEvaluationMapping:ClassMap
{
公共WorkEvaluationMapping（）
{
Id（x=>x.Id）.GeneratedBy.Identity（）；
引用（x=>x.SalaryReview）.Not.Nullable（）；
引用（x=>x.WorkEvaluationTemplate）.Column（“WorkEvaluationTemplate_Id”）.Not.Nullable（）；
组件（x=>x.0，m=>
{
m、 Map（x=>x.HitInterval，“HitInterval”）；
m、 HasMany（x=>x.QuestionWeights）.KeyColumn（“工作评估id”）.Cascade.All（）；
});
}
}
公共类映射：类映射
{
公共问题权重映射（）
{
不是。懒汉（）；
Id（x=>x.Id）.GeneratedBy.Identity（）；
组件（x=>x.重量，m=>
{
m、 映射（x=>x.值，“权重值”）；
m、 Map（x=>x.TypeOfWeight，“WeightType”）；
});
引用（x=>x.Question）.Column（“Question_id”）.Not.Nullable（）.UniqueKey(
“每个问题和工作评估一个权重”；
引用（x=>x.WorkEvaluation）.Column（“WorkEvaluation_id”）.Not.Nullable（）.UniqueKey(
“每个问题和工作评估一个权重”；
}
}

我想要完成的只是将QuestionWeights和HitInterval的集合移动到一个值对象（组件映射）中，因为它们仍然在db表WorkEvaluation中

另外，我看了一些示例解决方案DDDSample.net（c#中的Eric Evans DDD示例），他们使用Internative类实现了这一点，该类将列表作为ctor参数，并映射为Cargo组件。不同之处在于，该示例有一个valueobjects Leg列表，但Leg有对Location的引用，Location是一个实体类

希望有人知道如何做到这一点。先谢谢你。。。

---

/好的。我终于解决了。现在，我的WorkEvaluation对象可以与包含权重和命中间隔列表的QuestionScoreTuning对象（valueobject）一起应用。这很好，如果有人想了解更多关于在值对象中拥有集合并在fluent NH中映射它们的信息，请在这里提出评论。我可以提供代码示例