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