public void Apply(FluentNHibernate.Conventions.Instances.IIdentityInstance instance)
 {
     instance.Column("Id");
     instance.UnsavedValue("0");
     //instance.GeneratedBy.Identity();
     //instance.GeneratedBy.HiLo("1000");
 }

        protected override string GetKeyName(FluentNHibernate.Member property, Type type)
        {
            if (property == null)
                return type.Name + "ID";

            return property.Name + "ID";
        }

 public void Apply(FluentNHibernate.Conventions.Instances.IIdentityInstance instance)
 {
     if (Attribute.IsDefined(instance.EntityType, typeof(GeneratedByAssignedAttribute)))
         instance.GeneratedBy.Assigned();
     else
         instance.Column("Id");
 }

        protected override string GetKeyName(FluentNHibernate.Member property, Type type)
        {
            if (property == null)
                return type.Name + "ID";  // many-to-many, one-to-many, join

            return property.Name + "ID"; // many-to-one
        }

        protected override string GetKeyName(FluentNHibernate.Member property, Type type)
        {
            if (property == null)
                return "fk_" + type.Name;

            return "fk_" + property.Name;
        }

 public void Apply(FluentNHibernate.Conventions.Instances.IOneToManyCollectionInstance instance)
 {
     instance.Key.Column(instance.EntityType.Name + "Id");
     instance.Cascade.AllDeleteOrphan();
     instance.Inverse();
     instance.Access.CamelCaseField(CamelCasePrefix.Underscore);//http://stackoverflow.com/questions/781443/private-collection-mapping-in-fluent-nhibernate
 }

 public void Apply(FluentNHibernate.Conventions.Instances.IOneToManyCollectionInstance instance)
 {
     instance.Generic();
     instance.LazyLoad();
     instance.Fetch.Select();
     instance.BatchSize(10);
 }

        public void Apply(FluentNHibernate.Conventions.Instances.IIdentityInstance instance)
        {
            if (instance.EntityType.BaseType != typeof (IntEntity))
                instance.GeneratedBy.Assigned();

            instance.UniqueKey("PK_" + instance.EntityType.Name);
        }

 public void Apply(FluentNHibernate.Conventions.Instances.IVersionInstance instance)
 {
     instance.Column("RowVersion");
     instance.Not.Nullable();
     instance.UnsavedValue("0");
     instance.Default(1);
 }

 public override bool ShouldMap(FluentNHibernate.Member member)
 {
     if (member.IsProperty && !member.CanWrite)
     {
         return false;
     }
     return base.ShouldMap(member);
 }

        public void Apply(FluentNHibernate.Conventions.Instances.IPropertyInstance instance)
        {
            var regexString = @"([A-Z][\w^[A-Z]]*)([A-Z][\w^[A-Z]]*)*";

            var newName = Regex.Replace(instance.Name, regexString, (m => (m.Index != 0 ? "_" : "") + m.Value.ToLower()));

            instance.Column(newName);
        }

 public void Apply(FluentNHibernate.Conventions.Instances.IOneToManyCollectionInstance instance)
 {
     instance.Key.Column(instance.EntityType.Name + "Id");
     instance.Key.ForeignKey(instance.EntityType.Name+"_"+instance.ChildType.Name+"_FK");
     instance.Cascade.AllDeleteOrphan();
     instance.Inverse();
     instance.LazyLoad();
 }

            protected override string GetKeyName(FluentNHibernate.Member property, Type type)
            {
                if (property == null)
                    return type.Name + "Id";

                // make foreign key compatible with Entity Framework
                return type.Name + "_" + property.Name + "Id";
            }

        protected override string GetKeyName(FluentNHibernate.Member property, Type type)
        {
            if (property == null || typeof(Entity) == type.BaseType)
            {
                return type.Name + "Id";
            }

            return property.Name + "Id";
        }

 public void Apply(FluentNHibernate.Conventions.Instances.IManyToManyCollectionInstance instance)
 {
     if (instance.OtherSide == null)
     {
         instance.Table(
            string.Format(
                "{0}To{1}",
                instance.EntityType.Name + "_Id",
                instance.ChildType.Name + "_Id"));
     }
     else
     {
         instance.Inverse();
     }
     instance.Cascade.All();
 }

        private static ISessionFactory BuildSessionFactory(string connectionString, FluentNHibernate.Conventions.IConvention[] conventions, Assembly[] assemblies, params Assembly[] overrides)
        {
            var persistenceModel = AutoMap.Assemblies(assemblies)
                        .Conventions.Add(conventions)
                        .Conventions.Add(Cache.Is(x => x.NonStrictReadWrite()))
                        .IgnoreBase<Entity>()
                        .Where(t => typeof(EntityWithTypedId<Guid>).IsAssignableFrom(t));

            if (overrides != null)
            {
                overrides.Each(a => persistenceModel.UseOverridesFromAssembly(a));
            }

            var config = Fluently.Configure()
                            .ProxyFactoryFactory<DefaultProxyFactoryFactory>()
                            .Database(
                                MsSqlConfiguration.MsSql2008
                                    .ConnectionString(connectionString)
                                    .Provider<ContextDriverConnectionProvider>())
                            .CurrentSessionContext<LazySessionContext>()
                            .Cache(c => c.ProviderClass<SysCacheProvider>().UseSecondLevelCache().UseQueryCache())
                            .Mappings(m =>
                            {
                                m.AutoMappings.Add(persistenceModel);
                                if (overrides != null)
                                    overrides.Each(a => m.HbmMappings.AddFromAssembly(a));
                            })
                            .BuildConfiguration();

            #if DEBUG
            persistenceModel.WriteMappingsTo(AppDomain.CurrentDomain.BaseDirectory + @"Hbm");
            using (ISession session = config.BuildSessionFactory().OpenSession())
            {
                string syntax = AppDomain.CurrentDomain.BaseDirectory + @"Hbm\{0}.sql";
                string filename = string.Format(syntax, session.Connection.Database);

                using (TextWriter stringWriter = new StreamWriter(filename))
                {
                    new SchemaExport(config).Execute(false, false, false, session.Connection, stringWriter);
                }
            }
            #endif
            return config.BuildSessionFactory();
        }

        public void Apply(FluentNHibernate.Conventions.Instances.IPropertyInstance instance)
        {
            // instance.CustomType

            if (instance.Type.IsGenericType && instance.Type.GetGenericTypeDefinition() == tp)
            {
                var realType = instance.Type.GenericArguments.First();
                if (realType.IsEnum)
                {
                    instance.CustomType(realType);
                }

            }

            var list = instance.Property.MemberInfo.GetCustomAttributes(typeof(FieldLengthAttribute), true);
            if (list.Length > 0)
            {
                instance.Length(((FieldLengthAttribute)list[0]).Length);
            }
        }

 public void Apply(FluentNHibernate.Conventions.Instances.IClassInstance instance)
 {
     instance.Table(instance.EntityType.Name.InflectTo().Pluralized);
 }

 public void Apply(FluentNHibernate.Conventions.Instances.IClassInstance instance)
 {
     instance.Table(Inflector.Net.Inflector.Pluralize(instance.EntityType.Name));
 }

 public void Apply(FluentNHibernate.Conventions.Instances.IIdentityInstance instance)
 {
     instance.Column(instance.EntityType.Name + "Id");
 }