protected void Application_Start()
        {
#if DEBUG
            HibernatingRhinos.Profiler.Appender.NHibernate.NHibernateProfiler.Initialize();
#endif
            AreaRegistration.RegisterAllAreas();
            RegisterRoutes(RouteTable.Routes);
 
            RegisterDomainModel(AssemblyOf<Item>());
            

// 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();
        }

public interface ICriteriaQuery<TEntity>
{
    DetachedCriteria Criteria { get; }
}
 
public interface ILinqQuery<TEntity>
{
    Expression<Func<TEntity, bool>> Expression { get; }
}

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)

public class EnumConvention :
    IPropertyConvention, 
    IPropertyConventionAcceptance
{
    #region IPropertyConvention Members
 
    public void Apply(IPropertyInstance instance)
    {
        instance.CustomType(instance.Property.PropertyType);
    }

public class ComponentPropertyConvention : IPropertyConvention, IPropertyConventionAcceptance
{
    public void Accept(IAcceptanceCriteria<IPropertyInspector> criteria)
    {
        criteria.Expect(x => x.EntityType.IsAny(typeof (IndividualInfo), typeof (CompanyInfo), typeof (Address)));
    }
 
    public void Apply(IPropertyInstance instance)
    {
        var name = string.Format("{0}_{1}", instance.EntityType.Name, instance.Property.Name);