This question is related to Mapping interface or abstract class component I'm also trying to map a component declared as an interface, but I'm using the built-in mapping-by-code/Conformist approach.
Let's say I have an entity Login (C#):
public class Login
{
public virtual int Id { get; set; }
public virtual string UserName { get; set; }
public virtual IPassword Password { get; set; }
}
I want to abstract away how the password is stored, so I've defined a simple interface IPassword
public interface IPassword
{
bool Matches(string password);
}
An example implementation is HashedPassword:
public class HashedPassword : IPassword
{
public virtual string Hash { get; set; }
public virtual string Salt { get; set; }
public virtual bool Matches(string password){ /* [snip] */ }
}
I want to map Login.Password as a component rather than a many-to-one or one-to-one relation. Using XML I'd map it like this:
<?xml version="1.0"?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="..." namespace="...">
<class name="Login">
<id name="Id">...</id>
<property name="UserName" .../>
<component name="Password" class="HashedPassword">
<property name="Hash" not-null="true" length="32"/>
<property name="Salt" not-null="true" length="32"/>
</component>
</class>
</hibernate-mapping>
This works as expected.
Here's my attempt to map it using NHibernate's built-in mapping-by-code facilities:
public class LoginMapping : ClassMapping<Login>
{
public LoginMapping()
{
Id(x => x.Id, map => map.Generator(Generators.HighLow));
Property(x => x.UserName, map => map.Length(32));
Component(x => x.Password, comp =>
{
comp.Class<HashedPassword>();
comp.Property("Salt", map => map.Length(32));
comp.Property("Hash", map => map.Length(32));
});
}
}
When I use this mapping I get the following exception:
NHibernate.MappingException: Member not found. The member 'Salt' does not exists in type IPassword
While it's true that Salt isn't a member of IPassword, it is a member of the class that I set with comp.Class<HashedPassword>()
Do you know how I can map this scenario without getting the exception?
So far there I haven't found a solution to the question itself. There are two work-arounds at the moment:
Resort to XML mapping or FluentNHibernate. This could probably done for the "problematic" mappings only.
Instead of a component, use a user type. This is what I'm doing right now. The type in my case (the hashed password) is immutable and can be stored as a single column, so the user type is fairly simple.
Here's the user type I'm currently using (for sake of completion). I use PBKDF2 to create secure hashes. Note that in my application all data (salt, hash and PBKDF2 iteration count) is stored in one property (simply named Hash) of the HashedPassword.
public abstract class ImmutableValue<T> : IUserType where T : class
{
public abstract SqlType[] SqlTypes { get; }
public virtual Type ReturnedType
{
get { return typeof (T); }
}
public bool IsMutable
{
get { return false; }
}
bool IUserType.Equals(object x, object y)
{
return InternalEquals(x, y);
}
protected virtual bool InternalEquals(object x, object y)
{
return Equals(x, y);
}
public virtual int GetHashCode(object x)
{
return x == null ? 0 : x.GetHashCode();
}
public virtual object NullSafeGet(IDataReader rs, string[] names, object owner)
{
return Load(rs, names, owner);
}
protected abstract T Load(IDataReader rs, string[] names, object owner);
public virtual void NullSafeSet(IDbCommand cmd, object value, int index)
{
Save(cmd, (T) value, index);
}
protected abstract void Save(IDbCommand cmd, T value, int index);
public virtual object DeepCopy(object value)
{
return value;
}
public virtual object Replace(object original, object target, object owner)
{
return original;
}
public virtual object Assemble(object cached, object owner)
{
return cached;
}
public virtual object Disassemble(object value)
{
return value;
}
protected void SetParameter(IDbCommand cmd, int index, object value)
{
var parameter = (IDataParameter) cmd.Parameters[index];
var parameterValue = value ?? DBNull.Value;
parameter.Value = parameterValue;
}
}
public class HashedPasswordType : ImmutableValue<HashedPassword>
{
public override SqlType[] SqlTypes
{
get { return new SqlType[] {SqlTypeFactory.GetString(HashedPassword.ContentLength)}; }
}
protected override HashedPassword Load(IDataReader rs, string[] names, object owner)
{
var str = NHibernateUtil.String.NullSafeGet(rs, names[0]) as string;
return HashedPassword.FromContent(str);
}
protected override void Save(IDbCommand cmd, HashedPassword value, int index)
{
SetParameter(cmd, index, value == null ? null : value.Hash);
}
}
The required mapping is then comparatively simple:
Property(x => x.Password, map =>
{
map.Type<HashedPasswordType>();
map.NotNullable(true);
});
