Crafting .NET

NerdDinner with Fluent NHibernate Part 3 – The infrastructure

bengtbe — Thu, 08 Oct 2009 03:00:00 +0000

This is the final post in a series of three where I’m going to see how we can change the NerdDinner project to use Fluent NHibernate instead of LINQ to SQL:

Introduction

In the first post we took a look at the domain model of NerdDinner.com, and recreated and improved the code that was auto generated by the LINQ to SQL designer. In the second post we saw how to map this domain model to the database using Fluent NHibernate. In this final post we are going to take a look at the required changes to the rest of the application.

Session per request

In order for the repository to use NHibernate it needs to get a hold of an ISession. In this application I have chosen to follow the session per request pattern, in which a session is created at the beginning of the HTTP request, and closed at the end of the HTTP request. I also wanted to keep the changes to the NerdDinner project as small as possible; hence the entire infrastructure for NHibernate is isolated in a single class:



public class NHibernateSessionPerRequest : IHttpModule
{
    private static readonly ISessionFactory _sessionFactory;
    static NHibernateSessionPerRequest()
    {
        _sessionFactory = CreateSessionFactory();
    }
    public void Init(HttpApplication context)
    {
        context.BeginRequest += BeginRequest;
        context.EndRequest += EndRequest;
    }
    public static ISession GetCurrentSession()
    {
        return _sessionFactory.GetCurrentSession();
    }
    public void Dispose() { }
    private static void BeginRequest(object sender, EventArgs e)
    {
        ISession session = _sessionFactory.OpenSession();
        session.BeginTransaction();
        CurrentSessionContext.Bind(session);
    }
    private static void EndRequest(object sender, EventArgs e)
    {
        ISession session = CurrentSessionContext.Unbind(_sessionFactory);
        if (session == null) return;
        try
        {
            session.Transaction.Commit();
        }
        catch (Exception)
        {
            session.Transaction.Rollback();
        }
        finally
        {
            session.Close();
            session.Dispose();
        }
    }
    private static ISessionFactory CreateSessionFactory()
    {
        string connString = "NerdDinnerConnectionString";
        FluentConfiguration configuration = Fluently.Configure()
        .Database(MsSqlConfiguration.MsSql2005.ConnectionString(
           x => x.FromConnectionStringWithKey(connString)))
        .ExposeConfiguration(
            c => c.SetProperty("current_session_context_class", "web"))
        .Mappings(m => m.FluentMappings.AddFromAssemblyOf<Dinner>());
        return configuration.BuildSessionFactory();
    }
}

Some comments about the infrastructure:

It implements the IHttpModule, in order to plug into the request handling pipeline.
Since it is expensive to create an ISessionFactory you only want to create this once. This is why the factory is stored in a static field that is initialized by the static constructor.
At the beginning of the HTTP request the ISession is created and “stored” using the CurrentSessionContext.Bind method.
Other code can get a hold of this session by calling the GetCurrentSession method.
At the end of the HTTP request we “remove” the session by using the CurrentSessionContext.Unbind method. We also commit any changes, and close the session.

There are some drawbacks to this approach. We create a session for every request, even if it is not needed. However, a session is very lightweight, and we can easily tweak this behavior later. Another drawback is that we commit the transaction at the end of the HTTP request. In a more complex business application you probably want more control over your unit of work.

In order to activate this IHttpModule we need to add the following to httpModules/modules section of the Web.config:

name=”NHibernateSessionPerRequest” type=”NerdDinner.Models.NHibernateSessionPerRequest” />

Changes to the repository

In the DinnerRepository we are mainly going to use LINQ to NHibernate to replace the LINQ to SQL queries:

public class DinnerRepository : IDinnerRepository
{
    public ISession Session
    {
        get { return NHibernateSessionPerRequest.GetCurrentSession(); }
    }
    public IQueryable<Dinner> FindAllDinners()
    {
        return Session.Linq<Dinner>();
    }
    public IQueryable<Dinner> FindUpcomingDinners()
    {
        return from dinner in FindAllDinners()
               where dinner.EventDate >= DateTime.Now
               orderby dinner.EventDate
               select dinner;
    }
    public IQueryable<Dinner> FindByLocation(float latitude, float longitude)
    {
        return Session.CreateSQLQuery(
                @”SELECT d.* 
                    FROM Dinners d 
                    JOIN NearestDinners(:Latitude, :Longitude) n
                      ON d.DinnerId = n.DinnerId
                   WHERE EventDate >= :EventDate
                   ORDER BY EventDate Desc”)
            .AddEntity(typeof(Dinner))
            .SetDouble(“Latitude”, latitude)
            .SetDouble(“Longitude”, longitude)
            .SetDateTime(“EventDate”, DateTime.Now)
            .List<Dinner>().AsQueryable();
    }
    public Dinner GetDinner(int id)
    {
        return Session.Linq<Dinner>()
            .SingleOrDefault(d => d.DinnerID == id);
    }
    public void Add(Dinner dinner)
    {
        Session.SaveOrUpdate(dinner);
    }
    public void Delete(Dinner dinner)
    {
        Session.Delete(dinner);
    }
}

The LINQ to SQL and NHibernate Linq syntax are similar, so the changes to this class were fairly simple. However in the FindByLocation method I had to create a custom SQL query, because I don’t think (not sure) that LINQ to NHibernate supports calling the database function NearestDinners.

Update: It seems that NHibernate Linq supports database functions. However I couldn’t find much information about the functionality except for one simple example in the source code.

The ISession is retrieved by calling the GetCurrentSession() method. In an application with an IoC container I would prefer to inject the session in the constructor.

finally {}

In the final post in this series we have taken a look at the necessary changes to the infrastructure. We used a session per request pattern to create the session, and LINQ to NHibernate in the repository. As you hopefully have seen it was not very difficult to replace LINQ to SQL with Fluent NHibernate. As a benefit the domain part of the application has been greatly improved over the auto generated code from the LINQ to SQL designer.

If you liked this post then please shout and kick me

Auto-mocking hierarchies (a.k.a. recursive mocks) with Moq

bengtbe — Thu, 27 Aug 2009 03:35:00 +0000

I have just read a good post by Richard Dingwall called Law of Demeter is easy to spot when you need extra mock. He shows how you can spot violations of the Law of Demeter when you have to create extra mocks in order to stub a single method.

While I totally agree with his points about the Law of Demeter, it might not be so easy to spot violations thanks to a feature of Moq called auto-mocking hierarchies (a.k.a. recursive mocks). In this post I will show how this cool feature can simplify your tests.

System under test

Below is the code from Richard’s post that are under test:

public class ClassUnderTest
{
    public string DoSomething(IFoo foo)
    {
        return foo.Profile.GetStatus();
    }
}

public interface IFoo
{
    IProfile Profile { get; set; }
}

public interface IProfile
{
    string GetStatus();
}

The DoSomething method calls into the privates of IProfile (this is the violations of the law).

Test without recursive mocks

Below is the test without recursive mocks:

[Test]
public void Test_Without_Recursive_Mocks()
{
    const string SOME_RETURN_VALUE = “SomeReturnValue”;
    var foo = new Mock<IFoo>();
    var profile = new Mock<IProfile>();
    profile.Setup(p => p.GetStatus()).Returns(SOME_RETURN_VALUE);
    foo.SetupGet(f => f.Profile).Returns(profile.Object);

    var sut = new ClassUnderTest();
    string returnValue = sut.DoSomething(foo.Object);

    Assert.AreEqual(SOME_RETURN_VALUE, returnValue);
}

In this test we need to create an extra mock of the type IProfile to be able to mock IFoo. This makes the test much harder to read. Imagine the horror if another class was also part of the call chain.

Test with recursive mocks

Below is a simplified test that uses the recursive mocks feature of Moq:

[Test]
public void Test_With_Recursive_Mocks()
{
    const string SOME_RETURN_VALUE = “SomeReturnValue”;
    var foo = new Mock<IFoo>();
    foo.Setup(f => f.Profile.GetStatus()).Returns(SOME_RETURN_VALUE);

    var sut = new ClassUnderTest();
    string returnValue = sut.DoSomething(foo.Object);

    Assert.AreEqual(SOME_RETURN_VALUE, returnValue);
}

As you can see, we have eliminated the need for the IProfile mock. This results in a much cleaner test.

finally{}

In this post I have shown you a cool feature of Moq that can greatly simplify your mocking code. Of course you should still try to spot violations of the Law of Demeter, even though the extra mocks will no longer help you with this. Just remember that the law is really more of a guideline, but I guess Rule of thumb of Demeter doesn’t sound as catchy

If you want to read a great post (and discussion) about this law (eh guideline) check out The Law of Demeter Is Not A Dot Counting Exercise by Phil Haacked.

If you liked this post then please shout and kick me

NerdDinner with Fluent NHibernate Part 2 – The mapping

bengtbe — Tue, 25 Aug 2009 04:00:00 +0000

This is the second post in a series of three where I’m going to see how we can change the NerdDinner project to use Fluent NHibernate instead of LINQ to SQL:

Introduction

In the first post we took a look at the domain model of NerdDinner.com, and recreated and improved the code that was auto generated by the LINQ to SQL designer. In this post we are going to look at how to map this domain model to the database using Fluent NHibernate.

Fluent NHibernate

Fluent NHibernate gives you an alternative to NHibernate’s XML mapping files. It lets you write mapping in strongly typed (and ReSharper friendly) C# code. In order to map an entity, you create a mapping class that derives from ClassMap. All the mapping code is done inside the constructor by calling methods from the base class.

Last week the Release Candidate for Fluent NHibernate 1.0 was released. The code in this post has been updated with the changes in this release.

The mapping for the Dinner entity

The code for DinnerClassMap is shown below:

public class DinnerClassMap : ClassMap<Dinner>
{
    public DinnerClassMap()
    {
        Table(“Dinners”);
        Id(d => d.DinnerID).GeneratedBy.Identity();
        Map(d => d.Title).Not.Nullable().Length(50);
        Map(d => d.EventDate).Not.Nullable();
        Map(d => d.Description).Not.Nullable().Length(256);
        Map(d => d.HostedBy).Not.Nullable().Length(20);
        Map(d => d.ContactPhone).Not.Nullable().Length(20);
        Map(d => d.Address).Not.Nullable().Length(50);
        Map(d => d.Country).Not.Nullable().Length(30);
        Map(d => d.Latitude).Not.Nullable();
        Map(d => d.Longitude).Not.Nullable();
        HasMany(d => d.RSVPs).KeyColumn(“DinnerId”).Cascade.All();
    }
}

Explaination of code:

The Table method maps “Dinners” as the name of the table. By default Fluent NHibernate assumes it to be “Dinner”.
The Id method maps DinnerId as the primary key, and specifies that an identity column in SQL Server is used to generate ids.
The Map method is used to map simple properties to columns.
The HasMany method maps the one-to-many relationship to the RSVP table. Cascade.All() is used to make sure that RSVPs are saved/updated/deleded when the dinner is saved/updated/deleded.

The RSVP mapping

The code for the RSVPClassMap is shown below:

public class RSVPClassMap : ClassMap<RSVP>
{
    public RSVPClassMap()
    {
        Id(r => r.RsvpID).GeneratedBy.Identity(); ;
        Map(r => r.AttendeeName).Not.Nullable().Length(30);
        References(r => r.Dinner, “DinnerId”).Not.Nullable();
    }
}

Explaination of code:

No need to call the Table method, since Fluent NHibernate correctly assumes that the table name is “RSVP”.
The References method maps the “other side” of the HasMany relationship in the DinnerClassMap.

Is all this mapping code needed?

The mapping code shown above contains a lot of information about the database schema. In this case, where we just wanted to map the domain to an existing database we could remove the following:

Not.Nullable()
Length(int length)

In Greenfield projects I prefer to start with the domain, and then write the mapping, and finally automatically generate the database schema. You then need to include this information in the mappings. In the post Mapping a Twitter like domain with Fluent NHibernate I showed how you generate the database from the mapping.

If you have an existing database you can also use this to troubleshoot your mapping code. Generate a new database from your schema and check it against the existing database.

Give me a new identity!

NerdDinner uses the identity column of SQL Server as primary key. In most cases this works just fine, however it can cause problems with the Unit of Work functionality of NHibernate. If I designed this application from scratch I would rather choose the Guid.Comb or HiLo algorithm to generate primary keys.

If you want to read more about this, check out the post NHibernate POID Generators revealed.

Do you prefer to live in XML hell?

If you miss the good old days of XML (???), then Fluent NHibernate can help you with this. The code below shows how to export your Fluent Mappings to XML-files:

[TestMethod]
public void ExportMappings()
{
    FluentConfiguration conf =
       NHibernateConfiguration.CreateConfiguration(false);
    conf.Mappings(m =>
    {
        m.FluentMappings.ExportTo(@”PATH_TO_EXPORT_FOLDER”);
    });
    conf.BuildSessionFactory();
}

This technique is actually quite useful for several reasons:

First, if you are skeptical about using Fluent NHibernate because it has not reached 1.0, or because it might not support all mapping options, you can easily switch back to XML-files later.
Secondly, it can also be useful to troubleshoot mapping problems, because there is currently more information on the web regarding XML-mapping.

finally{}

In this post we have taken a look at how to use Fluent NHibernate to specify the mapping between the domain model and the database. In the next post we will take a look at the rest of the changes that was necessary in order to use the new domain and Fluent NHibernate.

If you liked this post then please shout and kick me

NerdDinner with Fluent NHibernate Part 1 – The domain model

bengtbe — Mon, 10 Aug 2009 04:00:00 +0000

This is the first post in a series of three where I’m going to see how we can change the NerdDinner project to use Fluent NHibernate instead of LINQ to SQL:

Introduction

NerdDinner.com is a site where you can organize dinner meetings for nerds, but even more, it is a great tutorial to the ASP.NET MVC framework. If you want to learn this framework (you should!) download the free tutorial (186 pages) from the site and get going!

NerdDinner uses LINQ to SQL as a data access layer generator. LINQ to SQL is perfectly suitable for this project, since the domain is small, and not very complex. However in these posts I would like to explore how the project would look using a real Object/Relational Mapper (O/RM). More specifically, I’m going to use Fluent NHibernate.

Preperations

First I downloaded the latest source code from CodePlex using the Subversion client TortoiseSVN. Then I added references to the NHibernate, Fluent NHibernate, and LINQ to NHibernate assemblies.

The existing domain model

Most of the domain model in NerdDinner is auto generated from the database as partial classes by the LINQ to SQL designer. You can find the Dinner and RSVP class in the NerdDinner.Designer.cs file; however since they are auto generated they are not very readable.

The Dinner class is also extended (using partial classes) with additional methods in the Dinner.cs file.

The new domain model

Since most of the existing domain model is auto generated we need to write a new domain model. The new Dinner class looks as follows:

public class Dinner
{
    public Dinner()
    {
        RSVPs = new List<RSVP>();
    }

    public virtual int DinnerID { get; private set; }
    public virtual string Title { get; set; }
    public virtual string Description { get; set; }
    public virtual DateTime EventDate { get; set; }
    public virtual double Latitude { get; set; }
    public virtual double Longitude { get; set; }
    public virtual string Country { get; set; }
    public virtual string Address { get; set; }
    public virtual string HostedBy { get; set; }
    public virtual string ContactPhone { get; set; }

    public virtual IList<RSVP> RSVPs { get; private set;}

    public virtual void AddRSVP(string attendeeName)
    {
        if (dinner.IsUserRegistered(User.Identity.Name)) return;

        RSVPs.Add(new RSVP
                      {
                          AttendeeName = attendeeName,
                          Dinner = this
                      });
    }

    public virtual bool IsHostedBy(string userName) { … }
    public virtual bool IsUserRegistered(string userName) { … }
    public virtual bool IsValid { … }
    public virtual IEnumerable<RuleViolation> GetRuleViolations() { … }
}

The new RSVP class looks as follows:

public class RSVP
{
    public virtual int RsvpID { get; private set; }
    public virtual Dinner Dinner { get; set; }
    public virtual string AttendeeName { get; set; }
}

If you wonder why every method is marked by virtual, this is a requirement of NHibernate in order to support Lazy-Loading. I explained this in more detail in the post Mapping a Twitter like domain with Fluent NHibernate.

The public interface of the domain model is more or less identical to the existing domain model. However I did make some changes.

Protect thy privates!

One of the changes I made was to make some of the property setters private; DinnerID, RSVPs, and RsvpID. Since the consumer code (the controllers) is not supposed to change to these properties we want to communicate this to our fellow programmers. The next change is also about protecting privates.

New method to add a RSVP to a dinner

To the Dinner class I added a new method called AddRSVP. By using terms from Domain Driven Design, the Dinner entity is the aggregate root of the RSVP entity. This basically means that a RSVP must belong to a Dinner; hence I want the Dinner class to control the list of RSVPs.

This change will help reduce code in the controllers and remove duplication. Previously the creating and adding of RSVPs was done both in the RSVPController.Register and the DinnerController.Create action methods. The Register method is shown below:

[Authorize, AcceptVerbs(HttpVerbs.Post)]
public ActionResult Register(int id) {

    Dinner dinner = dinnerRepository.GetDinner(id);

    if (!dinner.IsUserRegistered(User.Identity.Name)) {

        RSVP rsvp = new RSVP();
        rsvp.AttendeeName = User.Identity.Name;

        dinner.RSVPs.Add(rsvp);
        dinnerRepository.Save();
    }

    return Content(“Thanks – we’ll see you there!”);
}

Thanks to our new method, this can now be reduced to:

[Authorize, AcceptVerbs(HttpVerbs.Post)]
public ActionResult Register(int id) {

    Dinner dinner = dinnerRepository.GetDinner(id);
    dinner.AddRSVP(User.Identity.Name);

    return Content(“Thanks – we’ll see you there!”);
}

Similar reduction can be done to the Create method. BTW if you wonder what happened to the call to the Save method then we will come back to this in part 3 (teaser!).

As a rule of thumb always try to keep your action methods as simple as possible!

More object-oriented

The last change is the removal of the DinnerId property from the RSVP class. This property is purly database related, and does not belong in an object-oriented domain model. You can use the Dinner propety to get the DinnerId.

finally{}

In my opinion one of the benefits of using an OR/M like NHibernate as supposed to LINQ to SQL is that the domain model is much clearer. When trying to understand a new project one of the best places to start is by looking at the domain. I also did some changes (improvements?) to the domain model to better communicate intent, and to reduce code duplication.

The next step is to tell NHibernate how to map this domain model to the database. This will be explained in the next post where we look at the mapping.

If you liked this post then please shout and kick me

DotNetShoutout and DotNetKicks extensions for BlogEngine.NET

bengtbe — Mon, 27 Jul 2009 22:50:00 +0000

At the end of every .NET post I include counter buttons to DotNetKicks.com and DotNetShoutout.com. At first I manually created these buttons by copying some code from these sites after the post was submitted to them, however this quickly became tiresome. Now I just write [ kickit ] and [ shout ] (without the spaces!) at the end of the post to get these buttons.

DotNetKicks.com

In order to generate the DotNetKicks button I found an extension created by Sean Blakemore, described in this blog post. This extension was both simple and worked great!

DotNetShoutout.com

Inspired by the work of Sean, I created a similar extension for DotNetShoutout. If you want this functionality on your own blog then download the zip-file at the end of this post, unzip it, and finally upload the cs-file to the App_Code/Extensions catalog of your BlogEngine.NET installation.

As you can see above they both work

DotNetShoutout.zip (751.00 bytes)

Use specific return types in your ASP.NET MVC action methods

bengtbe — Wed, 01 Jul 2009 17:00:00 +0000

When looking at ASP.NET MVC examples on the web almost all action methods return ActionResult, even methods that could return a specific subclass. Here is an example from the NerdDinner source code:

public ActionResult Index(int? page)
{
    const int pageSize = 25;
    var upcoming = dinnerRepository.FindUpcomingDinners();
    var paginated = new PaginatedList<Dinner>(upcoming, page ?? 0, pageSize);
    return View(paginated);
}

This method always returns a ViewResult, still they declare the return type as the ActionResult base class. This practice often leads to test code like the following:

ViewResult result = controller.Index(0) as ViewResult;
Assert.IsNotNull(result, “Controller should return a ViewResult”);

In NerdDinner they even have a whole test just to make sure that the result is a ViewResult:

[TestMethod]
public void IndexAction_Should_Return_View()
{
    // Arrange
    var controller = CreateDinnersControllerAs(“robcon”);
    // Act
    var result = controller.Index(0);
    // Assert
    Assert.IsInstanceOfType(result, typeof(ViewResult));
}

All this testing code are unnecessary, if you just let your action methods use specific return types, like shown below:

public ViewResult Index(int? page)
{
    const int pageSize = 25;
    var upcoming = dinnerRepository.FindUpcomingDinners();
    var paginated = new PaginatedList<Dinner>(upcoming, page ?? 0, pageSize);
    return View(paginated);
}

This also makes it immediately clear for people reading the code, what this action method returns.

The only time I would return ActionResult is when different paths of the action method returns different subclasses. In these cases, you should of course write tests that verify the return types of the different paths.

In the book Pro ASP.NET MVC Framework Steven Sanderson also recommends returning specific types. Take a look at the quote below:

“This action method specifically declares that it returns an
instance of ViewResult. It would work just the same if instead the
method return type was ActionResult (the base class for all action
results). In fact, some ASP.NET MVC programmers declare all their
action methods as returning a nonspecific ActionResult, even if they
know for sure that it will always return one particular subclass.
However, it’s a well-established principle in object-oriented
programming that methods should return the most specific type they can
(as well as accepting the most general parameter types they can).
Following this principle maximizes convenience and flexibility for code
that calls your method, such as your unit tests.”

BTW: This blog post is not meant to criticize the NerdDinner tutorial. It is a great free tutorial, and is probably one of the best ways to get introduced to the ASP.NET MVC framework

Book review: NHibernate in Action

bengtbe — Thu, 04 Jun 2009 17:39:00 +0000

Authors: Pierre Henri Kuaté, Tobin Harris, Christian Bauer, and Gavin King
Publisher: Manning Publications Co.
Purchase: Manning, Amazon.com, Amazon.co.uk

Introduction

As part of my goal to learn ORM and NHibernate I purchased the NHibernate in Action book from Manning Publications.
Before I give my conclusion, let’s start with a summary of the different chapters in the book.

1. Object/relation persistence in .NET

This chapter starts the first part of the book, called Discovering ORM with NHibernate. Discusses object persistence, and briefly compares different approaches: hand coding, DataSets, LINQ-to-SQL, NHibernate, and ADO.NET Entity Framework. Describes Object/Relational mapping (ORM), and how it is used to solve the Object/Relational mismatch.

2. Hello NHibernate

Guides you through the process of setting up a project, creating a domain model, setting up the database, creating mapping file, configuring NHibernate, and doing some basic CRUD operations. Takes a high level look at NHibernate, its architecture and how it is configured.

3. Writing and mapping classes

This chapter starts the second part of the book, called NHibernate deep dive. Describes the most common scenarios when mapping a domain model to the database, including important concepts, such as object identity, inheritance, associations, entities vs. value-types, fine-grained object models, and transparent persistence. Finally, it shows three inheritance mapping strategies; table per concrete class, table per class hierarchy, and table per subclass. Covers both XML-mapping and attribute mapping.

4. Working with persistent objects

Describes the three object states (persistent, detached, and transient) that domain models have in a NHibernate application, and how they move from one state to another. It also gives an overview of different ways to get objects out of the database.

5. Transactions, concurrency, and caching

Shows how NHibernate handles transactions, short vs. long conversations, optimistic concurrency control and versioning. Finally it discusses caching and describes the first- and second-level cache that NHibernate provides.

6. Advanced mapping concepts

Goes into detail of more advanced mapping techniques, covering mapping types, custom mapping types, nullable types, enumerated types, collection of value types, mapping of entity associations, and mapping of polymorphic associations.

7. Retrieving objects efficiently

Describes object retrieval with both HQL, Query by Criteria, and native SQL. Topics covered are parameters, comparison operators, logical operators, ordering, joining, report queries, dynamic queries, and query optimization.

8. Developing NHibernate applications

This chapter starts the last part of the book, called NHibernate in the real world. Discusses N-tier development by going through the business, persistence, and presentation layer. Finally it shows how NHibernate can be used to implement audit logging.

9. Writing real-world domain models

Covers domain-model development processes and tools, legacy schema mapping, understanding persistence ignorance, implementing business logic, data binding entities in the GUI, and filling DataSets from entities.

10. Architectural patterns for persistence

Focuses on the design of the persistence layer. Covers designing the persistence layer, implementing reusable Data Access Objects, implementing conversations, and using NHibernate in an Enterprise Services application.

Conclusion

First let’s start with the things that I like about the book. As far as I know it is the only book published about NHibernate, and great OR/M deserves its own book. The book is well written and structured. It covers many aspects of NHibernate, and gives you enough information to start using NHibernate in your own project. The first part of the book is great for beginners of NHibernate. The second part covers more advanced topics and people with some experience with NHibernate should also find something useful in these chapters.

Unfortunately, there are some things that I don’t like about the book. It covers NHibernate 1.2, even though 2.0 was released when the book came out. I also think that the last part of the book covers to much basic stuff about Domain Driven Design and N-tier development, instead of focusing on how to utilize NHibernate. Hopefully, the authors will release a second edition that covers version 2+, and also covers more community project, like Fluent NHibernate.

Overall I give this book 3.5 of 5 stars

Mapping a Twitter like domain with Fluent NHibernate

bengtbe — Sun, 24 May 2009 08:00:00 +0000

I’m currently learning NHibernate, and one of the best ways to learn is to blog about it Since I’m not a big fan of XML files, I also wanted to use Fluent NHibernate to do the mapping. As an example I will use a social messaging domain, similar to Twitter. I will also use a Top-down approach, starting with the domain model, writing the mapping, and finally creating the database schema using the SchemaExport class in NHibernate.

The domain model

Let’s start with a look at the domain model:

The domain model mainly consists of the User entity and the Message entity and their associations:

The user has a list of Messages that he/she has posted.
The user has a list of other users that are interested in his/hers messages, called Followers.
The user has a list of other users whose messages he/she is interested, called Following.
The message has a PostedBy reference to the user who posted it.

Both entities derive from the Entity base class that contains the Id property and implements Equals and GetHashCode methods.

The domain classes

Let’s take a close look at the domain classes. Below is the class for the Message entity:

public class Message : Entity<Message>
{
    public virtual string Text { get; set; }
    public virtual User PostedBy { get; set; }
    public virtual DateTime CreatedAt { get; set; }
}

It contains the message text, a reference to the user who posted it, and the time it was created.

Below is the class for the User entity:

public class User : Entity<User>
{
    public User()
    {
        Name = Url = Email = “”;
        Followers = new List<User>();
        Following = new List<User>();
        Messages = new List<Message>();
    }
    public virtual string Name { get; set; }
    public virtual string Username { get; set; }
    public virtual string Email { get; set; }
    public virtual string Url { get; set; }
    public virtual IList<User> Followers { get; private set; }
    public virtual IList<User> Following { get; private set; }
    public virtual IList<Message> Messages { get; private set; }
    public virtual void AddFollowing(User user)
    {
        if (Following.Contains(user)) return;
        Following.Add(user);
        user.Followers.Add(this);
    }
    public virtual void AddMessage(string messageText)
    {
        var message = new Message
                          {
                              Text = messageText,
                              PostedBy = this,
                              CreatedAt = DateTime.Now
                          };
        Messages.Add(message);
    }
}
 

The User class contains some properties about the user, a list of followers, a list of following users, and a list of messages. It also contains two methods:

AddFollowing(User user) - Adds another user to the list of users that the current user is following. Since this is a bidirectional relationship, it also adds the current user to the other user’s followers.
AddMessage(string messageText) – Adds a new message that the user has posted. Sets the PostedBy to the current user.

Why is everything virtual?

When using NHibernate the domain model can be close to Persistence Ignorant (PI), which means that you don’t have to take any special considerations when designing the domain model, like derive from a specific base class. However to support transparent lazy-loading, NHibernate needs to return a proxy that inherit from your entity and override the properties.

If you dislike marking everything with virtual you can turn of lazy-loading, but I don’t recommend doing this.

Mapping with Fluent NHibernate

As mentioned, Fluent NHibernate lets you write mapping with strongly typed C# code, instead of the traditional NHibernate XML mapping files. This allows you to use tools like ReSharper to alter both the domain and mapping files when refactoring.

The mapping files must derive from ClassMap and the mapping code is done inside the constructor using lambda expressions and a fluent syntax.

Let’s take a look at the mapping file for the Message entity:

public class MessageClassMap : ClassMap<Message>
{
    public MessageClassMap()
    {
        Id(m => m.Id).GeneratedBy.GuidComb();
        Map(m => m.Text).Not.Nullable().WithLengthOf(140);
        Map(m => m.CreatedAt).Not.Nullable();
        References(m => m.PostedBy, “PostedBy”).Not.Nullable();
    }
}
 

Explanation of the mapping:

The Id method maps the Id property as the identifier of the Message entity. It should be generated using the GuidComb algorithm.
The Map method maps the Text property. It also specifies that is should not be null, and that the max length is 120.
The Map method also maps the CreatedAt property.
The References method maps the PostedBy property as a many-to-one relationship between the message and user. Hence, one message belongs to a single user, but a user can have many messages. It also specifies that the column name in the database should be PostedBy.

Let’s take a look at the mapping file for the User entity:

public class UserClassMap : ClassMap<User>
{
    public UserClassMap()
    {
        Id(u => u.Id);
        Map(u => u.Name).Not.Nullable().WithLengthOf(50);
        Map(u => u.Username).Not.Nullable().WithLengthOf(50).Unique();
        Map(u => u.Email).Not.Nullable().WithLengthOf(100);
        Map(u => u.Url).Not.Nullable().WithLengthOf(100);
        HasMany(u => u.Messages).LazyLoad().Cascade.All()
            .KeyColumnNames.Add(“PostedBy”);
        HasManyToMany(u => u.Following).LazyLoad()
            .WithParentKeyColumn(“FollowerId”)
            .WithChildKeyColumn(“FollowingId”);
        HasManyToMany(u => u.Followers).LazyLoad()
            .WithParentKeyColumn(“FollowingId”)
            .WithChildKeyColumn(“FollowerId”).Inverse();
    }
}
 

Explanation of the mapping:

The mapping of the Id, Name, Email, Url does not contain any new syntax.
The mapping of the UserName property uses the Unique method to specify uniqueness. This will create a unique constrain in the database schema.
The HasMany method maps the Messages property as a one-to-many between the user entity and message entity. The Cascade.All means the message will become persistent when you add it to a persistent user. The messages will also be deleted when you delete the user. It also specifies that the name of the column should be PostedBy in order to make sure that it uses the same column as specified in the message mapping.
The HasManyToMany method maps the Following as a many-to-many mapping between users with specified column names.
The HasManyToMany method maps the Followers as a many-to-many mapping between users. This is the inverse of the Following association, hence the call to Inverse().

We also call LazyLoad() to specify that we want support for lazy loading of the lists.

Is something missing in the mapping?

You might have noticed that we often don’t specify the table or column name in the mapping. In these cases the table will get the same name as the class, and the column will get the same name as the property. Below is an example of how to specify table and column names:

WithTable(“TBL_MESSAGES”);
Map(c => c.CreatedAt, “COL_CREATEDAT”).Not.Nullable();

You also don’t need to specify the type of the properties (e.g. that PostedBy is of type User). NHibernate uses reflection to determine the type.

Creating the database

In a top-down approach you change the database after you make changes to the domain or the mapping. During development you can recreate the database using the SchemaExport class in a test or console application. Below is an example using an explicit test in NUnit:

    [TestFixture]
    public class DatabaseSetup
    {
        [Test, Explicit]
        public void SetupDatabase()
        {
            FluentConfiguration conf = NHConfiguration.CreateConfiguration(false);
            conf.ExposeConfiguration(BuildSchema)
                .BuildSessionFactory();
        }
        private static void BuildSchema(Configuration conf)
        {
            new SchemaExport(conf).Drop(false, true);
            new SchemaExport(conf).Create(false, true);
        }
    }
}

The test is marked with the Explicit attribute because you want to control when this test is run, e.g. you do not want to run it every time you run your tests. The SetupDatabase() test receives a FluentConfiguration from the NHibernate configuration class in the project. The database is created in the BuildSchema method that is passed to the ExposeConfiguration method. The call to BuildSessionFactory() is needed to trigger the FluentConfiguration to actually execute the call to the BuildSchema method.

Finally the database schema

Below is the database schema that has been created from the domain model and the mappings:

Some notes about the database schema:

The length of the nvarchar fields are according to the WithLengthOf call in the mappings.
All fields are not nullable because of the Not.Nullable() call in the mappings.
The many-to-many association between users are represented using the UserToUser junction table.
The one-to-many association between the message and users are done by the PostedBy column in the Message table.
It is not shown in the diagram, but Username has a unique constrain due to the Unique() call in the mappings.

Conclusion

In this post I have shown how to use Fluent NHibernate in a top-down approach in a Twitter like domain. Since I’m fairly new to NHibernate I welcome any comments and suggestions!

Using AutoMapper to map view models in ASP.NET MVC

bengtbe — Tue, 14 Apr 2009 04:27:00 +0000

In projects that have complex domain models it is often necessary to map the domain models to simpler objects such as Data Transfer Objects (DTO) which is “an object that carries data between processes in order to reduce the number of method calls” or Presentation Models which “represent the state and behavior of the presentation independently of the GUI controls used in the interface“.

The mapping code is often boring and tedious to write, so when I first read about AutoMapper it triggered my interest. In this post I will take a first look at AutoMapper, and show how it can be used to map a complex domain model to a view model in an ASP.NET MVC application.

About AutoMapper

The project homepage describes AutoMapper as “a fluent configuration API to define an object-object mapping strategy. AutoMapper uses a convention-based matching algorithm to
match up source to destination values. Currently, AutoMapper is geared towards model projection scenarios to flatten complex object models to DTOs and other simple objects, whose design is better suited for serialization, communication, messaging, or simply an anti-corruption layer between the domain and application layer.“

AutoMapper is a fairly new project; the current version is 0.30 Beta, and it seems to be in active development.

A complex domain model

The domain model that I’m going to use in this example is a Customer class that has a reference to an Address class:

public class Customer
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Email { get; set; }
    public Address HomeAddress { get; set; }

    public string GetFullName()
    {
        return string.Format(“{0} {1}”, FirstName, LastName);
    }
}

The Address class is as follows:

public class Address
{
    public string Address1 { get; set; }
    public string Address2 { get; set; }
    public string City { get; set; }
    public string PostalCode { get; set; }
    public string Country { get; set; }
}

Ok, I admit that this domain model is not very complex, but it will serve the purpose of this post

The simple view model

The view is going to show a list of customers with name, email and country. We therefore create a view model called CustomerListViewModel:

public class CustomerListViewModel
{
    public string FullName { get; set; }
    public string Email { get; set; }
    public string HomeAddressCountry { get; set; }
}

I save this view model in the file ViewModel/Customers/CustomerListViewModel.cs in the web-project. In an ASP.NET MVC application the view models belong to the Web-project, they are not part of the domain model. Usually a view model belongs to a single controller, and its views.

The controller

The URL used to display the customers should be http://application/Customers/, hence the name of the controller is CustomersController, and the action used is the Index():

public class CustomersController : Controller
{
    private readonly ICustomerService m_CustomerService;

    public CustomersController(ICustomerService customerService)
    {
        m_CustomerService = customerService;
    }

    // GET: /Customers/
    public ActionResult Index()
    {
        IList<Customer> customers = m_CustomerService.GetCustomers();

        Mapper.CreateMap<Customer, CustomerListViewModel>();
        IList<CustomerListViewModel> viewModelList =
           Mapper.Map<IList<Customer>, IList<CustomerListViewModel>>(customers);

        return View(viewModelList);
    }
}

In the above controller I use Dependency Injection to inject the CustomerService in the constructor. In a previous post I have shown how to use Dependency Injection in the controllers.

When using AutoMapper you first have to create a map between the two classes:

Mapper.CreateMap<Customer, CustomerListViewModel>();

The following line maps the list of Customers to a list of CustomerListViewModel:

IList<CustomerListViewModel> viewModelList =
   Mapper.Map<IList<Customer>, IList<CustomerListViewModel>>(customers);

If you just wanted to map a single instance you would use:

CustomerListViewModel viewModel = Mapper.Map<Customer, CustomerListViewModel>(customer);

AutoMapper will perform the following mapping automatically:

FullName gets its value by calling the Customer.GetFullName() method.
Email gets its value from the Customer.Email propery.
HomeAddressCountry gets its value from the Customer.HomeAddress.Country property.

The view

Below is the view used to display the view model:

<%@ Page Title=”" Language=”C#” MasterPageFile=”~/Views/Shared/Site.Master”
       Inherits=”System.Web.Mvc.ViewPage>” %>
<%@ Import Namespace=”MyApp.Web.ViewModels.Customers”%>

<asp:Content ID=”Content1″ ContentPlaceHolderID=”MainContent” runat=”server”>

    <h2>Customer listh2>

    <table>
        <tr>
            <th>Nameth>
            <th>Emailth>
            <th>Countryth>
        tr>
    <% foreach (var customer in Model) { %>
        <tr>
            <td><%= Html.Encode(customer.FullName) %>td>
            <td><%= Html.Encode(customer.Email) %>td>
            <td><%= Html.Encode(customer.HomeAddressCountry) %>td>
        tr>
    <% } %>
    table>
asp:Content>

<asp:Content ID=”Content2″ ContentPlaceHolderID=”head” runat=”server”>asp:Content>

As you can see from the Inherits attribute, this view is strongly typed to the IEnuerable. The foreach uses the Model property to retrieve the list of CustomerListViewModel, and creates a table row for each instance.

Some advanced features of AutoMapper

In the example above I have shown some simple usages of AutoMapper. I will now take a quick look at some of its more advanced features:

Let’s say that the Customer has a Birthday property of type DateTime that we want to map to a YearOfBirth property of type int:

Mapper.CreateMap<Customer, CustomerListViewModel>()
    .ForMember(dest => dest.YearOfBirth, opt => opt.MapFrom(src => src.Birthday.Year));

Don’t get confused by all the lamdas (=>). The ForMember method just says YearOfBirth should get its value from Birthday.Year.

AutoMapper can also help you test the mapping:

[Test]
public void Should_be_able_to_map_Customer_to_CustomerListViewModel()
{
    Mapper.CreateMap<Customer, CustomerListViewModel>()
        .ForMember(dest => dest.ThisIsMappedElsewhere, opt => opt.Ignore());
    Mapper.AssertConfigurationIsValid();
}

In the above test AutoMapper will check to make sure that every single member on CustomerListViewModel has a corresponding member on the Customer, except for the property ThisIsMappedElsewhere that we told it to ignore.

There are many more features that I haven’t covered. You can find more information in the following places:

Book review: Microsoft .NET: Architecting Applications for the Enterprise

bengtbe — Mon, 09 Mar 2009 07:17:00 +0000

Authors: Dino Esposito & Andrea Saltarello
Publisher: Microsoft Press
Purchase: Amazon.com, Amazon.co.uk

Introduction

I first heard of this book when Jeremy Miller (the maker of StructureMap) wrote that he was impressed by it. So I decided to purchase it, and now I have finished reading it. Before I give my conclusion, lets start with a summary of the different chapters in the book.

1. Architects and Architecture Today

Discusses the design of architecture and the role of the architect. Also gives a brief overview of different models for software development: Waterfall, Agile and Microsoft Solutions Framework.

2. UML Essentials

Covers the most important UML diagram types – Use Case, Class, and Sequence Diagrams. Describes three main modes of using UML – Sketch mode (emerging design), Blueprint mode (up front design), and Programming mode (Model-Driven Architecture). The authors prefer to use UML as a sketching tool to communicate ideas, which seems like a sensible choice.

3. Design Principles and Patterns

Looks at goals of design principles and design – High Cohesion, Low Couping, and Separation of Concerns. Also looks at more advanced Object-Oriented Design principles – Open/Closed Principle, Liskov’s Substitution Principle, and Dependency Inversion Principle. Aspect-Oriented programming (AOP) is also explained by looking at Microsft’s Policy Injection Application Block.

This concludes the first part of the book, the rest of it looks at how to design a system by going through each application layer.

4. The Business Layer

Discusses different ways to organize business logic. The business logic can either be organized around user actions or around the domain. When organizing the logic around user actions, either the Transaction Script (TS) or Table Module (TM) pattern can be applied. These are best suited for low complexity in the domain. When organizing around the domain a Domain Model (DM) pattern can be applied. This pattern can deal with high complexity in the domain.

5. The Service Layer

The service layer is placed between the presentation layer and the business layer, it can also be thought as the upper part of the business layer. It basically is a list of actions that can be triggered from the user interface. One of its main responsibilities is dealing with roles and security. The chapter also discusses the following patterns that are related to the service layer – the Remote Facade Pattern, the Data Transfer Object Pattern, and the Adapter Pattern. It has a good discussion on when to use DTO’s and when it can be considered overkill. It gives a brief introduction to Service-Oriented Arhcitecture (SOA). Finally, it discusses the Serivice Layer in regards to AJAX.

6. The Data Access Layer

Starts off with a discussion of the responsibilities of a Data Access Layer (DAL), and how it “communicates” with the other layers. Then it describes patterns and principles to use when manually designing your own DAL – Service Locator, Inversion of Control, Transactions, Data Context, Query by Criteria, Unit of Work, Concurrency, and Lazy Loading. Afterwards it looks how an Object/Relational Mapper (OR/M) tool can be used to power the DAL, using NHibernate as an example. The authors consider NHibernate to be the de facto standard for O/RM tools, while Entity Framework (EF) is not yet mature enough. At the end of the chapter there is a great section called “To SP or Not to SP”, where the authors dispel many myths about Stored Procedures. At last, a book from Microsoft where SP are not described as the core of a DAL

7. The Presentation Layer

Presents the responsibilities of the presentation layer, and splits it into two segments – the user interface and presentation logic. Gives a great overview of the evolution of presentation patterns – Autonomous Views (AV), Model-View-Controller (MVC), Model2, Model-View-Presenter (MVP), and Presentation Model (PM). Also shows examples from different presentation frameworks – Web Client Software Factory, ASP.NET MVC Framework, MVC# Framework, and Windows Presentation Foundation.

Conclusion

I truly recommend this book to both intermediate and senior .NET developers. It has a great coverage of many current thoughts and aspects of system architecture. Many of the patterns in the book are from Patterns of Enterprise Application Architecture by Martin Fowler, and the book sets them into perspective in an enterprise .NET application. I like that a Microsoft Press book describes and even recommends Open Source tools, e.g. the book recommends NHibernate over Entity Framework. Dino’s writing is very consise and clear, and the book is full of code-examples, not just theory. However, since the scope of the book is very big, it cannot go into too much detail. So don’t expect to learn all you need about e.g. Domain Driven Design or NHibernate by reading this book.

Overall I give this book 4.5 of 5 stars