Jeremy D. Miller -- The Shade Tree Developer

@cristian,

Sure, it did help to flush out the syntax.  What I've learned with Fluent Interfaces though is that it's best to go with more coarse grained tests to avoid over specification.

@Chad,

Jeremy made the exact same mistake earlier, only you weren't around to see it blow up in my face;)

@Ruud,

I'm not testing NHibernate per se, I'm testing whether or not my particular interaction with NHibernate was done correctly (and it wasn't).

@Sheraz,

We will be Open Sourcing it at some point, but here's a sample (we generate the database from the Domain Model, so the column names are derived from the object properties):

   public class SalesTransactionMap : DomainClassMap<SalesTransaction>

   {

       public SalesTransactionMap()

       {

           Map(x => x.BuyerName);

           Map(x => x.DeliveryDate);

           Map(x => x.DeliveryNotes);

           Map(x => x.ExpirationDate);

           Map(x => x.OrderDate);

           Map(x => x.QuoteDate);

           Map(x => x.QuoteOrder);

           Map(x => x.TransactionId).ValueIsAutoNumber();

           Map(x => x.CustomerPurchaseOrder);

           Map(x => x.JobName);

           References(x => x.Customer);

           References(x => x.CustomerContact);

           References(x => x.SalesRepresentative);

           References(x => x.Warehouse);

           References(x => x.CustomerJob);

           Component<DeliveryDetails>(x => x.DeliveryDetails, m => configureDetails(m));

           HasMany<SalesLineItem>(x => x.Items);

       }

       private void configureDetails(ComponentPart<DeliveryDetails> deliveryMap)

       {

           deliveryMap.Map(x => x.Mechanism);

           deliveryMap.Map(x => x.DeliveryName);

           deliveryMap.Map(x => x.Distance);

           deliveryMap.Map(x => x.CarrierName);

           deliveryMap.References(x => x.CustomerDeliveryAddress);

           deliveryMap.Component<Address>(x => x.Address, m =>

           {

               m.Map(x => x.AddressLine1);

               m.Map(x => x.AddressLine2);

               m.Map(x => x.AddressLine3);

               m.Map(x => x.CityName);

               m.Map(x => x.CountryName);

               m.References(x => x.State);

               m.References(x => x.PostalCode);

           });

       }

   }

@Colin,

We hit inheritance yesterday.  I stuffed in support for the one table per hierarchy (all I needed in my case), and it worked out well.

"I must admit I don't find that the complexity/readability of the HBM mapping files themselves is too bad,"

Given the choice between writing Xml with strings or ripping through something with Intellisense, which would you rather have?  Plus we're doing quite a bit of "convention over configuration" along the way as well (setting up id's, foreign key naming, taking care of enumeration mapping, pulling some metadata out of embedded validation stuff, etc.)

The inheritance is here:

   public class CategoryMap : DomainClassMap<Category>

   {

       public CategoryMap()

       {

           Map(x => x.Description);

           DiscriminateSubClassesOnColumn<string>("Type")

               .SubClass<WidgetCategory>().IsIdentifiedBy("Widget").MapSubClassColumns(map => { })

               .SubClass<AreaCategory>().IsIdentifiedBy("Area")

                   .MapSubClassColumns(map =>

                                   {

                                       map.Map(x => x.TrackThickness);

                                   })

               .SubClass<LengthCategory>().IsIdentifiedBy("Length")

                   .MapSubClassColumns(map =>

                                   {

                                       map.Map(x => x.TrackOD);

                                   });

       }

   }