NHibernate blog : NHibernate

NHibernate 3 Beginners Guide published

gabriel.schenker — Mon, 29 Aug 2011 20:27:00 GMT

Note: This post has been cross posted from my own blog at Los Techies.

I am very pleased to announce that my book NHibernate 3 Beginners Guide has finally been published. It is a wonderful feeling to finally have a book in my hands that cost me a couple of months of intense work. But I think the result is well worth it.

If you are interested in the book then there is also a free chapter available for download.

I was lucky to have Fabio Maulo and José F. Romaniello as my reviewer, the former being the lead of the NHibernate project and the latter an active contributor to the the project.

My goal for this book has been to provide an easy to follow introduction to NHibernate 3.x. The text covers NHibernate up to version 3.1 GA and even references some of the new features of NHibernate 3.2 GA. It was very important to me to not use a data centric approach but rather choose a model first approach.

In this regard this book is NOT just an updated version of NHibernate 2 Beginners Guide but rather a complete rewrite.

I also have paid attention to cover all foundational topics in a clear and concise way. In no way did I want to abandon the reader in the dust of uncertainty.

Let me provide you the list of chapters found in the book with a short introduction about the respective content of each chapter.

Chapter 1, First Look… explains what NHibernate is and why we would use it in an application that needs to access data in a relational database. The chapter also briefly presents what is new in NHibernate 3.x compared to the version 2.x and discusses how one can get this framework. Links to various sources providing documentation and help are presented.

Chapter 2, A First Complete Sample…walks through a simple yet complete sample where the core concepts of NHibernate and its usage are introduced.

Chapter 3, Creating a Model… discusses what a domain model is and what building blocks constitute such a model. In an exercise the reader creates a domain model for a simple ordering system.

Chapter 4, Defining the Database Schema…explains what a database schema is and describes in details the individual parts comprising such a schema. A schema for the ordering system is created in an exercise.

Chapter 5, Mapping the Model to the Database…teaches how to bridge the gap between the domain model and the database schema with the aid of some wiring. This chapter presents four distinct techniques how the model can be mapped to the underlying database or vice versa. It is also shown how we can use NHibernate to automatically create the database schema by leveraging the meta-information contained in the domain model.

Chapter 6, Sessions and Transactions…teaches how to create NHibernate sessions to communicate with the database and how to use transactions to group multiple tasks into one consistent operation which succeeds or fails as a whole.

Chapter 7, Testing, Profiling, Monitoring and Logging…introduces how to test and profile our system during development to make sure we deliver a reliable, robust and maintainable application. It also shows how an application can be monitored in a productive environment and how it can log any unexpected or faulty behavior.

Chapter 8, Configuration… explains how we can tell NHibernate which database to use, as well as provide it the necessary credentials to get access to the stored data. In addition to that many more settings for NHibernate to tweak and optimize the database access are explained in this chapter.

Chapter 9, Writing Queries… discusses the various means how we can easily and efficiently query data from the database to create meaningful reports on screen or on paper.

Chapter 10, Validating the data to persist…discusses why data collected by an application needs to be correct, complete and consistent. It shows how we can instrument NHibernate to achieve this goal through various validation techniques.

Chapter 11, Common Pitfalls – Things to avoid… as the last chapter of this book presents the most common errors developers can make when using NHibernate to write or read data to and from the database. Each such pitfall is discussed in details and possible solutions to overcome the problems are shown.

Integrating Adobe Flex Applications with NHibernate

Kathleen Erickson — Tue, 01 Mar 2011 05:03:00 GMT

If you are using NHibernate and suddenly find yourself needing to integrate with a Flex client, this article written by Joseph Magly will be helpful. http://www.adobe.com/devnet/flex/articles/flex-nhibernate.html

Visual NHibernate – Using Templates

Gareth Hayter — Mon, 07 Feb 2011 23:51:00 GMT

Visual NHibernate can be customized in many ways. Today we’ll look at the built-in template engine. You can easily create the exact output you need by tweaking the built-in templates or creating new custom templates.

Visual NHibernate currently has two built-in templates:

The standard NHibernate template
The new Sharp Architecture template.

Template Editor

The template editor enables you to specify how the generated files and folders should be laid out in the destination folder, WYSIWYG style. Script can be written to generate dynamic files, while static files such as images and DLLs can also be included in the output.

The code editor has IntelliSense and syntax-highlighting, as well as live feedback about errors. Compile errors are underlined in red squiggly lines. They also appear in the errors grid and cause the title-bar to change color from green to red.

Find and replace can be accessed via the standard keyboard shortcuts (Ctrl+F, Ctrl+Shift+F, Ctrl+H, Ctrl+Shift+H).

Laying out folders and files

Add the first folder or file by right-clicking the ‘Output Folder’ node in the treeview.

Folders and files can have iterators. You can generate either a single file, or generate one file or folder per Entity, Table, Column, Component or View. If you select an iterator then you will have access to the iterator in script via a lowercase name, such as entity.Name or table.Name.

File-names and folder-names can be dynamic and can contain script:

Folders

Add a folder by right-clicking on the parent folder.

Dynamic files

A dynamic file is one in which the body is created dynamically via script. Add a file by right-clicking on the parent folder.

Static files

A static file is one that is distributed as-is. It can be an image file, a readme file, a DLL etc.

Static files need to be added to the Resources collection. To do this, select the Resources tab on the left then click the Add button to select the file.

Scripting

Dynamic files output text. Create dynamic content by using either ASP-style delimiters <%...%> or T4-style delimiters <#...#>.

Select the delimiter style towards the top right corner of the screen.

Writing output

Dynamic text can be inserted into the document in a number of ways:

Mixing script and output text, similar to ASP
Placeholders: <%=entity.Name%>
Write(text)
WriteLine(text)
WriteFormat(formatText, args)
WriteIf(boolean expression, trueText)
WriteIf(boolean expression, trueText, falseText)

Skipping files

A dynamic file can be skipped via script by setting SkipThisFile = true and returning the reason. For example:

if (!Project.Settings.UseFluentNHibernate)
{
    SkipThisFile = true;
    return “Project.Settings.UseFluentNHibernate is false”;
}

Testing

Visual NHibernate has a smooth edit-test cycle, giving immediate feedback on your template and scripts. It also enables you to test individual entities, tables, views etc.

Create your template script
Select the ‘Test’ tab
If the file has an iterator, select the iterator you want to test with. Example: if you’ve specified that one file should be created for each entity, then select an entity to test with. If the iterator is a table then a list of tables will be presented for you to make a selection.
Click the ‘Test’ button to run the test.
The script will execute and display the generated text (file-body) or errors if they occur.

Scripting API

The API available for scripting exposes all details about the current project. You have full access to all properties or entities, tables, relationships etc.

The editor has full IntelliSense and the API is easily discoverable:

Here’s a small portion of the API:

CurrentFilePath: Gets or sets the path of the file being written. You can override the path specified in the filename editor via code.
SkipThisFile: Set this to true to stop the current file from being generated. Return the reason for skipping. This reason will be displayed when testing this dynamic file.
Project: Object containing all project-level variables, objects and settings.
- Project.Settings: The Settings object allows access to the values of all settings on the Settings tab.
- Project.Entities: A collection of all entities.
- Project.Components: A collection of all components.
- Project.Tables: A collection of all tables.
- Project.Views: A collection of all views.
- Project.OutputFolder: The path of the output folder selected by the user.

Extend your existing NHibernate projects

Visual NHibernate can reverse-engineer your existing NHibernate Visual Studio projects. Your existing code becomes the model. This enables you to create new code based on your existing code. Create a new template, import your existing code, generate new code.

Conclusion

Custom templates give you a tremendous amount of freedom and power. The best way to learn about the capabilities of templates is to inspect the built-in templates. Download Visual NHibernate, have a play, and tell us what you think.

Loquacious Configuration in NHibernate 3

James Kovacs — Fri, 21 Jan 2011 21:54:07 GMT

[This article was originally published on my personal blog here. I hereby grant myself permission to re-publish it on NHForge.org.]

[Code for this article is available on GitHub here.]

One of the new features in NHibernate 3 is the addition of a fluent API for configuring NHibernate through code. Fluent NHibernate has provided a fluent configuration API for awhile, but now we have an option built into NHibernate itself. (Personally I prefer the new Loquacious API to Fluent NHibernate’s configuration API as I find Loquacious more discoverable. Given that Fluent NHibernate is built on top of NHibernate, you can always use Loquacious with Fluent NHibernate too. N.B. I still really like Fluent NHibernate’s ClassMap<T>, automapping capabilities, and PersistenceSpecification<T>. So don’t take my preference regarding fluent configuration as a denouncement of Fluent NHibernate.)

The fluent configuration API built into NHibernate is called Loquacious configuration and exists as a set of extensions methods on NHibernate.Cfg.Configuration. You can access these extension methods by importing in the NHibernate.Cfg.Loquacious namespace.

var cfg = new Configuration();
cfg.Proxy(p => p.ProxyFactoryFactory<ProxyFactoryFactory>())
   .DataBaseIntegration(db => {
                            db.ConnectionStringName = "scratch";
                            db.Dialect<MsSql2008Dialect>();
                            db.BatchSize = 500;
                        })
   .AddAssembly(typeof(Blog).Assembly)
   .SessionFactory().GenerateStatistics();

On the second line, we configure the ProxyFactoryFactory, which is responsible for generating the proxies needed for lazy loading. The ProxyFactoryFactory type parameter (stuff between the <>) is in the NHibernate.ByteCode.Castle namespace. (I have a reference to the NHibernate.ByteCode.Castle assembly too.) So we’re using Castle to generate our proxies. We could also use LinFu or Spring.

Setting db.ConnectionStringName causes NHibernate to read the connection string from the <connectionStrings/> config section of the [App|Web].config. This keeps your connection strings in an easily managed location without being baked into your code. You can perform the same trick in XML-based configuration by using the connection.connection_string_name property instead of the more commonly used connection.connection_string.

Configuring BatchSize turns on update batching in databases, which support it. (Support is limited to SqlClient and OracleDataClient currently and relies on features of these drivers.) Updating batching allows NHibernate to group together multiple, related INSERT, UPDATE, or DELETE statements in a single round-trip to the database. This setting isn’t strictly necessary, but can give you a nice performance boost with DML statements. The value of 500 represents the maximum number of DML statements in one batch. The choice of 500 is arbitrary and should be tuned for your application.

The assembly that we are adding is the one that contains our hbm.xml files as embedded resources. This allows NHibernate to find and parse our mapping metadata. If you have your metadata located in multiple files, you can call cfg.AddAssembly() multiple times.

The last call, cfg.SessionFactory().GenerateStatistics(), causes NHibernate to output additional information about entities, collections, connections, transactions, sessions, second-level cache, and more. Although not required, it does provide additional useful information about NHibernate’s performance.

Notice that there is no need to call cfg.Configure(). cfg.Configure() is used to read in configuration values from [App|Web].config (from the hibernate-configuration config section) or from hibernate.cfg.xml. If we’ve not using XML configuration, cfg.Configure() is not required.

Loquacious and XML-based configuration are not mutually exclusive. We can combine the two techniques to allow overrides or provide default values – it all comes down to the order of the Loquacious configuration code and the call to cfg.Configure().

var cfg = new Configuration();
cfg.Configure();
cfg.Proxy(p => p.ProxyFactoryFactory<ProxyFactoryFactory>())
   .SessionFactory().GenerateStatistics();

Note the cfg.Configure() on the second line. We read in the standard XML-based configuration and then force the use of a particular ProxyFactoryFactory and generation of statistics via Loquacious configuration.

If instead we make the call to cfg.Configure() after the Loquacious configuration, the Loquacious configuration provides default values, but we can override any and all values using XML-based configuration.

var cfg = new Configuration();
cfg.Proxy(p => p.ProxyFactoryFactory<ProxyFactoryFactory>())
   .DataBaseIntegration(db => {
                            db.ConnectionStringName = "scratch";
                            db.Dialect<MsSql2008Dialect>();
                            db.BatchSize = 500;
                        })
   .AddAssembly(typeof(Blog).Assembly)
   .SessionFactory().GenerateStatistics();
cfg.Configure();

You can always mix and match the techniques by doing some Loquacious configuration before and som after the call to cfg.Configure().

WARNING: If you call cfg.Configure(), you need to have <hibernate-configuration/> in your [App|Web].config or a hibernate.cfg.xml file. If you don’t, you’ll throw a HibernateConfigException. They can contain an empty root element, but it needs to be there. Another option would be to check whether File.Exists(‘hibernate.cfg.xml’) before calling cfg.Configure().

So there you have it. The new Loquacious configuration API in NHibernate 3. This introduction was not meant as a definitive reference, but as a jumping off point. I would recommend that you explore other extension methods in the NHibernate.Cfg.Loquacious namespace as they provide the means to configure the 2nd-leve cache, current session context, custom LINQ functions, and more. Anything you can do in XML-based configuration can now be accomplished with Loquacious or the existing methods on NHibernate.Cfg.Configuration. So get out there and start coding – XML is now optional…

NHibernate Bootstrapper: Unit Tests and Project References

John Davidson — Sun, 05 Dec 2010 15:59:00 GMT

This post is the second one about the NHibernate Bootstrapper. The first is located here. The first post set up the project structure, introduced the generic DAO, and demonstrated the SessionPerRequest implementation in an IHttpModule. This post will factor the reference to NHibernate out of the web application project and cover some unit testing techniques. Programmers that are not familiar with SOLID should review the Wikipedia page and the references there. The first post noted that the version of NHibernate Bootstrapper presented there was not suitable for use in anything other than a demonstration program. The version of the solution discussed in this post is suitable for use in a small-scale system where there no more than 15 classes involved. The version following this post should be suitable for even the largest deployments, though there will be at least one additional post that refines the capabilities of an enterprise ready solution. The project sources are in a zip file located here and are updated to use the NHibernate 3.0.0 GA release.

PresentationManager

The solution in the first post used NHibernate references in the web application project. In this version of the solution those references have been moved to the presenter project. Now the solution is taken on the characteristics of the Model-View-Presenter (MVP) , discussed by Martin Fowler here, and later refined into a Supervising Presenter and Passive View. The solution employed here follows the Passive View pattern, where the view has no direct interaction with the model. The solution builds on 2 Code Project articles, originally released in Jul 2006. The first reference used is Model View Presenter with ASP.Net by Bill McCafferty and the second is Advancing the Model-View-Presenter Pattern – Fixing the Common Problems by Acoustic. There are a number of reasons for using the MVP pattern, but the most important of them is the enabling of testing. The second half of this post will show how it becomes possible to test the code behind of an aspx page.

In the first post the BusinessServices project, that would hold the presenters, was empty. Now there is a Presentation Manager and a Presenter classes. The PresentationManager is able to register the view of the ASP.Net page and associate it with the correct presenter. It is also remarkable in that it automatically instantiates the correct presenter for use by the ASP.Net page. This is done in the LoadPresenter method. The auto-instantiation is how ASP.Net pages are able to function with only a reference to the PresenterTypeAttribute in the web application project.

PresentationManager.cs
 using System;
using Infrastructure;
 
namespace BusinessServices
{
    public static class PresentationManager
    {
        public static T RegisterView<T>(Type presenterType, IView myView) where T : Presenter
        {
            return RegisterView<T>(presenterType, myView, null);
        }
 
        public static T RegisterView<T>(Type presenterType, IView view, IHttpSessionProvider httpSession) where T : Presenter
        {
            return (LoadPresenter(presenterType, view, httpSession)) as T;
        }
 
        public static void RegisterView(Type presenterType, IView view)
        {
            RegisterView(presenterType, view, null);
        }
 
        public static void RegisterView(Type presenterType, IView view, IHttpSessionProvider httpSession)
        {
            LoadPresenter(presenterType, view, httpSession);
        }
 
        private static Object LoadPresenter(Type presenterType, IView view, IHttpSessionProvider httpSession)
        {
            int arraySize = ((httpSession == null) ? 1 : 2);
            Object[] constructorParams = new Object[arraySize];
 
            constructorParams[0] = view;
 
            if (arraySize.Equals(2))
            {
                constructorParams[1] = httpSession;
            }
            return Activator.CreateInstance(presenterType, constructorParams);
        }
 
    }
}
 

The PresenterTypeAttribute is what each page uses to drive SelfRegister. This is the mechanism that ties the individual web pages to the appropriate presenter in an automated fashion. This is one aspect of a poor man’s Inversion of Control without requiring a separate container to hold the various dependencies.

PresenterTypeAttribute.cs
 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace BusinessServices
{
    //[AttributeUsage(AttributeTargets.All, Inherited = true)]
    public class PresenterTypeAttribute : Attribute
    {
        private Type _presenterType;
 
        public PresenterTypeAttribute(Type presenterType)
        {
            _presenterType = presenterType;
        }
 
        public Type PresenterType
        {
            get { return _presenterType; }
            set { _presenterType = value; }
        }
    }
}
 

Revised Web Application Project

The code behind for the web page has been revised to work with a presenter. You will note that a large amount of code that was in the original code behind file has now been commented out, as it has been revised slightly and moved to the the PersonPresenter class. The code behind file is now left with just event declarations, a number of properties and the occasional method for working with gridview or dropdown controls and the Page_Load event. All that remains in the code behind are methods and properties that are referencing System.Web, while the various presenter classes have no reference to System.Web. It is important to note that the removal of the reference to System.Web in the presenter classes is what enables a high degree of code coverage in the Unit Tests.

Default.aspx.cs (Part 1)
 using System;
using System.Collections.Generic;
using System.Web.UI;
using System.Web.UI.WebControls;
using BusinessServices;
using BusinessServices.Interfaces;
using BusinessServices.Presenters;
using DataServices.Person;
 
namespace WebNHibernate
{
    [PresenterType(typeof(PersonPresenter))]
    public partial class _Default : BasePage, IPersonView
    {
 
        public event GridViewBtnEvent OnEditCommand;
        public event GridViewBtnEvent OnDeleteCommand;
        public event EmptyBtnEvent OnRefreshPersonGrid;
        public event EmptyBtnEvent OnSaveEditPerson;
        public event EmptyBtnEvent OnClearEditPerson;
        //added event for presenter
        public event EmptyEvent OnPageLoadNoPostback;
 
        //private ISession m_session = null;
 
        protected void Page_Load(object sender, EventArgs e)
        {
            //added for the presenter
            base.SelfRegister(this);
 
            //OnEditCommand += new GridViewBtnEvent(_view_OnEditCommand);
            //OnDeleteCommand += new GridViewBtnEvent(_view_OnDeleteCommand);
            //OnRefreshPersonGrid += new EmptyBtnEvent(_view_OnRefreshPersonGrid);
            //OnSaveEditPerson += new EmptyBtnEvent(_view_OnSaveEditPerson);
            //OnClearEditPerson += new EmptyBtnEvent(_view_OnClearEditPerson);
 
            //if (m_session == null)
            //    m_session = SessionManager.SessionFactory.GetCurrentSession();
 
            if (!Page.IsPostBack)
            {
                //added line below for presenter
                OnPageLoadNoPostback();
                //IList<PersonDto> gvData = Get_PersonData();
                //Fill_gvPerson(gvData);
            }
           
        }
 

Default.aspx.cs (Part 2)
 protected void gvPerson_OnRowCommand(object sender, GridViewCommandEventArgs e)
{
    Guid id = new Guid(gvPerson.DataKeys[Convert.ToInt32(e.CommandArgument)].Value.ToString());
    if (e.CommandName == "EditRow")
        OnEditCommand(id);
    else if (e.CommandName == "DeleteRow")
        OnDeleteCommand(id);
}
 
//public void _view_OnEditCommand(Guid id)
//{
//    if (m_session == null)
//        m_session = SessionManager.SessionFactory.GetCurrentSession();
 
//    PersonDAOImpl dao = new PersonDAOImpl(m_session);
//    Person pers = dao.GetByID(id);
 
//    txtPersonIdValue = pers.Id.ToString();
//    txtFirstNameValue = pers.FirstName;
//    txtLastNameValue = pers.LastName;
//    txtEmailValue = pers.Email;
//    txtUserIdValue = pers.UserID;
 
//    pers = null;
//    dao = null;
//}
 
//public void _view_OnDeleteCommand(Guid id)
//{
//    if (m_session == null)
//        m_session = SessionManager.SessionFactory.GetCurrentSession();
 
//    PersonDAOImpl dao = new PersonDAOImpl(m_session);
//    using (var tx = m_session.BeginTransaction())
//    {
//        dao.Delete(id);
//        tx.Commit();
//    }
 
//    dao = null;
//    _view_OnRefreshPersonGrid();
//}
 

Default.aspx.cs (Part 3)
 //public void _view_OnRefreshPersonGrid()
//{
//    IList<PersonDto> gvData = Get_PersonData();
//    Fill_gvPerson(gvData);
//}
 
//public void _view_OnSaveEditPerson()
//{
 
//    if (m_session == null)
//        m_session = SessionManager.SessionFactory.GetCurrentSession();
 
//    Guid editId = new Guid();
//    Person editPers = new Person();
 
//    if (!string.IsNullOrEmpty(txtPersonIdValue))
//        editId = new Guid(txtPersonIdValue);
 
//    PersonDAOImpl dao = new PersonDAOImpl(m_session);
//    using (var tx = m_session.BeginTransaction())
//    {
//        if (editId.ToString().Length == 36)
//            editPers = dao.GetByID(editId);
//        editPers.FirstName = txtFirstNameValue;
//        editPers.LastName = txtLastNameValue;
//        editPers.Email = txtEmailValue;
//        editPers.UserID = txtUserIdValue;
 
//        editPers = dao.Save(editPers);
//        tx.Commit();
//    }
 
//    editPers = null;
//    dao = null;
//    _view_OnRefreshPersonGrid();
//    _view_OnClearEditPerson();
//}
 
//public void _view_OnClearEditPerson()
//{
//    txtPersonIdValue = null;
//    txtFirstNameValue = null;
//    txtLastNameValue = null;
//    txtEmailValue = null;
//    txtUserIdValue = null;
//}
 

Default.aspx.cs (Part 4)
 protected void btnRefresh_Click(object sender, EventArgs e)
{
    OnRefreshPersonGrid();
}
 
protected void btnSave_Click(object sender, EventArgs e)
{
    OnSaveEditPerson();
}
 
protected void btnClear_Click(object sender, EventArgs e)
{
    OnClearEditPerson();
}
 
public void Fill_gvPerson(IList<PersonDto> data)
{
    gvPerson.DataSource = data;
    gvPerson.DataBind();
}
 
//public IList<PersonDto> Get_PersonData()
//{
//    IList<PersonDto> retVal = null;
 
//    if (m_session == null)
//        m_session = SessionManager.SessionFactory.GetCurrentSession();
 
//    ICriteria crit = m_session.CreateCriteria(typeof(Person));
//    PersonDAOImpl dao = new PersonDAOImpl(m_session);
 
//    IList<Person> people = dao.GetByCriteria(crit);
//    retVal = (from person in people
//              select new PersonDto
//                  {
//                      PersonID = person.Id,
//                      FirstName = person.FirstName,
//                      LastName = person.LastName,
//                      Email = person.Email,
//                      UserID = person.UserID
//                  }).ToList<PersonDto>();
//    crit = null;
//    dao = null;
//    people = null;
 
//    return retVal;
//}
 

Default.aspx.cs (Part 5)
         public string txtPersonIdValue
        {
            get { return txtPersonID.Text; }
            set { txtPersonID.Text = value; }
        }
 
        public string txtFirstNameValue
        {
            get { return txtFirstName.Text; }
            set { txtFirstName.Text = value; }
        }
 
        public string txtLastNameValue
        {
            get { return txtLastName.Text; }
            set { txtLastName.Text = value; }
        }
 
        public string txtEmailValue
        {
            get { return txtEmail.Text; }
            set { txtEmail.Text = value; }
        }
 
        public string txtUserIdValue
        {
            get { return txtUserID.Text; }
            set { txtUserID.Text = value; }
        }
 
    }
}
 

BasePage

The web project has had a BasePage class added to reuse element and methods common to more than just a single web page. This includes the SelfRegister method and various properties for RequestString, RequestUrl and IsPostBack. These are sample functions which have common utility throughout all the web pages. It is here that additional utility methods and functions with similar commonality would be added.

BasePage.cs
 using System;
using System.Collections.Specialized;
using BusinessServices;
 
namespace WebNHibernate
{
    public class BasePage : System.Web.UI.Page, IView
    {
 
        private string _requestUrl;
 
        protected T RegisterView<T>() where T : Presenter
        {
            return PresentationManager.RegisterView<T>(typeof(T), this, new HttpSessionProvider());
        }
 
        protected void SelfRegister(System.Web.UI.Page page)
        {
            if (page != null && page is IView)
            {
                object[] attributes = page.GetType().GetCustomAttributes(typeof(PresenterTypeAttribute), true);
 
                if (attributes != null && attributes.Length > 0)
                {
                    foreach (Attribute viewAttribute in attributes)
                    {
                        if (viewAttribute is PresenterTypeAttribute)
                        {
                            PresentationManager.RegisterView((viewAttribute as PresenterTypeAttribute).PresenterType,
                                page as IView, new HttpSessionProvider());
                            break;
                        }
                    }
                }
            }
        }
 
        public NameValueCollection RequestString
        {
            get { return Request.QueryString; }
        }
 
        public string RequestUrl
        {
            get { return Request.RawUrl;  }
            set { _requestUrl = value; }
        }
 
        public bool IsPostback
        {
            get { return this.IsPostBack; }
        }
    }
}
 

PersonPresenter

The PersonPresenter class now inherits the code that was commented out in the code behind file. It must also setup event listeners for events that will be raised from the web page. It is these event listeners that improve the testability of the solution, as now this functionality can be unit tested separate from any System.Web dependency. At this point the various presenters have a reference to NHibernate and work directly with the data access layer. The next iteration of the bootstrapper will refactor the presenter and place a data services layer between the presenter and the data access layer. The presenter will then no longer reference NHibernate.

PersonPresenter.cs (Part 1)
 using System;
using System.Collections.Generic;
using System.Linq;
using NHibernate;
using NHibernateDAO;
using NHibernateDAO.DAOImplementations;
using DataServices.Person;
using DomainModel.Person;
using Infrastructure;
using BusinessServices.Interfaces;
 
namespace BusinessServices.Presenters
{
    public class PersonPresenter : Presenter
    {
        private ISession m_session = null;
 
 
        public PersonPresenter(IPersonView view)
            : this(view, null)
        { }
 
        public PersonPresenter(IPersonView view, IHttpSessionProvider httpSession)
            : base(view, httpSession)
        {
            IPersonView _personView = null;
            _personView = base.GetView<IPersonView>();
            _personView.OnEditCommand += new GridViewBtnEvent(_view_OnEditCommand);
            _personView.OnDeleteCommand += new GridViewBtnEvent(_view_OnDeleteCommand);
            _personView.OnRefreshPersonGrid += new EmptyBtnEvent(_view_OnRefreshPersonGrid);
            _personView.OnSaveEditPerson += new EmptyBtnEvent(_view_OnSaveEditPerson);
            _personView.OnClearEditPerson += new EmptyBtnEvent(_view_OnClearEditPerson);
            _personView.OnPageLoadNoPostback += new EmptyEvent(_personView_OnPageLoadNoPostback);
        }
 
 
        public void _personView_OnPageLoadNoPostback()
        {
            IPersonView _personView = base.GetView<IPersonView>();
            IList<PersonDto> gvData = Get_PersonData();
            _personView.Fill_gvPerson(gvData);
        }
 

PersonPresenter.cs (Part 2)
 public void _view_OnEditCommand(Guid id)
{
    IPersonView _personView = base.GetView<IPersonView>();
    m_session = SessionManager.SessionFactory.GetCurrentSession();
 
    PersonDAOImpl dao = new PersonDAOImpl(m_session);
    DomainModel.Person.Person pers = dao.GetByID(id);
 
    _personView.txtPersonIdValue = pers.Id.ToString();
    _personView.txtFirstNameValue = pers.FirstName;
    _personView.txtLastNameValue = pers.LastName;
    _personView.txtEmailValue = pers.Email;
    _personView.txtUserIdValue = pers.UserID;
 
    pers = null;
    dao = null;
}
 
public void _view_OnDeleteCommand(Guid id)
{
    IPersonView _personView = base.GetView<IPersonView>();
    m_session = SessionManager.SessionFactory.GetCurrentSession();
 
    PersonDAOImpl dao = new PersonDAOImpl(m_session);
    using (var tx = m_session.BeginTransaction())
    {
        dao.Delete(id);
        tx.Commit();
    }
 
    dao = null;
    _view_OnRefreshPersonGrid();
}
 
public void _view_OnRefreshPersonGrid()
{
    IPersonView _personView = base.GetView<IPersonView>();
    IList<PersonDto> gvData = Get_PersonData();
    _personView.Fill_gvPerson(gvData);
}
 

PersonPresenter.cs (Part 3)
 public void _view_OnSaveEditPerson()
{
    IPersonView _personView = base.GetView<IPersonView>();
    m_session = SessionManager.SessionFactory.GetCurrentSession();
 
    Guid editId = new Guid();
    Person editPers = new Person();
 
    if (!string.IsNullOrEmpty(_personView.txtPersonIdValue))
        editId = new Guid(_personView.txtPersonIdValue);
 
    PersonDAOImpl dao = new PersonDAOImpl(m_session);
    using (var tx = m_session.BeginTransaction())
    {
            if ((editId != null) && (!editId.Equals(System.Guid.Empty))) //was a bug here
                editPers = dao.GetByID(editId);
            editPers.FirstName = _personView.txtFirstNameValue;
            editPers.LastName = _personView.txtLastNameValue;
            editPers.Email = _personView.txtEmailValue;
            editPers.UserID = _personView.txtUserIdValue;
 
            editPers = dao.Save(editPers);
            tx.Commit();
    }
 
    editPers = null;
    dao = null;
    _view_OnRefreshPersonGrid();
    _view_OnClearEditPerson();
}
 
public void _view_OnClearEditPerson()
{
    IPersonView _personView = base.GetView<IPersonView>();
 
    _personView.txtPersonIdValue = null;
    _personView.txtFirstNameValue = null;
    _personView.txtLastNameValue = null;
    _personView.txtEmailValue = null;
    _personView.txtUserIdValue = null;
}
 

PersonPresenter.cs (Part 4)
         public IList<PersonDto> Get_PersonData()
        {
            IPersonView _personView = base.GetView<IPersonView>();
            IList<PersonDto> retVal = null;
 
            m_session = SessionManager.SessionFactory.GetCurrentSession();
 
            ICriteria crit = m_session.CreateCriteria(typeof(Person));
            PersonDAOImpl dao = new PersonDAOImpl(m_session);
 
            IList<Person> people = dao.GetByCriteria(crit);
            retVal = (from person in people
                      select new PersonDto
                      {
                          PersonID = person.Id,
                          FirstName = person.FirstName,
                          LastName = person.LastName,
                          Email = person.Email,
                          UserID = person.UserID
                      }).ToList<PersonDto>();
            crit = null;
            dao = null;
            people = null;
 
            return retVal;
        }
 
        public IPersonView personView
        {
            get { return base.GetView<IPersonView>(); }
        }
 
    }
}
 

The interface for the PersonView web page has also had to be revised. Here the methods that are commented out have had the implementations moved from the web page to the presenter. One new event has been added for the presenter.

IPersonView.cs
 using System.Collections.Generic;
using DataServices.Person;
 
namespace BusinessServices.Interfaces
{
 
    public interface IPersonView : IView
    {
 
        event GridViewBtnEvent OnEditCommand;
        event GridViewBtnEvent OnDeleteCommand;
        event EmptyBtnEvent OnRefreshPersonGrid;
        event EmptyBtnEvent OnSaveEditPerson;
        event EmptyBtnEvent OnClearEditPerson;
        //the event below had to be added for the presenter
        event EmptyEvent OnPageLoadNoPostback;
 
        //void _view_OnEditCommand(Guid id);
        //void _view_OnDeleteCommand(Guid id);
        //void _view_OnRefreshPersonGrid();
        //void _view_OnSaveEditPerson();
        //void _view_OnClearEditPerson();
 
        string txtPersonIdValue { get; set; }
        string txtFirstNameValue { get; set; }
        string txtLastNameValue { get; set; }
        string txtEmailValue { get; set; }
        string txtUserIdValue { get; set; }
 
        void Fill_gvPerson(IList<PersonDto> data);
        //IList<PersonDto> Get_PersonData();
 
 
    }
}
 

Data Access Objects Improvements

The data access objects have been expanded to include support for NHibernate LINQ, which is now part of the core. Also support for selection of an unique object has been included, rather than always returning an IList. This means that there has been an update to the IRead.cs file as shown below.

IRead.cs
 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DomainModel;
using NHibernate;
 
namespace NHibernateDAO
{
    public interface IRead<TEntity> where TEntity : Entity
    {
        TEntity GetByID(Guid ID);
        IList<TEntity> GetByCriteria(ICriteria criteria);
        TEntity GetUniqByCriteria(ICriteria criteria);
        IList<TEntity> GetByQueryable(IQueryable<TEntity> queryable);
        TEntity GetUniqByQueryable(IQueryable<TEntity> queryable);
    }
}
 

The implementation file for the data access objects has been revised to include the implementation details for LINQ and unique object support.

GenericDAOImpl.cs (Pt 1)
 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DomainModel;
using NHibernate;
 
namespace NHibernateDAO
{
    public class GenericDAOImpl<TEntity> : IRead<TEntity>, ISave<TEntity> where TEntity : Entity
    {
        public GenericDAOImpl(ISession Session)
        {
            m_Session = Session;
        }
 
        protected readonly ISession m_Session;
 
        public TEntity GetByID(Guid ID)
        {
            if (!m_Session.Transaction.IsActive)
            {
                TEntity retval;
                using (var tx = m_Session.BeginTransaction())
                {
                    retval = m_Session.Get<TEntity>(ID);
                    tx.Commit();
                    return retval;
                }
            }
            else
            {
                return m_Session.Get<TEntity>(ID);
            }
        }
 

GenericDAOImpl.cs (Pt 2)
 public IList<TEntity> GetByCriteria(ICriteria criteria)
{
    if (!m_Session.Transaction.IsActive)
    {
        IList<TEntity> retval;
        using (var tx = m_Session.BeginTransaction())
        {
            retval = criteria.List<TEntity>();
            tx.Commit();
            return retval;
        }
    }
    else
    {
        return criteria.List<TEntity>();
    }
}
 
public TEntity GetUniqByCriteria(ICriteria criteria)
{
    if (!m_Session.Transaction.IsActive)
    {
        TEntity retval;
        using (var tx = m_Session.BeginTransaction())
        {
            retval = criteria.UniqueResult<TEntity>();
            tx.Commit();
            return retval;
        }
    }
    else
    {
        return criteria.UniqueResult<TEntity>();
    }
}
 

GenericDAOImpl.cs (Pt 3)
 public IList<TEntity> GetByQueryable(IQueryable<TEntity> queryable)
{
    if (!m_Session.Transaction.IsActive)
    {
        IList<TEntity> retval;
        using (var tx = m_Session.BeginTransaction())
        {
            retval = queryable.ToList<TEntity>();
            tx.Commit();
            return retval;
        }
    }
    else
    {
        return queryable.ToList<TEntity>();
    }
}
 
public TEntity GetUniqByQueryable(IQueryable<TEntity> queryable)
{
    if (!m_Session.Transaction.IsActive)
    {
        TEntity retval;
        using (var tx = m_Session.BeginTransaction())
        {
            retval = queryable.Single<TEntity>();
            tx.Commit();
            return retval;
        }
    }
    else
    {
        return queryable.Single<TEntity>();
    }
}
 

GenericDAOImpl.cs (Pt 4)
         public TEntity Save(TEntity entity)
        {
            if (!m_Session.Transaction.IsActive)
            {
                using (var tx = m_Session.BeginTransaction())
                {
                    m_Session.SaveOrUpdate(entity);
                    tx.Commit();
                }
            }
            else
            {
                m_Session.SaveOrUpdate(entity);
            }
            return entity;
        }
 
    }
}
 

Unit Test

The unit testing capabilities of the solution have been expanded. It starts with a fake PersonView class in the unit test project that includes functionality similar to that in the web page, but implemented without any reference to System.Web

PersonView.cs (Part 1)
 using System;
using System.Collections.Generic;
using BusinessServices;
using BusinessServices.Interfaces;
using BusinessServices.Presenters;
using DataServices.Person;
 
namespace BootstrapperUnitTests.Views
{
    [PresenterType(typeof(PersonPresenter))]
    public class PersonView : BaseView, IPersonView
    {
        private bool blnRegistered = false;
 
        private string _txtPersonID;
        private string _txtFirstName;
        private string _txtLastName;
        private string _txtEmail;
        private string _txtUserID;
        private static bool postBack;
 
        private IList<PersonDto> _gvPerson;
 
        public event GridViewBtnEvent OnEditCommand;
        public event GridViewBtnEvent OnDeleteCommand;
        public event EmptyBtnEvent OnRefreshPersonGrid;
        public event EmptyBtnEvent OnSaveEditPerson;
        public event EmptyBtnEvent OnClearEditPerson;
        public event EmptyEvent OnPageLoadNoPostback;
 
        public PersonView()
        {
            postBack = false;
            base.SelfRegister(this);
            blnRegistered = true;
        }
 
        /// <summary>
        /// This is used by the test subsystem to avoid the self-registry action and allow normal
        /// object creation.
        /// </summary>
        /// <param name="noRegister"></param>
        public PersonView(bool noRegister)
        {
            blnRegistered = false;
            postBack = false;
        }
 

PersonView.cs (Part 2)
 public void Fill_gvPerson(IList<PersonDto> data)
{
    _gvPerson = data;
}
 
protected internal IList<PersonDto> GvPerson
{
    get { return _gvPerson; }
}
 
public void FireEvent_OnEditCommand(Guid id)
{
    OnEditCommand(id);
}
 
public void FireEvent_OnDeleteCommand(Guid id)
{
    OnDeleteCommand(id);
}
 
public void FireEvent_OnRefreshPersonGrid()
{
    OnRefreshPersonGrid();
}
 
public void FireEvent_OnSaveEditPerson()
{
    if (_txtUserID != null)
    {
        OnSaveEditPerson();
    }
}
 
public void FireEvent_OnClearEditPerson()
{
    OnClearEditPerson();
}
 
public void FireEvent_OnPageLoadNoPostback()
{
    OnPageLoadNoPostback();
}
 

PersonView.cs (Part 3)
         public string txtPersonIdValue
        {
            get { return _txtPersonID; }
            set { _txtPersonID = value; }
        }
 
        public string txtFirstNameValue
        {
            get { return _txtFirstName; }
            set { _txtFirstName = value; }
        }
 
        public string txtLastNameValue
        {
            get { return _txtLastName; }
            set { _txtLastName = value; }
        }
 
        public string txtEmailValue
        {
            get { return _txtEmail; }
            set { _txtEmail = value; }
        }
 
        public string txtUserIdValue
        {
            get { return _txtUserID; }
            set { _txtUserID = value; }
        }
 
        bool IView.IsPostback
        {
            get 
            {
                if (!postBack)
                {
                    postBack = true;
                    return false;
                }
                else
                    return true;
            }
        }
    }
}
 

BasePage.cs must also be copied to the unit test project, and it also no longer references System.Web. It is renamed to BaseView.cs in the actual solution. You will note that the property IsPostBack throws a NotImplementedException, but it could be set to a read/write property and provide values through an external property setter in the tests.

BaseView.cs
 using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Text;
using BusinessServices;
 
namespace BootstrapperUnitTests
{
    public class BaseView : IView
    {
        private string _requestUrl;
        private NameValueCollection _queryString = new NameValueCollection();
        
 
        protected T RegisterView<T>() where T : Presenter
        {
            return PresentationManager.RegisterView<T>(typeof(T), this, null);
        }
 
        protected void SelfRegister(IView page)
        {
            if (page != null && page is IView)
            {
                object[] attributes = page.GetType().GetCustomAttributes(typeof(PresenterTypeAttribute), true);
 
                if (attributes != null && attributes.Length > 0)
                {
                    foreach (Attribute viewAttribute in attributes)
                    {
                        if (viewAttribute is PresenterTypeAttribute)
                        {
                            PresentationManager.RegisterView((viewAttribute as PresenterTypeAttribute).PresenterType,
                                page as IView, null);
                            break;
                        }
                    }
                }
            }
        }
 
        public NameValueCollection RequestString
        {
            get { return _queryString; }
        }
 
        public string RequestUrl
        {
            get { return _requestUrl; }
            set { _requestUrl = value; }
        }
 
        public bool IsPostback
        {
            get { throw new NotImplementedException(); }
        }
    }
}
 

The tests themselves have been expanded and now show a considerably increased code coverage. In doing so the tests are now a combination of unit tests and integration tests, but I would argue that this is desirable as it increases the overall reliability of the solution, which is the purpose of automated tests.

PersonPresenterTests.cs (Pt 1)
 using System;
using System.Collections.Generic;
using NUnit.Framework;
using DomainModel.Person;
using NHibernate;
using NHibernate.Context;
using NHibernateDAO;
using NHibernateDAO.DAOImplementations;
using BootstrapperUnitTests.Views;
using BootstrapperUnitTests.TestData;
using BusinessServices.Interfaces;
using BusinessServices.Presenters;
using DataServices.Person;
 
namespace BootstrapperUnitTests.PresenterTests
{
    [TestFixture]
    public class PersonPresenterTests
    {
        private ISession m_session;
 
        [TestFixtureSetUp]
        public void TestFixtureSetup()
        {
            var session = SessionManager.SessionFactory.OpenSession();
            CallSessionContext.Bind(session);
        }
 
        [TestFixtureTearDown]
        public void TestFixtureTeardown()
        {
            PersonTestData ptd = new PersonTestData();
            ptd.RemoveAllPersonEntries();
 
            var session = CallSessionContext.Unbind(SessionManager.SessionFactory);
            if (session != null)
            {
                if (session.Transaction != null && session.Transaction.IsActive)
                {
                    session.Transaction.Rollback();
                }
                else
                    session.Flush();
 
                session.Close();
            }
 
            session.Dispose();
        }
 

PersonPresenterTests.cs (Pt 2)
 [Test]
public void View_OnEditCommandTest()
{
    PersonTestData ptd = new PersonTestData();
    ptd.CreatePersonEntries(1);
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    ICriteria crit = m_session.CreateCriteria(typeof(Person));
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
 
    IList<Person> people;
 
    using (var tx = m_session.BeginTransaction())
    {
        people = daoPerson.GetByCriteria(crit);
        tx.Commit();
        Assert.GreaterOrEqual(people.Count, 1);
    }
 
    PersonPresenter _pp =new PersonPresenter(new PersonView(false));
 
    daoPerson = null;
    m_session = null;
 
    _pp._view_OnEditCommand(people[0].Id);
    IPersonView _pv = _pp.personView;
    Assert.IsTrue(new Guid(_pv.txtPersonIdValue).Equals(people[0].Id));
    Assert.IsTrue(_pv.txtUserIdValue.Equals(people[0].UserID));
 
    ptd = null;
    _pv = null;
    _pp = null;
}
 

PersonPresenterTests.cs (Pt 3)
 [Test]
public void FireEvent_OnEditCommandTest()
{
    PersonTestData ptd = new PersonTestData();
    ptd.CreatePersonEntries(1);
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    ICriteria crit = m_session.CreateCriteria(typeof(Person));
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
 
    IList<Person> people;
 
    using (var tx = m_session.BeginTransaction())
    {
        people = daoPerson.GetByCriteria(crit);
        tx.Commit();
        Assert.GreaterOrEqual(people.Count, 1);
    }
 
    IPersonView _pv = new PersonView();
    PersonView _pvc = _pv as PersonView;
 
    daoPerson = null;
    m_session = null;
 
    _pvc.FireEvent_OnEditCommand(people[0].Id);
    Assert.IsTrue(new Guid(_pv.txtPersonIdValue).Equals(people[0].Id));
    Assert.IsTrue(_pv.txtUserIdValue.Equals(people[0].UserID));
 
    ptd = null;
    _pv = null;
    _pvc = null;
}
 

PersonPresenterTests.cs (Pt 4)
 [Test]
public void View_OnDeleteCommandTest()
{
    PersonTestData ptd = new PersonTestData();
    ptd.RemoveAllPersonEntries();
    ptd.CreatePersonEntries(1);
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    ICriteria crit = m_session.CreateCriteria(typeof(Person));
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
 
    IList<Person> people;
 
    using (var tx = m_session.BeginTransaction())
    {
        people = daoPerson.GetByCriteria(crit);
        tx.Commit();
        Assert.GreaterOrEqual(people.Count, 1);
    }
 
    PersonPresenter _pp = new PersonPresenter(new PersonView(false));
    IPersonView _pv = _pp.personView;
 
    daoPerson = null;
    m_session = null;
 
    _pp._view_OnDeleteCommand(people[0].Id);
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    daoPerson = new PersonDAOImpl(m_session);
 
    using (var tx = m_session.BeginTransaction())
    {
        people = daoPerson.GetByCriteria(crit);
        tx.Commit();
        Assert.AreEqual(people.Count, 0);
    }
 
    ptd = null;
    _pv = null;
    _pp = null;
}
 

PersonPresenterTests.cs (Pt 5)
 [Test]
public void FireEvent_OnDeleteCommandTest()
{
    PersonTestData ptd = new PersonTestData();
    ptd.RemoveAllPersonEntries();
    ptd.CreatePersonEntries(1);
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    ICriteria crit = m_session.CreateCriteria(typeof(Person));
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
 
    IList<Person> people;
 
    using (var tx = m_session.BeginTransaction())
    {
        people = daoPerson.GetByCriteria(crit);
        tx.Commit();
        Assert.GreaterOrEqual(people.Count, 1);
    }
 
    IPersonView _pv = new PersonView();
    PersonView _pvc = _pv as PersonView;
 
    daoPerson = null;
    m_session = null;
 
    _pvc.FireEvent_OnDeleteCommand(people[0].Id);
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    daoPerson = new PersonDAOImpl(m_session);
 
    using (var tx = m_session.BeginTransaction())
    {
        people = daoPerson.GetByCriteria(crit);
        tx.Commit();
        Assert.AreEqual(people.Count, 0);
    }
 
    ptd = null;
    _pv = null;
    _pvc = null;
}
 

PersonPresenterTests.cs (Pt 6)
         [Test]
        public void View_OnClearEditPerson()
        {
            PersonPresenter _pp = new PersonPresenter(new PersonView(false));
            IPersonView _pv = _pp.personView;
 
            _pv.txtFirstNameValue = "testData";
 
            _pp._view_OnClearEditPerson();
            Assert.IsNullOrEmpty(_pv.txtFirstNameValue);
 
            _pv = null;
            _pp = null;
        }
 
        [Test]
        public void FireEvent_OnClearEditPerson()
        {
            IPersonView _pv = new PersonView();
            PersonView _pvc = _pv as PersonView;
 
            _pv.txtFirstNameValue = "testData";
 
            _pvc.FireEvent_OnClearEditPerson();
            Assert.IsNullOrEmpty(_pv.txtFirstNameValue);
 
            _pv = null;
            _pvc = null;
        }
 
        [Test]
        public void Get_PersonDataTest()
        {
            PersonTestData ptd = new PersonTestData();
            ptd.CreatePersonEntries(3);
 
            m_session = SessionManager.SessionFactory.GetCurrentSession();
            ICriteria crit = m_session.CreateCriteria(typeof(Person));
            PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
 
            IList<Person> people;
 
            using (var tx = m_session.BeginTransaction())
            {
                people = daoPerson.GetByCriteria(crit);
                tx.Commit();
                Assert.GreaterOrEqual(people.Count, 1);
            }
 
            PersonPresenter _pp = new PersonPresenter(new PersonView(false));
            Assert.IsInstanceOf<PersonPresenter>(_pp);
 
 
            daoPerson = null;
            m_session = null;
 
            IList<PersonDto> pers = _pp.Get_PersonData();
            Assert.GreaterOrEqual(pers.Count, 3);
 
            ptd = null;
 
            _pp = null;
        }
 

PersonPresenterTests.cs (Pt 7)
 [Test]
public void FireEvent_OnPageLoadNoPostbackTest()
{
    PersonTestData ptd = new PersonTestData();
    ptd.CreatePersonEntries(3);
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    ICriteria crit = m_session.CreateCriteria(typeof(Person));
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
 
    IList<Person> people;
 
    using (var tx = m_session.BeginTransaction())
    {
        people = daoPerson.GetByCriteria(crit);
        tx.Commit();
        Assert.GreaterOrEqual(people.Count, 1);
    }
 
    IPersonView _pv = new PersonView();
    PersonView _pvc = _pv as PersonView;
 
    people = null;
    daoPerson = null;
    m_session = null;
 
    _pvc.FireEvent_OnPageLoadNoPostback();
    Assert.GreaterOrEqual(_pvc.GvPerson.Count, 3);
 
    ptd = null;
    _pv = null;
    _pvc = null;
}
 

PersonPresenterTests.cs (Pt 8)
 [Test]
public void View_OnRefreshPersonGridTest()
{
    PersonTestData ptd = new PersonTestData();
    ptd.CreatePersonEntries(3);
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    ICriteria crit = m_session.CreateCriteria(typeof(Person));
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
 
    IList<Person> people;
 
    using (var tx = m_session.BeginTransaction())
    {
        people = daoPerson.GetByCriteria(crit);
        tx.Commit();
        Assert.GreaterOrEqual(people.Count, 1);
    }
 
    PersonPresenter _pp = new PersonPresenter(new PersonView(false));
    IPersonView _pv = _pp.personView;
    PersonView _pvc = _pv as PersonView;
 
    people = null;
    daoPerson = null;
    m_session = null;
 
    _pvc.FireEvent_OnRefreshPersonGrid();
    Assert.GreaterOrEqual(_pvc.GvPerson.Count, 3);
 
    ptd = null;
    _pp = null;
    _pv = null;
    _pvc = null;
}
 

PersonPresenter.cs (Pt 9)
 [Test]
public void FireEvent_OnRefreshPersonGridTest()
{
    PersonTestData ptd = new PersonTestData();
    ptd.CreatePersonEntries(3);
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    ICriteria crit = m_session.CreateCriteria(typeof(Person));
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
 
    IList<Person> people;
 
    using (var tx = m_session.BeginTransaction())
    {
        people = daoPerson.GetByCriteria(crit);
        tx.Commit();
        Assert.GreaterOrEqual(people.Count, 1);
    }
 
    IPersonView _pv = new PersonView();
    PersonView _pvc = _pv as PersonView;
 
    people = null;
    daoPerson = null;
    m_session = null;
 
    _pvc.FireEvent_OnRefreshPersonGrid();
    Assert.GreaterOrEqual(_pvc.GvPerson.Count, 3);
 
    ptd = null;
 
    _pv = null;
    _pvc = null;
}
 

PersonPresenterTests.cs (Pt10)
 [Test]
public void View_OnSaveEditPersonNewTest()
{
    PersonTestData ptd = new PersonTestData();
    ptd.RemoveAllPersonEntries();
 
    PersonPresenter _pp = new PersonPresenter(new PersonView(false));
    IPersonView _pv = _pp.personView;
 
    _pv.txtPersonIdValue = "";
    _pv.txtFirstNameValue = "Mary";
    _pv.txtLastNameValue = "Johnston";
    _pv.txtEmailValue = "some@email";
    _pv.txtUserIdValue = "mj1";
 
    _pp._view_OnSaveEditPerson();
 
    _pv = null;
    _pp = null;
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    ICriteria crit = m_session.CreateCriteria(typeof(Person));
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
 
    IList<Person> people;
 
    using (var tx = m_session.BeginTransaction())
    {
        people = daoPerson.GetByCriteria(crit);
        tx.Commit();
        Assert.GreaterOrEqual(people.Count, 1);
    }
 
    people = null;
    daoPerson = null;
    m_session = null;
 
    ptd = null;
}
 

PersonPresneterTests.cs (Pt11)
 [Test]
public void FireEvent_OnSaveEditPersonNewTest()
{
    PersonTestData ptd = new PersonTestData();
    ptd.RemoveAllPersonEntries();
 
    IPersonView _pv = new PersonView();
 
    _pv.txtPersonIdValue = "";
    _pv.txtFirstNameValue = "Mary";
    _pv.txtLastNameValue = "Johnston";
    _pv.txtEmailValue = "some@email";
    _pv.txtUserIdValue = "mj1";
 
    PersonView _pvc = _pv as PersonView;
    _pvc.FireEvent_OnSaveEditPerson();
 
    _pv = null;
    _pvc = null;
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    ICriteria crit = m_session.CreateCriteria(typeof(Person));
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
 
    IList<Person> people;
 
    using (var tx = m_session.BeginTransaction())
    {
        people = daoPerson.GetByCriteria(crit);
        tx.Commit();
        Assert.GreaterOrEqual(people.Count, 1);
    }
 
    people = null;
    daoPerson = null;
    m_session = null;
 
    ptd = null;
}
 

PersonPresenterTests.cs (Pt12)
 [Test]
public void View_OnSaveEditPersonExistingTest()
{
    PersonTestData ptd = new PersonTestData();
    ptd.RemoveAllPersonEntries();
    ptd.CreatePersonEntries(1);
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    ICriteria crit = m_session.CreateCriteria(typeof(Person));
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
 
    IList<Person> people;
 
    using (var tx = m_session.BeginTransaction())
    {
        people = daoPerson.GetByCriteria(crit);
        tx.Commit();
        Assert.GreaterOrEqual(people.Count, 1);
    }
 
    PersonPresenter _pp = new PersonPresenter(new PersonView(false));
    IPersonView _pv = _pp.personView;
 
    _pv.txtPersonIdValue = people[0].Id.ToString();
    _pv.txtFirstNameValue = people[0].FirstName;
    _pv.txtLastNameValue = people[0].LastName;
    _pv.txtEmailValue = people[0].Email;
    _pv.txtUserIdValue = "differentUser";
 
    _pp._view_OnSaveEditPerson();
 
    _pv = null;
    _pp = null;
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    crit = m_session.CreateCriteria(typeof(Person));
    daoPerson = new PersonDAOImpl(m_session);
 
    using (var tx = m_session.BeginTransaction())
    {
        people = daoPerson.GetByCriteria(crit);
        tx.Commit();
        Assert.GreaterOrEqual(people.Count, 1);
    }
 
    people = null;
    daoPerson = null;
    m_session = null;
 
    ptd = null;
}
 

PersonPresenterTests.cs (Pt13)
         [Test]
        public void FireEvent_OnSaveEditPersonExistingTest()
        {
            PersonTestData ptd = new PersonTestData();
            ptd.RemoveAllPersonEntries();
            ptd.CreatePersonEntries(1);
 
            m_session = SessionManager.SessionFactory.GetCurrentSession();
            ICriteria crit = m_session.CreateCriteria(typeof(Person));
            PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
 
            IList<Person> people;
 
            using (var tx = m_session.BeginTransaction())
            {
                people = daoPerson.GetByCriteria(crit);
                tx.Commit();
                Assert.GreaterOrEqual(people.Count, 1);
            }
 
            IPersonView _pv = new PersonView();
 
            _pv.txtPersonIdValue = people[0].Id.ToString();
            _pv.txtFirstNameValue = people[0].FirstName;
            _pv.txtLastNameValue = people[0].LastName;
            _pv.txtEmailValue = people[0].Email;
            _pv.txtUserIdValue = "differentUser";
 
            PersonView _pvc = _pv as PersonView;
            _pvc.FireEvent_OnSaveEditPerson();
 
            _pv = null;
            _pvc = null;
 
            m_session = SessionManager.SessionFactory.GetCurrentSession();
            crit = m_session.CreateCriteria(typeof(Person));
            daoPerson = new PersonDAOImpl(m_session);
 
            using (var tx = m_session.BeginTransaction())
            {
                people = daoPerson.GetByCriteria(crit);
                tx.Commit();
                Assert.GreaterOrEqual(people.Count, 1);
            }
 
            people = null;
            daoPerson = null;
            m_session = null;
 
            ptd = null;
        }
 
    }
}
 

Unit tests have also been included for an unique object and also for the added NHibernate LINQ capabilities

PersonDAOImplTest.cs (Pt 1)
 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DomainModel.Person;
using NHibernateDAO;
using NHibernateDAO.DAOImplementations;
using NUnit.Framework;
using NHibernate;
using NHibernate.Context;
using NHibernate.Linq;
using BootstrapperUnitTests.TestData;
 
namespace BootstrapperUnitTests
{
    [TestFixture]
    public class PersonDAOImplTests
    {
 
        private ISession m_session;
 
        [TestFixtureSetUp]
        public void TestFixtureSetup()
        {
            var session = SessionManager.SessionFactory.OpenSession();
            CallSessionContext.Bind(session);
        }
 
        [TestFixtureTearDown]
        public void TestFixtureTeardown()
        {
            PersonTestData ptd = new PersonTestData();
            ptd.RemoveAllPersonEntries();
 
            var session = CallSessionContext.Unbind(SessionManager.SessionFactory);
            if (session != null)
            {
                if (session.Transaction != null && session.Transaction.IsActive)
                {
                    session.Transaction.Rollback();
                }
                else
                    session.Flush();
 
                session.Close();
            }
 
            session.Dispose();
        }
 

PersonDAOImplTests.cs (Pt 2)
 [Test]
public void PersonSaveTestWithTx()
{
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    Person _person = new Person();
    _person.FirstName = "John";
    _person.LastName = "Davidson";
    _person.Email = "jwdavidson@gmail.com";
    _person.UserID = "jwd";
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
    
    using (var tx = m_session.BeginTransaction())
    {
        Person newPerson = daoPerson.Save(_person);
        tx.Commit();
        Assert.AreEqual(_person, newPerson);
    }
 
    _person = null;
    daoPerson = null;
    m_session = null;
}
 
[Test]
public void PersonCriteriaQueryTestWithTx()
{
    PersonTestData ptd = new PersonTestData();
    ptd.CreatePersonEntries(3);
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    ICriteria crit = m_session.CreateCriteria(typeof(Person));
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
 
    using (var tx = m_session.BeginTransaction())
    {
        IList<Person> people = daoPerson.GetByCriteria(crit);
        tx.Commit();
        Assert.GreaterOrEqual(people.Count, 3);
    }
 
    daoPerson = null;
    m_session = null;
 
    ptd.RemoveAllPersonEntries();
    ptd = null;
}
 

PersonDAOImplTest.cs (Pt 3)
 [Test]
public void PersonDeleteTestWithTx()
{
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    m_session.FlushMode = FlushMode.Commit;
    Person _person = new Person();
    _person.FirstName = "John";
    _person.LastName = "Davidson";
    _person.Email = "jwdavidson@gmail.com";
    _person.UserID = "jwd";
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
 
    Person newPerson;
    using (var tx = m_session.BeginTransaction())
    {
        newPerson = daoPerson.Save(_person);
        tx.Commit();
        Assert.AreEqual(_person, newPerson);
        Console.WriteLine("Person ID: {0}", newPerson.Id);
    }
 
    ICriteria crit = m_session.CreateCriteria(typeof(Person));
    
    Int32 pers = 0;
    using (var tx = m_session.BeginTransaction())
    {
        IList<Person> people = daoPerson.GetByCriteria(crit);
        tx.Commit();
        Assert.Greater(people.Count, 0);
        pers = people.Count;
        Console.WriteLine("Count After Add: {0}", pers);
    }
 
    using (var tx = m_session.BeginTransaction())
    {
        daoPerson.Delete(newPerson);
        tx.Commit();
        newPerson = null;
    }
 
    using (var tx = m_session.BeginTransaction())
    {
        IList<Person> people = daoPerson.GetByCriteria(crit);
        tx.Commit();
        Console.WriteLine("Count after Delete: {0}", people.Count);
 
        Assert.IsTrue(pers.Equals(people.Count + 1));
    }
 
    _person = null;
    daoPerson = null;
    m_session = null;
}
 

PersonDAOImplTests.cs (Pt 4)
 [Test]
public void PersonSaveTestWithoutTx()
{
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    Person _person = new Person();
    _person.FirstName = "John";
    _person.LastName = "Davidson";
    _person.Email = "jwdavidson@gmail.com";
    _person.UserID = "jwd";
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
    Person newPerson = daoPerson.Save(_person);
 
    Assert.AreEqual(_person, newPerson);
    _person = null;
    newPerson = null;
    daoPerson = null;
    m_session = null;
}
 
[Test]
public void PersonCriteriaQueryTestWithoutTx()
{
    PersonTestData ptd = new PersonTestData();
    ptd.CreatePersonEntries(3);
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    ICriteria crit = m_session.CreateCriteria(typeof(Person));
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
    IList<Person> people = daoPerson.GetByCriteria(crit);
 
    Assert.GreaterOrEqual(people.Count, 3);
    people = null;
    daoPerson = null;
    m_session = null;
 
    ptd.RemoveAllPersonEntries();
    ptd = null;
}
 

PersonDAOImplTest.cs (Pt 5)
 [Test]
public void PersonLinqQueryTestWithTx()
{
    PersonTestData ptd = new PersonTestData();
    ptd.CreatePersonEntries(3);
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    IQueryable<Person> qry = from p in m_session.Query<Person>() select p;
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
 
    using (ITransaction tx = m_session.BeginTransaction())
    {
        IList<Person> people = daoPerson.GetByQueryable(qry);
        tx.Commit();
        Assert.GreaterOrEqual(people.Count, 3);
    }
 
    daoPerson = null;
    m_session = null;
 
    ptd.RemoveAllPersonEntries();
    ptd = null;
}
 
[Test]
public void PersonLinqQueryWhereTestWithTx()
{
    PersonTestData ptd = new PersonTestData();
    ptd.CreatePersonEntries(3);
 
    string userid = "jwd2";
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    IQueryable<Person> qry = from p in m_session.Query<Person>() where p.UserID == userid select p;
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
 
    using (ITransaction tx = m_session.BeginTransaction())
    {
        IList<Person> people = daoPerson.GetByQueryable(qry);
        tx.Commit();
        Assert.GreaterOrEqual(people.Count, 1);
    }
 
    daoPerson = null;
    m_session = null;
 
    ptd.RemoveAllPersonEntries();
    ptd = null;
}
 

PersonDAOImplTests.cs (Pt 6)
 [Test]
public void PersonLinqQueryTestWithoutTx()
{
    PersonTestData ptd = new PersonTestData();
    ptd.CreatePersonEntries(3);
 
    m_session = SessionManager.SessionFactory.GetCurrentSession();
    IQueryable<Person> qry = from p in m_session.Query<Person>() select p;
    PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
    IList<Person> people = daoPerson.GetByQueryable(qry);
 
    Assert.GreaterOrEqual(people.Count, 3);
    people = null;
    daoPerson = null;
    m_session = null;
 
    ptd.RemoveAllPersonEntries();
    ptd = null;
}
 

PersonDAOImplTests.cs (Pt 7)
         [Test]
        public void PersonDeleteTestWithoutTx()
        {
            m_session = SessionManager.SessionFactory.GetCurrentSession();
            m_session.FlushMode = FlushMode.Commit;
            Person _person = new Person();
            _person.FirstName = "John";
            _person.LastName = "Davidson";
            _person.Email = "jwdavidson@gmail.com";
            _person.UserID = "jwd";
            PersonDAOImpl daoPerson = new PersonDAOImpl(m_session);
            Person newPerson = daoPerson.Save(_person);
 
            Assert.AreEqual(_person, newPerson);
            Console.WriteLine("Person ID: {0}", newPerson.Id);
 
            ICriteria crit = m_session.CreateCriteria(typeof(Person));
            IList<Person> people = daoPerson.GetByCriteria(crit);
 
            Assert.Greater(people.Count, 0);
            Int32 pers = people.Count;
            Console.WriteLine("Count After Add: {0}", pers);
 
            people = null;
            daoPerson.Delete(newPerson);
            newPerson = null;
            people = daoPerson.GetByCriteria(crit);
            Console.WriteLine("Count after Delete: {0}", people.Count);
 
            Assert.IsTrue(pers.Equals(people.Count + 1));
 
            people = null;
            _person = null;
            daoPerson = null;
            m_session = null;
        }
    }
}
 

Summary

This solution retains all the functionality as was included in the original solution, but it has now been placed in an architecture that improves testability and simplifies the creation of functionality as each element now has a clear project where it belongs within the solution. The next evolution of the bootstrapper will investigate data service usage and more complex mappings. However this version of the bootstrapper is now appropriate to use for simple projects with NHibernate where the domain model is relatively simple.

If you remember back to the code behind file discussion there were still methods that remained for working with the gridview and drop down controls on the web page. These could be moved up to the presenter if these controls were redesigned as composite controls in a separate project in the solution so that they were no longer inherited through System.Web.

NHibernate Code Base Analysis

Patrick Smacchia — Fri, 26 Nov 2010 13:40:00 GMT

Patrick Smacchia writing. I am not a NH developer but the creator of a static analysis tool for .NET developer: NDepend. I recently analyzed NH v3.0.0 Candidate Release 1 with NDepend and I had a chance to discuss some results with NH developer Fabio Maulo. Fabio suggested me to show some results on the NH blog, so here it is.

NDepend generated a report by analyzing NH v3.0.0 CR1 code base. See the report here. NDepend has also the ability to show static analysis results live, inside Visual Studio. The live results are richer than the static report results. Here, I will mostly focus on results extracted from the report, but a few additional results will be obtained from the richer NDepend live capabilities.

Code Size

NH code base weights almost 63K Lines of Code (LoC as defined here). Developers hates LoC as a productivity yardstick measurement, but it doesn't mean that the LoC code metric is useless. LoC represents a great way to compare code base size and gets an idea of the overall development effort. In the report namespace metrics section, we can see that the namespace NHibernate.Hql.Ast.ANTLR.* generated by ANTLR weights around 18K LoC. So we can consider that NH handcrafted code weights 45 LoC. Now we have a number to compare to the 19K LoC of NUnit, the 28K LoC of CC.NET, the 32K LoC of Db4o, the 110K LoC of NDepend, the roughly 130 KLoC of Llblgen, the roughly 500K LoC (or so) of R# (that certainly contains a significant portion of generated code) and the roughly 2M LoC of the .NET Fx 4.

So not only NH is one of the most successful OSS initiative, it is also one of the biggest OSS code base. To quote one NH contributor, NH is a big beast!

Assembly Partitioning

NH is packaged in a single NHibernate.dll assembly. I am a big advocate of reducing the number of assemblies and one assembly seems an ideal number. This way:

Projects consumers of NH just need to link, maintain the reference to just one assembly. This is a very good thing compared to many other OSS Fx that force to reference, maintain many assemblies.
Compilation time is much (much) faster. Compilation time of one single VS project can be easily 10 times faster than the compilation time of the same code base partitioned in many VS projects.
Startup-time of an application using NH is a bit faster. Indeed, the CLR comes with a slight overhead for each extra assemblies to load at runtime.

On the dependency graph or dependency matrix diagrams of the report, I can see that the NH assembly is linking 3 extra assemblies that needs to be redistributed as well: Antlr3.Runtime, Remotion.Data.Linq, and Iesi.Collections.

Code Coverage and NH Code Correctness

The report shows the number 75.93% code coverage ratio. This is an excellent score, especially taken account the large code size. I consider code coverage ratio as the queen the of the code quality metrics. The higher it is, the less likely it is to release a bug in production. However things are not so simple. High code coverage ratio matters if (and only if) the number of checks performed while running unit tests is also high. These checks are usually done in test code (through API like Assert.IsTrue(...) ). But few developers realize that checks have the same value if they are done in the code tested itself through the API Debug.Assert(...) or through the new Microsoft Code Contract API. The two important things is that checks (or contract if you prefer) must not slow down execution, and must fail abruptly when the condition is violated.

I can quickly see that NH doesn't use Debug.Assert(...) nor the new Microsoft Code Contract API. But on the other hands I can see that NH comes with 2735 unit tests, all successfully executed. This significant number, coupled with the 75,93% code coverage ratio, advocate for an excellent testing plan for NH. To quote one NH contributor I talked with once: NH is very hard to break! (but by using code contracts and striving for an even higher code coverage ratio it would be even harder to break).

An another and obvious reason why NH code is rock solid, is related to the huge NH community size, that can be counted in hundred of thousands of developers and projects. In this condition, any bug has very few chances to live for a long time.

Code Architecture

Most of .NET developers consider (wrongly IMHO) that .NET code must be componentized through .NET assembly (meaning through VS projects). As discussed above, having very few assemblies comes with important benefits. The essential point is that assemblies are physical artifacts while components are logical artifacts. Hence assembly partitioning must be driven by physical reasons (like lazy-code loading or an addin system).

Nevertheless a 63K LoC code base needs a solid architecture. A solid architecture is the key for high code maintainability. How to define components in .NET code? Personally my preference goes to the usage of namespaces to define component. This way of doing comes wit many advantages: namespaces are logical artifacts, namespaces can be structured hierarchically, architecture explorer tooling can deal out-of-the-box with namespaces, namespaces are supported at language-level and namespaces can be used to draw explicit and concrete boundaries.

In a framework such as NH, namespaces are essentially used to organize the public API. This way of doing is not incompatible with componentizing the code through namespaces. But in the case of NH, the project inherited the API structure of the Hibernate project in the Java sphere. The former Hibernate project doesn't rely on code componentization through namespaces, so NH doesn't as well. And there is no hope for any refactoring : this would result in a fatal tsunami of breaking changes in the NH public API.

So NH code base has no obvious (at least to me) nor explicit componentization. I know there are architecture guidelines that NH contributors must learn, understand and follow, but sitting outside of the project, I cannot easily figure them out.

Code Quality

If you look back at the report, you'll see many typical Code Quality rules violated. As said, I consider Code Coverage ratio as the queen of code quality rules, but that doesn't mean that other code quality metrics don't matter. So I can see through the rule Methods too complex - critical (ILCyclomaticComplexity) two dozens of awfully complex methods. Most of them seems to be generated by ANTLR . So there is room here to refine the NDepend Code Query Rule to exclude this generated code, like for example...

// <Name>Methods too complex - critical (ILCyclomaticComplexity)</Name>
WARN IF Count > 0 IN SELECT METHODS
OUT OF NAMESPACES "NHibernate.Hql.Ast.ANTLR" WHERE
  ILCyclomaticComplexity > 40 AND
  ILNestingDepth > 4
  ORDER BY ILCyclomaticComplexity DESC

...and see than now only 3 handcrafted methods are matched (one of those, NHibernate.Cfg.Configuration.GenerateSchemaUpdateScript(Dialect,DatabaseMetadata) has 49 lines of code, a Cyclomatic Complexity of 25 and is 87% covered by tests).

The rule violated Methods with too many parameters - critical (NbParameters) is more a concern since we can see here a redundant code smell of having many constructors with plenty of parameters (up to 22 parameters for the ctor of the class NHibernate.Cfg.Mappings).

The rule violated Type should not have too many responsibilities (Efferent Coupling) seems to me another concern. It exhibits several god classes, meaning classes with too many responsibilities. Here NDepend bases its measure on the Efferent Coupling code metric, that represents, the number of other types a type is using. The notion of class responsibility is a bit abstract, it is often translated to the tenet: a class should have only one reason to change which is still abstract in my opinion. Obviously the higher the Efferent Coupling, the more likely a class has too many responsibilities. God classes often result from the lack of refactoring during project evolution, iterations after iterations. The god class represented an initial clear concept that has evolved without appropriate refactoring, and developers got used to live with this code smell. In the context of a public framework such as NH, refactoring a public god class or interface might be not and option if this implies unacceptable API public breaking changes.

The rule violated Complex methods should be 100% covered by tests exhibits a few hundreds of relatively complex methods not thoroughly covered by tests. Here also a lot of these methods belong to NHibernate.Hql.Ast.ANTLR and by filtering them, we still have more than 200 matches. This fact is a concern because having high code coverage ratio is not enough. What is important is to have a lot of methods and classes, 100% covered by tests. Indeed, empirically I noticed that: code that is hard to test is often code that contains subtle and hard to find bugs. Unfortunately, the 10% code hard to test is the code that demands more than 50% of test writing resources.

We could continue to enumerate one by one Code Quality rules violated. The truth is that any sufficiently large code base contains thousands of violation of most basic code quality rules. An important decision must be taken to care for code quality before the code becomes so messy that it discourage developers to work on it (and to be honest, I had feedback from two NH contributors that left the project, partly for that reason). Once again, the NH situation here is more the rule than the exception and I'd say that if you are a real-world developer yourself, there are 9 chances on 10 that you are not satisfied by the code quality of the everyday code base you are working on. The problem when deciding to begin to care for code quality is that tooling like NDepend or FxCop reports literally thousands of flaws. However, a tool like NDepend makes things easier through its support for baseline. Concretely one can decide to continuously compare the code base against, say, the last release, and then fix flaws only on code refactored or added since the baseline. This way the team follow the rule if it's not broken don't fix it and it achieves better and better code quality without significant effort. Concretely a CQL rule that should take account of the baseline can be refactored as easily as:

// <Name>From now, all methods added or refactored should not be too complex</Name>
WARN IF Count > 0 IN SELECT METHODS WHERE

// Match methods new or modified since Baseline for Comparison...
(WasAdded OR CodeWasChanged) AND

// ...that are too complex
CyclomaticComplexity > 10

Code Evolution

And this was a good transition to the last part I'd like to comment: Code Diff. As said NDepend can compare 2 versions of a code base and in the report we compared NH v3.0.0.CR1 with v2.1.2.GA. The rule API Breaking Changes: Types seems to exhibit a few matches:

// <Name>API Breaking Changes: Types</Name>
WARN IF Count > 0 IN SELECT TYPES
WHERE IsPublic AND (VisibilityWasChanged OR WasRemoved)

Types like NHibernate.Dialect.SybaseAnywhereDialect, NHibernate.Cache.ISoftLock or NHibernate.Cfg.ConfigurationSchema.ClassCacheUsage were public types that have either be removed, renamed, or set to internal types. Also we can see that some public interfaces such as, NHibernate.Proxy.IProxyFactory or NHibernate.Hql.IQueryTranslator have been changed. This can break client code if these interfaces were meant to be implemented by clients.

In the Code diff report section, the query Public Types added and also Namespaces added represent a mean to list new features added to NH v3.

// <Name>Public Types added</Name>
SELECT TYPES WHERE WasAdded AND IsPublic

Here, we mostly see the prominent new NH v3 linq capabilities through the numerous NHibernate.Linq.* namespaces added, and we can also focus on the many secondary featurettes like NHibernate.SqlTypes.XmlSqlType or NHibernate.Transaction.AdoNetWithDistributedTransactionFactory.

NHibernate 3.0 Cookbook

Fabio Maulo — Tue, 05 Oct 2010 16:28:00 GMT

This week Packt published the NHibernate 3.0 Cookbook. Packt are offering all members of the NHibernate community 20% off the book.

The book helps users to get solutions to common NHibernate problems to develop high-quality performance-critical data access applications.

The book, which is 328 pages long, contains quick-paced self-explanatory recipes organized in progressive skill levels and functional areas.

Overview of NHibernate 3.0 Cookbook

Master the full range of NHibernate features
Reduce hours of application development time and get better application architecture and performance
Create, maintain, and update your database structure automatically with the help of NHibernate
Written and tested for NHibernate 3.0 with input from the development team distilled in to easily accessible concepts and examples
Part of Packt's Cookbook series: each recipe is a carefully organized sequence of instructions to complete the task as efficiently as possible

Is this book for you?

This book is written for NHibernate users at all levels of experience. Examples are written in C# and XML. Some basic knowledge of SQL is assumed.

To get your exclusive 20% discount when you buy through PacktPub.com, just enter the discount code NHIBCBK20 (case sensitive), to the shopping cart.

Click here to read more about the NHibernate 3.0 Cookbook.

Note : the customers must be logged in to PacktPub.com for discount code to be applied

NHibernate Auditing v3 – Poor Man’s Envers

Jason Dentler — Tue, 06 Jul 2010 05:25:00 GMT

First, let me explain the title of this post. The Hibernate folks – you know, that NHibernate knock off written in the Java (pronounced “ex em el”) programming language – have a project called Envers. Among other things, It audits changes to entities, then allows you to easily retrieve the entity as it was at any previous point in time.

Well, Simon Duduica is porting this over to .NET and NHibernate, and he’s making some AMAZING progress. On June 28th, he shared this news with us on the NH Contrib development group:

Hi everybody,

I have news regarding Envers.NET. I've commited a version that works in basic tests for CUD operations, with entities that have relationships between them, also with entities that are not audited. To make things work I had to make two small modifications of NHibernate, both modifications were tested running all NHibernate unit tests and they all passed. I already sent the first modification to Fabio and the second I will send this evening. I would like to thank Tuna for helping me out with good advices when I was stuck :)

So, on to the topic of this post. For NHibernate 3.0 Cookbook, I’ve included a section that explains how to use NHibernate to generate audit triggers. Originally, I had planned to use the code from my previous blog post on the topic, but I didn’t like its structure. I also didn’t want to include all that plumbing code in the printed book. Instead, I’ve rewritten and contributed the “framework” code to uNHAddIns. The “how-to use it” is explained in the book, so I won’t explain it here.

Today, I was writing an integration test for this contribution, and thought the idea was worth sharing. I have a simple Cat class:

When I do anything to this cat, in addition to the normal INSERT, UPDATE, or DELETE, a database trigger records that action in a table called CatAudit:

I wanted an easy way to investigate the contents of this table to prove that my audit triggers worked. Here’s what I came up with, along with help from Jose Romaniello (@jfroma). First, I created a class to match this table:

Next, I mapped it, made it readonly and excluded it from hbm2ddl with this mapping:

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
				   assembly="uNhAddIns.Test"
				   namespace="uNhAddIns.Test.Audit.TriggerGenerator">
  <typedef class="NHibernate.Type.EnumStringType`1[[uNhAddIns.Audit.TriggerGenerator.TriggerActions, uNhAddIns]], NHibernate"
           name="triggerActions" />
  <class name="CatAudit" 
         mutable="false"
         schema-action="none">
    <composite-id>
      <key-property name="Id" />
      <key-property name="AuditUser" />
      <key-property name="AuditTimestamp" />
    </composite-id>
    <property name="Color"/>
    <property name="AuditOperation" type="triggerActions" />
  </class>
	
</hibernate-mapping>

I made it readonly by setting mutable="false" and excluded it from hbm2ddl with schema-action="none". That’s it!

By the way, the <typedef> along with type="triggerActions" just tells NHibernate I've stored my TriggerActions enum values as strings, not numbers.