private void ResourceStart() { MySqlInsightDbProvider.RegisterProvider(); _database = new SqlConnectionStringBuilder("server=localhost;user=root;database=newserver;port=3306;password=;"); _userRepository = _database.Connection().As <IUserRepository>(); }
static void SqlConnectionStringBuilder_Connection() { SqlConnectionStringBuilder database = new SqlConnectionStringBuilder(connectionString); // make other changes here // run a query right off the connection (this performs an auto-open/close) database.Connection().QuerySql("SELECT * FROM Beer", Parameters.Empty); }
private static void PerfTest() { SqlConnectionStringBuilder database = new SqlConnectionStringBuilder(connectionString); using (var connection = database.Connection()) { connection.Open(); var results = connection.QuerySql <PerfTestData>("SELECT Int=1, String='2', Decimal=3, [Double]=4"); PerformanceTest.WithDurationAndKeyWait(3, 1 * 1000, () => { results = connection.QuerySql <PerfTestData>("SELECT Int=1, String='2', Decimal=3, [Double]=4"); }); } }
// ReSharper disable once UnusedParameter.Local static async Task Main(string[] args) { var cfg = AppConfig.InitOptions <ApiClientOptions>("ApiClientOptions"); var apiClient = new ApiClient(cfg); var connectionString = AppConfig.GetConfiguration().GetConnectionString("fitdb"); var database = new SqlConnectionStringBuilder(connectionString); var partners = database.Connection() .QuerySql <PartnerRecord>("SELECT * FROM Common.Partners") .ToList(); Console.WriteLine($"Loaded {partners.Count}"); Console.WriteLine(); var response = await apiClient.GetEntityManagementDataUsingQueryAsync("(dbaName:'John Snow')"); Console.WriteLine($"Found {response?.TotalRecords ?? 0} registrations"); response?.EntityData.ForEach(entity => Console.WriteLine($"Entity: {entity.EntityRegistration.LegalBusinessName}")); Console.WriteLine(); partners.ForEach(partner => { try { response = apiClient.GetEntityManagementDataByDunsAsync(partner.DUNS).Result; if (response.EntityData.Any()) { Console.WriteLine($"Partner DUNS {partner.DUNS} has UEID {response.EntityData.First().EntityRegistration.UeiSAM}"); } else { Console.WriteLine($"Unable to find {partner.DUNS}"); } Thread.Sleep(new TimeSpan(0, 0, 0, 30)); } catch (Exception ex) { Console.WriteLine($"Exception with {partner.DUNS}: {ex.Message}"); } }); }
/// <summary> /// Reads the BizTalk configuration settings from the /// registry and the Management database. /// </summary> private void Initialize() { var callToken = TraceProvider.Logger.TraceIn(); try { TraceProvider.Logger.TraceInfo("Retrieving BizTalk administration settings from registry..."); // the BizTalk management database server and database names // are stored in the registry RegistryKey key = Registry.LocalMachine.OpenSubKey(BTS_ADMIN_REGISTRY_KEY); if (key != null) { string bizTalkMgmtDBServer = key.GetValue(BTS_MGMT_DB_SERVER_REGISTRY_KEY) as string; string bizTalkMgmtDBName = key.GetValue(BTS_MGMT_DB_NAME_REGISTRY_KEY) as string; if (String.IsNullOrEmpty(bizTalkMgmtDBServer) == false && String.IsNullOrEmpty(bizTalkMgmtDBName) == false) { TraceProvider.Logger.TraceInfo("BizTalk ManagementDB Server: {0}, Database Name: {1}", bizTalkMgmtDBServer, bizTalkMgmtDBName); // get the management db connection string this.btsMgmtConnectionString = String.Format(CONNECTION_STRING_FORMAT, bizTalkMgmtDBServer, bizTalkMgmtDBName); TraceProvider.Logger.TraceInfo("Retrieving additional BizTalk database settings..."); // using the management db connection string query for the other databases // database instace SqlConnectionStringBuilder database = new SqlConnectionStringBuilder(this.btsMgmtConnectionString); dynamic databasesInfo = database.Connection().QuerySql(GET_DATABASES_SQL, Parameters.Empty).SingleOrDefault(); if (databasesInfo != null) { this.btsMsgBoxConnectionString = String.Format(CONNECTION_STRING_FORMAT, databasesInfo.SubscriptionDBServerName, databasesInfo.SubscriptionDBName); this.btsBamConnectionString = String.Format(CONNECTION_STRING_FORMAT, databasesInfo.BamDBServerName, databasesInfo.BamDBName); this.btsTrackingConnectionString = String.Format(CONNECTION_STRING_FORMAT, databasesInfo.TrackingDBServerName, databasesInfo.TrackingDBName); } } } } catch (Exception ex) { TraceProvider.Logger.TraceError(ex); throw ex; } finally { TraceProvider.Logger.TraceOut(callToken); } }
/// <summary> /// Asynchronously opens and returns a database connection implementing a given interface. /// </summary> /// <typeparam name="T">The interface to implmement.</typeparam> /// <param name="builder">The connection string to open and return.</param> /// <param name="cancellationToken">The cancellation token to use for the operation.</param> /// <returns>The opened connection.</returns> public static Task <T> OpenAsAsync <T>(this SqlConnectionStringBuilder builder, CancellationToken cancellationToken = default(CancellationToken)) where T : class, IDbConnection { return(builder.Connection().OpenAsAsync <T>(cancellationToken)); }
/// <summary> /// Opens and returns a database connection implementing a given interface. /// </summary> /// <typeparam name="T">The interface to implmement.</typeparam> /// <param name="builder">The connection string to open and return.</param> /// <returns>The opened connection.</returns> public static T OpenAs <T>(this SqlConnectionStringBuilder builder) where T : class, IDbConnection { return(builder.Connection().OpenAs <T>()); }
/// <summary> /// Opens and returns a database connection. /// </summary> /// <param name="builder">The connection string to open and return.</param> /// <returns>The opened connection.</returns> public static Task <SqlConnection> OpenAsync(this SqlConnectionStringBuilder builder) { return(builder.Connection().OpenConnectionAsync()); }
/// <summary> /// Opens and returns a database connection. /// </summary> /// <param name="builder">The connection string to open and return.</param> /// <returns>The opened connection.</returns> public static SqlConnection Open(this SqlConnectionStringBuilder builder) { return(builder.Connection().OpenConnection()); }
/// <summary> /// Creates and returns a new DbConnection for the connection string and implments the given interface. /// </summary> /// <typeparam name="T">The interface to implement on the connection.</typeparam> /// <param name="builder">The SqlConnectionStringBuilder containing the connection string.</param> /// <returns>A closed connection.</returns> public static T As <T>(this SqlConnectionStringBuilder builder) where T : class { return(builder.Connection().As <T>()); }
/// <summary> /// Asynchronously opens a database connection and begins a new transaction that is disposed when the returned object is disposed. /// </summary> /// <param name="builder">The builder for the connection.</param> /// <param name="cancellationToken">The cancellation token to use for the operation.</param> /// <returns>A task returning a connection when the connection has been opened.</returns> public static Task <DbConnectionWrapper> OpenWithTransactionAsync(this SqlConnectionStringBuilder builder, CancellationToken cancellationToken = default(CancellationToken)) { return(builder.Connection().OpenWithTransactionAsync(cancellationToken)); }
/// <summary> /// Opens a database connection and begins a new transaction that is disposed when the returned object is disposed. /// </summary> /// <param name="builder">The builder for the connection.</param> /// <returns>A wrapper for the database connection.</returns> public static DbConnectionWrapper OpenWithTransaction(this SqlConnectionStringBuilder builder) { return(builder.Connection().OpenWithTransaction()); }
static void Execute() { Beer beer = new Beer() { Name = "IPA" }; // map a beer the stored procedure parameters Database.Connection().Insert("InsertBeer", beer); // map an anonymous object to the stored procedure parameters Database.Connection().Execute("DeleteBeer", beer); }
private IBookSqlDal GetBookSqlDal() { return(_builder.Connection().As <IBookSqlDal>()); }
/// <summary> /// Asynchronously opens a database connection implementing a given interface, and begins a new transaction that is disposed when the returned object is disposed. /// </summary> /// <typeparam name="T">The interface to implement.</typeparam> /// <param name="builder">The builder for the connection.</param> /// <param name="cancellationToken">The cancellation token to use for the operation.</param> /// <returns>A task returning a connection when the connection has been opened.</returns> public static Task <T> OpenWithTransactionAsAsync <T>(this SqlConnectionStringBuilder builder, CancellationToken?cancellationToken = null) where T : class, IDbConnection, IDbTransaction { return(builder.Connection().OpenWithTransactionAsAsync <T>(cancellationToken)); }
/// <summary> /// Opens a database connection and begins a new transaction with the specified isolation level that is disposed when the returned object is disposed. /// </summary> /// <param name="builder">The builder for the connection.</param> /// <param name="isolationLevel">The isolationLevel for the transaction.</param> /// <returns>A wrapper for the database connection.</returns> public static DbConnectionWrapper OpenWithTransaction(this SqlConnectionStringBuilder builder, IsolationLevel isolationLevel) { return(builder.Connection().OpenWithTransaction(isolationLevel)); }