NHibarnate – using event listeners to set entity modification date

2013-08-242016-01-30 TPodolakc#, EventListeners, FluentNhibernate, Nhibernate

I think, that it is a common practice to store information about creation and modification date of entities. However keeping appropriate columns up to date manually is error prone. We must remember that every time we modify entity, we also have to change its modification date. Fortunately thanks to event listeners, NHibernate can do all of this boring stuff for us. Let’s start from creating class which implements two interfaces:

IPreInsertEventListener
IPreUpdateEventListener

public class NHListener : IPreInsertEventListener, IPreUpdateEventListener
{
    public bool OnPreInsert(PreInsertEvent @event)
    {
        throw new NotImplementedException();
    }

    public bool OnPreUpdate(PreUpdateEvent @event)
    {
        throw new NotImplementedException();
    }
}

public class NHListener : IPreInsertEventListener, IPreUpdateEventListener

{

public bool OnPreInsert(PreInsertEvent @event)

{

throw new NotImplementedException();

}

public bool OnPreUpdate(PreUpdateEvent @event)

{

throw new NotImplementedException();

}

As You probably guessed OnPreInsert method is invoked before insert, and OnPreUpdate is called before update of entity. Having prepared the basic skeleton of class, it is time to configure NHibernate to use our event listeners. The basic configuration is taken from my previous post about NHibernate automappings, so I will only extend it by appending event listeners

Fluently.Configure().Database(
                    MsSqlConfiguration.MsSql2008.ConnectionString(
                        @"YourConnectionString"))
                    .Mappings(val => val.AutoMappings.Add(CreateAutomappings))
                    .ExposeConfiguration(val =>
                    {
                        val.AppendListeners(ListenerType.PreUpdate, new IPreUpdateEventListener[] { new NHListener() });
                        val.AppendListeners(ListenerType.PreInsert, new IPreInsertEventListener[] { new NHListener() });
                    })
                    .BuildSessionFactory();

Fluently.Configure().Database(

MsSqlConfiguration.MsSql2008.ConnectionString(

@"YourConnectionString"))

.Mappings(val => val.AutoMappings.Add(CreateAutomappings))

.ExposeConfiguration(val =>

{

val.AppendListeners(ListenerType.PreUpdate, new IPreUpdateEventListener[] { new NHListener() });

val.AppendListeners(ListenerType.PreInsert, new IPreInsertEventListener[] { new NHListener() });

})

.BuildSessionFactory();

Now we can put some logic into OnPreInsert and OnPreUpdate functions. First of all we have to somehow identify entities which hold information about creation and modification time. In order to do that I created simple interface IDateInfo

public interface IDateInfo
{
    DateTime ModificationDate { get; set; }
    DateTime CreationDate { get; set; }
}

public interface IDateInfo

{

DateTime ModificationDate { get; set; }

DateTime CreationDate { get; set; }

}

In the next step we have to modify OnPreInsert and OnPreUpdate methods, so that they can set creation and modification date of entities which implement IDateInfo interface.

public class NHListener : IPreInsertEventListener, IPreUpdateEventListener
{
    public bool OnPreInsert(PreInsertEvent @event)
    {
        IDateInfo dateInfo;
        if ((dateInfo = @event.Entity as IDateInfo) != null)
        {
            var currentDate = DateTime.Now;
            dateInfo.CreationDate = dateInfo.ModificationDate = currentDate;
        }
        return false;
    }

    public bool OnPreUpdate(PreUpdateEvent @event)
    {
        IDateInfo dateInfo;
        if ((dateInfo = @event.Entity as IDateInfo) != null)
        {
            var currentDate = DateTime.Now;
            dateInfo.ModificationDate = currentDate;
        }
        return false;
    }
}

public class NHListener : IPreInsertEventListener, IPreUpdateEventListener

{

public bool OnPreInsert(PreInsertEvent @event)

{

IDateInfo dateInfo;

if ((dateInfo = @event.Entity as IDateInfo) != null)

{

var currentDate = DateTime.Now;

dateInfo.CreationDate = dateInfo.ModificationDate = currentDate;

}

return false;

}

public bool OnPreUpdate(PreUpdateEvent @event)

{

IDateInfo dateInfo;

if ((dateInfo = @event.Entity as IDateInfo) != null)

{

var currentDate = DateTime.Now;

dateInfo.ModificationDate = currentDate;

}

return false;

}

Unfortunately at this moment saving entity (which implements IDateInfo interface) will throw exception

Despite the fact that we set values of ModificationDate and CreationDate properties , NHiberante seems not to notice that. That is why we have to manually update values of State object from PreInsertEvent and PreUpdateEvent. According to the documentation State object from class PreInsertEvent holds values which should be inserted and State object from class PreUpdateEvent holds values which should be updated. Function which update values of state object might look like that

private void SetState(IEntityPersister persister, object[] state, string propertyName, object value)
{
    var index = Array.IndexOf(persister.PropertyNames, propertyName);
    if (index == -1)
        return;
    state[index] = value;
}

private void SetState(IEntityPersister persister, object[] state, string propertyName, object value)

{

var index = Array.IndexOf(persister.PropertyNames, propertyName);

if (index == -1)

return;

state[index] = value;

}

Updated NHListener class now looks like that

using System;
using System.Linq.Expressions;
using NHibernate.Event;
using NHibernate.Impl;
using NHibernate.Persister.Entity;

namespace DataAccessLayer
{
    public class NHListener : IPreInsertEventListener, IPreUpdateEventListener
    {
        private static readonly string ModificationDatePropertyName = GetPropertyName<IDateInfo>(val => val.ModificationDate),
                                       CreationDatePropertyName = GetPropertyName<IDateInfo>(val => val.CreationDate);

        public bool OnPreInsert(PreInsertEvent @event)
        {
            IDateInfo dateInfo;
            if ((dateInfo = @event.Entity as IDateInfo) != null)
            {
                var currentDate = DateTime.Now;
                dateInfo.CreationDate = dateInfo.ModificationDate = currentDate;
                SetState(@event.Persister, @event.State, ModificationDatePropertyName, currentDate);
                SetState(@event.Persister, @event.State, CreationDatePropertyName , currentDate);
            }
    
            return false;
        }
    
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            IDateInfo dateInfo;
            if ((dateInfo = @event.Entity as IDateInfo) != null)
            {
                var currentDate = DateTime.Now;
                dateInfo.ModificationDate = currentDate;
                SetState(@event.Persister, @event.State, ModificationDatePropertyName, currentDate);
            }
            return false;
        }
        
        private void SetState(IEntityPersister persister, object[] state, string propertyName, object value)
        {
            var index = Array.IndexOf(persister.PropertyNames, propertyName);
            if (index == -1)
                return;
            state[index] = value;
        }
    
        private static string GetPropertyName<TType>(Expression<Func<TType, object>> expression)
        {
            return ExpressionProcessor.FindPropertyExpression(expression.Body);
        }
    }
}

using System;

using System.Linq.Expressions;

using NHibernate.Event;

using NHibernate.Impl;

using NHibernate.Persister.Entity;

namespace DataAccessLayer

{

public class NHListener : IPreInsertEventListener, IPreUpdateEventListener

{

private static readonly string ModificationDatePropertyName = GetPropertyName<IDateInfo>(val => val.ModificationDate),

CreationDatePropertyName = GetPropertyName<IDateInfo>(val => val.CreationDate);

public bool OnPreInsert(PreInsertEvent @event)

{

IDateInfo dateInfo;

if ((dateInfo = @event.Entity as IDateInfo) != null)

{

var currentDate = DateTime.Now;

dateInfo.CreationDate = dateInfo.ModificationDate = currentDate;

SetState(@event.Persister, @event.State, ModificationDatePropertyName, currentDate);

SetState(@event.Persister, @event.State, CreationDatePropertyName , currentDate);

}

return false;

}

public bool OnPreUpdate(PreUpdateEvent @event)

{

IDateInfo dateInfo;

if ((dateInfo = @event.Entity as IDateInfo) != null)

{

var currentDate = DateTime.Now;

dateInfo.ModificationDate = currentDate;

SetState(@event.Persister, @event.State, ModificationDatePropertyName, currentDate);

}

return false;

}

private void SetState(IEntityPersister persister, object[] state, string propertyName, object value)

{

var index = Array.IndexOf(persister.PropertyNames, propertyName);

if (index == -1)

return;

state[index] = value;

}

private static string GetPropertyName<TType>(Expression<Func<TType, object>> expression)

{

return ExpressionProcessor.FindPropertyExpression(expression.Body);

}

As You can see, after setting values of IDateInfo I also call function SetState and update state of appropriate properties. From now everything works fine and our entities can be saved without problems. Source code for this post can be found here

Fluent Nhibernate – automappings

2013-03-252016-01-30 TPodolakAutomapper, Automappings, c#, FluentNhibernate6 Comments

1. Introduction

Writing mappings for models in large application is quite boring task. Fortunatelly, Fluent NHibernate provides possibility for automatic mapping creation – so called automappings.

2. Creating database and model

In order to show you, how to configure automappings in Fluent NHibernate, let’s create simple database along with model classes. The database structure is presented in the picture below.

Model classes which represent database tables look this way

public abstract class ModelBase
{
    public virtual int Id { get; set; }
}

public class Project : ModelBase
{
    public virtual string Name { get; set; }
    public virtual User User { get; set; }
    public virtual IList<Task> Tasks { get; set; }
}

public class Task : ModelBase
{
    public virtual string Name { get; set; }
    public virtual Project Project { get; set; }
}

public class User : ModelBase
{
    public virtual string Name { get; set; }
    public virtual string Surname { get; set; }
}

public abstract class ModelBase

{

public virtual int Id { get; set; }

}

public class Project : ModelBase

{

public virtual string Name { get; set; }

public virtual User User { get; set; }

public virtual IList<Task> Tasks { get; set; }

}

public class Task : ModelBase

{

public virtual string Name { get; set; }

public virtual Project Project { get; set; }

}

public class User : ModelBase

{

public virtual string Name { get; set; }

public virtual string Surname { get; set; }

}

3. Automappings configuration

Having our database and models prepared, now we can create and configure SessionFactory to use automappings.

var factory = Fluently.Configure().Database(MsSqlConfiguration.MsSql2008.ConnectionString("YourConnectionString"))
                      .Mappings(val => val.AutoMappings.Add(AutoMap.AssemblyOf<Project>))
                      .BuildSessionFactory();

var factory = Fluently.Configure().Database(MsSqlConfiguration.MsSql2008.ConnectionString("YourConnectionString"))

.Mappings(val => val.AutoMappings.Add(AutoMap.AssemblyOf<Project>))

.BuildSessionFactory();

As You can see I used the static AutoMap.AssemblyOf method. This method takes a generic type parameter from which Fluent NHibernate can deduce which assembly to look in for mappable entities. From now all classes defined in the assemlby of Project are mapped using build-in convention.

4. Mapping only specified classes

Mapping all classes from specyfic assembly may not be very useful. That is why, we need to “tell” Automapper which classes should be mapped. It can be achieved by creating custom configuration class which implements IAutomappingConfiguration interface or which is subclass of DefaultAutomappingConfiguration. IAutomappingConfiguration interface has quite a lot of functions, that is why I decided to craete class which inherits from DefaultAutomappingConfiguration and override only one method – ShouldMap

public class AutomappingConfiguration : DefaultAutomappingConfiguration
{
    public override bool ShouldMap(Type type)
    {
        return type.IsSubclassOf(typeof (ModelBase));
    }
}

public class AutomappingConfiguration : DefaultAutomappingConfiguration

{

public override bool ShouldMap(Type type)

{

return type.IsSubclassOf(typeof (ModelBase));

}

As You can see by overriding ShouldMap function,I specified that only classes which inherit from ModelBase class should be mapped. To use our new configuration, we need to pass an instance of it to AutoMap setup

var factory = Fluently.Configure().Database(MsSqlConfiguration.MsSql2008.ConnectionString("YourConnectionString"))
                      .Mappings(val => val.AutoMappings.Add(AutoMap.AssemblyOf<Project>(new  DefaultAutomappingConfiguration())))
                      .BuildSessionFactory();

var factory = Fluently.Configure().Database(MsSqlConfiguration.MsSql2008.ConnectionString("YourConnectionString"))

.Mappings(val => val.AutoMappings.Add(AutoMap.AssemblyOf<Project>(new DefaultAutomappingConfiguration())))

.BuildSessionFactory();

5. Defining custom conventions

It is rather obvious that default automapping conventions may not come along with our database naming conventions. Fortunately we can create custom conventions(which override default ones), and pass them to AutoMap configuration. Here are examples of conventions I use IClassConvention – gives us access to properties and functions which allow us to change a default table name format for our entities.

public class DefaultTableNameConvention : IClassConvention
{
    public void Apply(IClassInstance instance)
    {
        instance.Table(string.Format("{0}{1}", "GL_", instance.EntityType.Name));
    }
}

public class DefaultTableNameConvention : IClassConvention

{

public void Apply(IClassInstance instance)

{

instance.Table(string.Format("{0}{1}", "GL_", instance.EntityType.Name));

}

IIdConvention is used for altering default identity conventions.

public class DefaultPrimaryKeyConvention : IIdConvention
{
    public void Apply(IIdentityInstance instance)
    {
        instance.Column("Id");
        instance.GeneratedBy.Native();
    }
}

public class DefaultPrimaryKeyConvention : IIdConvention

{

public void Apply(IIdentityInstance instance)

{

instance.Column("Id");

instance.GeneratedBy.Native();

}

IPropertyConvention – allows us to modify properties mappings (lazy load, nullability,length etc)

public class DefaultStringLengthConvention : IPropertyConvention
{
    public void Apply(IPropertyInstance instance)
    {
        instance.Length(50);
    }
}

public class DefaultStringLengthConvention : IPropertyConvention

{

public void Apply(IPropertyInstance instance)

{

instance.Length(50);

}

IReferenceConvention – allows us to modify entities relationship convention

public class DefaultReferenceConvention : IReferenceConvention
{
    public void Apply(IManyToOneInstance instance)
    {
        instance.Column(string.Format(instance.Class.Name.StartsWith("Id") ? "{1}" : "{0}{1}", "Id",
                                      instance.Class.Name));
        instance.LazyLoad();
    }
}

public class DefaultReferenceConvention : IReferenceConvention

{

public void Apply(IManyToOneInstance instance)

{

instance.Column(string.Format(instance.Class.Name.StartsWith("Id") ? "{1}" : "{0}{1}", "Id",

instance.Class.Name));

instance.LazyLoad();

}

IHasManyConvention – allow us to modify default has-many relationship convention

public class DefaultHasManyConvention : IHasManyConvention
{
    public void Apply(IOneToManyCollectionInstance instance)
    {
        instance.Key.Column(string.Format("{0}{1}", "Id", instance.EntityType.Name));
        instance.LazyLoad();
    }
}

public class DefaultHasManyConvention : IHasManyConvention

{

public void Apply(IOneToManyCollectionInstance instance)

{

instance.Key.Column(string.Format("{0}{1}", "Id", instance.EntityType.Name));

instance.LazyLoad();

}

In order to use new conventions we need to pass them into AutoMap configuration.

Fluently.Configure()
                .Database(
                    MsSqlConfiguration.MsSql2008.ConnectionString("YourConnectionString"))
                .Mappings(val => val.AutoMappings.Add(AutoMap.AssemblyOf<Project>(new DefaultAutomappingConfiguration()).Conventions.Setup(con =>
                                                                           {
                                                                               con.Add<DefaultTableNameConvention>();
                                                                               con.Add<DefaultPrimaryKeyConvention>();
                                                                               con.Add<DefaultStringLengthConvention>();
                                                                               con.Add<DefaultReferenceConvention>();
                                                                               con.Add<DefaultHasManyConvention>();
                                                                           })))
                .BuildSessionFactory();

Fluently.Configure()

.Database(

MsSqlConfiguration.MsSql2008.ConnectionString("YourConnectionString"))

.Mappings(val => val.AutoMappings.Add(AutoMap.AssemblyOf<Project>(new DefaultAutomappingConfiguration()).Conventions.Setup(con =>

{

con.Add<DefaultTableNameConvention>();

con.Add<DefaultPrimaryKeyConvention>();

con.Add<DefaultStringLengthConvention>();

con.Add<DefaultReferenceConvention>();

con.Add<DefaultHasManyConvention>();

})))

.BuildSessionFactory();

6. Overriding mappings

Sometimes it is necessary to slightly modify entity mapping. It can be achieved by creating class which implements IAutoMappingOverride interface

public class ProjectMapping: IAutoMappingOverride<Project>
{
    public void Override(AutoMapping<Project> mapping)
    {
        mapping.IgnoreProperty(val=>val.SomeIgnoredProperty);
    }
}

public class ProjectMapping: IAutoMappingOverride<Project>

{

public void Override(AutoMapping<Project> mapping)

{

mapping.IgnoreProperty(val=>val.SomeIgnoredProperty);

}

Override method gives us access to all actions known from fluent mappings. After creating class map, we have to call function UseOverridesFromAssemblyOf in our automapping configuration

var factory = Fluently.Configure().Database(MsSqlConfiguration.MsSql2008.ConnectionString("YourConnectionString"))
                                  .Mappings(val => val.AutoMappings.Add(AutoMap.AssemblyOf<Project>(new DefaultAutomappingConfiguration()).UseOverridesFromAssemblyOf<Project>()
                                  .Conventions.Setup(con =>
                                                                           {
                                                                               con.Add<DefaultTableNameConvention>();
                                                                               con.Add<DefaultPrimaryKeyConvention>();
                                                                               con.Add<DefaultStringLengthConvention>();
                                                                               con.Add<DefaultReferenceConvention>();
                                                                               con.Add<DefaultHasManyConvention>();
                                                                           }))).BuildSessionFactory();

var factory = Fluently.Configure().Database(MsSqlConfiguration.MsSql2008.ConnectionString("YourConnectionString"))

.Mappings(val => val.AutoMappings.Add(AutoMap.AssemblyOf<Project>(new DefaultAutomappingConfiguration()).UseOverridesFromAssemblyOf<Project>()

.Conventions.Setup(con =>

{

con.Add<DefaultTableNameConvention>();

con.Add<DefaultPrimaryKeyConvention>();

con.Add<DefaultStringLengthConvention>();

con.Add<DefaultReferenceConvention>();

con.Add<DefaultHasManyConvention>();

}))).BuildSessionFactory();

7. It works

Here just couple of screens from NHibernateProfiler with basic queries

Source code for this post can be found here

FluentNhibernate – mapowanie kolumn typu time

2012-03-132016-01-31 TPodolakFluentNhibernate, MsSql, Nhibernate

Witam
Ostatnio napotkałem na dość ciekawy wyjątek podczas wykonywania NHibernatowego inserta. W bazie danych mam prostą tabelę

Do takiej tabeli został stworzony model

namespace Model
{
    public class Appointment
    {
        public virtual int Id { get; set; }
        public virtual string Name { get; set; }
        public virtual DateTime StartDate { get; set; }
        public virtual TimeSpan Duration { get; set; }
    }
}

namespace Model

{

public class Appointment

{

public virtual int Id { get; set; }

public virtual string Name { get; set; }

public virtual DateTime StartDate { get; set; }

public virtual TimeSpan Duration { get; set; }

}

oraz mapping

namespace Model.Mappings
{
    public class AppointmentMapping : ClassMap<Appointment>
    {
        public AppointmentMapping()
        {
            Id(val => val.Id).GeneratedBy.Native();
            Map(val => val.Name).Not.Nullable();
            Map(val => val.StartDate).Not.Nullable();
            Map(val => val.Duration).Not.Nullable();
        }
    }
}

namespace Model.Mappings

{

public class AppointmentMapping : ClassMap<Appointment>

{

public AppointmentMapping()

{

Id(val => val.Id).GeneratedBy.Native();

Map(val => val.Name).Not.Nullable();

Map(val => val.StartDate).Not.Nullable();

Map(val => val.Duration).Not.Nullable();

}

Niestety ku mojemu zaskoczeniu próbując zapisać do bazy obiekt typu Appointment dostałem następujący wyjątek
SqlException: Operand type clash: bigint is incompatible with time

Mówiąc szczerze wyjątek ten niewiele mi powiedział, zwłaszcza, że zapytanie wygenerowane przez NHibernata (przechwycone w NHibernateProfilerze) wyglądało jak najbardziej poprawnie. Jednakże zapytanie przechwycone przez SqlProfilera wyglądało w następujący sposób

exec sp_executesql N'INSERT INTO [Appointment] (Name,StartDate,Duration) VALUES (@p0,@p1,@p2); 
select SCOPE_IDENTITY()',
N'@p0 nvarchar(4000),
@p1 datetime,
@p2 bigint',
@p0=N'appoitnemt',
@p1='2012-03-13 00:00:00',
@p2=439320000000

exec sp_executesql N'INSERT INTO [Appointment] (Name,StartDate,Duration) VALUES (@p0,@p1,@p2);

select SCOPE_IDENTITY()',

N'@p0 nvarchar(4000),

@p1 datetime,

@p2 bigint',

@p0=N'appoitnemt',

@p1='2012-03-13 00:00:00',

@p2=439320000000

Widać tutaj, że drugi parametr (@p2) został oznaczony jako bigint, a nie time (tak jak jest to oznaczone w bazie). Przyczyną takiego stanu rzeczy jest zły mapping. Z tego co wyczytałem, jeżeli chcemy aby poprawnie zmapować TimeSpana na kolumnę typu time, musimy zmodyfikować interesujący nas mapping na następujący.

Map(val => val.Duration).Not.Nullable().CustomType("TimeAsTimeSpan");

1	Map(val => val.Duration).Not.Nullable().CustomType("TimeAsTimeSpan");

Mając taki mapping nasze zapytanie zostanie wygenerowane poprawnie i operacja insertu zakończy się powodzeniem

.NET BLOG

.NET, C# blog

FluentNhibernate

NHibarnate – using event listeners to set entity modification date

Fluent Nhibernate – automappings

1. Introduction

2. Creating database and model

3. Automappings configuration

4. Mapping only specified classes

5. Defining custom conventions

6. Overriding mappings

7. It works

FluentNhibernate – mapowanie kolumn typu time