public void CanGetImplementor() { using (IStatelessSession ss = Sfi.OpenStatelessSession()) { Assert.That(ss.GetSessionImplementation(), Is.SameAs(ss)); } }
public void CanGetImplementor() { using (IStatelessSession ss = sessions.OpenStatelessSession()) { ss.GetSessionImplementation().Should().Be.SameInstanceAs(ss); } }
/// <summary> /// Adds NHibernate classes required to support <see cref="NHibernateRepository{T,TId}" />, /// <see cref="LinqRepository{TEntity,TId}" /> instantiation from container. /// <para> /// <see cref="ISessionFactory" /> and <see cref="ITransactionManager" /> are registered as Singleton. /// </para> /// <para> /// <see cref="ISession" /> is registered as Scoped (e.g. per Http request for ASP.NET Core) /// </para> /// <para> /// <see cref="IStatelessSession" /> is transient. Since it does not tracks state, there is no reason to share it. /// Stateless session must be disposed by caller /// as soon as it is not used anymore. /// </para> /// </summary> /// <remarks> /// Repository registration needs to be done separately. /// </remarks> /// <param name="services">Service collection.</param> /// <param name="configureSessionFactory"> /// NHibernate session factory configuration. /// Function should return <see cref="NHibernateSessionFactoryBuilder" /> instance, /// <see cref="IServiceProvider" /> is passed to allow retrieval of configuration. /// </param> /// <param name="sessionConfigurator">Optional callback to configure new session options.</param> /// <param name="statelessSessionConfigurator">Optional callback to configure new stateless session options.</param> /// <returns> /// <paramref name="services" /> /// </returns> public static IServiceCollection AddNHibernateWithSingleDatabase( this IServiceCollection services, Func <IServiceProvider, NHibernateSessionFactoryBuilder> configureSessionFactory, Func <ISessionBuilder, IServiceProvider, ISession>?sessionConfigurator = null, Func <IStatelessSessionBuilder, IServiceProvider, IStatelessSession>?statelessSessionConfigurator = null ) { if (services == null) { throw new ArgumentNullException(nameof(services)); } if (configureSessionFactory == null) { throw new ArgumentNullException(nameof(configureSessionFactory)); } services.AddSingleton(sp => { var logger = GetLogger(sp); logger.Debug?.Log("Building session factory..."); var sfBuilder = configureSessionFactory(sp); var sessionFactory = sfBuilder.BuildSessionFactory(); logger.Information?.Log("Build session factory {SessionFactoryId}", sessionFactory.GetHashCode()); return(sessionFactory); }); services.AddScoped(sp => { var sessionFactory = sp.GetRequiredService <ISessionFactory>(); ISession session = sessionConfigurator == null ? sessionFactory.OpenSession() : sessionConfigurator(sessionFactory.WithOptions(), sp); GetLogger(sp).Debug?.Log("Created Session {SessionId}", session.GetSessionImplementation().SessionId); return(session); }); services.AddScoped(sp => { var sessionFactory = sp.GetRequiredService <ISessionFactory>(); IStatelessSession session = statelessSessionConfigurator == null ? sessionFactory.OpenStatelessSession() : statelessSessionConfigurator(sessionFactory.WithStatelessOptions(), sp); GetLogger(sp).Debug?.Log("Created stateless Session {SessionId}", session.GetSessionImplementation().SessionId); return(session); }); services.AddScoped <TransactionManager>(); services.AddTransient <INHibernateTransactionManager>(sp => sp.GetRequiredService <TransactionManager>()); services.AddTransient <ITransactionManager>(sp => sp.GetRequiredService <TransactionManager>()); return(services); }
public static IEnumerable DeepClone(this IStatelessSession session, IEnumerable entities, DeepCloneOptions opts) { var collection = (IEnumerable)CreateNewCollection(entities.GetType()); var resolvedEntities = new Dictionary <object, object>(); foreach (var entity in entities) { AddItemToCollection(collection, DeepClone(session.GetSessionImplementation(), entity, opts, null, resolvedEntities)); } return(collection); }
private static void CancelQuery(IStatelessSession session) { try { ISessionImplementor sessionImplementor = session.GetSessionImplementation(); if (sessionImplementor != null && sessionImplementor.Batcher != null) { sessionImplementor.Batcher.CancelLastQuery(); } } catch (Exception) { // ignore } }
/// <summary> /// Flush the batcher. When batching is enabled, a stateless session is no more fully stateless. It may retain /// in its batcher some state waiting to be flushed to the database. /// </summary> /// <param name="session">The session.</param> /// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param> public static Task FlushBatcherAsync(this IStatelessSession session, CancellationToken cancellationToken = default(CancellationToken)) { if (cancellationToken.IsCancellationRequested) { return(Task.FromCanceled <object>(cancellationToken)); } try { return(session.GetSessionImplementation().FlushAsync(cancellationToken)); } catch (Exception ex) { return(Task.FromException <object>(ex)); } }
IEnumerable <D> ImportTableData <T, D>(Func <IDataReader, D> action) where T : new() { using (var cmd = session.Connection.CreateCommand()) { var persister = session.GetSessionImplementation().GetEntityPersister(null, new T()) as ILockable; if (persister == null) { throw new NullReferenceException(); } cmd.CommandType = CommandType.TableDirect; cmd.CommandText = persister.RootTableName; using (var reader = cmd.ExecuteReader()) { while (reader.Read()) { yield return(action(reader)); } } } }
public static IQueryable <T> Query <T>(this IStatelessSession session, string entityName) { return(new NhQueryable <T>(session.GetSessionImplementation(), entityName)); }
public static IQueryable <T> Query <T>(this IStatelessSession session) { return(new NhQueryable <T>(session.GetSessionImplementation())); }
private static string GetTenantId(IStatelessSession session) { return(session.GetSessionImplementation().GetTenantIdentifier()); }
/// <summary> /// Flush the batcher. When batching is enabled, a stateless session is no more fully stateless. It may retain /// in its batcher some state waiting to be flushed to the database. /// </summary> /// <param name="session">The session.</param> public static void FlushBatcher(this IStatelessSession session) { session.GetSessionImplementation().Flush(); }
public static object DeepClone(this IStatelessSession session, object entity, System.Type entityType, DeepCloneOptions opts) { return(DeepClone(session.GetSessionImplementation(), entity, opts, entityType, new Dictionary <object, object>())); }
public static T DeepClone <T>(this IStatelessSession session, T entity, DeepCloneOptions opts) { return((T)DeepClone(session.GetSessionImplementation(), entity, opts, null, new Dictionary <object, object>())); }
public static IList <T> DeepClone <T>(this IStatelessSession session, IEnumerable <T> entities, DeepCloneOptions opts) { var resolvedEntities = new Dictionary <object, object>(); return(entities.Select(entity => (T)DeepClone(session.GetSessionImplementation(), entity, opts, null, resolvedEntities)).ToList()); }
public static IEnumerable <object> GetIds(IStatelessSession session, Type type, Query query) { return(GetIds(session.GetSessionImplementation(), type, query)); }
public static SearchFactoryImpl GetSearchFactory(this IStatelessSession s) { return(GetSearchFactory(s.GetSessionImplementation())); }
// 6.0 TODO: consider if it should be added as a property on IStatelessSession then obsolete this, or if it should stay here as an extension method. /// <summary> /// Get the current transaction if any is ongoing, else <see langword="null" />. /// </summary> /// <param name="session">The session.</param> /// <returns>The current transaction or <see langword="null" />..</returns> public static ITransaction GetCurrentTransaction(this IStatelessSession session) => session.GetSessionImplementation().ConnectionManager.CurrentTransaction;
/// <summary> /// Get an executable instance of <c>Criteria</c>, /// to actually run the query.</summary> public ICriteria GetExecutableCriteria(IStatelessSession session) { impl.Session = session.GetSessionImplementation(); return(impl); }
public ISessionImplementor GetSessionImplementation() { return(_Session.GetSessionImplementation()); }