public TopicClient CreateTopicClient(string nsName, string topicName, string keyName, string key) { string cs = _csp.GetConnectionString(nsName, keyName, key); MessagingFactory mf = MessagingFactory.CreateFromConnectionString(cs); return(mf.CreateTopicClient(topicName)); }
public DataConnection Use(string connectionStringName = null) { var dbProvider = _providerSource.Provide(connectionStringName); var cs = _connectionStringProvider.GetConnectionString(connectionStringName); return(new DataConnection(dbProvider, cs)); }
public async Task <IStorageAccount> GetAccountAsync(string connectionStringName, CancellationToken cancellationToken) { IStorageAccount account = null; var isPrimary = true; if (connectionStringName == ConnectionStringNames.Dashboard) { account = DashboardAccount; } else if (connectionStringName == ConnectionStringNames.Storage) { account = StorageAccount; } else { // see if this is a user connnection string (i.e. for multi-account scenarios) string connectionString = _ambientConnectionStringProvider.GetConnectionString(connectionStringName); if (!string.IsNullOrEmpty(connectionString)) { account = ParseAccount(connectionStringName, connectionString); isPrimary = false; } } if (account != null) { // On the first attempt, this will make a network call to verify the credentials work. await _storageCredentialsValidator.ValidateCredentialsAsync(account, isPrimary, cancellationToken); } return(account); }
public void ExecuteNonQuery(string query) { using (SqlConnection connection = new SqlConnection(_connectionStringProvider.GetConnectionString())) { SqlCommand command = new SqlCommand(query) { Connection = connection }; connection.Open(); command.ExecuteNonQuery(); connection.Close(); } }
public IDbConnection GetInstance() { var cn = new SqlConnection(_connectionStringProvider.GetConnectionString()); cn.Open(); return(cn); }
public async Task <UserDto> GetAsync(string id) { _logger.LogDebug("Getting user with id '{0}'.", id); var connectionString = await _connectionStringProvider.GetConnectionString(); await using var connection = new SqlConnection(connectionString); var parameters = new Dictionary <string, object> { { "@Id", id } }; var user = await connection.QuerySingleOrDefaultAsync <UserDto>("GetUser", parameters); if (user == null) { _logger.LogDebug("No user was found with id '{0}'", id); throw new NotFoundException(ErrorMessages.UserNotFound); } _logger.LogDebug("Successfully retrieved user by id '{0}'", id); return(user); }
public async Task <IDbConnection> GetConnection() { var conn = new NpgsqlConnection(ConnectionString.GetConnectionString()); await conn.OpenAsync(); return(conn); }
public StrategyRepository(IConnectionStringProvider connectionStringProvider) { var client = new MongoClient(connectionStringProvider.GetConnectionString()); var database = client.GetDatabase(connectionStringProvider.GetDatabase()); _strategies = database.GetCollection <Strategy>(connectionStringProvider.GetStrategyCollectionName()); }
public async Task <IReadOnlyList <RoleListItemDto> > GetListAsync(string term) { var connectionString = await _connectionStringProvider.GetConnectionString(); await using var connection = new SqlConnection(connectionString); var parameters = new Dictionary <string, object> { { "@SearchTerm", $"%{term}%" } }; var roles = (await connection.QueryAsync <RoleListItemDto>("GetRoles", parameters, commandType: CommandType.StoredProcedure)).ToList(); _logger.LogDebug("Found {0} roles with search term '{1}'", roles.Count, term); return(roles); }
public IDbConnection GetDbConnection() { using (var conn = new SqlConnection(_provider.GetConnectionString())) { return(conn); } }
//--open conection--- public SqlConnection GetOpenConnection() { var connection = new SqlConnection(_connectionStringProvider.GetConnectionString()); connection.Open(); return(connection); }
/// <summary> /// /// </summary> /// <param name="args">[repository] [source collection name] [target collection name]</param> /// <returns></returns> public async Task RunAsync(string[] args) { var repository = args[0]; var sourceCollectionName = args[1]; var targetCollectionName = args[2]; var client = new MongoClient(_connectionStringProvider.GetConnectionString(repository)); IMongoDatabase _database = client.GetDatabase(repository); IMongoCollection <BsonDocument> targetCollection = _database.GetCollection <BsonDocument>(targetCollectionName); IMongoCollection <BsonDocument> sourceCollection = _database.GetCollection <BsonDocument>(sourceCollectionName); await sourceCollection.Find(new BsonDocument()).ForEachAsync(async(thread) => { foreach (var user in thread.GetElement(targetCollectionName).Value.AsBsonArray) { var filter = Builders <BsonDocument> .Filter.Eq("id", user.ToBsonDocument().GetElement("id").Value); var count = await targetCollection.Find(filter).CountAsync(); if (count == 0) { await targetCollection.InsertOneAsync(user.ToBsonDocument()); } } }); }
public ItemRepository(IConnectionStringProvider connectionStringProvider) { var databaseUrl = MongoUrl.Create(connectionStringProvider.GetConnectionString()); var database = new MongoClient(databaseUrl).GetDatabase(databaseUrl.DatabaseName); _itemsCollection = database.GetCollection <Item>("Items"); }
protected IDbConnection GetConnection() { var connection = new SqlConnection(_connectionStringProvider.GetConnectionString()); connection.Open(); return(connection); }
public ApiRepositoryContext Build() { var connection = new SqliteConnection(_connectionStringProvider.GetConnectionString()); var context = new ApiRepositoryContext(new DbContextOptionsBuilder <ApiRepositoryContext>().UseSqlite(connection).Options); return(context); }
public GCloudContext(IConnectionStringProvider connStringProvider) : base(connStringProvider.GetConnectionString()) { // Disable proxy creation and lazy loading; not wanted in this service context. Configuration.LazyLoadingEnabled = false; Configuration.ProxyCreationEnabled = false; }
public SimulationRepository(IConnectionStringProvider connectionStringProvider) { var client = new MongoClient(connectionStringProvider.GetConnectionString()); var database = client.GetDatabase(connectionStringProvider.GetDatabase()); _simulations = database.GetCollection <Simulation>(connectionStringProvider.GetSimulaionCollectionName()); }
public void Configure(String targetDir) { String errMsg = "Not empty"; while (!String.IsNullOrEmpty(errMsg)) { String connStr = _ConnectionStringProvider.GetConnectionString(); errMsg = _ConnectionStringValidator.Validate(connStr); if (String.IsNullOrEmpty(errMsg)) { String[] configFiles = Directory.GetFiles(targetDir, "*.config"); IConfigurationTextUpdater configUpdater = new ConfigurationTextUpdater(); DbType dbType = _ConnectionStringValidator.GetDbType(connStr); IDictionary <String, String> configTerms = new Dictionary <String, String>(); String dbTypeString, dbNameString; DbConnectionStringBuilder connStrBldr; if (dbType == DbType.Vfp) { connStrBldr = new OleDbConnectionStringBuilder(connStr); configTerms.Add(new KeyValuePair <String, String>(Constants.ConfigTokenNames.HostDirectory, connStrBldr[Constants.ConnectionStringDetails.DataSourcePropertyName].ToString())); dbTypeString = Constants.ConfigTokenValues.DbTypeVfp; dbNameString = Constants.ConfigTokenValues.DbNameVfp; } else { connStrBldr = new SqlConnectionStringBuilder(connStr); configTerms.Add(new KeyValuePair <String, String>(Constants.ConfigTokenNames.SqlServerName, connStrBldr[Constants.ConnectionStringDetails.DataSourcePropertyName].ToString())); configTerms.Add(new KeyValuePair <String, String>(Constants.ConfigTokenNames.SqlDbName, connStrBldr[Constants.ConnectionStringDetails.InitialCatalogPropertyName].ToString())); dbTypeString = Constants.ConfigTokenValues.DbTypeSql; dbNameString = Constants.ConfigTokenValues.DbNameSql; } configTerms.Add(new KeyValuePair <String, String>(Constants.ConfigTokenNames.DbType, dbTypeString)); configTerms.Add(new KeyValuePair <String, String>(Constants.ConfigTokenNames.DbName, dbNameString)); foreach (String fileName in configFiles) { IEnumerable <String> configIn = File.ReadAllLines(fileName); IEnumerable <String> configOut = configUpdater.Update(configIn, configTerms); if (configOut != null) { File.WriteAllLines(fileName, configOut); } } } else { MessageBox.Show(errMsg); } } }
public IDbConnection GetConnection(string csName = null) { var conn = new SqlConnection(_connectionStringProvider.GetConnectionString(csName)); conn.Open(); return(conn); }
public ImsDbContext(IConnectionStringProvider connectionStringProvider) : base(connectionStringProvider.GetConnectionString()) { // This is a hack to ensure that Entity Framework SQL Provider is copied across to the output folder. // As it is installed in the GAC, Copy Local does not work. It is required for probing. // Fixed "Provider not loaded" error var ensureDLLIsCopied = SqlProviderServices.Instance; }
UpgradeEngine GetDbUpEngine() { return(DeployChanges .To .SQLiteDatabase(connectionStringProvider.GetConnectionString()) .WithScriptsEmbeddedInAssembly(Assembly.GetExecutingAssembly()) .Build()); }
public IDbConnection GetDbConnection() { var conn = new NpgsqlConnection(_connectionStringProvider.GetConnectionString()); conn.Open(); return(conn); }
public string GetValue(string value) { var dbProvider = _providerSource.Provide(null); var cs = _connectionStringProvider.GetConnectionString(); using var c = new DataConnection(dbProvider, cs); return(c.Query <string>($"select \"{value}\";").First()); }
public IActionResult Initialize() { var initialize = new Initialize() .With(connectionStringProvider.GetConnectionString("ConnectionString")) .CreateDatabase() .PopulateDatabase(); return(RedirectToAction("Index")); }
private void CreateTopicAndSubscriber() { NamespaceManager nsm = NamespaceManager.CreateFromConnectionString(_csp.GetConnectionString(nsName, nsKeyName, nsKey)); CreateTopic(nsm); initialized = true; Task.Run(() => SubscriberTask <string>()); }
/// <summary> /// Initializes a new instance of the <see cref="SqlCommandCacheDependencyEnlister"/> class. /// </summary> /// <param name="command">The command.</param> /// <param name="isStoredProcedure">if set to <c>true</c> [is stored procedure].</param> /// <param name="connectionName">Name of the connection.</param> /// <param name="connectionStringProvider">The <see cref="IConnectionStringProvider"/> to use /// to retrieve the connection string to connect to the underlying data store and enlist in query notifications</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="command"/> or /// <paramref name="connectionStringProvider"/> is null or empty.</exception> public SqlCommandCacheDependencyEnlister(string command, bool isStoredProcedure, string connectionName, IConnectionStringProvider connectionStringProvider) { //validate the parameters if (String.IsNullOrEmpty(command)) { throw new ArgumentNullException("command"); } if (connectionStringProvider == null) { throw new ArgumentNullException("connectionStringProvider"); } this.command = command; this.isStoredProcedure = isStoredProcedure; this.connectionName = connectionName; connectionString = String.IsNullOrEmpty(this.connectionName) ? connectionStringProvider.GetConnectionString() : connectionStringProvider.GetConnectionString(this.connectionName); }
protected virtual void ConfigureDatabase(Configuration config) { var connectionString = connectionStringProvider.GetConnectionString(); config.DataBaseIntegration(x => { x.Driver <MonoSafeSQLite20Driver>(); x.Dialect <SQLiteDialect>(); x.ConnectionString = connectionString; x.ConnectionReleaseMode = ConnectionReleaseMode.OnClose; }); }
public DatabaseFactory(IConnectionStringProvider connectionStringProvider, IMappingProvider mappingProvider) { DatabaseFactoryConfigOptions options = new DatabaseFactoryConfigOptions(); var connectionString = connectionStringProvider.GetConnectionString(); var mappings = mappingProvider.GetMappings(); options.Database = () => new LoggingDatabase(connectionString); options.PocoDataFactory = FluentMappingConfiguration.Configure(mappings); databaseFactory = new NPoco.DatabaseFactory(options); }
public DapperUnitOfWork(IConnectionStringProvider connectionStringProvider) { var connectionString = connectionStringProvider.GetConnectionString(); IDbFactory dbFactory = new SqlDbFactory(connectionString); Db = dbFactory; if (Db.Context().State != ConnectionState.Open) { Db.Context().Open(); } DbTransaction = Db.Context().BeginTransaction(); }
/// <summary> /// 构建<see cref="DbContextOptionsBuilder"/>,附加必要的扩展属性 /// </summary> public static DbContextOptionsBuilder BuildDbContextOptionsBuilder <TDbContext>(this IServiceProvider provider, DbContextOptionsBuilder builder) where TDbContext : DbContext { Type dbContextType = typeof(TDbContext); OsharpOptions osharpOptions = provider.GetOSharpOptions(); OsharpDbContextOptions osharpDbContextOptions = osharpOptions?.GetDbContextOptions(dbContextType); if (osharpDbContextOptions == null) { throw new OsharpException($"无法找到数据上下文 {dbContextType.DisplayName()} 的配置信息"); } ILogger logger = provider.GetLogger(typeof(ServiceExtensions)); //启用延迟加载 if (osharpDbContextOptions.LazyLoadingProxiesEnabled) { builder = builder.UseLazyLoadingProxies(); logger.LogDebug($"数据上下文类型 {dbContextType} 应用延迟加载代理"); } DatabaseType databaseType = osharpDbContextOptions.DatabaseType; //处理数据库驱动差异处理 IDbContextOptionsBuilderDriveHandler driveHandler = provider.GetServices <IDbContextOptionsBuilderDriveHandler>() .LastOrDefault(m => m.Type == databaseType); if (driveHandler == null) { throw new OsharpException($"无法解析类型为 {databaseType} 的 {typeof(IDbContextOptionsBuilderDriveHandler).DisplayName()} 实例,是否未在Startup执行AddPack<{databaseType}DefaultDbContextMigrationPack>()"); } //选择主/从数据库连接串 IConnectionStringProvider connectionStringProvider = provider.GetRequiredService <IConnectionStringProvider>(); string connectionString = connectionStringProvider.GetConnectionString(typeof(TDbContext)); ScopedDictionary scopedDictionary = provider.GetRequiredService <ScopedDictionary>(); string key = $"DbConnection_{connectionString}"; DbConnection existingDbConnection = scopedDictionary.GetValue <DbConnection>(key); builder = driveHandler.Handle(builder, connectionString, existingDbConnection); //使用模型缓存 DbContextModelCache modelCache = provider.GetService <DbContextModelCache>(); IModel model = modelCache?.Get(dbContextType); if (model != null) { builder = builder.UseModel(model); } return(builder); }
/// <summary> /// /// </summary> /// <param name="args">[repository] [user collection name] [thread collection name] [target collection name]</param> /// <returns></returns> public async Task RunAsync(string[] args) { var repository = args[0]; var threadCollectionName = args[1]; var client = new MongoClient(_connectionStringProvider.GetConnectionString(string.Format("mongo:{0}", repository))); var database = client.GetDatabase(repository); var threadCollection = database.GetCollection <BsonDocument>(threadCollectionName); var list = await threadCollection.Find("{}").ToListAsync(); using (var scope = new EmitScope(new SqlConnection(_connectionStringProvider.GetConnectionString("EasIndexConnection")))) { list.ForEach(item => { ExtractInThread(item, scope); }); } }
public SqlConnectionProvider(IConnectionStringProvider connectionStringProvider, string connectionName) { _connectionString = connectionStringProvider.GetConnectionString(connectionName); }
public MSSQLDatabaseEngine(IConnectionStringProvider provider) { _connectionString = provider.GetConnectionString(); }