private string ResolveConnectionString(string connectionStringName)
    {
        // Multi-tenancy unaware contexts should always use the host connection string
        if (typeof(TDbContext).IsDefined(typeof(IgnoreMultiTenancyAttribute), false))
        {
            using (_currentTenant.Change(null))
            {
                return(_connectionStringResolver.Resolve(connectionStringName));
            }
        }

        return(_connectionStringResolver.Resolve(connectionStringName));
    }
Esempio n. 2
0
        public TDbContext GetDbContext()
        {
            Logger.LogWarning(
                "UnitOfWorkDbContextProvider.GetDbContext is deprecated. Use GetDbContextAsync instead! " +
                "You are probably using LINQ (LINQ extensions) directly on a repository. In this case, use repository.GetQueryableAsync() method " +
                "to obtain an IQueryable<T> instance and use LINQ (LINQ extensions) on this object. "
                );
            Logger.LogWarning(Environment.StackTrace.Truncate(2048));

            var unitOfWork = _unitOfWorkManager.Current;

            if (unitOfWork == null)
            {
                throw new AbpException("A DbContext can only be created inside a unit of work!");
            }

            var connectionStringName = ConnectionStringNameAttribute.GetConnStringName <TDbContext>();
            var connectionString     = _connectionStringResolver.Resolve(connectionStringName);

            var dbContextKey = $"{typeof(TDbContext).FullName}_{connectionString}";

            var databaseApi = unitOfWork.GetOrAddDatabaseApi(
                dbContextKey,
                () => new EfCoreDatabaseApi <TDbContext>(
                    CreateDbContext(unitOfWork, connectionStringName, connectionString)
                    ));

            return(((EfCoreDatabaseApi <TDbContext>)databaseApi).DbContext);
        }
Esempio n. 3
0
        public TMongoDbContext GetDbContext()
        {
            var unitOfWork = _unitOfWorkManager.Current;

            if (unitOfWork == null)
            {
                throw new AbpException(
                          $"A {nameof(IMongoDatabase)} instance can only be created inside a unit of work!");
            }

            var connectionString = _connectionStringResolver.Resolve <TMongoDbContext>();
            var dbContextKey     = $"{typeof(TMongoDbContext).FullName}_{connectionString}";

            var mongoUrl     = new MongoUrl(connectionString);
            var databaseName = mongoUrl.DatabaseName;

            if (databaseName.IsNullOrWhiteSpace())
            {
                databaseName = ConnectionStringNameAttribute.GetConnStringName <TMongoDbContext>();
            }

            //TODO: Create only single MongoDbClient per connection string in an application (extract MongoClientCache for example).
            var databaseApi = unitOfWork.GetOrAddDatabaseApi(
                dbContextKey,
                () => new MongoDbDatabaseApi <TMongoDbContext>(CreateDbContext(unitOfWork, mongoUrl, databaseName)));

            return(((MongoDbDatabaseApi <TMongoDbContext>)databaseApi).DbContext);
        }
Esempio n. 4
0
        public IMongoDatabase GetDatabase()
        {
            var unitOfWork = _unitOfWorkManager.Current;

            if (unitOfWork == null)
            {
                throw new AbpException($"A {nameof(IMongoDatabase)} instance can only be created inside a unit of work!");
            }

            var connectionString = _connectionStringResolver.Resolve <TMongoDbContext>();
            var dbContextKey     = $"{typeof(TMongoDbContext).FullName}_{connectionString}";

            string databaseName;

            if (connectionString.Contains("|"))
            {
                var splitted = connectionString.Split('|');
                connectionString = splitted[0];
                databaseName     = splitted[1];
            }
            else
            {
                databaseName = ConnectionStringNameAttribute.GetConnStringName <TMongoDbContext>();
            }

            //TODO: Create only single MongoDbClient per connection string in an application (extract MongoClientCache for example).
            var databaseApi = unitOfWork.GetOrAddDatabaseApi(
                dbContextKey,
                () => new MongoDbDatabaseApi(
                    new MongoClient(connectionString).GetDatabase(databaseName)
                    ));

            return(((MongoDbDatabaseApi)databaseApi).Database);
        }
        public Dog3DapperRepository(IConnectionStringResolver connectionStringResolver)
        {
            string connectionString = connectionStringResolver.Resolve("DogStore");

            //_dbConnection = new Microsoft.Data.SqlClient.SqlConnection(connectionString);
            _dbConnection = new MySqlConnection(connectionString);
        }
Esempio n. 6
0
        public TMongoDbContext GetDbContext()
        {
            var unitOfWork = _unitOfWorkManager.Current;

            if (unitOfWork == null)
            {
                throw new RocketException($"A {nameof(IMongoDatabase)} instance can only be created inside a unit of work!");
            }

            var connectionString = _connectionStringResolver.Resolve <TMongoDbContext> ();
            var dbContextKey     = $"{typeof(TMongoDbContext).FullName}_{connectionString}";

            var mongoUrl     = new MongoUrl(connectionString);
            var databaseName = mongoUrl.DatabaseName;

            if (databaseName.IsNullOrWhiteSpace())
            {
                databaseName = ConnectionStringNameAttribute.GetConnStringName <TMongoDbContext> ();
            }

            //TODO: 考虑创建一个单例的客户端 MongoDbClient (除了作为示例 MongoClientCache).
            var databaseApi = unitOfWork.GetOrAddDatabaseApi(
                dbContextKey,
                () => {
                var database = new MongoClient(mongoUrl).GetDatabase(databaseName);

                var dbContext = unitOfWork.ServiceProvider.GetRequiredService <TMongoDbContext> ();

                dbContext.ToRocketMongoDbContext().InitializeDatabase(database);

                return(new MongoDbDatabaseApi <TMongoDbContext> (dbContext));
            });

            return(((MongoDbDatabaseApi <TMongoDbContext>)databaseApi).DbContext);
        }
Esempio n. 7
0
        public TMongoDbContext GetDbContext()
        {
            Logger.LogWarning(
                "UnitOfWorkDbContextProvider.GetDbContext is deprecated. Use GetDbContextAsync instead! " +
                "You are probably using LINQ (LINQ extensions) directly on a repository. In this case, use repository.GetQueryableAsync() method " +
                "to obtain an IQueryable<T> instance and use LINQ (LINQ extensions) on this object. "
                );
            Logger.LogWarning(Environment.StackTrace.Truncate(2048));

            var unitOfWork = _unitOfWorkManager.Current;

            if (unitOfWork == null)
            {
                throw new AbpException(
                          $"A {nameof(IMongoDatabase)} instance can only be created inside a unit of work!");
            }

            var connectionString = _connectionStringResolver.Resolve <TMongoDbContext>();
            var dbContextKey     = $"{typeof(TMongoDbContext).FullName}_{connectionString}";

            var mongoUrl     = new MongoUrl(connectionString);
            var databaseName = mongoUrl.DatabaseName;

            if (databaseName.IsNullOrWhiteSpace())
            {
                databaseName = ConnectionStringNameAttribute.GetConnStringName <TMongoDbContext>();
            }

            //TODO: Create only single MongoDbClient per connection string in an application (extract MongoClientCache for example).
            var databaseApi = unitOfWork.GetOrAddDatabaseApi(
                dbContextKey,
                () => new MongoDbDatabaseApi <TMongoDbContext>(CreateDbContext(unitOfWork, mongoUrl, databaseName)));

            return(((MongoDbDatabaseApi <TMongoDbContext>)databaseApi).DbContext);
        }
Esempio n. 8
0
        /// <summary>
        /// The core upsert implementation.
        /// </summary>
        /// <param name="event">The event to be upserted.</param>
        /// <returns>The updated event.</returns>
        /// <exception cref="Veritema.Data.ScheduleException">
        /// The event must start in the future.
        /// or
        /// The event must end after it starts.
        /// or
        /// The event must be at least 30 minutes in duration.
        /// </exception>
        private async Task <Event> UpsertKernelAsync(Event @event)
        {
            string connectionString = _resolver.Resolve(ConnectionStringName)
                                      .Match(
                Some: v => v,
                None: () => { throw new ConfigurationErrorsException($"Cannot load the configuration string with name {{{ConnectionStringName}}}"); }
                );

            if (@event.StartUtc < DateTime.UtcNow)
            {
                throw new ScheduleException("The event must start in the future.");
            }

            if (@event.EndUtc < @event.StartUtc)
            {
                throw new ScheduleException("The event must end after it starts.");
            }

            if (@event.EndUtc < @event.StartUtc.AddMinutes(30))
            {
                throw new ScheduleException("The event must be at least 30 minutes in duration.");
            }

            string sql = LoadScript("UpsertEvent.Sql");

            using (var connection = new SqlConnection(connectionString))
            {
                var record = new EventRecord
                {
                    Id         = @event.Id > -1 ? @event.Id : 0,
                    Title      = @event.Title,
                    Details    = @event.Description,
                    End        = new DateTimeOffset(@event.EndUtc),
                    Start      = new DateTimeOffset(@event.StartUtc),
                    Confirmed  = @event.Confirmed,
                    StyleId    = @event.Style.HasValue ? (int)@event.Style.Value : new int?(),
                    LocationId = @event.Location != null ? @event.Location.Id : new int?(),
                    Updated    = DateTimeOffset.Now,
                    TypeId     = (char)@event.Type
                };
                record = await connection.QueryFirstAsync <EventRecord>(sql, record);

                @event = new Event
                {
                    Id          = record.Id,
                    Title       = record.Title,
                    Description = record.Details,
                    EndUtc      = record.End.UtcDateTime,
                    StartUtc    = record.Start.UtcDateTime,
                    Confirmed   = record.Confirmed,
                    Style       = record.StyleId.HasValue ? (MartialArtStyle)record.StyleId.Value : new MartialArtStyle?(),
                    Location    = record.LocationId.HasValue ? await _locationLoader.GetAsync(record.LocationId.Value) : null,
                    Updated     = record.Updated,
                    Type        = (EventType)record.TypeId
                };
            }

            return(@event);
        }
Esempio n. 9
0
        public TDbContext GetDbContext()
        {
            if (!(_unitOfWorkManager.Current is  EfUnitOfWork uow))
            {
                throw new NotSupportedException($"UnitOfWork is not type of {typeof(EfUnitOfWork).FullName}.");
            }
            var connectionString = _connectionStringResolver.Resolve <TDbContext>();

            return(uow.GetOrCreateDbContext <TDbContext>(connectionString));
        }
    public IMemoryDatabase GetDatabase()
    {
        var unitOfWork = _unitOfWorkManager.Current;

        if (unitOfWork == null)
        {
            throw new AbpException($"A {nameof(IMemoryDatabase)} instance can only be created inside a unit of work!");
        }

        var connectionString = _connectionStringResolver.Resolve <TMemoryDbContext>();
        var dbContextKey     = $"{typeof(TMemoryDbContext).FullName}_{connectionString}";

        var databaseApi = unitOfWork.GetOrAddDatabaseApi(
            dbContextKey,
            () => new MemoryDbDatabaseApi(
                _memoryDatabaseManager.Get(connectionString)
                ));

        return(((MemoryDbDatabaseApi)databaseApi).Database);
    }
Esempio n. 11
0
        /// <summary>
        /// Gets the defined locations.
        /// </summary>
        /// <returns>The set of locations.</returns>
        public async Task <IEnumerable <Location> > GetAsync()
        {
            string connectionString = _resolver.Resolve(ConnectionStringName)
                                      .Match(
                Some: v => v,
                None: () => { throw new ConfigurationErrorsException($"Cannot load the configuration string with name {{{ConnectionStringName}}}"); }
                );


            string sql = LoadScript("QueryLocations.sql");

            IEnumerable <Location> locations;

            using (var connection = new SqlConnection(connectionString))
            {
                var records = await connection.QueryAsync(sql);

                locations = records.Select(i => Map(i)).Cast <Location>().ToArray();
            }

            return(locations);
        }
Esempio n. 12
0
        /// <summary>
        /// Deletes the event asynchronously.
        /// </summary>
        /// <param name="id">The event identifier.</param>
        public async Task DeleteAsync(long id)
        {
            string connectionString = _resolver.Resolve(ConnectionStringName)
                                      .Match(
                Some: v => v,
                None: () => { throw new ConfigurationErrorsException($"Cannot load the configuration string with name {{{ConnectionStringName}}}"); }
                );

            using (var connection = new SqlConnection(connectionString))
            {
                await connection.ExecuteAsync("DELETE from [v].[Event] where Id = @id", new { id = id });
            }
        }
Esempio n. 13
0
        public Dfhv(IOptions <Option> options, IRazorLightEngine razorLightEngine, INameResolver nameResolver, IConnectionStringResolver connectionStringResolver)
        {
            _razorLightEngine         = razorLightEngine;
            _nameResolver             = nameResolver;
            _connectionStringResolver = connectionStringResolver;
            _option = options.Value;
            var connectionName = _option.AzureStorageConnectionStringName ?? ConnectionStringNames.Storage;
            var resolvedStorageConnectionString = _connectionStringResolver.Resolve(connectionName);
            var account = CloudStorageAccount.Parse(resolvedStorageConnectionString);

            _tableClient = account.CreateCloudTableClient();
            _blobClient  = account.CreateCloudBlobClient();
            _handler     = new HttpHandler(_tableClient, _option.HubName, _razorLightEngine, this);
        }
Esempio n. 14
0
        public RedisDurabilityProviderFactory(IOptions <DurableTaskOptions> options, IConnectionStringResolver connectionStringResolver)
        {
            this.defaultConnectionName = options.Value.StorageProvider["connectionName"] as string;
            string redisConnectionString = connectionStringResolver.Resolve(this.defaultConnectionName);

            this.defaultHubName     = options.Value.HubName;
            this.connectionResolver = connectionStringResolver;
            var defaultTaskHubService = new RedisOrchestrationService(new RedisOrchestrationServiceSettings()
            {
                TaskHubName           = this.defaultHubName,
                RedisConnectionString = redisConnectionString,
            });

            this.defaultProvider = new DurabilityProvider("Redis", defaultTaskHubService, defaultTaskHubService, this.defaultConnectionName);
        }
Esempio n. 15
0
        internal SqlOrchestrationServiceSettings GetOrchestrationServiceSettings(
            DurableTaskOptions extensionOptions,
            IConnectionStringResolver connectionStringResolver)
        {
            if (connectionStringResolver == null)
            {
                throw new ArgumentNullException(nameof(connectionStringResolver));
            }

            string?connectionString = connectionStringResolver.Resolve(this.ConnectionStringName);

            if (string.IsNullOrEmpty(connectionString))
            {
                throw new InvalidOperationException(
                          $"No SQL connection string configuration was found for the app setting or environment variable named '{this.ConnectionStringName}'.");
            }

            // Validate the connection string
            try
            {
                new SqlConnectionStringBuilder(connectionString);
            }
            catch (ArgumentException e)
            {
                throw new ArgumentException("The provided connection string is invalid.", e);
            }

            var settings = new SqlOrchestrationServiceSettings(connectionString, this.TaskHubName)
            {
                CreateDatabaseIfNotExists = this.CreateDatabaseIfNotExists,
                LoggerFactory             = this.LoggerFactory,
                WorkItemBatchSize         = this.TaskEventBatchSize,
                WorkItemLockTimeout       = this.TaskEventLockTimeout,
            };

            if (extensionOptions.MaxConcurrentActivityFunctions.HasValue)
            {
                settings.MaxConcurrentActivities = extensionOptions.MaxConcurrentActivityFunctions.Value;
            }

            if (extensionOptions.MaxConcurrentOrchestratorFunctions.HasValue)
            {
                settings.MaxActiveOrchestrations = extensionOptions.MaxConcurrentOrchestratorFunctions.Value;
            }

            return(settings);
        }
Esempio n. 16
0
        /// <summary>
        /// Issue the specified TSQL query against the backing store.
        /// </summary>
        /// <param name="tsql">The TSQL to be executed.</param>
        /// <param name="parameters">The request parameters.</param>
        /// <returns>The meterialized events.</returns>
        private async Task <IEnumerable <Person> > QueryAsync(string tsql, object parameters)
        {
            string connectionString = _resolver.Resolve(ConnectionStringName)
                                      .Match(
                Some: v => v,
                None: () => { throw new ConfigurationErrorsException($"Cannot load the configuration string with name {{{ConnectionStringName}}}"); }
                );

            IEnumerable <Person> people;

            using (var connection = new SqlConnection(connectionString))
            {
                var records = await connection.QueryAsync(tsql, parameters);

                people = records.Map(i => ToPerson(i)).Cast <Person>().ToArray();
            }
            return(people);
        }
Esempio n. 17
0
        /// <summary>
        /// Issue the specified TSQL query against the backing store.
        /// </summary>
        /// <param name="tsql">The TSQL to be executed.</param>
        /// <param name="parameters">The request parameters.</param>
        /// <returns>The meterialized events.</returns>
        private async Task <IEnumerable <Event> > Query(string tsql, object parameters)
        {
            string connectionString = _resolver.Resolve(ConnectionStringName)
                                      .Match(
                Some: v => v,
                None: () => { throw new ConfigurationErrorsException($"Cannot load the configuration string with name {{{ConnectionStringName}}}"); }
                );

            IEnumerable <Event> events;

            using (var connection = new SqlConnection(connectionString))
            {
                var records = await connection.QueryAsync <EventRecord>(tsql, parameters);

                events = records.Select((async(i) => await MapAsync(i))).Select(i => i.Result).ToArray();
            }
            return(events);
        }
Esempio n. 18
0
        public TDbContext GetDbContext()
        {
            var unitOfWork = _unitOfWorkManager.Current;

            if (unitOfWork == null)
            {
                throw new Exception("A DbContext can only be created inside a unit of work!");
            }

            var connectionStringName = ConnectionStringNameAttribute.GetConnStringName <TDbContext>();
            var connectionString     = _connectionStringResolver.Resolve(connectionStringName);
            var dbContextKey         = $"{typeof(TDbContext).FullName}_{connectionString}";
            var databaseApi          = unitOfWork.GetOrAddDatabaseApi(dbContextKey, () =>
                                                                      new EfCoreDatabaseApi <TDbContext>(CreateDbContext(unitOfWork, connectionStringName, connectionString)
                                                                                                         ));

            return(((EfCoreDatabaseApi <TDbContext>)databaseApi).DbContext);
        }
Esempio n. 19
0
        private static StorageAccountDetails GetStorageAccountDetailsOrNull(IConnectionStringResolver connectionStringResolver, string connectionName)
        {
            if (string.IsNullOrEmpty(connectionName))
            {
                return(null);
            }

            string resolvedStorageConnectionString = connectionStringResolver.Resolve(connectionName);

            if (string.IsNullOrEmpty(resolvedStorageConnectionString))
            {
                throw new InvalidOperationException($"Unable to resolve the Azure Storage connection named '{connectionName}'.");
            }

            return(new StorageAccountDetails
            {
                ConnectionString = resolvedStorageConnectionString,
            });
        }
        public TDbContext GetDbContext <TDbContext>() where TDbContext : AbpDbContext
        {
            var unitOfWork = _unitOfWorkManager.Current;

            if (unitOfWork == null)
            {
                throw new AbpException("A DbContext can only be created inside a unit of work!");
            }

            var connectionStringName = typeof(TDbContext).Name;
            var connectionString     = _connectionStringResolver.Resolve <TDbContext>();
            var dbContextKey         = $"{typeof(TDbContext).FullName}:{unitOfWork.Options.IsTransactional}:{connectionString}";
            var databaseProvider     = _connectionStringResolver.GetDatabaseProvider();
            var databaseApi          = unitOfWork.GetOrAddDatabaseApi(
                dbContextKey,
                () => new EfCoreDatabaseApi <TDbContext>(
                    CreateDbContext <TDbContext>(unitOfWork, connectionStringName, connectionString, databaseProvider)
                    ));

            return(((EfCoreDatabaseApi <TDbContext>)databaseApi).DbContext);
        }
        public TRavenDbContext GetDbContext()
        {
            IUnitOfWork unitOfWork;

            try
            {
                unitOfWork = _unitOfWorkManager.Current;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }



            if (unitOfWork == null)
            {
                throw new AbpException($"A {nameof(IAsyncDocumentSession)} instance can only be created inside a unit of work!");
            }

            var connectionString = _connectionStringResolver.Resolve <TRavenDbContext>();
            var dbContextKey     = $"{typeof(TRavenDbContext).FullName}_{connectionString}";

            var databaseApi = unitOfWork.GetOrAddDatabaseApi(
                dbContextKey,
                () =>
            {
                var dbContext = unitOfWork.ServiceProvider.GetRequiredService <TRavenDbContext>();

                var session = RavenFactory.Store.OpenAsyncSession();

                //dbContext.ToAbpMongoDbContext().InitializeDatabase(database);

                return(new RavenDbDatabaseApi <TRavenDbContext>(dbContext));
            });

            return(((RavenDbDatabaseApi <TRavenDbContext>)databaseApi).DbContext);
        }
Esempio n. 22
0
        /// <summary>
        /// 获取或创建数据库上下文
        /// </summary>
        /// <param name="dbContextType">数据库上下文类型</param>
        /// <param name="name">名称</param>
        /// <returns>数据库上下文对象</returns>
        public virtual DbContext GetOrCreateDbContext()
        {
            // 获取连接字符串
            var nameOrConnectionString = _connectionStringResolver.Resolve(this.GetConnectionStringName());

            // 缓存键值
            var dbContextKey = this.GetDbContextKey(nameOrConnectionString);

            DbContext dbContext;

            if (!ActiveDbContexts.TryGetValue(dbContextKey, out dbContext))
            {
                if (Options.IsTransactional == true)
                {
                    dbContext = _transactionStrategy.CreateDbContext(nameOrConnectionString, _dbContextResolver, this._dbContextProviderName);
                }
                else
                {
                    dbContext = _dbContextResolver.Resolve(nameOrConnectionString, null, this.Options, this._dbContextProviderName);
                }

                if (Options.Timeout.HasValue &&
                    dbContext.Database.IsRelational() &&
                    !dbContext.Database.GetCommandTimeout().HasValue)
                {
                    var commandTimeout = Convert.ToInt32(Options.Timeout.Value.TotalSeconds);

                    //dbContext.Database.SetCommandTimeout(Options.Timeout.Value.TotalSeconds.To<int>());
                    dbContext.Database.SetCommandTimeout(commandTimeout);
                }

                //TODO: Object materialize event
                //TODO: Apply current filters to this dbcontext

                ActiveDbContexts[dbContextKey] = dbContext;
            }

            return(dbContext);
        }
Esempio n. 23
0
        public void All_Tests()
        {
            //No tenant in current context
            _connectionResolver.Resolve().ShouldBe("default-value");
            _connectionResolver.Resolve("db1").ShouldBe("db1-default-value");

            //Overrided connection strings for tenant1
            using (_currentTenant.Change(_tenant1Id))
            {
                _connectionResolver.Resolve().ShouldBe("tenant1-default-value");
                _connectionResolver.Resolve("db1").ShouldBe("tenant1-db1-value");
            }

            //No tenant in current context
            _connectionResolver.Resolve().ShouldBe("default-value");
            _connectionResolver.Resolve("db1").ShouldBe("db1-default-value");

            //Undefined connection strings for tenant2
            using (_currentTenant.Change(_tenant2Id))
            {
                _connectionResolver.Resolve().ShouldBe("default-value");
                _connectionResolver.Resolve("db1").ShouldBe("db1-default-value");
            }
        }
        public TVfpContext GetDbContext()
        {
            var unitOfWork = _unitOfWorkManager.Current;

            if (unitOfWork == null)
            {
                throw new AbpException($"A {nameof(Database)} instance can only be created inside a unit of work!");
            }

            var connectionString = _connectionStringResolver.Resolve <TVfpContext>();
            var dbContextKey     = $"{typeof(TVfpContext).FullName}_{connectionString}";

            //var mongoUrl = new MongoUrl(connectionString);
            string databaseName = @"D:\GitHub\dados\SincaTeste.dbc"; //mongoUrl.DatabaseName;

            if (databaseName.IsNullOrWhiteSpace())
            {
                databaseName = ConnectionStringNameAttribute.GetConnStringName <TVfpContext>();
            }

            //TODO: Create only single MongoDbClient per connection string in an application (extract MongoClientCache for example).
            var databaseApi = unitOfWork.GetOrAddDatabaseApi(
                dbContextKey,
                () =>
            {
                var database = new DbContext(new VfpConnection(@"D:\GitHub\dados\SincaTeste.dbc"), true);

                var dbContext = unitOfWork.ServiceProvider.GetRequiredService <TVfpContext>();

                dbContext.ToAbpVfpContext().InitializeDatabase(database.Database);

                return(new VfpDatabaseApi <TVfpContext>(dbContext));
            });

            return(((VfpDatabaseApi <TVfpContext>)databaseApi).DbContext);
        }
 public ConnectionContext GetCurrentConnectionContext()
 {
     return(new ConnectionContext(_connectionStringResolver.Resolve()));
 }
Esempio n. 26
0
 /// <summary>
 ///
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="resolver"></param>
 /// <returns></returns>
 public static string Resolve <T>(this IConnectionStringResolver resolver)
 {
     return(resolver.Resolve(ConnectionStringNameAttribute.GetConnStringName <T>()));
 }
Esempio n. 27
0
 public static string Resolve <T>(this IConnectionStringResolver resolver)
 {
     return(resolver.Resolve(typeof(T)));
 }
Esempio n. 28
0
 public static string Resolve(this IConnectionStringResolver resolver, Type type)
 {
     return(resolver.Resolve(ConnectionStringNameAttribute.GetConnStringName(type)));
 }
Esempio n. 29
0
        /// <summary>
        /// 获取当前的连接和事务信息
        /// </summary>
        /// <returns></returns>
        public virtual ActiveTransactionInfo GetActiveTransactionInfo()
        {
            var nameOrConnectionString = _connectionStringResolver.Resolve(this.GetConnectionStringName());

            return(this._transactionStrategy.GetActiveTransactionInfo(nameOrConnectionString));
        }