Overview of Nhibernate 3 Beginner’s Guide

· Clear, precise step-by-step directions to get you up and running quickly

· Test, profile, and monitor data access to tune the performance and make your applications fly

· Reduce hours of application development time and get better application architecture and performance

Read more about this book and download free Sample Chapter

How to Enter?

All you need to do is head on over to the book page and look through the product description of this book and drop a line via the comments below to let us know what interests you the most about this book. It’s that simple

Product description for NHibernate book: http://www.packtpub.com/nhibernate-3-beginners-guide/book

Winners from the U.S. and Europe can either choose a physical copy of the book or the eBook. Users from other locales are limited to the eBook only.

Deadline

The contest will close on 30/12/11 PT. Winners will be contacted by email, so be sure to use your real email address when you comment!

Yesterday Anders Hejlsberg gave a talk about future directions of C# and VB.Net. He started with look back and then immediately dive into the new features of C# 5.0 which is part of VS 2011 and .NET 4.5. The most prominent new feature is of course the direct language support for asynchronous programming. The compiler provides two new keywords async and await which doesn’t sound exciting at all but in reality dramatically simplifies the way we developers can write “fast and fluid” code. Instead of dealing with threads, thread synchronization and callback functions ourselves we can now write fully asynchronous code in a sequential way. The compiler will do the heavy lifting for us and convert this “sequential and seemingly synchronous” code into a sequence of asynchronous calls and their corresponding continuations.

If you think that this is not worth talking about then try to write a sequence of asynchronous calls that depend on each other. And make sure that you provide adequate exception handling.

During his presentation Anders Hejlsberg also revealed some details about the future version of C# and he announced that a first developer preview will be available in about 4 weeks. The main part of the upcoming version of C# is a completely new compiler which is written in C# and can be used as a service. The project has the code name Rosalyn.

This “compiler as a service” will be of tremendous value for various scenarios. All kinds of tools, utilities or plugins will be able the leverage the compilers capabilities to their favor. Some samples are

• Intellisense, code coloring will leverage the output of the parser part of the compiler
• Refactoring tools like Resharper do not have to provide their own parser any more and can leverage the compiler
• Compile and execute scripts or code snippets (provided e.g. as string) on the fly
• Future versions of Visual Studio will leverage the compiler and provide an interactive console for C#
• Automatically translating code from one language to another; Anders demoed the translation from C# to VB.NET and vice versa
• Meta programming a la Boo or Ruby will be possible
• etc.

I think this new compiler will once again dramatically improve the development experience with C# (and VB.NET).

The new XAML editor in VS 2011

If you have worked with WPF or Silverlight in Visual Studio 2010 or 2008 you know that the XAML editor was extremely slow and limited in its functionality. Now that has changed dramatically in VS 2011. First of all the new XAML editor is backed by the same engine (or at least part of it) as Expression Blend. The editor now runs in its own process to not compromise the stability and availability of VS. The editing capabilities have tremendously improved and members of the VS team  confirmed me that they are tuning the editor as much as possible and make it performing well also in very large project with many assets.

Expression Blend for HTML5/CSS applications

Expression Blend is now available in a new flavor. HTML5/CSS3 based Metro style applications can now be visually designed in Blend. Many of the new CSS3 features are fully supported by this new editor. Not only is Expression Blend a layout tool but it fully supports the interactive mode (that is JavaScript is executed) which is very important in scenarios where most of the page is rendered dynamically, driven by JavaScript.

WinRT is the new layer providing a language neutral interface to the underlying operating system. It is written in C++ and consists of purely native code. For me it seems to be the revival of the dinosaurs since WinRT basically is a collection of COM objects. Hello IUnknown, nice to meet you again!

C++ developers must feel like in paradise. This old language celebrates a true revival during this conference and with the advent of Windows 8. It seems awkward to me that a language that is not really object oriented in its roots, still can play such an important role. I ask myself why did the project “Singularity” of Microsoft, which had (amongst others) the goal to create an OS which consists purely of managed code – except for a very very limited set of low level functionality, which had to be implemented in native code – not drive Microsoft towards a more managed Windows OS. Why do we still need to rely on COM which is a very old and outdated concept?

On the positive side we can acknowledge that WinRT provides meta information in the same format as the .NET type meta information. As a consequence this API can be accessed from C#, VB.NET and JavaScript in a very natural way. To an e.g. C# developer components of WinRT look 100% alike true managed objects. The availability of this meta data allows Visual Studio to provide true intellisense for all of these components.

Another positive aspect of WinRT is that all functions that take more than 15 milliseconds are now executed asynchronously. This helps to achieve the goal to make all Metro type applications execute “fast an fluid”. From C# (and .NET 4.5) it is very easy to access such asynchronous functions since the compiler provides the concept of async and await. With these two new keywords we can write fully asynchronous code in a way as if everything was sequential.

JavaScript introduces the concept of promises to deal with asynchronous calls. This concept makes it very easy to create applications that remain responsive even if long running functions are called.

There is one positive change that the Windows team did to COM to avoid unnecessary race conditions when calling asynchronous functions of WinRT. In Windows 8 no method of a COM object is executed as long any other method of the same instance is still pending. Sweet!

Windows 8 will run everywhere on big servers sitting in the data center as well as on the small gadget we carry around all day with us. this makes it much easier for us developer to come up with applications that run on a huge array of different devices having different form factors.

Windows 8 will continue to support all applications that currently run on Windows 7. These applications will act and feel exactly the same way as they currently do on Windows 7. But then there will be the new Metro style applications which are unique to Windows 8 (and thus will not run on any older version of Windows).

The new type of applications can be developed either in a managed language like C# or VB using XAML as the layout “language” or in JavaScript using HTML5 and CSS as the layout language. Even C++ can be used in conjunction with XAML to produce native Metro applications.

Microsoft has completely rewritten the XAML stack and based it fully on DirectX. Yes, that is amazing, not only will XAML be supported in the future but it has been radically improved.

Expression Blend 5 can now be used to edit XAML templates as well as HTML templates. That was another nice thing to hear since Blend is a really powerful and cool tool to do UI design. Expression Blend and Visual Studio work hand in hand.

The new Windows 8 Metro interface actually makes a lot of sense. One of its key paradigms is “content over chrome”, which means that we developer should more focus on presenting content to the user than unnecessary clutter around it. Windows 8 will also make sure that in the future any screen is a multi-touch surface. Using our fingers will become another natural way of doing things on a computer as it is already the case with keyboards and mice. Yes, keyboards and mice will not be replaced. There is no better tool to enter large amounts of text than a keyboard and there is hardly a better device than a mouse (or track ball) to precisely position or move things on the screen. On the other hand there are many areas where it just feels more natural and direct to use our fingers than the keyboard or mouse. If you use a smart phone with a big touch screen then you know what I’m talking about.

All Metro type applications will sit on top of the new WinRT API. This API provides the applications access to the underlying system. It is possible to access the file system or network resources as well as devices in an easy and straight forward manner. We can e.g. create a Web application and write JavaScript code which accesses, to give a sample, the camera of the device it is running on and take the pictures and movies produced by this camera and save them on the local hard disk. But wait, isn’t that dangerous? Luckily the security system will prevent the application in doing so without the users explicit consent.

I am very pleased to hear that maximizing the performance of the system while minimizing the required resources was one of the main goals while developing Windows 8. We have seen numerous samples how Windows 8 performed better than Windows 7 on the same hardware.

I am looking forward to day 2 presenting us much more in depth information about various areas of this new version of Windows.

Quite some years ago our company chose Silverlight as the platform for the user interface of our application suite. During all this time Microsoft has assured its clients that Silverlight is one of their strategic platforms. New releases of Silverlight have been publish in short intervals. Currently version 5 is available as release candidate. Silverlight was used exclusively on Windows phone 7 and was meant to be the ubiquitous platform on all future mobile devices produced and/or supported by Microsoft. As a side note: you might remember that Windows Mobile 6.5 is a dead end and is not developed an further.

A couple of month ago Microsoft publicly announced that Windows 8 will deeply integrate HTM5, Java Script and CSS into the platform. They also announced that HTML5 will be the main development platform on Windows and that Windows 8 will run everywhere, on servers, workstations, tablet devices , phones and embedded systems. No word about Silverlight though…

All our questions regarding the future of Silverlight were left unanswered.

Ok, today and during the coming days we will hopefully get some more insight into the future strategies of Microsoft. This will be interesting.

“I have a question regarding NHibernate and mapping. In an application we want to access the database through NHibernate from inside a WCF service, thus lazy loading is not an option for us.  To avoid to have to use the whole graph around an entity each time I want to use two domain models. The first model contains all entities without associations and the second one the model with all associations between the entities.

Is this the usual approach people chose when dealing with similar problems? Are there any problems to be expected if two different entities are mapped to the same table?”

Now, let me try to answer this question(s). First of all let’s try to clarify what thoughts might be behind those questions.

1. If we turn off lazy loading in NHibernate and have a domain model where (almost) all entities are connected to each other through relations then we have a problem when loading telling NHibernate to load one of the entities of the domain model. Since lazy loading is turned off NHibernate would not only load the entity itself but all other entities that are related to the entity to be loaded. In an extreme case one would cause the whole database to be loaded.
2. We can “kind of” solve this problem if we break the chain of relations in the model. In the extreme case we have a (degenerated) domain model with entities that are not related to each other.
3. But if we only have a bunch of entities in our model that are not related to each other then we cannot easily navigate from one entity to another and thus using the domain for querying becomes unhandy if not impossible since when querying data to display on screen or in a report we most certainly need more data then the one that is stored in a single entity (e.g. when displaying the details of a product on screen we also want to display the categories the product is associated with as well as a photo of the product and maybe even related products.).

Now, what is the correct answer?

As always I have to say: “It depends!” There is no good answer which fits any situation. That said, let’s try to give some possible guidelines for different scenarios

Scenario 1: Relatively simple forms over data type application

In this scenario we should keep things as simple as possible. We want to define only one model of the domain at hand and we want to use this model for data manipulation as well as for query operations. In this case I would recommend to use lazy loading of NHibernate (or any other ORM). All entities of the model are interconnected through relations. As a simple sample lets take the blog sample.

Commands – that is writing data

Now when we want to manipulate data we can have different scenarios

1. Manipulating the blog entity
   • create a new blog.
   • update an existing blog and change its title, add another author or add some more categories. etc.
   • delete the blog (with all its posts)
2. Authoring posts
   • write a new post.
   • edit a post to modify the content or add tags
   • delete a post.
3. Commenting a post
   • reader adds a new comment to a blog post

Each of the above operations is very limited in its extent. When manipulating the blog entity I am not interested in the post that were written as part of this blog and certainly I am not interested in the comments to each post. Thus I do not need to load any post or comment data. Since the relations from the blog entity to the posts are mapped as lazy I can load the blog entity without any side effects. Only the blog data is loaded and no other entity is populated by this operation

var blog = session.Get<Blog>(1);

Specifically NHibernate does not populate the Authors nor the Categories collection of the blog entity

On the other hand when authoring a new post I am not really interested in the details of the blog to which the post is associated. The only things I need to know when creating a new post are a) the content of the post, b) the key (ID) of the blog to which the post is associated and c) the collection of tags under which the post shall be classified. The code might then look like this:

var post = new Post{ Content = dto.Content };

post.Blog = session.Load<Blog>(dto.BlogId);

foreach(var tag in dto.Tags) {

    post.AddTag(tag);

}

session.Save(post);

Here dto is the data transfer object that contains the data coming from the client.

Please not the session.Load<Blog>(…) operation. This operation does not load any data from the database. It just creates a proxy of the blog entity in memory and populates the ID with the value provided, that is dto.BlogId. That’s enough for NHibernate to successfully make an association between the post and the blog.

If we update an existing post we can load it like this

var post = session.Load<Post>(postId);

Since we have lazy loading turned on no associated entities will be loaded and I can happily update my post entity.

Queries – reading data

When reading data to display on screen or in a report the situation is a little bit different. Now all of a sudden I need the relations between the entities to not only load an entity but also associated information stored in related entities. Samples:

1. Display blog details and a list of titles of the 10 most recent posts
2. Display the content of a post and all its associated comments
3. Display a list of the most popular blog posts of the last year
4. etc.

How can we do that in knowing that we have NHibernate lazy loading turned on? And how can we do it efficiently and avoid such things as the infamous select-(n+1) problem? And please do not forget that we are querying the database from within a WCF service and thus need to make sure that all data has been loaded at the moment the (NHibernate) session is disposed.

The answer is: use eager loading! Whether we use HQL, Criteria Queries or LINQ to retrieve the data, we always have the possibility to instruct NHibernate to eagerly load some associated data. Let’s give a sample: I want to load the details of a post and all its associated comments. Using LINQ the query would look similar to this:

var post = session.Query<Post>

    .Fetch(p => p.Comments)

    .Single(p => p.PostId = 101);

Note the Fetch function which instructs LINQ to load the collection of comments with the post.

Although the relation between Post and Comment is mapped as lazy we were able to load post and comments in one go. Nice.

Scenario 2: Complex domain with many complicated business rules

This is a completely different situation than the previous one. Here we are probably talking about an enterprise application where we can justify some “overhead” if it helps us to decrease or manage the complexity of the overall system.

In such a scenario I would highly recommend to use an architectural pattern known as CQRS (command query responsibility segregation). In this pattern data manipulation (commands) and data retrieval (query) operations are strictly separated. The commands operate on a domain model whereas the queries do NOT use the domain model but are sent as directly as possible to the database. Having this separation of concerns helps us to reduce the complexity of the domain. The domain is now not responsible to satisfy query request but can be fully optimized for data manipulation (i.e. business transaction).

The domain model is carefully segregated into aggregates which represent the boundaries of a typical business transaction. Inside an aggregate entities are associated to each other through relations. Any associations to entities which are not part of the aggregate are achieved by using (foreign-) keys.

Having defined these aggregates we do not need to use lazy loading since we always want to load the whole aggregate when operation on (part of) it.

For the queries we don’t even necessarily need NHibernate to access the database but can use a thin data layer and ADO.NET to get to the required data.

The data we want to read can be provided by various means. Each has its advantages and disadvantages

• The application uses two databases. One for the write operations and the other one for the read operations. The read only database contains the de-normalized data of the write-only database (the two databases are synchronized through some services). One can think of this read-only database as being kind of a data warehouse.
• The application only uses one database for writing and reading. We access the data through database views which provide a de-normalized view of the data which is optimized for read operations.
• Here also we use only one database. Dynamic SQL is used to retrieve the data 

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.

First of all I have to admit that we failed completely when searching candidates ourselves by announcing open positions in blog post, on our company’s web site or when placing ads in various well known lists. Not only did we get low quality applications, no, we got near to zero response. Thus we hired some head hunters; not only one, but four of them. Finally we got some CVs from potential candidates. With the candidates that had interesting enough resumeés we arranged phone interviews. During these phone calls we give the candidates the opportunity to tell us where they think they are best at and what they are looking for. Although we do not ask very specific and certainly not very difficult questions, a lot of candidates have big troubles in coming up with some “meaningful” or “relevant” answers. Most of the candidates just fail on this first hurdle. Some interesting sample questions and answers:

• We might ask the candidate something like: “Please tell us what principles or practices you use in your daily work to create robust, maintainable and/or extendable code.” One candidate, after asking us to repeat the question, said: “I am sorry, I cannot answer this question, but can you give me an answer?” Our answer then was rather clear: “I am sorry, but we are looking for candidates who know an answer to this question…”
• To another candidate we said: “On a scale of 1 to 10, where would position yourself regarding your skills in C#?”. The candidate answered without hesitating: “I think I would give myself a 9.5.” Ha, you can imagine how we felt goaded and our next question was “Please tell us about some of the more advanced things you did with C# and .NET.”. The answer this time was rather disappointing and the things mentioned by the candidate where nowhere near bleeding edge.
• Yet another developer, when asked what he did and where he is good at, did not talk about development or things a developer does and is proud of, but he rather started to talk about processes along and around development in general. It remained a “blah-blah” even when we insisted on hearing more “technical details”.

If what a candidate tells us at the phone sounds interesting we arrange a face-to-face meeting. Sometimes we give the candidates some “home work” to do, to be prepared for the interview. Most often the topic of this home work are the S.O.L.I.D. principles. We just tell the candidates that this topic will be one of our discussion points during the interview.

During the face-to-face interview we do an exercise with the candidate. It is basically coding in Notepad. We are typing since the candidate might get too nervous if he had to type. (We all know that it is difficult to type when somebody watches you over your shoulders, do we?). The goal of this exercise is not that the candidate finds “the” correct answer (there might not be such a thing…) but we want to find out, how a candidate approaches a problem, how he is thinking and how he is refining his approach to a possible solution. The outcome of this exercise completely depends on the candidate and how he approaches things. While trying to find a solution we might discuss such topics as: programming against abstractions (using interfaces or dependency inversion principle), encapsulation, tell don’t ask principle, single responsibility principle, interface segregation principle, the usage of strategy patterns, etc. We do not expect that the candidate knows all this principles and patterns by name nor that he knows when and how to apply them but some of them might just naturally exhibit themselves during the exercise.

This exercise really separates candidates of good quality from those of mediocre or low quality. We had some candidates that did an excellent job although it was the first time they ever heard of all those principles and/or patterns and certainly have never applied them consciously before. Others that knew all patterns and principles by heart and could rephrase their definitions failed miserably when asked where those principles and patterns could be applied in the sample at hand.

Sadly developers of low quality are far more common than the ones of decent or high quality.

Even more sad is the fact that developers having a (very) limited skill set are most often not aware of this fact and consider themselves to be “seniors”.

Am I expecting too much? I don’t think so. Developers have I high responsibility. They produce software to automate business or mission critical processes. One should expect this software to be of high quality. To write high quality software we need good developers!

The title of the book is “NHibernate 3 Beginner Guide” and it will be published by Packt Publishing. As the title tells it is an introduction to the most recent version of NHibernate. But in contrast to other books that have been written about NHibernate so far I want to address the topic in a little bit different way. My goal is to introduce this ORM framework by using a model centric view and not a data centric view. Consequently NHibernate is used to map the model to a data store and the details of the data store (although important) do not play the same central role as in many other texts.

As the book is an introduction to NHibernate I want to provide the reader a friction-less approach to how to use this ORM framework. In the spirit of this I will discuss topics as mapping entities to tables or configuring NHibernate mostly by using convention based approaches (e.g. ConfORM, Auto-mapping with Fluent NHibernate) or by using fluent APIs. XML based configuration and mapping will also be discussed, but only as “one” way to do things and not “the” way to do it.

Luckily ,while writing the book, I can leverage all the positive and negative experiences we’ve had in our day to day work with NHibernate. That led me to the conclusion that I absolutely have to add a chapter about “how you can screw up things with NHibernate…”. Of course, the title of the chapter will be different, but it will be fun.

At the time of writing I have already finished the first 3 chapters and “only” 8 chapters are left. Stay tuned…

The book is called “NHibernate 3.0 Cookbook” and can be ordered here. There is even a discount available; please refer to this post of Fabio Maulo.

This is so far the best and most complete book I ever held in my hands. It covers NHibernate 3.0 and thus is really up to date. The author has done a tremendous job in covering all the important aspects of interest when implementing business relevant solutions. The book is very focused and gives a step by step introduction into all the necessary details to get a solution up an running. No space is wasted for (potentially) unimportant details.

One of the things I like most is that the book/the author does not have a data centric view but is more domain focused.