/// <summary>
   /// Singleton-Pattern for ISession and doing some configuration
   /// </summary>

public class Configure
{
   private Configuration cfg = null;
   private ISessionFactory sessions = null;
   static readonly Configure instance = new Configure();
   static Configure(){}
   
   Configure()
   {
      this.cfg = new Configuration()
         .AddAssembly("NHTest");
      this.sessions = cfg.BuildSessionFactory();
   }
   public static Configure Instance
   {
      get
      {
         return instance;
      }
   }
   public ISessionFactory Sessions
   {
      get
      {
         return sessions;
      }
   }
   public Configuration Cfg
   {
      get
      {
         return cfg;
      }
   }
   public void ErschaffeTabellen(Configuration cfg)
   {
      Console.WriteLine("###### Erstelle Datenbank-Schema! Verwerfe Tabellen und erstelle Neue! #######");
      Console.WriteLine("##############################################################################\n");
         
            
      NHibernate.Tool.hbm2ddl.SchemaExport schemaExport = new NHibernate.Tool.hbm2ddl.SchemaExport(cfg);
      schemaExport.SetOutputFile("schema.txt");
      schemaExport.Create(true, true);
   }

}


class Class1
{   
   /// <summary>
   /// Do some Testing
   /// </summary>
   /// <param name="args"></param>
   [STAThread]
   static void Main(string[] args)
   {
      Configure config = Configure.Instance;
      ISessionFactory fabrik = config.Sessions;
      ISession session = fabrik.OpenSession();
      config.ErschaffeTabellen(config.Cfg);
      FillDB(fabrik);
      //...
   }
   public static void FillDB(ISessionFactory fabrik)
      {
         
         NHibernate.ISession session = null;
         NHibernate.ITransaction transaction = null;
         //...
         // Objects are created here!!!
         //...
         Random rd = new Random();
         
         try
         {
            session = fabrik.OpenSession();
            transaction = session.BeginTransaction();
            for (int i = 0; i < 200; i++)
            {
               // creating 200 objects
               session.Save(newObject);
            }
            // Commit modifications (=> Build and execute queries)
            transaction.Commit();
         }
         catch
         {
            if(transaction != null)
               transaction.Rollback(); // Error => we MUST roll back modifications
            throw; // Here, we throw the same exception so that it is handled (printed)
         }
         finally
         {
            if(session != null)
               session.Close();
         }
      }
}
   

namespace NHibernate
{
    public class NHibernateSessionFactory
    {
        private static ISessionFactory _sessionFactory;

        // Factory for Sessions. Uses the design pattern Singleton
        public static ISessionFactory GetFactory()
        {
            if (_sessionFactory == null)
            {
                lock (typeof(NHibernateSessionFactory))
                {
                    if (_sessionFactory == null)
                    {
                        Configuration cfg = new Configuration();
                        cfg.AddAssembly("Your assembly");

                        _sessionFactory = cfg.BuildSessionFactory();
                    }
                }
            }

            return _sessionFactory;
        }

        private NHibernateSessionFactory()
        {
        }       
    }
}

ISessionFactory factory = NHibernateSessionFactory.GetFactory();
ISession session = factory.OpenSession();
...

using System;
using NHibernate;
using NHibernate.Cfg;

public sealed class NHibernateSessionFactory
{
   private static volatile ISessionFactory instance;
   private static object syncRoot = new Object();

   private NHibernateSessionFactory() {}

   public static ISessionFactory getFactory()
   {
      
         if (instance == null)
         {
            lock (syncRoot)
            {
               if (instance == null)
               {
                  Configuration cfg = new Configuration();
                  cfg.AddAssembly("vcf");
                  instance = cfg.BuildSessionFactory();
               }
                  
            }
         }

         return instance;
      
   }
}