private bool IsAjaxError()
{
  return HttpContext.Current.Response.StatusCode == 500 && HttpContext.Current.Request.RawUrl.Contains(".asmx");
}

Recipes for Disaster:

Team of developers all working/developing off of a central database

Team of developers working/developing off of local database, with no way to keep changes in sync.

So we’ve got a problem, do we have a solution?

1. Tarantino is a forward only change management system, you can’t roll back.
2. If you use Tarantino, you can’t go make changes by hand manually
3. Tarantino uses RedGate SQL Compare if you want, to compare DB Schemas
4. Tarantino makes a table in every DB it touches to keep track of what scripts have been executed on that DB

Project Setup

public class Order

{

    public virtual int Id { get; set; }

    public virtual int OrderNumber { get; set; }

    public virtual string PONumber { get; set; }

    public virtual IList<OrderItem> OrderItems { get; set;}

   public Order()

   {

       OrderItems = new List<OrderItem>();

   }

}

public class OrderItem

{

    public virtual int Id { get; set; }

    public string ItemName { get; set; }

    public string Description { get; set; }

}

[TestFixture]

public class DB_Setup_Fixture

{

    private Configuration _configuration;

    [TestFixtureSetUp]

    public void FixtureSetup()

    {

        _configuration = Fluently.Configure()

            .Database(MsSqlConfiguration.MsSql2008

                          .ConnectionString(c =>

                                            c.FromConnectionStringWithKey("testData"))

                          .UseReflectionOptimizer()

                          .ShowSql())

            .Mappings(m =>

                      m.AutoMappings.Add(AutoMap.AssemblyOf<Order>()

                                             .Where(x => x.Namespace.EndsWith("Domain"))))

            .BuildConfiguration();

    }

    [Test, Explicit, Category("DBSetup")]

    public void Create_DB_Schema()

    {

        var exporter = new SchemaExport(_configuration);

        exporter.Create(true, true);

    }

}

The one thing to make note of here, is that my test is set to explicit, and I gave it a category of “DBSetup”. This will be important once we start configuring NAnt and Tarantino.

Common.build

<?xml version="1.0" encoding="utf-8"?>

<project xmlns="http://nant.sf.net/schemas/nant.xsd">

    <!-- Database change management -->

    <target name="rebuildDatabase" depends="dropDatabase, createDatabase" />

    <target name="updateDatabase">

        <property name="action" value="Update" />

        <call target="manageSqlDatabase" />

    </target>

    <target name="createDatabase">

        <property name="action" value="Create" />

        <call target="manageSqlDatabase" />

    </target>

    <target name="dropDatabase">

        <property name="action" value="Drop" />

        <call target="manageSqlDatabase" failonerror="false"/>

    </target>

    <target name="manageSqlDatabase">

        <manageSqlDatabase

            scriptDirectory="${database.script.directory}"

            action="${action}"

            server="${database.server}"

            integratedAuthentication="${database.integrated}"

            database="${database.name}"

      username="${database.username}"

      password="${database.password}"

        />

        <if test="${action != 'Drop'}">

            <echo message="Current Database Version: ${usdDatabaseVersion}" />

        </if>

    </target>

  <script language="C#" prefix="migration" >

    <references>

      <include name="System.IO.dll" />

    </references>

    <code>

      <![CDATA[

              [Function("next-migration-number")]

              public static string NextMigration(string path  ) {

                  string[] files = System.IO.Directory.GetFiles(path);

                  int count=1;

                    if(files.Length > 0)

                    {

                        string filename = System.IO.Path.GetFileName(files[files.Length-1]);

                        try

                        {

                            count = Convert.ToInt32(filename.Substring(0, 4));

                            count++;

                            if(count%2 == 0)

                                count++;

                        }

                        catch

                        {

                        }

                    }

                  return string.Format("{0:0000}", count);

              }

            ]]>

    </code>

  </script>

</project>

NAnt.build

<?xml version="1.0" encoding="utf-8"?>

<!--EXTERNAL_PROPERTIES: usdDatabaseVersion, CCNetLabel-->

<project name="TarantinoSample" xmlns="http://nant.sf.net/schemas/nant.xsd">

      <!-- ************** -->

    <!-- Initialization -->

    <!-- ************** -->

    <include buildfile="common.build"/>

      <loadtasks assembly="lib\nant\Tarantino.Nant.Tasks.dll" />

    <!-- ***************** -->

    <!-- Master Properties -->

    <!-- ***************** -->

    <property name="company.name" value="Tarantino Test"/>

    <property name="assembly.unittests" value="TarantinoSample.dll"/>

    <!-- Version settings -->

    <property name="project.config" value="debug"/>

    <!-- Folder references -->

    <property name="dir.solution" value="src"/>

    <property name="dir.build" value="build" dynamic="true"/>

    <!-- Compilation settings -->

    <property name="nant.settings.currentframework" value="net-3.5" />

    <property name="file.solution" value="${dir.solution}/${project::get-name()}.sln"/>

    <!-- Database migration settings -->

    <property name="database.script.directory" value="dbChangeScripts" />

      <property name="database.server" value="localhost" overwrite="false"/>

    <property name="database.name" value="OrderData" overwrite="false"/>

    <property name="database.integrated" value="true" overwrite="false" />

    <property name="database.username" value="dbuser" overwrite="false"/>

    <property name="database.password" value="P@ssword1" overwrite="false"/>

    <!-- ********************************** -->

    <!-- Database Change Management Targets -->

    <!-- ********************************** -->

    <target name="reset-database" depends="dropDatabase, createDatabase">

        <nunit2 failonerror="true" verbose="true">

            <formatter type="Plain" />

            <test assemblyname="${dir.solution}/bin/${project.config}/${assembly.unittests}">

                <categories>

                    <include name="DBSetup"/>

                    <exclude name="*"/>

                </categories>

            </test>

        </nunit2>

    </target>

      <target name="db-migration">

        <delete file="${database.script.directory}/Update/_New_Script.sql"  />

        <call target="reset-database" />

        <call target="create-versioned-database" />

        <property name="migrationScriptName" value="${migration::next-migration-number(database.script.directory+'/Update')}_AutoGeneratedMigration.sql"/>

        <if test="${file::exists('c:\program files (x86)\red gate\SQL Compare 8\SQLCompare.exe')}" >

              <property name="redgate.exe" value="c:\program files (x86)\red gate\SQL Compare 8\SQLCompare.exe"/>

        </if>

        <if test="${file::exists('c:\program files\red gate\SQL Compare 8\SQLCompare.exe')}" >

              <property name="redgate.exe" value="c:\program files\red gate\SQL Compare 8\SQLCompare.exe"/>

        </if>

        <exec

              program="${redgate.exe}"

              commandline="/f /v /server1:${database.server} /server2:${database.server} /database1:${database.name} /database2:${database.name}Versioned /scriptfile:${database.script.directory}/Update/_New_Script.sql /exclude:Table:usd_AppliedDatabaseScript"

              resultproperty="execReturnCode"

              failonerror ="false"/>

          <fail if="${execReturnCode != '0' and execReturnCode != '63'}" message="Redgate Compare Failed!"/>

        <if test="${file::exists(database.script.directory + '/Update/_New_Script.sql') == false}">

            <echo message=""/>

              <echo message="---------------------"/>

              <echo message="No Migration Required"/>

        </if>

        <if test="${file::exists(database.script.directory + '/Update/_New_Script.sql')}">

            <move file="${database.script.directory}/Update/_New_Script.sql" tofile="${database.script.directory}/Update/${migrationScriptName}"/>

            <echo message="Created Migration File ${database.script.directory}/Update/${migrationScriptName}"/>

          </if>

      </target>

      <target name="create-versioned-database">

        <tstamp></tstamp>

        <manageSqlDatabase

            action="Drop"

            server="${database.server}"

            integratedAuthentication="true"

            database="${database.name}Versioned"

            username=""

            password="" />

        <manageSqlDatabase

            scriptDirectory="${database.script.directory}"

            action="Create"

            server="${database.server}"

            integratedAuthentication="true"

            database="${database.name}Versioned"

            username=""

            password="" />

      </target>

</project>

Change script creation

lib\nant\nant.exe –buildfile:nant.build create-versioned-database

Push to Production or Dev

lib\nant\nant.exe –buildfile:nant.build updateDatabase –D:database.name=OrderDataProd

lib\nant\nant.exe –buildfile:nant.build createDatabase –D:database.name=OrderDataProd

Source Code

• Zip File Download
• Elegant Code SVN Repository

Information Sources

Building a UI can be a very database intensive operation in terms of the number of separate calls required. And for each one of those calls the time taken to actually execute the query can be a small compared to the duration of the roundtrip to request and fetch the data. The obvious solution is some type of batching and with Future<T> this happens automagically without any change to the consuming logic (for databases that support it). Let me restate that, you get a huge performance benefit with only a simple change to your query methods in the Repository. So why aren’t you using it?

Cascading deletes are all great if your database of choice supports CASCADE DELETE foreign key constraints. But what if it doesn't provide this feature or, as in my case, the database in question does support this feature but the DBA's don't want anything to do with it? In case of a parent domain object having a collection of many child objects, you still might want to have a one-shot delete capability instead of having separate DELETE statements for each child record.

The newly released NHibernate 2.1 (congratulations to the entire team for their efforts and hard work) comes to the rescue, which introduces a couple of new event listeners that deal with collections.

First we need an example. Suppose we are building an auction web site and the domain has a class called Item which in turn has a collection of Bids.

public class Item
{
    private ISet<Bid> _bids;    
    public Int64 Id { get; private set; }
    
    ...
}

public class Bid
{
    public Double Amount { get; private set; }
    public Sting Code { get; private set; }

    ...
}

The mapping for these classes looks something like this:

<class name="MyAuction.Item, MyAuction" 
       table="Item">
    <id name="Id" type="Int64" unsaved-value="-1">
        <column name="Id" sql-type="integer"/>
        <generator class="native"/>
    </id>
    
    ...
    
    <set name="Bids" 
         access="field.camelcase-underscore" 
         lazy="false" 
         cascade="all-delete-orphan" 
         inverse="true" 
         optimistic-lock="false">
        <key>
            <column name="ItemId"/>
        </key>
        <one-to-many class="MyAuction.Bid, MyAuction"/>
    </set>
</class>

<class name="MyAuction.Bid, MyAuction" 
       table="Bid">
    <composite-id>
        <key-property name="ItemId" 
                      column="ItemId" 
                      type="Int64"/>
        <key-property name="Code" 
                      column="Code" 
                      type="String"/>
    </composite-id>
    
    ...
    
</class>

Just to give you a general idea of the situation here. Now suppose we want to delete a quite popular Item object  which has a numerous amount of Bids. Because the collection of Bids is mapped as inverse, NHibernate will remove every record for a Bid with a separate DELETE statement for each row.

DELETE FROM Bid WHERE ItemId=@p0 AND Code=@p1 ;@p0 = 2, @p1 = 'F1001'
DELETE FROM Bid WHERE ItemId=@p0 AND Code=@p1 ;@p0 = 2, @p1 = 'F1002'
DELETE FROM Bid WHERE ItemId=@p0 AND Code=@p1 ;@p0 = 2, @p1 = 'F1003'
...
DELETE FROM Item WHERE Id = @p0; @p0 = 2

We could solve this by creating a collection event listener. The first thing we have to do is figure out how to issue a one-shot delete instead of those separate DELETE statements.

public interface IOneShotDeleteHandler
{   
    Type ForEntity();
    Type[] ForChildEntities();
    void GiveItAShot(ISession session, Object entity);
}

public class OneShotDeleteHandlerForItem : IOneShotDeleteHandler
{
    public Type ForEntity()
    {
        return typeof(Item);
    }

    public Type[] ForChildEntities()
    {
        return new[] { typeof(Bid) };
    }

    public void GiveItAShot(ISession session, Object entity)
    {
        var item = (Item)entity;

        session.CreateQuery("delete Bid where ItemId = :itemId")
            .SetInt64("itemId", item.Id)
            .ExecuteUpdate();
    }
}

We created an IOneShotDeleteHandler interface with one implementation for the Item class.  The most notable aspect of this implementation is the use of the HQL delete statement that removes all Bids for a particular Item.

Next step is to create a collection event listener that implements the IPreCollectionRemoveEventListener interface.

public interface IEventListener
{
    void ConfigureFor(Configuration configuration);
}

public class CollectionRemoveEventListener 
    : IPreCollectionRemoveEventListener,
      IEventListener
{
    private readonly IEnumerable<IOneShotDeleteHandler> 
        _oneShotDeleteHandlers;
    
    public CollectionRemoveEventListener(
        IEnumerable<IOneShotDeleteHandler> oneShotDeleteHandlers)
    {
        _oneShotDeleteHandlers = oneShotDeleteHandlers;
    }

    public void OnPreRemoveCollection(
        PreCollectionRemoveEvent @event)
    {
        var affectedOwner = @event.AffectedOwnerOrNull;
        if(null == affectedOwner)
            return;

        var oneShotDeleteHandler = 
            _oneShotDeleteHandlers.SingleOrDefault(handler =>
            handler.ForEntity() == affectedOwner.GetType());

        if(null == oneShotDeleteHandler)
            return;

        oneShotDeleteHandler
            .GiveItAShot(@event.Session, affectedOwner);
    }

    public void ConfigureFor(Configuration configuration)
    {
        configuration
            .SetListener(ListenerType.PreCollectionRemove, this);
    }
}

Don't worry about the IEventListener interface. Its just there for registering all NHibernate event listeners in an IoC container.By doing so, it enables us to inject a collection of IOneShotDeleteHandler objects into the constructor of our event listener. When the OnPreRemoveCollection method is called, we simply lookup whether there's a handler available for the type of entity that's going to be deleted and give it a shot at removing its child collection in one sweep.

Now we only have to register this event listener:

var eventListeners = _dependencyContainer
    .ResolveAll<IEventListener>();
eventListeners.ForEach(eventListener => eventListener
    .ConfigureFor(configuration));

Now, if we would use this 'as is', NHibernate will give us the following error:

Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect)

This is due to the fact that the collection event listener does its work and deletes all Bids by executing the HQL statement, but NHibernate still tries to issue a DELETE statement for each Bid. This is the result of the all-delete-orphan cascading rule we imposed in the mapping. We could reduce it to save-update, but then no individual DELETE statements are executed when a singe Bid is removed from the collection. Now what?

Well, we could provide a regular delete event listener that allows individual DELETE statements for Bid entities as long as their parent Item is not removed.

public class DeleteEventListener : 
    DefaultDeleteEventListener,
    IEventListener
{
    private readonly IEnumerable<IOneShotDeleteHandler> 
        _oneShotDeleteHandlers;

    public DeleteEventListener(
        IEnumerable<IOneShotDeleteHandler> oneShotDeleteHandlers)
    {
        _oneShotDeleteHandlers = oneShotDeleteHandlers;
    }

    protected override void DeleteEntity(
        IEventSource session, object entity, 
        EntityEntry entityEntry, Boolean isCascadeDeleteEnabled, 
        IEntityPersister persister, ISet transientEntities)
    {
        var oneShotDeleteHandler = _oneShotDeleteHandlers
            .SingleOrDefault(handler =>
                handler.ForChildEntities()
                    .Contains(entity.GetType()));

        if(null == oneShotDeleteHandler ||
           !IsParentAlsoDeletedIn(
                session.PersistenceContext, 
                oneShotDeleteHandler.ForEntity())
            )
        {
            base.DeleteEntity(session, entity, entityEntry, 
                              isCascadeDeleteEnabled, persister, 
                              transientEntities);
            return;
        }

        CascadeBeforeDelete(session, persister, entity, 
                            entityEntry, transientEntities);
        CascadeAfterDelete(session, persister, entity, 
                           transientEntities);
    }

    public void ConfigureFor(Configuration configuration)
    {
        configuration.SetListener(ListenerType.Delete, this);
    }

    private static Boolean IsParentAlsoDeletedIn(
        IPersistenceContext persistenceContext, Type typeOfParent)
    {
        foreach(DictionaryEntry entry in 
                                    persistenceContext.EntityEntries)
        {
            if(typeOfParent != entry.Key.GetType())
                continue;
            
            var entityEntry = (EntityEntry)entry.Value;
            if(Status.Deleted == entityEntry.Status)
                return true;
        }

        return false;
    }
}

With both event listeners registered, deleting a single Bid results in a single DELETE statement as one would expect:

DELETE FROM Bid WHERE ItemId=@p0 AND Code=@p1 ;@p0 = 2, @p1 = 'F1002'

and  removing an entire Item now results in a one-shot delete for all Bids:

DELETE FROM Bid WHERE ItemId=@p0; @p0 = 2
DELETE FROM Item WHERE Id = @p0; @p0 = 2

Make sure you use this solution for one-shot deletes wisely and only if you have to. If you can use the CASCADE DELETE foreign key constraints, then by all means, this is the preferred option. If not, only resort to this kind of solution only if you must and that you can prove that its going to give you a tremendous performance benefit. Also take a look at the batching support that NHibernate provides (at the moment only SQL Server and Oracle are supported).

Till next time

Using NHibernate in these scenarios can be challenging sometimes but its built in flexibility and extensibility really helps you to deal with those cases. The problem I ran into last week was that we needed to store a domain object into a table that had a lot more columns than were actually required for our application. If it would be possible to store null values in these columns or if they had default values configured for them in the schema, then this would not be a problem. Instead, these unnecessary columns could not store null values and had no default values associated with them.

First option would be to make some changes to the schema of the table. Alas, no luck there because the other legacy applications that are using the same table would break. Now what?

We needed to insert the default values ourselves, but those columns are not known by NHibernate because they are not mapped to any members of the domain object. One way to solve this, is to pollute the domain object by adding private fields that are initialized to the required default values.

public class SomeDomainEntity
{
    // Legacy fields with no purpose for the domain but required 
    // by the database.
    private Int32 _legacyField1 = 2;
    private Boolean _legacyField2 = false;
    private String _legacyField3 = "";
}

This is probably the simplest option, but imposes a broken window as infrastructure concerns are bleeding into the domain this way. In other words, this is not a viable solution. Keeping the legacy stuff isolated as much as possible, NHibernate provides some ways to deal with this by providing an extensive extensibility model.

After some snooping around in the source code of NHibernate, the solution we chose for dealing with this issue is by creating a custom access strategy. The built in property access strategies are probably already well known, but its also possible to write your own access strategy by implementing the IPropertyAccessor interface.

public class SomeDomainObjectAccessor : IPropertyAccessor
{
    private IEnumerable<IGetter> _defaultValueGetters;
    
    public SomeDomainObjectAccessor()
    {
        _defaultValueGetters = new List<IGetter>()
        {
            { new DefaultValueGetter<Int32>("LegacyColumn1", 2) }
            { new DefaultValueGetter<Boolean>("LegacyColumn2", false) }
            { new DefaultValueGetter<String>("LegacyColumn3", 2) }
        }
    }

    public IGetter GetGetter(Type type, String propertyName)
    {
        return _defaultValueGetters        
            .Where(getter => getter.PropertyName == propertyName)        
            .SingleOrDefault();
    }
    
    public ISetter GetSetter(Type type, String propertyName)
    {
        return new NoopSetter();
    }

    public Boolean CanAccessTroughReflectionOptimizer
    {
        get { return true; }
    }
}

private class DefaultValueGetter<T> : IGetter
{
    private readonly String _propertyName;
    private T Value { get; set; }

    public DefaultValueGetter(String propertyName, T value)
    {
        _propertyName = propertyName;
        Value = value;
    }

    public Object Get(Object target)
    {
        return Value;
    }

    public Type ReturnType
    {
        get { return typeof(T); }
    }

    public String PropertyName
    {
        get { return _propertyName; }
    }

    public MethodInfo Method
    {
        get
        {
            var method = typeof(BasicPropertyAccessor)              
                .GetMethod("GetGetterOrNull",
                           BindingFlags.Static | BindingFlags.NonPublic);

            var result = (BasicPropertyAccessor.BasicGetter)method              
                .Invoke(null, new Object[] { GetType(), "Value" });

            return result.Method;
        }
    }

    public object GetForInsert(Object owner, IDictionary mergeMap,
                               ISessionImplementor session)
    {
        return Get(owner);
    }
}

private sealed class NoopSetter : ISetter
{
    public void Set(Object target, Object value)
    {}

    public String PropertyName
    {
        get { return null; }
    }

    public MethodInfo Method
    {
        get { return null; }
    }
}

This simply involves a getter for providing default values and a dummy setter as we're not interested in setting any values on the domain objects. The DefaultValueGetter class uses a trick so that we can keep using the reflection optimizer of NHibernate. This also seems to be necessary when using NHibernate Profiler.

Now we only have to provide some properties in the mapping of the domain object using our custom access strategy:

<property 
    name="LegacyColumn1"
    column="LegacyColumn1"
    not-null="true"
    type="Int32"
    access="SomeNamespace.SomeDomainObjectAccessor, SomeAssembly"/>
          
<property 
    name="LegacyColumn2"
    column="LegacyColumn2"
    not-null="true"
    type="Boolean"
    access="SomeNamespace.SomeDomainObjectAccessor, SomeAssembly"/>
          
<property 
    name="LegacyColumn3"
    column="LegacyColumn3"
    not-null="true"
    type="String"
    access="SomeNamespace.SomeDomainObjectAccessor, SomeAssembly"/>

This is probably not the best solution, but it does the job and prevents polluting the domain objects as a result of database quirks like these. I'm interested in hearing feedback or any better approaches.

Anyway, the easy extensibility of NHibernate makes it the best data access solution around. This way, one can deal with all edge case scenarios that weren't anticipated by the framework builders.

Till next time  

But support in NHibernate for Sybase is not great. The basics work but some of the more advanced features are not implemented at all or are done poorly. Fortunately we have an excellent relationship with our vendor and have had for many years. Earlier this week they contacted me and mentioned that they will be undertaking an effort to improve their support for NHibernate and were looking for some beta testers.

For this effort they can be commended. It’s also telling (and significant) that OR/M usage is becoming mainstream enough for them to consider this effort worthwhile.

Glenn is going to be leading the effort (as he did for the Java version last year). If you want to influence the direction that we go then please tell us what needs to be fixed.

• FubuMVC From Scratch Part 1 – Basic project structure setup
• FubuMVC From Scratch Part 2 – FubuMVC configuration and Controller setup
• FubuMVC From Scratch – Part 3 (Adding View to project)

Persistence is a requirement in virtually every application that we write today, and now the time has come for us to add a persistence model to our FubuMVC app. I know I mentioned moving my samples to the FubuCart source, but I am going to go ahead and implement the persistence piece in the same project the previous articles using, FubuSample. I have also added all the code for this series to the FubuMVC-Contrib project

We will be implementing our persistence model to use NHibernate, Fluent NHibernate, Repository Pattern and UnitOfWork pattern all on top of SQL Express or standard. This will also work for sqllite and other database servers.

Class and Interfaces we have to implement:

• ISessionSourceConfiguration
• SQLServerSessionSourceConfiguration
• IUnitOfWork
• INHibernateUnitOfWork
• NHibernateUnitOfWork
• IRepository
• NHibernateRepository
• DomainEntity
• IDomainQuery
• FubuSamplePersistenceModel

Note: I put the first two in the list in my Core.Config namespace, and the rest in Core.Persistence

Before we start you probably want to go ahead and add the following references to your core project and Web project

Let’s just work our way down the list and get these files implemented.

ISessionSourceConfiguration

public interface ISessionSourceConfiguration

{

    bool IsNewDatabase { get; }

    ISessionSource CreateSessionSource(PersistenceModel model);

}

SQLServerSessionSourceConfiguration

public class SQLServerSessionSourceConfiguration : ISessionSourceConfiguration

{

    #region Implementation of ISessionSourceConfiguration

    public bool IsNewDatabase

    {

        get { return false; }

    }

    public ISessionSource CreateSessionSource(PersistenceModel model)

    {

        var properties = GetProperties();

        var source = new SessionSource(properties, model);

        create_schema_if_it_does_not_already_exist(source);

        return source;

    }

    private void create_schema_if_it_does_not_already_exist(ISessionSource source)

    {

        if (IsNewDatabase) source.BuildSchema();

    }

    protected IDictionary<string, string> GetProperties()

    {

        MsSqlConfiguration config = MsSqlConfiguration.MsSql2005;

        config.ConnectionString.FromConnectionStringWithKey(“MYDBKEY”);

        config.ShowSql();

        config.UseOuterJoin();

        return config.ToProperties();

    }

    #endregion

}

A quick note here: We told SQLServerSessionSourceConfiguration to use a connection string from the app settings file (Web.Config) with a key of “MYDBKEY” This will be important later.

IUnitOfWork

public interface IUnitOfWork : IDisposable

{

    void Initialize();

    void Commit();

    void Rollback();

}

INHibernateUnitOfWork

public interface INHibernateUnitOfWork : IUnitOfWork

{

    ISession CurrentSession { get; }

}

NHibernateUnitOfWork

public class NHibernateUnitOfWork : INHibernateUnitOfWork

{

    private ITransaction _transaction;

    private bool _isDisposed;

    private readonly ISessionSource _source;

    private bool _isInitialized;

    public NHibernateUnitOfWork(ISessionSource source)

    {

        _source = source;

    }

    public void Initialize()

    {

        should_not_currently_be_disposed();

        CurrentSession = _source.CreateSession();

        begin_new_transaction();

        _isInitialized = true;

    }

    public ISession CurrentSession { get; private set; }

    public void Commit()

    {

        should_not_currently_be_disposed();

        should_be_initialized_first();

        _transaction.Commit();

        begin_new_transaction();

    }

    private void begin_new_transaction()

    {

        if (_transaction != null)

        {

            _transaction.Dispose();

        }

        _transaction = CurrentSession.BeginTransaction();

    }

    public void Rollback()

    {

        should_not_currently_be_disposed();

        should_be_initialized_first();

        _transaction.Rollback();

        begin_new_transaction();

    }

    private void should_not_currently_be_disposed()

    {

        if (_isDisposed) throw new ObjectDisposedException(GetType().Name);

    }

    private void should_be_initialized_first()

    {

        if (!_isInitialized) throw new InvalidOperationException("Must initialize (call Initialize()) on NHibernateUnitOfWork before commiting or rolling back");

    }

    public void Dispose()

    {

        if (_isDisposed || !_isInitialized) return;

        _transaction.Dispose();

        CurrentSession.Dispose();

        _isDisposed = true;

    }

}

IRepository

public interface IRepository

{

    void Save<ENTITY>(ENTITY entity)

        where ENTITY : DomainEntity;

    ENTITY Load<ENTITY>(Guid id)

        where ENTITY : DomainEntity;

    IQueryable<ENTITY> Query<ENTITY>()

        where ENTITY : DomainEntity;

    IQueryable<ENTITY> Query<ENTITY>(IDomainQuery<ENTITY> whereQuery)

        where ENTITY : DomainEntity;

    void Delete<ENTITY>(ENTITY entity);

    void DeleteAll<ENTITY>();

}

NHibernateRepository

public class NHibernateRepository : IRepository

{

    private readonly INHibernateUnitOfWork _unitOfWork;

    public NHibernateRepository(INHibernateUnitOfWork unitOfWork)

    {

        _unitOfWork = unitOfWork;

    }

    public void Save<ENTITY>(ENTITY entity) where ENTITY : DomainEntity

    {

        _unitOfWork.CurrentSession.SaveOrUpdate(entity);

    }

    public ENTITY Load<ENTITY>(Guid id) where ENTITY : DomainEntity

    {

        return _unitOfWork.CurrentSession.Load<ENTITY>(id);

    }

    public IQueryable<ENTITY> Query<ENTITY>() where ENTITY : DomainEntity

    {

        return _unitOfWork.CurrentSession.Linq<ENTITY>();

    }

    public IQueryable<ENTITY> Query<ENTITY>(IDomainQuery<ENTITY> whereQuery) where ENTITY : DomainEntity

    {

        return _unitOfWork.CurrentSession.Linq<ENTITY>().Where(whereQuery.Expression);

    }

    public void Delete<ENTITY>(ENTITY entity)

    {

        _unitOfWork.CurrentSession.Delete(entity);   

    }

    public void DeleteAll<ENTITY>()

    {

        var query = String.Format("from {0}", typeof(ENTITY).Name);

        _unitOfWork.CurrentSession.Delete(query);   

    }

}

DomainEntity

Note: I put both of these classes in my Core.Domain namespace, also XML comments are in Source Repository

public class DomainEntity : IEquatable<DomainEntity>

{

    public virtual Guid ID { get; set; }

    public virtual bool Equals(DomainEntity other)

    {

        if (ReferenceEquals(null, other)) return false;

        if (ReferenceEquals(this, other)) return true;

        return other.ID.Equals(ID);

    }

    public override bool Equals(object obj)

    {

        if (ReferenceEquals(null, obj)) return false;

        if (ReferenceEquals(this, obj)) return true;

        if (obj.GetType() != GetType()) return false;

        return Equals((DomainEntity)obj);

    }

    public override int GetHashCode()

    {

        return ID.GetHashCode();

    }

    public static bool operator ==(DomainEntity left, DomainEntity right)

    {

        return Equals(left, right);

    }

    public static bool operator !=(DomainEntity left, DomainEntity right)

    {

        return !Equals(left, right);

    }

}

IDomainQuery

public interface IDomainQuery<ENTITY>

    where ENTITY : DomainEntity

{

    Expression<Func<ENTITY, bool>> Expression { get; }

}

FubuSamplePersistenceModel

namespace FubuSample.Core.Domain.Persistence

{

    public class FubuSamplePersistenceModel : PersistenceModel

    {

        public FubuSamplePersistenceModel()

        {

            addMappingsFromThisAssembly();

        }

    }

}

Now that we have all the puzzle pieces in place we need to hook them up and make them do some work. Open up FubuSampleWebRegistry

And add the following code:

protected override void configure()

{

    ForRequestedType<ISessionSourceConfiguration>().AsSingletons()

        .TheDefault.Is.OfConcreteType<SQLServerSessionSourceConfiguration>();

    ForRequestedType<ISessionSource>().AsSingletons()

        .TheDefault.Is.ConstructedBy(ctx =>

                                     ctx.GetInstance<ISessionSourceConfiguration>()

                                         .CreateSessionSource(new FubuSamplePersistenceModel()));

    ForRequestedType<IUnitOfWork>().TheDefault.Is.ConstructedBy(ctx => ctx.GetInstance<INHibernateUnitOfWork>());

    ForRequestedType<INHibernateUnitOfWork>().CacheBy(InstanceScope.Hybrid)

        .TheDefault.Is.OfConcreteType<NHibernateUnitOfWork>();

    ForRequestedType<IRepository>().TheDefault.Is.OfConcreteType<NHibernateRepository>();

}

With a little luck and all of our mad skills, we should be able to talk to the database now. So we need to plumb our simple product object up to talk to NHibernate. We will do this with a mapping file, and since we are using FluentNHibernate we can do this strongly typed.

Make the following modifications to Product: Extend DomainEntity and get rid of Id Property, it is inherited

public class Product : DomainEntity

{

    public virtual string Name { get; set; }

    public virtual string Description { get; set; }

}

Add mapping file for Product:

namespace FubuSample.Core.Domain.Mapping

{

    public class ProductMap : ClassMap<Product>

    {

        public ProductMap()

        {

            Id(e => e.ID).GeneratedBy.GuidComb();

            Map(p => p.Name);

            Map(p => p.Description);

        }

    }

}

You may also want to setup your connection string at this point in the Web.Config file, mine looks like this:

<add name="MYDBKEY" connectionString="Data Source=LOCALHOST;initial catalog=FubuSample;Integrated Security=SSPI;" providerName="System.Data.SqlClient" />

I also created an empty database in my local SQL Server instance called “FubuSample” And then I went back to SQLServerSessionSourceConfiguration and changed the value of IsNewDatabase to return true. This will create the schema for the database when the application first runs. There is a multitude of different ways that we can handle this, but this was easy for the tutorial purposes.

Next we will add a behavior to our core project and tell FubuMVC to apply that behavior to all or our ControllerActions.

Create a class named “access_the_database_through_a_unit_of_work” in your Core.Web.Behaviors namespace. The contents will look like this:

public class access_the_database_through_a_unit_of_work : IControllerActionBehavior

{

    private readonly IUnitOfWork _unitOfWork;

    public access_the_database_through_a_unit_of_work(IUnitOfWork unitOfWork)

    {

        _unitOfWork = unitOfWork;

    }

    public IControllerActionBehavior InsideBehavior { get; set; }

    public IInvocationResult Result { get; set; }

    public OUTPUT Invoke<INPUT, OUTPUT>(INPUT input, Func<INPUT, OUTPUT> func)

        where INPUT : class

        where OUTPUT : class

    {

        _unitOfWork.Initialize();

        try

        {

            var output = InsideBehavior.Invoke(input, func);

            Result = InsideBehavior.Result;

            _unitOfWork.Commit();

            return output;

        }

        catch

        {

            _unitOfWork.Rollback();

            throw;

        }

        finally

        {

            _unitOfWork.Dispose();

        }

    }

}

Now to tell FubuMVC what to do, open up Global.asax.cs or your Bootstrapper, wherever you are doing the configuration of FubuMVC. In this project we are doing it in Global.asax.cs Add a new behavior to the section that starts with “x.ByDefault.EveryControllerAction” so it looks like this:

x.ByDefault.EveryControllerAction(d =>

   {

       d.Will<execute_the_result>();

       d.Will<access_the_database_through_a_unit_of_work>();

   });

The last thing we will do is open up HomeController and add this code above the Index action:

private IRepository _repository;

public HomeController(IRepository repository)

{

    _repository = repository;

}

I also modified the Index action to go ahead and create some database values before we query for them just so we can test this thing. (I only did this for the tutorial, I swear) So modify the Index action to look like this:

public IndexViewModel Index(IndexSetupViewModel inModel)

{

    var prod1 = new Product {Name = "TestProduct1", Description = "This is a test product"};

    _repository.Save(prod1);

    var prod2 = new Product {Name = "TestProduct2", Description = "This is a test product"};

    _repository.Save(prod2);

    var outModel = new IndexViewModel();

    var productList = _repository.Query<Product>();

    outModel.Products = productList.ToList().Select(x => new ProductDisplay(x));

    return outModel;

}

Now with you should be able to run your web app and browse to /home and all this will be executed and you will be on your way to creating a whole bunch of persist able objects for use with your FubuMVC app.

As always, feedback is welcome.

Catalog:

  <class name="Catalog" table="`Catalog`" optimistic-lock="version">
    <id name="Id" column="Id" type="Guid">
      <generator class="guid.comb" />
    </id>
    <version column="Version" name="Version" />
    <property name="Name" length="100" type="String">
      <column name="Name" />
    </property>
    ...
  </class>

CatalogCategory:

<class name="CatalogCategory" table="`CatalogCategory`" optimistic-lock="version">
  <id name="Id" column="Id" type="Guid">
    <generator class="guid.comb" />
  </id>
  <version column="Version" name="Version" />
  <property name="Description" length="100" type="String">
    <column name="Description" />
  </property>

   ...

</class>

DomainEntityMapping:

public abstract class DomainEntityMapping<TDomainEntity> :
ClassMap<TDomainEntity> where TDomainEntity : DomainEntity
{
    protected DomainEntityMapping()
    {
        Id(entity => entity.Id, "Id")
            .GeneratedBy.GuidComb();
        OptimisticLock.Version();
        Version(entity => entity.Version)
            .TheColumnNameIs("Version");
    }
}

CatalogMapping:

public class CatalogMapping : DomainEntityMapping<Catalog>
{
  public CatalogMapping()
  {
      Map(catalog=> catalog.Name, "Name");
  }
}

CatalogCategoryMapping:

public class CatalogCategoryMapping : DomainEntityMapping<CatalogCategory>
{
    public CatalogCategoryMapping()
    {
        Map(category=> category.Description, "Name");
    }
}

Mapping Tests

[TestFixture]
public class When_verifying_the_class_mapping_of_a_catalog
    : NHibernateSpecification
{
  [Test]
  public void Then_a_catalog_object_should_be_persistable()
  {
      new PersistenceSpecification<Catalog>(Session)
          .VerifyTheMappings();
  }
}

[TestFixture]
public class NHibernateSpecification
    : Specification
{
    protected ISession Session { get; private set; }
    protected override void Establish_context()
    {
        var config = new SQLiteConfiguration()
            .InMemory()
            .ShowSql()
            .ToProperties();

        var sessionSource = new SessionSource(config,
            new RetailerPersistenceModel());

        Session = sessionSource.CreateSession();
        sessionSource.BuildSchema(Session);

        ProvideInitialData(Session);

        Session.Flush();
        Session.Clear();
   }

    protected override void Dispose_context()
    {
        if(null != Session)
        {
            Session.Dispose();
            Session = null;
        }
    }
}

Recipes for Disaster:

Team of developers all working/developing off of a central database

Team of developers working/developing off of local database, with no way to keep changes in sync.

So we’ve got a problem, do we have a solution?

1. Tarantino is a forward only change management system, you can’t roll back.
2. If you use Tarantino, you can’t go make changes by hand manually
3. Tarantino uses RedGate SQL Compare if you want, to compare DB Schemas
4. Tarantino makes a table in every DB it touches to keep track of what scripts have been executed on that DB

Project Setup

public class Order

{

    public virtual int Id { get; set; }

    public virtual int OrderNumber { get; set; }

    public virtual string PONumber { get; set; }

    public virtual IList<OrderItem> OrderItems { get; set;}

   public Order()

   {

       OrderItems = new List<OrderItem>();

   }

}

public class OrderItem

{

    public virtual int Id { get; set; }

    public string ItemName { get; set; }

    public string Description { get; set; }

}

[TestFixture]

public class DB_Setup_Fixture

{

    private Configuration _configuration;

    [TestFixtureSetUp]

    public void FixtureSetup()

    {

        _configuration = Fluently.Configure()

            .Database(MsSqlConfiguration.MsSql2008

                          .ConnectionString(c =>

                                            c.FromConnectionStringWithKey("testData"))

                          .UseReflectionOptimizer()

                          .ShowSql())

            .Mappings(m =>

                      m.AutoMappings.Add(AutoMap.AssemblyOf<Order>()

                                             .Where(x => x.Namespace.EndsWith("Domain"))))

            .BuildConfiguration();

    }

    [Test, Explicit, Category("DBSetup")]

    public void Create_DB_Schema()

    {

        var exporter = new SchemaExport(_configuration);

        exporter.Create(true, true);

    }

}

The one thing to make note of here, is that my test is set to explicit, and I gave it a category of “DBSetup”. This will be important once we start configuring NAnt and Tarantino.

Common.build

<?xml version="1.0" encoding="utf-8"?>

<project xmlns="http://nant.sf.net/schemas/nant.xsd">

    <!-- Database change management -->

    <target name="rebuildDatabase" depends="dropDatabase, createDatabase" />

    <target name="updateDatabase">

        <property name="action" value="Update" />

        <call target="manageSqlDatabase" />

    </target>

    <target name="createDatabase">

        <property name="action" value="Create" />

        <call target="manageSqlDatabase" />

    </target>

    <target name="dropDatabase">

        <property name="action" value="Drop" />

        <call target="manageSqlDatabase" failonerror="false"/>

    </target>

    <target name="manageSqlDatabase">

        <manageSqlDatabase

            scriptDirectory="${database.script.directory}"

            action="${action}"

            server="${database.server}"

            integratedAuthentication="${database.integrated}"

            database="${database.name}"

      username="${database.username}"

      password="${database.password}"

        />

        <if test="${action != 'Drop'}">

            <echo message="Current Database Version: ${usdDatabaseVersion}" />

        </if>

    </target>

  <script language="C#" prefix="migration" >

    <references>

      <include name="System.IO.dll" />

    </references>

    <code>

      <![CDATA[

              [Function("next-migration-number")]

              public static string NextMigration(string path  ) {

                  string[] files = System.IO.Directory.GetFiles(path);

                  int count=1;

                    if(files.Length > 0)

                    {

                        string filename = System.IO.Path.GetFileName(files[files.Length-1]);

                        try

                        {

                            count = Convert.ToInt32(filename.Substring(0, 4));

                            count++;

                            if(count%2 == 0)

                                count++;

                        }

                        catch

                        {

                        }

                    }

                  return string.Format("{0:0000}", count);

              }

            ]]>

    </code>

  </script>

</project>

NAnt.build

<?xml version="1.0" encoding="utf-8"?>

<!--EXTERNAL_PROPERTIES: usdDatabaseVersion, CCNetLabel-->

<project name="TarantinoSample" xmlns="http://nant.sf.net/schemas/nant.xsd">

      <!-- ************** -->

    <!-- Initialization -->

    <!-- ************** -->

    <include buildfile="common.build"/>

      <loadtasks assembly="lib\nant\Tarantino.Nant.Tasks.dll" />

    <!-- ***************** -->

    <!-- Master Properties -->

    <!-- ***************** -->

    <property name="company.name" value="Tarantino Test"/>

    <property name="assembly.unittests" value="TarantinoSample.dll"/>

    <!-- Version settings -->

    <property name="project.config" value="debug"/>

    <!-- Folder references -->

    <property name="dir.solution" value="src"/>

    <property name="dir.build" value="build" dynamic="true"/>

    <!-- Compilation settings -->

    <property name="nant.settings.currentframework" value="net-3.5" />

    <property name="file.solution" value="${dir.solution}/${project::get-name()}.sln"/>

    <!-- Database migration settings -->

    <property name="database.script.directory" value="dbChangeScripts" />

      <property name="database.server" value="localhost" overwrite="false"/>

    <property name="database.name" value="OrderData" overwrite="false"/>

    <property name="database.integrated" value="true" overwrite="false" />

    <property name="database.username" value="dbuser" overwrite="false"/>

    <property name="database.password" value="P@ssword1" overwrite="false"/>

    <!-- ********************************** -->

    <!-- Database Change Management Targets -->

    <!-- ********************************** -->

    <target name="reset-database" depends="dropDatabase, createDatabase">

        <nunit2 failonerror="true" verbose="true">

            <formatter type="Plain" />

            <test assemblyname="${dir.solution}/bin/${project.config}/${assembly.unittests}">

                <categories>

                    <include name="DBSetup"/>

                    <exclude name="*"/>

                </categories>

            </test>

        </nunit2>

    </target>

      <target name="db-migration">

        <delete file="${database.script.directory}/Update/_New_Script.sql"  />

        <call target="reset-database" />

        <call target="create-versioned-database" />

        <property name="migrationScriptName" value="${migration::next-migration-number(database.script.directory+'/Update')}_AutoGeneratedMigration.sql"/>

        <if test="${file::exists('c:\program files (x86)\red gate\SQL Compare 8\SQLCompare.exe')}" >

              <property name="redgate.exe" value="c:\program files (x86)\red gate\SQL Compare 8\SQLCompare.exe"/>

        </if>

        <if test="${file::exists('c:\program files\red gate\SQL Compare 8\SQLCompare.exe')}" >

              <property name="redgate.exe" value="c:\program files\red gate\SQL Compare 8\SQLCompare.exe"/>

        </if>

        <exec

              program="${redgate.exe}"

              commandline="/f /v /server1:${database.server} /server2:${database.server} /database1:${database.name} /database2:${database.name}Versioned /scriptfile:${database.script.directory}/Update/_New_Script.sql /exclude:Table:usd_AppliedDatabaseScript"

              resultproperty="execReturnCode"

              failonerror ="false"/>

          <fail if="${execReturnCode != '0' and execReturnCode != '63'}" message="Redgate Compare Failed!"/>

        <if test="${file::exists(database.script.directory + '/Update/_New_Script.sql') == false}">

            <echo message=""/>

              <echo message="---------------------"/>

              <echo message="No Migration Required"/>

        </if>

        <if test="${file::exists(database.script.directory + '/Update/_New_Script.sql')}">

            <move file="${database.script.directory}/Update/_New_Script.sql" tofile="${database.script.directory}/Update/${migrationScriptName}"/>

            <echo message="Created Migration File ${database.script.directory}/Update/${migrationScriptName}"/>

          </if>

      </target>

      <target name="create-versioned-database">

        <tstamp></tstamp>

        <manageSqlDatabase

            action="Drop"

            server="${database.server}"

            integratedAuthentication="true"

            database="${database.name}Versioned"

            username=""

            password="" />

        <manageSqlDatabase

            scriptDirectory="${database.script.directory}"

            action="Create"

            server="${database.server}"

            integratedAuthentication="true"

            database="${database.name}Versioned"

            username=""

            password="" />

      </target>

</project>

Change script creation

lib\nant\nant.exe –buildfile:nant.build create-versioned-database

Push to Production or Dev

lib\nant\nant.exe –buildfile:nant.build updateDatabase –D:database.name=OrderDataProd

lib\nant\nant.exe –buildfile:nant.build createDatabase –D:database.name=OrderDataProd

Source Code

• Zip File Download
• Elegant Code SVN Repository

Information Sources