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));
}
