// "Server=localhost\\SQLEXPRESS;Database=master;Trusted_Connection=True;"
//Design-time DbContext Creation
//ToDo Docstings and Unit Tests
public BloodBowlAPIContext CreateDbContext(string[] args)
{
string environment = Environment.GetEnvironmentVariable("NETCORE_ENVIRONMENT");
var isDevelopment = string.IsNullOrEmpty(environment) || environment.ToLower() == "development";
var builder = new ConfigurationBuilder()
.SetBasePath(Path.Combine(Directory.GetCurrentDirectory(), "../BloodBowlAPI"))
.AddJsonFile("appsettings.json", optional: false)
.AddJsonFile($"appsettings.{environment}.json", optional: true);
if (isDevelopment)
{
builder.AddUserSecrets <BloodBowlAPIContextFactory>();
}
var configuration = builder.Build();
var optionsBuilder = new DbContextOptionsBuilder <BloodBowlAPIContext>();
//throw new Exception(configuration["Database.ConnectionString"]);
optionsBuilder.UseSqlServer(configuration["Database.ConnectionString"], b => b.MigrationsAssembly("BloodBowlMigrations"));
optionsBuilder.EnableDetailedErrors();
return(new BloodBowlAPIContext(optionsBuilder.Options));
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlServer("Server=localhost;Database=DopplerDB;Trusted_Connection=True;");
optionsBuilder.EnableDetailedErrors();
optionsBuilder.EnableSensitiveDataLogging();
base.OnConfiguring(optionsBuilder);
}
protected override void Load(ContainerBuilder builder)
{
#region DbContext Registrations
builder.Register(componentContext =>
{
var env = componentContext.Resolve <IWebHostEnvironment>();
bool isDevelopment = env.EnvironmentName == "Development";
var configuration = componentContext.Resolve <IConfiguration>();
var optionsBuilder = new DbContextOptionsBuilder <UserSqlDbContext>()
.UseNpgsql(configuration.GetReadStoreConnectionString(), option =>
{
option.MigrationsHistoryTable("EFMigrationsHistory");
});
optionsBuilder.EnableSensitiveDataLogging(!isDevelopment);
optionsBuilder.EnableDetailedErrors(isDevelopment);
var context = new UserSqlDbContext(optionsBuilder.Options);
context.Database.Migrate();
return(context);
}).AsSelf()
.AsImplementedInterfaces()
.InstancePerLifetimeScope();
#endregion
builder.RegisterType <PasswordService>().As <IPasswordService>().SingleInstance();
builder.RegisterType <UserRepository>().As <IUserRepository>().InstancePerLifetimeScope();
builder.RegisterType <UnitOfWork <IUserSqlDbContext> >().As <IUnitOfWork <IUserSqlDbContext> >().InstancePerLifetimeScope();
builder.RegisterType <UserDatabaseInitializer>().As <IUserDatabaseInitializer>().InstancePerDependency();
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.LogTo(Console.WriteLine, Microsoft.Extensions.Logging.LogLevel.Information);
optionsBuilder.EnableDetailedErrors();
optionsBuilder.EnableSensitiveDataLogging();
base.OnConfiguring(optionsBuilder);
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
base.OnConfiguring(optionsBuilder);
optionsBuilder.UseLazyLoadingProxies(); //启用延迟加载
optionsBuilder.LogTo(Console.WriteLine); //日志
optionsBuilder.EnableDetailedErrors(); //更详细的查询错误（以性能为代价）
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
// return if already configured (by mocking with InMemory provider)
if (optionsBuilder.IsConfigured)
{
return;
}
ConfigureConfiguration();
optionsBuilder
.UseNpgsql(
_configuration.GetConnectionString("PGSQL"),
npgsql => npgsql
.UseNodaTime()
.EnableRetryOnFailure(3)
.CommandTimeout(30)
.SetPostgresVersion(new Version(11, 2))
);
if (_environment == "Production")
{
return;
}
// Enable Sensitive data logging and detailed errors outside Production environment
optionsBuilder
.EnableDetailedErrors()
.EnableSensitiveDataLogging();
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
string connectionString = this.configuration.GetConnectionString("SqLiteConnection");
optionsBuilder.UseSqlite(connectionString);
optionsBuilder.EnableDetailedErrors();
}
/// <inheritdoc/>
protected override void OnConfiguring([NotNull] DbContextOptionsBuilder builder)
{
builder.UseMySql(UseSettings ? GetConnectionString() : RandomConnection());
builder.EnableDetailedErrors();
builder.EnableSensitiveDataLogging();
base.OnConfiguring(builder);
}
private static void DbContextOptionsBuilderAction(DbContextOptionsBuilder optionsBuilder)
=> optionsBuilder
.EnableDetailedErrors()
.EnableSensitiveDataLogging()
.UseSqlServer(
connectionString: Options.ConnectionString,
sqlServerOptionsAction: SqlServerOptionsAction);
#pragma warning restore CS8618 // Non-nullable field is uninitialized. Consider declaring as nullable.
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
// Use connection string if available
if (this._databaseOptions != null)
{
switch (this._databaseOptions.DatabaseProvider)
{
case DatabaseProvider.SqlServer:
optionsBuilder.UseSqlServer(this._databaseOptions.CreateConnectionString(), sql => sql.EnableRetryOnFailure());
break;
case DatabaseProvider.Sqlite:
SqliteConfigurator.ConfigureDbContext(optionsBuilder, this._databaseOptions);
break;
default:
throw new InvalidOperationException($"Invalid database provider: {this._databaseOptions.DatabaseProvider}");
}
}
// Error logging (DEBUG only)
#if DEBUG
optionsBuilder.EnableDetailedErrors();
optionsBuilder.EnableSensitiveDataLogging();
#endif
}
public void SetupBuilder(DbContextOptionsBuilder builder)
{
switch (databaseType)
{
case FakeDatabaseType.EFInMemory:
/* There are two ways to create distinct ef in-memory databases: by using InMemoryDatabaseRoot or ServiceProvider */
efInMemoryDatabaseRoot ??= new InMemoryDatabaseRoot();
builder.UseInMemoryDatabase(databaseName: "DataSource", efInMemoryDatabaseRoot);
//efServiceProvider ??= new ServiceCollection()
// .AddEntityFrameworkInMemoryDatabase()
// .BuildServiceProvider();
//builder.UseInMemoryDatabase("InMemoryDatabase");
//builder.UseInternalServiceProvider(efServiceProvider);
break;
case FakeDatabaseType.SQLiteInMemory:
sqliteConnection ??= new SqliteConnection("DataSource=:memory:");
sqliteConnection.Open();
builder.UseSqlite(sqliteConnection);
break;
case FakeDatabaseType.PostgreSQL:
string contextName = typeof(TContext).Name;
builder.UseNpgsql($"Host=localhost;Database=Test_{contextName};Username=TestMeDBUser;Password=TestMePass;");
break;
default:
throw new NotImplementedException();
}
builder.UseLoggerFactory(LoggerFactory);
builder.EnableDetailedErrors();
builder.EnableSensitiveDataLogging();
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlServer("Server=DESKTOP-9F6IC4T\\SQLEXPRESS;Database=RestaurantManagerDB;Trusted_Connection=True;");
optionsBuilder.UseLazyLoadingProxies();
optionsBuilder.EnableSensitiveDataLogging();
optionsBuilder.EnableDetailedErrors();
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
#if DEBUG
optionsBuilder.EnableSensitiveDataLogging();
optionsBuilder.EnableDetailedErrors();
#endif
}
public SqlServerDbProvider(IServiceProvider sp, DbServerOptions dbServerOptions)
{
var dbContextOptionsBuilder = new DbContextOptionsBuilder();
dbContextOptionsBuilder.EnableDetailedErrors(dbServerOptions.EnableDetailedErrors);
dbContextOptionsBuilder.EnableSensitiveDataLogging(dbServerOptions.EnableSensitiveDataLogging);
dbContextOptionsBuilder.UseSqlServer(
dbServerOptions.ConnectionString, c =>
{
c.EnableRetryOnFailure();
if (dbServerOptions.MaxBatchSize > 0)
{
c.MaxBatchSize(dbServerOptions.MaxBatchSize);
}
c.MigrationsAssembly(dbServerOptions.MigrationAssemblyName);
});
_sqlContext = (DbContext)ActivatorUtilities
.CreateInstance(sp,
Type.GetType(dbServerOptions.DbContextType) ?? throw new InvalidOperationException(), dbContextOptionsBuilder.Options);
//_sqlContext.Database.EnsureCreated();
_sqlContext.Database.Migrate();
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlServer(configuration["Doppler:DatabaseConnectionString"]);
optionsBuilder.EnableDetailedErrors();
optionsBuilder.EnableSensitiveDataLogging();
base.OnConfiguring(optionsBuilder);
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
base.OnConfiguring(optionsBuilder);
optionsBuilder
.EnableDetailedErrors(true)
.EnableSensitiveDataLogging(true);
}
private static DbContextOptions CreateContextOptions()
{
var dbContextOptionsBuilder = new DbContextOptionsBuilder <BloggingDataContext>();
// Detailed Errors Enabled
dbContextOptionsBuilder.EnableDetailedErrors();
// Sensitive Data Logging Enabled
dbContextOptionsBuilder.EnableSensitiveDataLogging();
// Sqlite EntityFrameworkCore Configuration
var connectionStringBuilder = new SqliteConnectionStringBuilder
{
DataSource = ":memory:"
};
var connectionString = connectionStringBuilder.ConnectionString;
var connection = new SqliteConnection(connectionString);
connection.Open();
dbContextOptionsBuilder.UseSqlite(connection);
var dbContextOptions = dbContextOptionsBuilder.Options;
return(dbContextOptions);
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
var server = Environment.GetEnvironmentVariable("Server");
var db = Environment.GetEnvironmentVariable("Database");
var uid = Environment.GetEnvironmentVariable("Uid");
var pwd = Environment.GetEnvironmentVariable("Pwd");
if (server == null || db == null || uid == null || pwd == null)
{
throw new Exception("Cannot find MySQL connection string in EnvVar.");
}
var connStr = new MySqlConnectionStringBuilder
{
Server = server,
Database = db,
UserID = uid,
Password = pwd
};
optionsBuilder.UseMySql(connStr.ToString());
optionsBuilder.UseLoggerFactory(LoggerFactory);
optionsBuilder.EnableDetailedErrors();
}
/// <summary>
///
/// </summary>
/// <param name="sp"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public override object GetInstance(IServiceProvider sp, params object[] parameters)
{
DbContext context = null;
try
{
DbContextOptionsBuilder <TContext> builder = new DbContextOptionsBuilder <TContext>();
this.OnDbContextOptionsBuilder(builder, parameters);
builder.UseApplicationServiceProvider(sp);
if (this.EnableDetailedErrors)
{
builder.EnableDetailedErrors();
}
if (this.EnableSensitiveDataLogging)
{
builder.EnableSensitiveDataLogging();
}
if (this.UseLoggerFactory)
{
builder.UseLoggerFactory(sp.GetRequiredService <ILoggerFactory>());
}
context = (DbContext)ActivatorUtilities.CreateInstance(sp, this.ImplementationType, builder.Options);
}
catch
{
throw new DbContextFactoryException(this.ImplementationType.FullName);
}
return(context);
}
protected override void OnConfiguring(DbContextOptionsBuilder builder)
{
//builder.UseLazyLoadingProxies().UseSqlite("Data Source=InfTest.db");
builder.UseLazyLoadingProxies().UseNpgsql("Host=localhost;Port=5432;Database=InfTest;Username=postgres;Password=postgres");
builder.EnableDetailedErrors();
builder.EnableSensitiveDataLogging();
}
internal static void ApplyOtherOptionSettings <T>(this DbContextOptionsBuilder <T> builder)
where T : DbContext
{
builder
.EnableDetailedErrors()
.EnableSensitiveDataLogging();
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseInMemoryDatabase(Guid.NewGuid().ToString());
optionsBuilder.EnableSensitiveDataLogging();
optionsBuilder.EnableDetailedErrors();
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
//optionsBuilder.UseNpgsql(HealthTrackerProcessorConstant.PostgresDBConnectionStr);
optionsBuilder.UseSqlite(HealthTrackerProcessorConstant.SQLiteDBConnectionStr);
optionsBuilder.EnableDetailedErrors();
base.OnConfiguring(optionsBuilder);
}
/// <summary>
/// OnConfiguring
/// </summary>
/// <param name="optionsBuilder"></param>
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
switch (DBType)
{
case DBTypeEnum.SqlServer:
try
{
var Configs = GlobalServices.GetRequiredService <Configs>();
if (Configs.IsOldSqlServer == true)
{
optionsBuilder.UseSqlServer(CSName, op => op.UseRowNumberForPaging());
}
else
{
optionsBuilder.UseSqlServer(CSName);
}
}
catch
{
optionsBuilder.UseSqlServer(CSName, op => op.UseRowNumberForPaging());
}
break;
case DBTypeEnum.MySql:
optionsBuilder.UseMySql(CSName);
break;
case DBTypeEnum.PgSql:
optionsBuilder.UseNpgsql(CSName);
break;
case DBTypeEnum.Memory:
optionsBuilder.UseInMemoryDatabase(CSName);
break;
case DBTypeEnum.SQLite:
optionsBuilder.UseSqlite(CSName);
break;
case DBTypeEnum.Oracle:
optionsBuilder.UseOracle(CSName);
break;
default:
break;
}
try
{
var Configs = GlobalServices.GetRequiredService <Configs>();//如果是debug模式,将EF生成的sql语句输出到debug输出
if (Configs.IsQuickDebug)
{
optionsBuilder.EnableDetailedErrors();
optionsBuilder.EnableSensitiveDataLogging();
optionsBuilder.UseLoggerFactory(LoggerFactory);
}
}
catch { }
base.OnConfiguring(optionsBuilder);
}
public DataContext CreateDbContext(string[] args)
{
var optionsBuilder = new DbContextOptionsBuilder<DataContext>();
optionsBuilder.UseSqlServer("Server=.\\SQLEXPRESS;Database=FrankBrewery;Integrated Security=true;");
optionsBuilder.EnableDetailedErrors();
optionsBuilder.EnableSensitiveDataLogging();
return new DataContext(optionsBuilder.Options);
}
public static void BuildDefaultOption(DbContextOptionsBuilder builder, string connectionString)
{
builder.EnableDetailedErrors(true);
builder.EnableSensitiveDataLogging(true);
builder.UseLazyLoadingProxies(false);
builder.UseQueryTrackingBehavior(QueryTrackingBehavior.TrackAll);
builder.UseNpgsql(connectionString);
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlite(ConnectionString);
optionsBuilder.EnableSensitiveDataLogging();
optionsBuilder.EnableDetailedErrors();
optionsBuilder.UseLoggerFactory(_myLoggerFactory);
base.OnConfiguring(optionsBuilder);
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.EnableDetailedErrors(true);
optionsBuilder.EnableSensitiveDataLogging(true);
//optionsBuilder.UseSqlServer("Server=localhost; Database=neopak2; Trusted_Connection=True; MultipleActiveResultSets=true");// _settings.ConnectionString, s => s.CommandTimeout(60));
optionsBuilder.UseSqlServer(_databaseSettings.ConnectionString);
optionsBuilder.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
}
protected override void OnConfiguring(DbContextOptionsBuilder options)
{
//添加是否开启ef日志的开关
options.EnableSensitiveDataLogging();
options.EnableDetailedErrors();
//注意:因为开启了ef执行日志，所以要注意Nlog日志记录时各参数的空判断
options.UseLoggerFactory(LoggerFactory);
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseLazyLoadingProxies(false);
optionsBuilder.EnableSensitiveDataLogging(true);
optionsBuilder.EnableDetailedErrors(true);
//optionsBuilder.UseSqlServer("server=172.20.4.20;database=manufacturing_inventory_dev;user=aelmendorf;password=Drizzle123!;MultipleActiveResultSets=true");
}
