Data access strategies have changed over the years. From Remote Data Objects (RDO), Data Access Objects (DAO), to ADO.NET, the industry has seen a marked improvement in the way data is accessed these days.

ORM tools enable you to access data from persistent storage devices without having to bother about how the underlying data is actually stored. NHibernate is a lightweight ORM tool for .NET. It has a statically compiled counterpart called Fluent NHibernate. Fluent NHibernate provides you with an XML-less, compile safe, automated NHibernate mapper with LINQ support. Domain modeling is an area where Entity Framework scores over NHibernate.

Consider the following entity class:

public class User
    {
        public virtual Int32 UserID { get; set; }        
        public virtual String UserName { get; set; }
        public virtual String CreatedBy { get; set; }
        public virtual DateTime CreatedDate { get; set; }        
        public virtual String ModifiedBy { get; set; }
        public virtual DateTime ModifiedDate { get; set; }
    }

The following class illustrates how you can create a mapping for the preceding class by extending the generic ClassMap<T> class:

public class UserMap : ClassMap<User>
    {
        public UserMap()
        {
            Table("Users");
            Id(x => x.UserID).GeneratedBy.Identity();
            Map(x => x.UserName);
            Map(x => x.CreatedBy);
            Map(x => x.CreatedDate);          
            Map(x => x.ModifiedBy);
            Map(x => x.ModifiedDate);
        }
    }

The following code example illustrates how you can create a data gateway for the User entity class:

using FluentNHibernate;
using NHibernate;
using FluentNHibernate.Cfg.Db;
using FluentNHibernate.Automapping;
using NHibernate.Cfg;
using NHibernate;
using FluentNHibernate.Cfg.Db;
using FluentNHibernate.Automapping;
using NHibernate.Cfg;
using NHibernate.Tool.hbm2ddl;
using System.Reflection;
namespace Packt
{
    public static class DataManager
    {
        private static ISessionFactory sessionFactory = null;
        private static readonly string businessObjectsNamespace = 
        "Packt.Entity.Mappings";
        private static readonly string connectionString = @"Data 
        Source=JOYDIP-PC\SQLServer2014;
        Initial Catalog=Security;Integrated Security=True";
        private static ISessionFactory SessionFactory
        {
            get
            {
                if (_sessionFactory == null)
                {
      //Code to create a new session factory instance and load the 
      business entities
                }   
             return sessionFactory;
            }
        }

        public static ISession OpenSession()
        {
            return SessionFactory.OpenSession();
        }
    }
}

Note that you can make a call to DataManager.OpenSession() to open the database connectivity session.

Entity Framework 6 is a mature ORM and comes up with many powerful features. When you use Entity Framework, you can concentrate more on writing application logic rather than writing the database connectivity code. This reduces development time and effort greatly.

Language Integrated Query (LINQ) is a query translation pipeline that you can use to integrate your queries into the object model. LINQ provides you with a framework that you can use to access relational data in a strongly typed way. LINQ provides a great way to query in-memory objects.

Here are the various forms that LINQ comes up with:

The LINQ library contains two primary interfaces that all generic collection classes implement. These are the IEnumerable<T> interface and the IQueryable<T> interface. While the former exposes an enumerator to iterate over a collection of a given type T, the latter provides a functionality to query a data source that will implement this interface. Also, IQueryable allows you to filter data on the server side.

The following diagram illustrates how these interfaces are related:

Important interfaces of the LINQ library