[英]Mapping an IUserType to a component property in fluent NHibernate
I'm trying to implement an IUserType
for states and country codes that will allow me to access both the two-letter code (what's stored in the database) as well as the full name. 我正在尝试为州和国家/地区代码实现
IUserType
,这将使我能够访问两个字母的代码(存储在数据库中的代码)以及全名。 I'm following the example in the NHibernate 3.0 Cookbook (p. 225), but my problem is that my StreetAddress
class is currently mapped as a component in my automapping configuration: 我正在遵循NHibernate 3.0 Cookbook(第225页)中的示例,但是我的问题是我的
StreetAddress
类当前已映射为自动映射配置中的组件:
public override bool IsComponent(Type type)
{
return type == typeof(StreetAddress);
}
With this class identified as a component, I don't know how I can use an IUserType
for the component class's property, since that class isn't explicitly mapped. 将此类标识为组件后,我不知道如何使用
IUserType
作为组件类的属性,因为未明确映射该类。 There's nowhere that I could tell fluent NHibernate to use the IUserType
specification. 我无法告诉流利的NHibernate使用
IUserType
规范。
@Firo was close, but there turned out to be a much easier solution. @Firo接近,但事实证明这是一个更容易的解决方案。 There were two steps here.
这里有两个步骤。 First, I had to tell Fluent NHibernate not to map the
State
and Country
classes, which reside in my domain layer: 首先,我不得不告诉Fluent NHibernate不要映射位于我的域层中的
State
和Country
类:
public override bool ShouldMap(Type type)
{
return type.Name != "State" && type.Name != "Country";
}
Next, I simply had to create the conventions for the IUserType
classes. 接下来,我只需要为
IUserType
类创建约定。 This turned out to be easier than @Firo suggested: 事实证明,这比@Firo建议的要容易:
public class CountryUserTypeConvention : UserTypeConvention<CountryType>
{
}
public class StateUserTypeConvention : UserTypeConvention<StateType>
{
}
The definition of those IUserTypes
was pulled out of the cookbook referenced in the original question, but in case you don't want to read it: 这些
IUserTypes
的定义IUserTypes
原始问题中引用的食谱中撤出,但是如果您不想阅读它:
public class CountryType : GenericWellKnownInstanceType<Country, string>
{
// The StateType is pretty much the same thing, only it uses "StateCode" instead of "CountryCode"
private static readonly SqlType[] sqlTypes =
new[] {SqlTypeFactory.GetString(2)};
public CountryType()
: base(new Countries(),
(entity, id) => entity.CountryCode == id,
entity => entity.CountryCode)
{
}
public override SqlType[] SqlTypes
{
get { return sqlTypes; }
}
}
And that derives from GenericWellKnownInstanceType
: 那是从
GenericWellKnownInstanceType
派生的:
[Serializable]
public abstract class GenericWellKnownInstanceType<T, TId> :
IUserType where T : class
{
private Func<T, TId, bool> findPredicate;
private Func<T, TId> idGetter;
private IEnumerable<T> repository;
protected GenericWellKnownInstanceType(
IEnumerable<T> repository,
Func<T, TId, bool> findPredicate,
Func<T, TId> idGetter)
{
this.repository = repository;
this.findPredicate = findPredicate;
this.idGetter = idGetter;
}
public Type ReturnedType
{
get { return typeof (T); }
}
public bool IsMutable
{
get { return false; }
}
public new bool Equals(object x, object y)
{
if (ReferenceEquals(x, y))
{
return true;
}
if (ReferenceEquals(null, x) ||
ReferenceEquals(null, y))
{
return false;
}
return x.Equals(y);
}
public int GetHashCode(object x)
{
return (x == null) ? 0 : x.GetHashCode();
}
public object NullSafeGet(IDataReader rs,
string[] names, object owner)
{
int index0 = rs.GetOrdinal(names[0]);
if (rs.IsDBNull(index0))
{
return null;
}
var value = (TId) rs.GetValue(index0);
return repository.FirstOrDefault(x =>
findPredicate(x, value));
}
public void NullSafeSet(IDbCommand cmd,
object value, int index)
{
if (value == null)
{
((IDbDataParameter) cmd.Parameters[index])
.Value = DBNull.Value;
}
else
{
((IDbDataParameter) cmd.Parameters[index])
.Value = idGetter((T) value);
}
}
public object DeepCopy(object value)
{
return value;
}
public object Replace(object original,
object target, object owner)
{
return original;
}
public object Assemble(object cached, object owner)
{
return cached;
}
public object Disassemble(object value)
{
return value;
}
/// <summary>
/// The SQL types for the columns
/// mapped by this type.
/// </summary>
public abstract SqlType[] SqlTypes { get; }
}
The repositories for these classes are just a pair of ReadOnlyCollection
of the State
and Country
objects. 这些类的存储库只是
State
和Country
对象的一对ReadOnlyCollection
。 Again, from the cookbook: 再次,从食谱:
public class States : ReadOnlyCollection<State>
{
// Truncated in the interest of brevity
public static State Arizona = new State("AZ", "Arizona");
public static State Florida = new State("FL", "Florida");
public static State California = new State("CA", "California");
public static State Colorado = new State("CO", "Colorado");
public static State Oklahoma = new State("OK", "Oklahoma");
public static State NewMexico = new State("NM", "New Mexico");
public static State Nevada = new State("NV", "Nevada");
public static State Texas = new State("TX", "Texas");
public static State Utah = new State("UT", "Utah");
public States() : base(new State[]
{
Arizona, Florida, California, Colorado,
Oklahoma, NewMexico, Nevada, Texas, Utah
}
)
{
}
}
Hopefully this helps someone out there. 希望这可以帮助某个人。
i couldnt test it, but it should be possible using a convention 我无法测试,但是应该可以使用约定
public class ComponentConvention : IComponentConvention, IComponentConventionAcceptance
{
public void Accept(IAcceptanceCriteria<IComponentInspector> criteria)
{
criteria.Expect(x => x.Type == typeof(StreetAddress);
}
public void Apply(IComponentInstance instance)
{
instance.Properties.First(p => p.Name == "CountrCode").CustomType<MyUserType>();
}
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.