Как я могу зарегистрировать два соединения с базой данных с помощью nhibernate / lightcore?

Question

Мне нужно настроить для существующей базы данных (Ms Sql) еще одну (PostgreSql) с Fluent Nhibernate для моего приложения C # Mvc. Кто-то знает, как я могу зарегистрировать базу данных postgreSql в LightCoreConfiguration (global.asax)?

Global.asax

protected void Application_Start()
{
    MvcHandler.DisableMvcResponseHeader = true;

    AreaRegistration.RegisterAllAreas();

    RegisterRoutes(RouteTable.Routes);

    RegisterDependencies();

    RegisterValidators();

}
private static void RegisterDependencies()
{
    var builder = new ContainerBuilder();
    builder.DefaultControlledBy<HttpRequestLifecycle>();

// This is the current Ms Sql connection to the database that works and I have register here another connection to the postgreSql database
    builder.Register(c => NHConfiguration.CreateSessionFactory()).ControlledBy<SingletonLifecycle>();
    builder.Register(c => c.Resolve<ISessionFactory>().OpenSession()).ControlledBy<HttpRequestLifecycle>();

    LightCoreConfiguration.RegisterGlobalDependencies(builder);
    _container = builder.Build();

}

NHConfiguration.cs

public static class NHConfiguration
    {

        private static FluentConfiguration CreateConfiguration()
        {
            return Fluently.Configure()
                           .Database(MsSqlConfiguration.MsSql2008
                                                       .ConnectionString(SessionFacade.DatabaseConnectionString)
                                                       .ShowSql())
                           .Mappings(m => m.FluentMappings
                                           .AddFromAssemblyOf<Entity>()
                                           .AddFromAssemblyOf<CustomEntity>()
                                           .Conventions.AddFromAssemblyOf<EnumConvention>())
                           .Cache(c => c.ProviderClass<SysCacheProvider>()
                                        .UseQueryCache()
                                        .UseSecondLevelCache());
        }

        private static FluentConfiguration CreatePostgresConfiguration()
        {
            return Fluently.Configure()
                           .Database(PostgreSQLConfiguration.Standard.ConnectionString(SessionFacade.DatabasePostgresConnectionString).ShowSql())
                           .Mappings(m => m.FluentMappings
                                           .AddFromAssemblyOf<Entity>()
                                           .AddFromAssemblyOf<CustomEntity>()
                                           .Conventions.AddFromAssemblyOf<EnumConvention>()
                                           .Conventions.Add(new IdentityConvention()))
                           .Cache(c => c.ProviderClass<SysCacheProvider>()
                                        .UseQueryCache()
                                        .UseSecondLevelCache());
        }

        public static ISessionFactory CreateSessionFactory()
        {
            return CreateConfiguration().BuildSessionFactory();
        }

        public static ISessionFactory CreatePostgresSessionFactory()
        {
            return CreatePostgresConfiguration().BuildSessionFactory();
        }
    }

Я уже пытался установить соединение с базой данных без lightcore (и закрыть сеанс после того, как приложение завершило запрос), но затем была выдана ошибка, что соединение было уже закрыто, поэтому я предполагаю, что мне нужно зарегистрировать сеанс с lightcore.

Answer 1

Я нашел решение, позволяющее использовать две базы данных, и где вы можете решить для каждой сущности, какую базу данных использовать:

Global.asax

private static void RegisterDependencies()
{
    var builder = new ContainerBuilder();

    builder.DefaultControlledBy<HttpRequestLifecycle>();

    SessionFacade.DatabaseSessionFactories[DbConnectionSessionType.MsqlSession] = NHConfiguration.CreateSessionFactory();
    SessionFacade.DatabaseSessionFactories[DbConnectionSessionType.PostgresqlSession] = NHConfiguration.CreatePostgresSessionFactory();

    builder.Register(c => c.ResolveAll<IDatabaseSessions>()).ControlledBy<HttpRequestLifecycle>();

    LightCoreConfiguration.RegisterGlobalDependencies(builder);

    // Build the container.
    _container = builder.Build();
}
protected void Application_EndRequest(object sender, EventArgs e)
{
            var sessions = _container.Resolve<IDatabaseSessions>();

            sessions.MssqlSession.Close();
            sessions.MssqlSession.Dispose();

            sessions.PostgresqlSession.Close();
            sessions.PostgresqlSession.Dispose();
}

SessionFacade.cs

public static class SessionFacade
{
    /// <summary>
    /// Gets the database connection string.
    /// </summary>
    public static string DatabaseConnectionString => Environment.GetEnvironmentVariable("Database:Connection");

    public static string DatabasePostgresConnectionString => Environment.GetEnvironmentVariable("DatabasePostgres:Connection");

    public static Dictionary<DbConnectionSessionType, ISessionFactory> DatabaseSessionFactories
    {
        set; get;
    } = new Dictionary<DbConnectionSessionType, ISessionFactory>() {
        {
            DbConnectionSessionType.MsqlSession,
            null
        },
        {
            DbConnectionSessionType.PostgresqlSession,
            null
        }
    };
}

IDatabaseSessions

public interface IDatabaseSessions
{
    ISession MssqlSession { get; set; }
    ISession PostgresqlSession { get; set; }
}

LightCoreConfiguration

public static class LightCoreConfiguration
    {

        public static void RegisterGlobalDependencies(ContainerBuilder builder)
        {
builder.Register<IDatabaseSessions, DatabaseSessions>();
        }
    }
}

DatabaseSessions

public class DatabaseSessions: IDatabaseSessions
{
    public DatabaseSessions()
    {
        MssqlSession = SessionFacade.DatabaseSessionFactories[DbConnectionSessionType.MsqlSession].OpenSession();
        PostgresqlSession = SessionFacade.DatabaseSessionFactories[DbConnectionSessionType.PostgresqlSession].OpenSession();
    }

    public ISession MssqlSession { get; set; }
    public ISession PostgresqlSession { get; set; }
}

Repository.cs

public class Repository<T> : IRepository<T> where T : Entity
{
    public Repository(IDatabaseSessions databaseSessions, DbConnectionSessionType connectionType = DbConnectionSessionType.PostgresqlSession)
            {
                if(connectionType == DbConnectionSessionType.MsqlSession) _session = databaseSessions.MssqlSession;
                if(connectionType == DbConnectionSessionType.PostgresqlSession) _session = databaseSessions.PostgresqlSession;
            }
    }
}

Наконец служба

public class UserService
    {
        public UserService(IDatabaseSessions databaseSessions) : base(new Repository<User>(databaseSessions))
        {
        }
}