namespace NHSample3.Domain
{
  public class Car
  {
      public virtual int Id { get; set; }
      public virtual string Name { get; set; }
      public virtual string Color { get; set; }
  }
}

using System.Collections.Generic;

namespace NHSample3.Domain
{
  public class Parking
  {
      public virtual int Id { get; set; }
      public virtual string Name { get; set; }
      public virtual string Location { get; set; }
      public virtual IList<Car> Cars { get; set; }

      public Parking()
      {
          Cars = new List<Car>();
      }
  }
}

using FluentNHibernate.Automapping;
using FluentNHibernate.Cfg;
using FluentNHibernate.Cfg.Db;
using NHibernate.Tool.hbm2ddl;

namespace NHSessionManager
{
  public class Config
  {
      public static FluentConfiguration GetConfig()
      {
          return
            Fluently.Configure()
                    .Database(
                       MsSqlConfiguration
                         .MsSql2008
                         .ConnectionString(x => x.FromConnectionStringWithKey("DbConnectionString"))                         
                        )
                      .ExposeConfiguration(
                           x => x.SetProperty("current_session_context_class", "managed_web")
                       )
                      .Mappings(
                        m => m.AutoMappings.Add(
                           new AutoPersistenceModel()
                               .Where(x => x.Namespace.EndsWith("Domain"))                               
                               .AddEntityAssembly(typeof(NHSample3.Domain.Car).Assembly))
                               );
      }

      public static void CreateDb()
      {
          bool script = false;//آیا خروجی در کنسول هم نمایش داده شود
          bool export = true;//آیا بر روی دیتابیس هم اجرا شود            
          bool dropTables = false;//آیا جداول موجود دراپ شوند
          new SchemaExport(GetConfig().BuildConfiguration()).Execute(script, export, dropTables);
      }
  }
}

<connectionStrings>
  <!--NHSessionManager-->
  <add name="DbConnectionString"
         connectionString="Data Source=(local);Initial Catalog=HelloNHibernate;Integrated Security = true" />
</connectionStrings>

using NHibernate;

namespace NHSessionManager
{
  /// <summary>
  /// lazy, lock-free, thread-safe singleton
  /// </summary>
  public class SingletonCore
  {
      private readonly ISessionFactory _sessionFactory;

      SingletonCore()
      {
          _sessionFactory = Config.GetConfig().BuildSessionFactory();
      }

      public static SingletonCore Instance
      {
          get
          {
              return Nested.instance;
          }
      }

      public static ISession GetCurrentSession()
      {
          return Instance._sessionFactory.GetCurrentSession();
      }

      public static ISessionFactory SessionFactory
      {
          get { return Instance._sessionFactory; }
      }

      class Nested
      {
          // Explicit static constructor to tell C# compiler
          // not to mark type as beforefieldinit
          static Nested()
          {
          }

          internal static readonly SingletonCore instance = new SingletonCore();
      }
  }
}

using System;
using System.Web;
using NHibernate;
using NHibernate.Context;

namespace NHSessionManager
{
  public class SessionModule : IHttpModule
  {
      public void Dispose()
      { }

      public void Init(HttpApplication context)
      {
          if (context == null)
              throw new ArgumentNullException("context");

          context.BeginRequest += Application_BeginRequest;
          context.EndRequest += Application_EndRequest;
      }

      private void Application_BeginRequest(object sender, EventArgs e)
      {
          ISession session = SingletonCore.SessionFactory.OpenSession();
          ManagedWebSessionContext.Bind(HttpContext.Current, session);
          session.BeginTransaction();
      }

      private void Application_EndRequest(object sender, EventArgs e)
      {
          ISession session = ManagedWebSessionContext.Unbind(
              HttpContext.Current, SingletonCore.SessionFactory);
          if (session == null) return;

          try
          {
              if (session.Transaction != null &&
                  !session.Transaction.WasCommitted &&
                  !session.Transaction.WasRolledBack)
              {
                  session.Transaction.Commit();
              }
              else
              {
                  session.Flush();
              }
          }
          catch (Exception)
          {
              session.Transaction.Rollback();
          }
          finally
          {
              if (session != null && session.IsOpen)
              {
                  session.Close();
                  session.Dispose();
              }
          }
      }
  }
}

  <httpModules>
    <!--NHSessionManager-->
    <add name="SessionModule" type="NHSessionManager.SessionModule"/>
  </httpModules>

using System.Linq;
using NHibernate;
using NHibernate.Linq;
using NHSample3.Domain;

namespace NHSample3
{
  public class ParkingContext : NHibernateContext
  {
      public ParkingContext(ISession session)
          : base(session)
      { }

      public IOrderedQueryable<Car> Cars
      {
          get { return Session.Linq<Car>(); }
      }

      public IOrderedQueryable<Parking> Parkings
      {
          get { return Session.Linq<Parking>(); }
      }
  }
}

using System;
using System.Collections.Generic;
using System.Linq;
using NHibernate;
using NHSample3.Domain;
using NHSessionManager;

namespace NHSample3
{
  public partial class _Default : System.Web.UI.Page
  {
      protected void Page_Load(object sender, EventArgs e)
      {
          //ایجاد دیتابیس در صورت نیاز
          //Config.CreateDb();

          //ثبت یک سری رکورد در دیتابیس
          ISession session = SingletonCore.GetCurrentSession();

          Car car1 = new Car() { Name = "رنو", Color = "مشکلی" };
          session.Save(car1);
          Car car2 = new Car() { Name = "پژو", Color = "سفید" };
          session.Save(car2);

          Parking parking1 = new Parking()
          {
              Location = "آدرس پارکینگ مورد نظر",
              Name = "پارکینگ یک",
              Cars = new List<Car> { car1, car2 }
          };

          session.Save(parking1);

          //نمایش حاصل در یک گرید ویوو
          ParkingContext db = new ParkingContext(session);
          var query = from x in db.Cars select new { CarName = x.Name, CarColor = x.Color };
          GridView1.DataSource = query.ToList();
          GridView1.DataBind();
      }
  }
}

using System.Xml.Linq;

namespace TestModel
{
   public class DynamicTable
   {
       public virtual int Id { get; set; }
       public virtual XDocument Document { get; set; }
   }
}

using FluentNHibernate.Automapping;
using FluentNHibernate.Automapping.Alterations;
using NHibernate.Type;

namespace TestModel
{
   public class DynamicTableMapping : IAutoMappingOverride<DynamicTable>
   {
       public void Override(AutoMapping<DynamicTable> mapping)
       {
           mapping.Id(x => x.Id);
           mapping.Map(x => x.Document).CustomType<XDocType>();
       }
   }
}

   if exists (select * from dbo.sysobjects
                where id = object_id(N'[DynamicTable]') and OBJECTPROPERTY(id, N'IsUserTable') = 1)
        drop table [DynamicTable]

   create table [DynamicTable] (
       Id INT IDENTITY NOT NULL,
      Document XML null,
      primary key (Id)
   )

//insert
object savedId = 0;
using (var session = sessionFactory.OpenSession())
{
   using (var tx = session.BeginTransaction())
   {
        var obj = new DynamicTable
        {
            Document = System.Xml.Linq.XDocument.Parse(
                    @"<Doc><Node1>Text1</Node1><Node2>Text2</Node2></Doc>"
                    )
        };
        savedId = session.Save(obj);
        tx.Commit();
    }
}

//simple query
using (var session = sessionFactory.OpenSession())
{
   using (var tx = session.BeginTransaction())
   {
        var entity = session.Get<DynamicTable>(savedId);
        if (entity != null)
        {
           Console.WriteLine(entity.Document.Root.ToString());
        }

        tx.Commit();
    }
}

//advanced query
using (var session = sessionFactory.OpenSession())
{
   using (var tx = session.BeginTransaction())
   {
       var list = session.CreateSQLQuery("select [Document].value('(//Doc/Node1)[1]','nvarchar(255)') from [DynamicTable] where id=:p0")
                               .SetParameter("p0", savedId)
                               .List();

        if (list != null)
        {
             Console.WriteLine(list[0]);
        }

        tx.Commit();
    }
}

namespace NHSample1.Domain
{
   public class Customer
   {
       public int Id { get; set; }
       public string FirstName { get; set; }
       public string LastName { get; set; }
       public string AddressLine1 { get; set; }
       public string AddressLine2 { get; set; }
       public string PostalCode { get; set; }
       public string City { get; set; }
       public string CountryCode { get; set; }
   }
}

using FluentNHibernate.Mapping;

namespace NHSample1.Domain
{
   class CustomerMapping : ClassMap<Customer>
   {
   }
}

using FluentNHibernate.Mapping;

namespace NHSample1.Domain
{
   class CustomerMapping : ClassMap<Customer>
   {
       public CustomerMapping()
       {
           Not.LazyLoad();
           Id(c => c.Id).GeneratedBy.HiLo("1000");
           Map(c => c.FirstName).Not.Nullable().Length(50);
           Map(c => c.LastName).Not.Nullable().Length(50);
           Map(c => c.AddressLine1).Not.Nullable().Length(50);
           Map(c => c.AddressLine2).Length(50);
           Map(c => c.PostalCode).Not.Nullable().Length(10);
           Map(c => c.City).Not.Nullable().Length(50);
           Map(c => c.CountryCode).Not.Nullable().Length(2);
       }
   }
}

using System.Collections.Generic;

namespace NHSample4.Domain
{
 public class Course
 {
     public virtual int Id { get; set; }
     public virtual string Teacher { get; set; }
     public virtual IList<Student> Students { get; set; }

     public Course()
     {
         Students = new List<Student>();
     }
 }
}

using System.Collections.Generic;

namespace NHSample4.Domain
{
 public class Student
 {
     public virtual int Id { get; set; }
     public virtual string Name { get; set; }
     public virtual IList<Course> Courses { get; set; }

     public Student()
     {
         Courses = new List<Course>();
     }
 }
}

using FluentNHibernate.Automapping;
using FluentNHibernate.Cfg;
using FluentNHibernate.Cfg.Db;
using NHibernate.Tool.hbm2ddl;

namespace NHSessionManager
{
 public class Config
 {
     public static FluentConfiguration GetConfig()
     {
         return
           Fluently.Configure()
                   .Database(
                      MsSqlConfiguration
                        .MsSql2008
                        .ConnectionString(x => x.FromConnectionStringWithKey("DbConnectionString"))                        
                       )
                     .Mappings(
                       m => m.AutoMappings.Add(
                          new AutoPersistenceModel()
                              .Where(x => x.Namespace.EndsWith("Domain"))
                              .AddEntityAssembly(typeof(NHSample4.Domain.Course).Assembly))                              
                              .ExportTo(System.Environment.CurrentDirectory)
                              );
     }

     public static void CreateDb()
     {
         bool script = false;//آیا خروجی در کنسول هم نمایش داده شود
         bool export = true;//آیا بر روی دیتابیس هم اجرا شود           
         bool dropTables = false;//آیا جداول موجود دراپ شوند
         new SchemaExport(GetConfig().BuildConfiguration()).Execute(script, export, dropTables);
     }
 }
}

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<connectionStrings>
 <!--NHSessionManager-->
 <add name="DbConnectionString"
      connectionString="Data Source=(local);Initial Catalog=HelloNHibernate;Integrated Security = true"/>
</connectionStrings>
</configuration>

using System;
using System.Linq;
using System.Linq.Expressions;

namespace NHSample4.NHRepository
{
 //Repository Interface
 public interface IRepository<T>
 {
     T Get(object key);

     T Save(T entity);
     T Update(T entity);
     void Delete(T entity);

     IQueryable<T> Find();
     IQueryable<T> Find(Expression<Func<T, bool>> predicate);
 }
}

using System;
using System.Linq;
using NHSessionManager;
using NHibernate;
using NHibernate.Linq;

namespace NHSample4.NHRepository
{
 public class Repository<T> : IRepository<T>, IDisposable
 {
     private ISession _session;
     private bool _disposed = false;

     public Repository()
     {
         _session = SingletonCore.SessionFactory.OpenSession();
         BeginTransaction();
     }

     ~Repository()
     {
         Dispose(false);
     }

     public T Get(object key)
     {
         if (!isSessionSafe) return default(T);

         return _session.Get<T>(key);
     }

     public T Save(T entity)
     {
         if (!isSessionSafe) return default(T);

         _session.Save(entity);
         return entity;
     }

     public T Update(T entity)
     {
         if (!isSessionSafe) return default(T);

         _session.Update(entity);
         return entity;
     }

     public void Delete(T entity)
     {
         if (!isSessionSafe) return;

         _session.Delete(entity);
     }

     public IQueryable<T> Find()
     {
         if (!isSessionSafe) return null;

         return _session.Linq<T>();
     }

     public IQueryable<T> Find(System.Linq.Expressions.Expression<Func<T, bool>> predicate)
     {
         if (!isSessionSafe) return null;

         return Find().Where(predicate);
     }

     void Commit()
     {
         if (!isSessionSafe) return;

         if (_session.Transaction != null &&
             _session.Transaction.IsActive &&
             !_session.Transaction.WasCommitted &&
             !_session.Transaction.WasRolledBack)
         {
             _session.Transaction.Commit();
         }
         else
         {
             _session.Flush();
         }
     }

     void Rollback()
     {
         if (!isSessionSafe) return;

         if (_session.Transaction != null && _session.Transaction.IsActive)
         {
             _session.Transaction.Rollback();
         }
     }

     private bool isSessionSafe
     {
         get
         {
             return _session != null && _session.IsOpen;
         }
     }

     void BeginTransaction()
     {
         if (!isSessionSafe) return;

         _session.BeginTransaction();
     }


     public void Dispose()
     {
         Dispose(true);
         // tell the GC that the Finalize process no longer needs to be run for this object.
         GC.SuppressFinalize(this);
     }

     protected virtual void Dispose(bool disposeManagedResources)
     {
         if (_disposed) return;
         if (!disposeManagedResources) return;
         if (!isSessionSafe) return;

         try
         {
             Commit();
         }
         catch (Exception ex)
         {
             Console.WriteLine(ex.ToString());
             Rollback();
         }
         finally
         {
             if (isSessionSafe)
             {
                 _session.Close();
                 _session.Dispose();
             }
         }

         _disposed = true;
     }
 }
}

using System;
using System.Collections.Generic;
using NHSample4.Domain;
using NHSample4.NHRepository;

namespace NHSample4
{
 class Program
 {
     static void Main(string[] args)
     {
         //ایجاد دیتابیس در صورت نیاز
         //NHSessionManager.Config.CreateDb();

      
         //ابتدا یک دانشجو را اضافه می‌کنیم
         Student student = null;
         using (var studentRepo = new Repository<Student>())
         {
             student = studentRepo.Save(new Student() { Name = "Vahid" });
         }

         //سپس یک واحد را اضافه می‌کنیم
         using (var courseRepo = new Repository<Course>())
         {
             var course = courseRepo.Save(new Course() { Teacher = "Shams" });
         }

         //اکنون یک واحد را به دانشجو انتساب می‌دهیم
         using (var courseRepo = new Repository<Course>())
         {
             courseRepo.Save(new Course() { Students = new List<Student>() { student } });
         }
      
         //سپس شماره دروس استادی خاص را نمایش می‌دهیم
         using (var courseRepo = new Repository<Course>())
         {
             var query = courseRepo.Find(t => t.Teacher == "Shams");

             foreach (var course in query)
                 Console.WriteLine(course.Id);
         }

         Console.WriteLine("Press a key...");
         Console.ReadKey();
     }
 }
}