BoC.Persistence.NHibernate.NHibernateConfigHelper.SetupAutoMapperForEntities C# (CSharp) Method

        public static Configuration SetupAutoMapperForEntities(IPersistenceConfigurer database, IDependencyResolver dependencyResolver, params Assembly[] assemblies)
        {
            var config = Fluently.Configure().Database(database)
                .Cache(cache => cache.UseQueryCache().ProviderClass<SysCacheProvider>().QueryCacheFactory<ProjectionEnabledQueryCacheFactory>())
                .ProxyFactoryFactory(typeof(DefaultProxyFactoryFactory))
                .CurrentSessionContext(CurrentSessionContextClass);

            var stringPropertyconvention = ConventionBuilder.Property.When(x => x.Expect(p => p.Property.PropertyType == typeof (string)), a => a.Length(255));

            var cacheConvention = ConventionBuilder.Class.Always(c => c.Cache.ReadWrite());

            var collectionsConventionMany = ConventionBuilder.HasMany.When(
                x => x.Expect(p => !(p.Member is DummyPropertyInfo)),
                instance => { instance.Cascade.SaveUpdate(); instance.Cache.ReadWrite(); });

            var collectionsConventionManyToMany = ConventionBuilder.HasManyToMany.When(
                x => x.Expect(p => !(p.Member is DummyPropertyInfo)),
                instance => { instance.Cascade.SaveUpdate(); instance.Cache.ReadWrite(); });
            var lazyConvention = ConventionBuilder.Reference.Always(c => c.LazyLoad());

            IEnumerable<Assembly> ass;
            if (assemblies == null || assemblies.Length == 0)
            {
                ass = AppDomain.CurrentDomain.GetAssemblies().Where(
                    a => !a.FullName.StartsWith("System.") &&
                         !a.FullName.StartsWith("Microsoft.") &&
                         !a.FullName.Contains("mscorlib") &&
                         a != typeof(ISession).Assembly &&
                         a != typeof(AutoMap).Assembly
               );
            }
            else
            {
                ass = assemblies;
            }

            var autoPersistenceModel = new AutoPersistenceModel()
                .Conventions.Add(cacheConvention, collectionsConventionMany, collectionsConventionManyToMany, stringPropertyconvention, lazyConvention)
                .IgnoreBase(typeof (BaseEntity<>))
                .IgnoreBase(typeof (IBaseEntity));

            foreach (var assembly in ass)
            {
                try
                {
                    assembly.GetExportedTypes();
                }
                catch (NotSupportedException)
                {
                    continue;//cannot do dynamic assemblies
                }
                if (assembly != null)
                {
                    Assembly automapper = assembly;

                    config.Mappings(m => m.HbmMappings.AddFromAssembly(automapper));
                    autoPersistenceModel
                        .AddEntityAssembly(automapper)
                        .Conventions.AddAssembly(automapper)
                        .Alterations(alterations => alterations.AddFromAssembly(automapper))
                        .Alterations(collection => collection.Add(new AutoMappingOverrideAlteration(automapper))) //same as: UseOverridesFromAssemblyOf<Tentity>()
                        .Where(t => typeof (IBaseEntity).IsAssignableFrom(t));

                    // MORE Evil hack, since adding to the Alterations does NOT work.
                    //new AutoMappingOverrideAlteration(automapper).Alter(autoPersistenceModel);
                }
            }

            // Evil hack, since adding to the Alterations does NOT work.
            //foreach (var overrideAssembly in ass)
            //{
            //    new AutoMappingOverrideAlteration(overrideAssembly).Alter(autoPersistenceModel);
            //}

            config.Mappings(m => m.AutoMappings.Add(autoPersistenceModel)
            #if DEBUG
            .ExportTo(@"C:\temp\")
            #endif
            );

            return config.BuildConfiguration();
        }