Mappatura di un iusertype a una proprietà componente in fluente nhibernate
-
28-10-2019 - |
Domanda
Sto cercando di implementare un IUserType
Per gli stati e i codici di campagna che mi permetteranno di accedere sia al codice a due lettere (ciò che è archiviato nel database) sia al nome completo. Sto seguendo l'esempio nel libro di cucina Nhibernate 3.0 (p. 225), ma il mio problema è che il mio StreetAddress
La classe è attualmente mappata come componente nella mia configurazione automatica:
public override bool IsComponent(Type type)
{
return type == typeof(StreetAddress);
}
Con questa classe identificata come componente, non so come posso usare un IUserType
Per la proprietà della classe componente, dal momento che quella classe non è esplicitamente mappata. Non c'è nessun posto che potrei dire fluente Nhibernate di usare il IUserType
specifica.
Soluzione
@Firo era vicino, ma si è rivelata una soluzione molto più semplice. Ci sono stati due passaggi qui. Innanzitutto, ho dovuto dire fluente Nhibernate di non mappare il State
e Country
Classi, che risiedono nel mio livello di dominio:
public override bool ShouldMap(Type type)
{
return type.Name != "State" && type.Name != "Country";
}
Successivamente, ho dovuto semplicemente creare le convenzioni per il IUserType
classi. Questo si è rivelato più facile di @firo suggerito:
public class CountryUserTypeConvention : UserTypeConvention<CountryType>
{
}
public class StateUserTypeConvention : UserTypeConvention<StateType>
{
}
La definizione di quelli IUserTypes
è stato tirato fuori dal libro di cucina a cui si fa riferimento nella domanda originale, ma nel caso in cui non vuoi leggerlo:
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; }
}
}
E questo deriva da 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; }
}
I repository per queste classi sono solo una coppia di ReadOnlyCollection
del State
e Country
oggetti. Ancora una volta, dal libro di cucina:
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
}
)
{
}
}
Spero che questo aiuti qualcuno là fuori.
Altri suggerimenti
non potevo testarlo, ma dovrebbe essere possibile usare una convenzione
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>();
}
}