private static ISessionFactory CreateSessionFactory()
{
    var cfg = new Configuration().Configure("nhibernate.config");
    cfg.SetProperty(NHibernate.Cfg.Environment.ConnectionStringName, 
System.Configuration.ConfigurationManager.ConnectionStrings[System.Environment.MachineName].ConnectionString));
    return cfg.BuildSessionFactory();
}

namespace Northwind
{
    /// <summary>
    /// A base class for all entities that implements identity equality.
    /// </summary>
    /// <typeparam name="TId">The type of the ID.</typeparam>
    /// <typeparam name="T">The type of the derived class (required for equality)</typeparam>
    public abstract class EntityBase<TId, T> where T : EntityBase<TId, T>
    {
        private TId _id;

// pseudo: if month(entered) greater than or equal to 7, return year(entered)
// else return year(entered)-1 (for school year conversion)
// returns distinct list of "school years"
 
var criteria = Session.CreateCriteria<MyEntity>();
var convertToSchoolYearProjection = 
Projections.Conditional(
 Restrictions.Ge(
  Projections.SqlFunction("month", 
    NHibernateUtil.Int32, 

class AuthorsByNameQuery   
{  
    internal DetachedCriteria Criteria;  
        
    public AuthorsByNameQuery()  
    {  
      Criteria = DetachedCriteria.For<Author>();  
    }  
          
    public IList<Author> List(ISession session)  

public IQueryable<T> Query(Expression<Func<T, bool>> predicate)
{
    IQueryable<T> returnValue;
    using (ITransaction transaction = _session.BeginTransaction())
    {
        try
        {
            returnValue = _session.Linq<T>().Where(predicate);
            transaction.Commit();
        }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NHibernate;
 
namespace Lucilla.Framework.Core.Data
{
    public static class QueryExtensions
    {

class Program
{
    private static ISessionFactory CreateSessionFactory()
    {
        return Fluently.Configure()
            .Database(
                OracleClientConfiguration
                    .Oracle10
                    .ConnectionString(Properties.Settings.Default.TWTest)
                    .ProxyFactoryFactory(typeof(NHibernate.ByteCode.LinFu.ProxyFactoryFactory)))

For<IUnitOfWork>()
    .LifecycleIs(new UniquePerRequestLifecycle())
    .Use(x => new UnitOfWork(x.GetInstance<ISessionFactory>(Keys.SessionFactoryName)));

public List<PersonInOrganization> ExtractInvalidEmails()
{
  EntityCollection<PersonInOrganization> list =  GetAllItems();
 
  //my first LINQ use!
  var invalids = from l in list where !string.IsNullOrEmpty(l.Email) && !IsValidEmail(l.Email) select l;
 
  return invalids.ToList<PersonInOrganization>();
}

public bool OnPreInsert(PreInsertEvent @event)
{
    var entity = @event.Entity as ParentVersion;
    if (entity == null)
    {
        return false;
    }
 
    var currentMaxVersion = @event.Session.CreateCriteria<ParentVersion>("pv")
        .Add(Restrictions.Eq("pv.Parent.Id", entity.Parent.Id))

public class ParentMap : ClassMap<Parent>
{
    public ParentMap()
    {
        Table("parent_def");      
        Id(x => x.Id,"parent_id");
        Map(x => x.UID, "parent_uid").CustomSqlType("varchar").Length(40);
        Map(x => x.DeletedAt ,"dte_deleted").Nullable();
        Map(x => x.ModifiedAt, "dte_modified").Nullable();
        Map(x => x.CreatedAt, "dte_created").Nullable();

.Mappings(m => { 
                 m.FluentMappings.AddFromAssemblyOf<SomeMap>();
         m.AutoMappings.AddFromAssemblyOf<SomeOtherMap>();
            });

<many-to-one cascade="all" update="false" insert="true" class="Data" foreign-key="backup_id" name="Data">
    <column name="backup_id" />
</many-to-one>

string res = string.Empty;
 
try
{
    IQuery query = session.CreateQuery("select ao.CostCenterAccount from " +
                                       "AssetObservation as ao where ao.Asset.ID=:KEY " +
                                       "and ao.Date<:DATETIME order by Date asc");
    query.SetInt64("KEY", asset.Id);
    query.SetDateTime("DATETIME", dateTime);

Configuration config = Fluently.Configure()
    .Database(MsSqlConfiguration.MsSql2008.ConnectionString(
                  c => c.FromConnectionStringWithKey("ConnectionString"))
                  .Cache(c =>
                         c.UseQueryCache()
                             .QueryCacheFactory<StandardQueryCacheFactory>()
                             .ProviderClass<HashtableCacheProvider>()
                             .UseMinimalPuts()
                  )
                  .UseReflectionOptimizer()

new PersistenceSpecification<Component>(session, new ComponentEqualityComparer())
 
public class ComponentEqualityComparer : IEqualityComparer
{
    #region IEqualityComparer Members
 
    public bool Equals(object x, object y)
    {
        if (x == null || y == null)
        {

private static ISessionFactory CreateSessionFactory()
       {
           return Fluently.Configure()
               .Database(MsSqlConfiguration.MsSql2008
                   .ConnectionString(c => c
                        .FromConnectionStringWithKey("MyStore.Properties.Settings.StoreConnectionString"))
                        )
               .Mappings(m =>
                   m.FluentMappings
                       .AddFromAssemblyOf<Program>())

public class XmlType : IUserType
{
    public new bool Equals(object x, object y)
    {
        if (x == null || y == null)
            return false;
 
        var xdoc_x = (XmlDocument)x;
        var xdoc_y = (XmlDocument)y;
        return xdoc_y.OuterXml == xdoc_x.OuterXml;

public static class ExtensionMethods
{
    public static Configure FluentSagaPersister(this Configure config)
    {
        ISessionFactory sessionFactory = FluentConfig.GetFluentSessionFactory();
        config.Configurer.RegisterSingleton<ISessionFactory>(sessionFactory);
        config.Configurer.ConfigureComponent<FluentSagaPersister>(ComponentCallModelEnum.Singlecall);
 
        return config;
    }

public class FluentSagaPersister : ISagaPersister
{
    /// <summary>
    /// Injected session factory.
    /// </summary>
    public ISessionFactory SessionFactory { get; set; }
 
    #region ISagaPersister Members
 
    public void Save(ISagaEntity saga)