The Mad Economist

In the RTM version, I also had to add the following property:

properties.Add("proxyfactory.factory_class", "NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle")

I did not need this before, but you need it now.  Otherwise you get this big ugly:

The ProxyFactoryFactory was not configured.
Initialize 'proxyfactory.factory_class' property of the session-factory configuration section with one of the available NHibernate.ByteCode providers.
Example:
<property name='proxyfactory.factory_class'>NHibernate.ByteCode.LinFu.ProxyFactoryFactory, NHibernate.ByteCode.LinFu</property>
Example:
<property name='proxyfactory.factory_class'>NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle</property>

To be honest, I have not explored the guts of NHibernate to figure this all out.  I just know I could not get my older version to run without the proxyfactory.factory_class property.

Next, come the autoMappings.  This has also changed.

//-> The Old
//let autoMappings = (AutoPersistenceModel.MapEntitiesFromAssemblyOf<StockPrices.COMPANY>()).Where(fun t -> (t.Namespace = "StockPrices"))

//-> The New
let autoMappings = (FluentNHibernate.Automapping.AutoMap.AssemblyOf<StockPrices.COMPANY>()).Where(fun t -> (t.Namespace="StockPrices"))

Not too much difference here -- basically the method "MapEntitiesFromAssemblyOf" has been replaced with "AutoMap.AssemblyOf".  It just took a while to figure it all out.

The point of this statement is that I want FluentNHibernate to map my Company class object and my database table automatically, obviating the need for a mapping interface xml file.

This part:

let autoMappings = FluentNHibernate.Automapping.AutoMap.AssemblyOf<StockPrices.COMPANY>()

says map my object StockPrices.COMPANY to the database.  I then need to add a where clause that tells FluentNHibernate  what namespace to use.  You should check out the FluentNHiernate site to get a more technical understanding of what is going on in the background.

I also discovered I need to wrap this:

FluentNHibernate.Automapping.AutoMap.AssemblyOf<StockPrices.COMPANY>()

in parentheses like this:

(FluentNHibernate.Automapping.AutoMap.AssemblyOf<StockPrices.COMPANY>())

in order to get intellisense to work.  Also, it generated this convoluted error:

"Successive arguments should be separated by spaces or tupled, and arguments involving function or method applications should be parenthesized"

It took me a while to figure out what this meant.  I guess I must be stupid.  Anyway, the where clause:

.Where(fun t -> t.Namespace = "StockPrices")

is an anonymous or lambda function.  The function returns true if the namespace of an entity equals the name "StockPrices" where my COMPANY class resides.

F# provides a way to define a nameless function using the keyword fun. This type of function receives just one input value and returns just one output value.  Generally, if a function is to be passed as an argument to another function (as in the case here), then often you don’t need to give it a name of its own. These functions are referred to as anonymous functions and sometimes called lambda functions or even just lambdas.

The guts of the function above:

t.Namespace = "StockPrices"

 could have just as easily have been written:

if t.Namespace = "StockPrices" then true else false

but that would not have been as cool.