Question

我有一个对象（限制），它包含两个字段（低，高），类型为ParsedValue。 ParsedValue有：

constructor (double, string);
method string ToString();

每个ParsedValue都有它的值：double和unit：string并用单位表示一些测量值。

我想要一个包含字段的表：

low:double
high:double
unit:string

因此，当选择Limit对象时，我需要使用新的ParsedValue（低，单位）填充Low字段，使用新的ParsedValue（高，单位）填充High字段。将Limit对象插入数据库时，应插入low = Low.Value，high = High.Value，unit = Low.Unit

我怎样才能使用Fluent NHibernate？

Answer 1

延伸布鲁克的评论：

假设以下课程

class LimitHolder
{
    public Limit Limit { get; set; }
}

class Limit
{
    public Limit(ParsedValue low, ParsedValue high)
    {
        Low = low;
        High = high;
    }

    public virtual ParsedValue Low { get; private set; }
    public virtual ParsedValue High { get; private set; }
}

class ParsedValue
{
    public ParsedValue(double value, string unit)
    {
        Value = value;
        Unit = unit;
    }
    public virtual double Value { get; private set; }
    public virtual string Unit { get; private set; }
}

映射

class LimitHolderMap : ClassMap<LimitHolder>
{
    public LimitHolderMap()
    {
        Map(lh => lh.Limit).CustomType<LimitUserType>();
    }
}

class LimitUserType : ImmutableUserType
{
    public object NullSafeGet(IDataReader rs, string[] names, object owner)
    {
        var str = (string)NHibernateUtil.String.NullSafeGet(rs, names[0]);

        if (string.IsNullOrEmpty(str))
            return null;
        else
        {
            var splitted = str.Split('|');
            return new Limit(
                new ParsedValue(double.Parse(splitted[0]), splitted[2]),
                new ParsedValue(double.Parse(splitted[1]), splitted[2]));
        }
    }

    public void NullSafeSet(IDbCommand cmd, object value, int index)
    {
        var limit = value as Limit;
        if (limit == null)
            NHibernateUtil.String.NullSafeSet(cmd, null, index);
        else
        {
            var str = string.Concat(limit.Low.Value, '|', limit.High.Value, '|', limit.Low.Unit);
            NHibernateUtil.String.NullSafeSet(cmd, str, index);
        }
    }

    public Type ReturnedType
    {
        get { return typeof(Limit); }
    }

    public SqlType[] SqlTypes
    {
        get { return new [] { SqlTypeFactory.GetString(100) }; }
    }
}

ImmutableUserType是我对不可变类型的IUserType的实现。如果需要，我可以发布代码。

这会将限制保存在与其持有者相同的表中

使用Fluent NHibernate进行解析，将两列映射到一个字段

1 个答案: