Nhibernate Domain Ojbect/View Model Mapping (One-to-Many) - asp.net-mvc

Question

Assume this simple Domain in my core assembly:
public class Country
{
protected ICollection<Province> _provinces = null;
public virtual int Id { get; protected set; }
public virtual string Name { get; set; }
public virtual string IsoCode2 { get; set; }
public virtual string IsoCode3 { get; set; }
public virtual int IsoCodeNumeric { get; set; }
public virtual ICollection<Province> Provinces
{
get { return _provinces ?? (_provinces = new List<Province>()); }
set { _provinces = value; }
}
}
public class Province
{
public virtual int Id { get; protected set; }
public virtual Country Country { get; set; }
public virtual string Name { get; set; }
public virtual string Abbreviation { get; set; }
}
The view models in my presentation layer are almost the same:
public class CountryModel
{
public int Id { get; set; }
public string Name { get; set; }
public string IsoCode2 { get; set; }
public string IsoCode3 { get; set; }
public int IsoCodeNumeric { get; set; }
public int NumberOfProvinces { get; set; }
}
public class ProvinceModel
{
public int Id { get; set; }
public int CountryId { get; set; }
public string Name { get; set; }
public string Abbreviation { get; set; }
}
I am creating some Extension methods for mapping back and forth between domain objects/view models:
public static class Extensions
{
public static Country ToEntity(this CountryModel model, Country entity = null)
{
if (entity == null)
entity = new Country();
entity.Name = model.Name;
entity.IsoCode2 = model.IsoCode2;
entity.IsoCode3 = model.IsoCode3;
entity.IsoCodeNumeric = model.IsoCodeNumeric;
entity.AddressFormat = model.AddressFormat;
entity.CanBillTo = model.CanBillTo;
entity.CanShipTo = model.CanShipTo;
entity.IsPublished = model.IsPublished;
return entity;
}
public static CountryModel ToModel(this Country entity, bool includeProvinceCount = false, CountryModel model = null)
{
if (model == null)
model = new CountryModel();
model.Id = entity.Id;
model.Name = entity.Name;
model.IsoCode2 = entity.IsoCode2;
model.IsoCode3 = entity.IsoCode3;
model.IsoCodeNumeric = entity.IsoCodeNumeric;
model.AddressFormat = entity.AddressFormat;
model.CanBillTo = entity.CanBillTo;
model.CanShipTo = entity.CanShipTo;
model.IsPublished = entity.IsPublished;
if (includeProvinceCount)
model.NumberOfProvinces = entity.Provinces.Count;
return model;
}
public static Province ToEntity(this ProvinceModel model, Province entity = null)
{
if (entity == null)
entity = new Province();
//entity.Country = LoadCountryById(model.CountryId); ???? <-- HERE
entity.Name = model.Name;
entity.Abbreviation = model.Abbreviation;
entity.CanBillTo = model.CanBillTo;
entity.CanShipTo = model.CanShipTo;
entity.IsPublished = model.IsPublished;
return entity;
}
public static ProvinceModel ToModel(this Province entity, ProvinceModel model)
{
if (model == null)
model = new ProvinceModel();
model.Id = entity.Id;
model.CountryId = entity.Country.Id;
model.Name = entity.Name;
model.Abbreviation = entity.Abbreviation;
model.CanBillTo = entity.CanBillTo;
model.CanShipTo = entity.CanShipTo;
model.IsPublished = entity.IsPublished;
return model;
}
}
With Entity Framework, the Province domain object would have had both Country and the corresponding CountryId properties. I could assign the Country by simply setting the CountryId.
With NHibernate, the id of the foreign key is unnecessary when creating the domain. So how do you map the ProvinceModel CountryId back to a Country object?
I've gone through all kinds of steps to abstract things into interfaces and use Dependency Injection. Should I use a service locator from within the mapping extensions and look it up? Should I look up the country outside of the mapping extension and require it as a parameter on the extension method? What are the recommended ways of handing this scenario?
Second, with NHibernate they recommend adding helper functions to the domain objects in order to maintain associations (not positive, but I think EF handles this "automagically" for me). For example, I would add a SetCountry method on Province, and AddProvince and RemoveProvince methods on Country.
Doesn't this hurt performance? Instead of simply setting the Country for a Province (which is where the association is managed), the entire list of the new Country's Provinces are loaded to see if it is already in the list before adding to the collection, then the entire list of the old Country's Provinces are loaded to see if the province needs to be removed from the collection.

Answer 1

[in EF] I could assign the Country by simply setting the CountryId.
This isn't true and in my opinion this is a major defect with Entity Framework. Having both Country and CountryId properties is a hack that allows you to set the Country without retrieving it from the database by setting the CountryId. In a web app this works because the record is saved with the CountryId foreign key set so the next time you load it the Country is populated. NHibernate's solution to this pattern is the ISession.Load method that creates a dynamic proxy.
In your example you would do something like
province.Country = session.Load<Country>(provinceModel.CountryId);
As to your second question, in general I only use methods to encapsulate access to collections. This ensures that the collection itself is not replaced by a setter and allows me to maintain both sides of the relationship. I would model this as:
public class Country
{
private ICollection<Province> _provinces;
public Country()
{
_provinces = new HashSet<Province>();
}
public virtual IEnumerable<Province> Provinces
{
get { return _provinces; }
}
public virtual void AddProvince(Province province)
{
province.Country = this;
_provinces.Add(province);
}
public virtual void RemoveProvince(Province province)
{
province.Country = null;
_provinces.Remove(province);
}
}
As you noted, this does require loading the collection. You have to remember that NHibernate (and Hibernate) were originally designed for stateful applications and many of the usage patterns are not strictly necessary in stateless web applications. However, I would profile performance before deviating from some of these patterns. For example, you may want to validate your objects before committing them and that requires that the in-memory representations are consistent.