Implementing INotifyPropertyChanged without lambda expressions and “magic” strings

2014-01-192016-01-30 TPodolak.NET 4.5, c#, CallerMemberName, INotifyPropertyChanged1 Comment

I think almost every .NET developer is familiar with INotifyPropertyChanged interface. Typical implementation of this interface looks more or less like that:

public class NotifyPropertyBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged( Expression<Func<object>> propertyExpression )
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null) handler( this, new PropertyChangedEventArgs( GetPropertyName( propertyExpression ) ) );
    }

    private string GetPropertyName( Expression<Func<object>> propertyExpression )
    {
        var unaryExpression = propertyExpression.Body as UnaryExpression;
        var memberExpression = unaryExpression == null ? (MemberExpression)propertyExpression.Body : (MemberExpression)unaryExpression.Operand;
        var propertyName = memberExpression.Member.Name;
        return propertyName;
    }
}

public class NotifyPropertyBase : INotifyPropertyChanged

{

public event PropertyChangedEventHandler PropertyChanged;

protected virtual void OnPropertyChanged( Expression<Func<object>> propertyExpression )

{

PropertyChangedEventHandler handler = PropertyChanged;

if (handler != null) handler( this, new PropertyChangedEventArgs( GetPropertyName( propertyExpression ) ) );

}

private string GetPropertyName( Expression<Func<object>> propertyExpression )

{

var unaryExpression = propertyExpression.Body as UnaryExpression;

var memberExpression = unaryExpression == null ? (MemberExpression)propertyExpression.Body : (MemberExpression)unaryExpression.Operand;

var propertyName = memberExpression.Member.Name;

return propertyName;

}

Thanks to lambda expressions we can get rid of so called “magic” strings when rising PorpertyChange event.

private int _myProperty;
public int MyProperty
{
    get { return _myProperty; }
    set
    {
        if (_myProperty == value) return;
        _myProperty = value;
        OnPropertyChanged( ( ) => MyProperty );
    }
}

private int _myProperty;

public int MyProperty

{

get { return _myProperty; }

set

{

if (_myProperty == value) return;

_myProperty = value;

OnPropertyChanged( ( ) => MyProperty );

}

However, with .NET 4.5 we can even get rid of lambda expressions itself. Everything thanks to CallerMemberNameAttribute, which provides us information about caller of given method. Now we can rewrite NotifyPropertyBase class as follows

public class NotifyPropertyBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged( [CallerMemberName] string propertyName = null )
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null) handler( this, new PropertyChangedEventArgs( propertyName));
    }
}

public class NotifyPropertyBase : INotifyPropertyChanged

{

public event PropertyChangedEventHandler PropertyChanged;

protected virtual void OnPropertyChanged( [CallerMemberName] string propertyName = null )

{

PropertyChangedEventHandler handler = PropertyChanged;

if (handler != null) handler( this, new PropertyChangedEventArgs( propertyName));

}

From this moment we can call OnPropertyChanged method without any arguments

private int _myProperty;
public int MyProperty
{
    get { return _myProperty; }
    set 
    {
      if (_myProperty == value) return;
      _myProperty = value;
      OnPropertyChanged();
    }
}

private int _myProperty;

public int MyProperty

{

get { return _myProperty; }

set

{

if (_myProperty == value) return;

_myProperty = value;

OnPropertyChanged();

}

and thanks to CallerMemberName attribute, argument propertyName will be filled with appropriate value.

Source code for this post can be found here

How to check if one function calls another function

2013-12-012016-01-30 TPodolakc#, crawler2 Comments

An application which I’m currently developing has quite complicated authorization system. That is why, we can not use role based authorization, and basically every developer is obliged to call appropriate security check method in every controller action he or she writes. As You probably know it is quite easy to forget about that, therefore I decided to write a test which would check whether all controller’s action invokes this security critical function. After hours of searching for some anchor point, I came across this article http://blogs.msdn.com/b/haibo_luo/archive/2006/11/06/system-reflection-based-ilreader.aspx in which author creates so called “reflection based ILReader”. ILReader is a class which allows You to iterate over IL instructions of every object of type RuntimeMethodInfo or RuntimeConstructorInfo .One of these instructions is InlineMethodInstruction which indicates method call. That is why, in order to get all methods which are called by given method, we have to simply select all instructions of type InlineMethodInstruction

public static class MethodInvokerCrawler
{
    public static IEnumerable<MethodBase> GetMethods(MethodBase caller)
    {
        ILReader reader = new ILReader(caller);
        return reader.OfType<InlineMethodInstruction>().Select(method => method.Method);
    }
}

public static class MethodInvokerCrawler

{

public static IEnumerable<MethodBase> GetMethods(MethodBase caller)

{

ILReader reader = new ILReader(caller);

return reader.OfType<InlineMethodInstruction>().Select(method => method.Method);

}

We can go a bit further and create a recursive version of this function to iterate over entire function execution chain

public static class MethodInvokerCrawler
{
    public const string DefaultPrefix = "GeneralLearning";
    public static IEnumerable<MethodBase> GetMethods(MethodBase caller, bool recursive = false, string namespacePrefix = DefaultPrefix)
    {
        ILReader reader = new ILReader(caller);
        foreach (InlineMethodInstruction method in
            reader.OfType<InlineMethodInstruction>())
        {
            yield return method.Method;
            if (recursive && method.Method.DeclaringType != null && method.Method.DeclaringType.FullName.StartsWith(namespacePrefix, StringComparison.InvariantCultureIgnoreCase))
            {
                foreach (var innerMethod in GetMethods(method.Method))
                {
                    yield return innerMethod;
                }
            }
        }
    }
}

public static class MethodInvokerCrawler

{

public const string DefaultPrefix = "GeneralLearning";

public static IEnumerable<MethodBase> GetMethods(MethodBase caller, bool recursive = false, string namespacePrefix = DefaultPrefix)

{

ILReader reader = new ILReader(caller);

foreach (InlineMethodInstruction method in

reader.OfType<InlineMethodInstruction>())

{

yield return method.Method;

if (recursive && method.Method.DeclaringType != null && method.Method.DeclaringType.FullName.StartsWith(namespacePrefix, StringComparison.InvariantCultureIgnoreCase))

{

foreach (var innerMethod in GetMethods(method.Method))

{

yield return innerMethod;

}

Please notice, that I limited recursion depth to methods from user defined namespace, otherwise we would end up iterating over .NET’s native functions.
Now it is time to show some results. Here is a sample program which demonstrate possibilities of MethodInvokerCrawler class

internal class Program
{
    public class FooClass
    {
        public FooClass()
        {
            this.X();
            this.Foo();
            this.Bar();
        }

        public void Foo(){}

        public void Bar()
        {
            this.Z();
            this.Foo();
        }

        public string X()
        {
            return null;
        }

        public void Y(){ }

        public void Z()
        {
            this.Y();
        }
    }

    public static void Main(string[] args)
    {
        Console.WriteLine("=== execution chain of Bar function no recursion ===");
        foreach (var s in MethodInvokerCrawler.GetMethods(typeof(FooClass).GetMethod("Bar")))
        {
            Console.WriteLine("{0}.{1}", s.DeclaringType.FullName, s.Name);
        }

        Console.WriteLine();
        Console.WriteLine("=== execution chain of Bar function with recursion ===");
        foreach (var s in MethodInvokerCrawler.GetMethods(typeof(FooClass).GetMethod("Bar"), true))
        {
            Console.WriteLine("{0}.{1}", s.DeclaringType.FullName, s.Name);
        }

        Console.WriteLine();
        Console.WriteLine("execution chain of FooClass default constructor no recursion");
        foreach (var s in MethodInvokerCrawler.GetMethods(typeof(FooClass).GetConstructors().Single()))
        {
            Console.WriteLine("{0}.{1}", s.DeclaringType.FullName, s.Name);
        }

        Console.WriteLine();
        Console.WriteLine("execution chain of FooClass default constructor with recursion");
        foreach (var s in MethodInvokerCrawler.GetMethods(typeof(FooClass).GetConstructors().Single(), true))
        {
            Console.WriteLine("{0}.{1}", s.DeclaringType.FullName, s.Name);
        }
        Console.ReadKey();
    }
}

internal class Program

{

public class FooClass

{

public FooClass()

{

this.X();

this.Foo();

this.Bar();

}

public void Foo(){}

public void Bar()

{

this.Z();

this.Foo();

}

public string X()

{

return null;

}

public void Y(){ }

public void Z()

{

this.Y();

}

public static void Main(string[] args)

{

Console.WriteLine("=== execution chain of Bar function no recursion ===");

foreach (var s in MethodInvokerCrawler.GetMethods(typeof(FooClass).GetMethod("Bar")))

{

Console.WriteLine("{0}.{1}", s.DeclaringType.FullName, s.Name);

}

Console.WriteLine();

Console.WriteLine("=== execution chain of Bar function with recursion ===");

foreach (var s in MethodInvokerCrawler.GetMethods(typeof(FooClass).GetMethod("Bar"), true))

{

Console.WriteLine("{0}.{1}", s.DeclaringType.FullName, s.Name);

}

Console.WriteLine();

Console.WriteLine("execution chain of FooClass default constructor no recursion");

foreach (var s in MethodInvokerCrawler.GetMethods(typeof(FooClass).GetConstructors().Single()))

{

Console.WriteLine("{0}.{1}", s.DeclaringType.FullName, s.Name);

}

Console.WriteLine();

Console.WriteLine("execution chain of FooClass default constructor with recursion");

foreach (var s in MethodInvokerCrawler.GetMethods(typeof(FooClass).GetConstructors().Single(), true))

{

Console.WriteLine("{0}.{1}", s.DeclaringType.FullName, s.Name);

}

Console.ReadKey();

}

At this point checking whether function or constructor calls another function is limited to simple LINQ query

MethodInvokerCrawler.GetMethods(typeof(FooClass).GetMethod("Bar")).Any(val => val.Name == "Foo");

1	MethodInvokerCrawler.GetMethods(typeof(FooClass).GetMethod("Bar")).Any(val => val.Name == "Foo");

Source code for this post can be found here

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

StringBuilder – removing trailing characters

2013-03-172016-01-30 TPodolak.NET, c#, StringBuilder

Today just quick tip about StringBuilder
I used to remove last character(s) from StringBuilder using Remove method.

 StringBuilder builder = new StringBuilder("some long text with comma,");
 builder.Remove(builder.Length - 1, 1);

1 2	StringBuilder builder = new StringBuilder("some long text with comma,"); builder.Remove(builder.Length - 1, 1);

However, recently I’ve came accross even simpler solution. You just need to lessen the Length property of StringBuilder, in order to get rid of last characters

StringBuilder builder = new StringBuilder("some long text with comma,");
builder.Length--;

1 2	StringBuilder builder = new StringBuilder("some long text with comma,"); builder.Length--;

.NET BLOG

.NET, C# blog

c#

Implementing INotifyPropertyChanged without lambda expressions and “magic” strings

How to check if one function calls another function

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

StringBuilder – removing trailing characters