public async Task <bool> TestDbConnection() { try { var optionsBuilder = new DbContextOptionsBuilder <KntDbContext>(); if (_repositoryRef.Provider == "Microsoft.Data.SqlClient") { optionsBuilder.UseSqlServer(_repositoryRef.ConnectionString); } else if (_repositoryRef.Provider == "Microsoft.Data.Sqlite") { optionsBuilder.UseSqlite(_repositoryRef.ConnectionString); optionsBuilder.ConfigureWarnings(x => x.Ignore(RelationalEventId.AmbientTransactionWarning)); } else { return(false); } var dbContext = new KntDbContext(optionsBuilder.Options, false); var systemValues = new KntSystemValuesRepository(dbContext, _repositoryRef); var res = await systemValues.GetAllAsync(); if (!res.IsValid) { return(false); } } catch (Exception) { return(false); } return(true); }
public static DbContextOptionsBuilder UseSerilog(this DbContextOptionsBuilder optionsBuilder, ILoggerFactory loggerFactory, bool throwOnQueryWarnings = false) { optionsBuilder.UseLoggerFactory(loggerFactory); optionsBuilder.ConfigureWarnings(warnings => { warnings.Log(RelationalEventId.TransactionError); if (!throwOnQueryWarnings) { //warnings.Throw(RelationalEventId.QueryClientEvaluationWarning); warnings.Throw(RelationalEventId.QueryPossibleExceptionWithAggregateOperatorWarning); warnings.Throw(RelationalEventId.QueryPossibleUnintendedUseOfEqualsWarning); } else { //warnings.Log(RelationalEventId.QueryClientEvaluationWarning); warnings.Log(RelationalEventId.QueryPossibleExceptionWithAggregateOperatorWarning); warnings.Log(RelationalEventId.QueryPossibleUnintendedUseOfEqualsWarning); } }); return(optionsBuilder); }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { var siteSettingsValue = SiteSettings.Value; siteSettingsValue.CheckArgumentIsNull(nameof(siteSettingsValue)); var connectionString = siteSettingsValue.GetDbConnectionString(HostingEnvironment.WebRootPath); switch (siteSettingsValue.ActiveDatabase) { case ActiveDatabase.InMemoryDatabase: optionsBuilder.UseInMemoryDatabase(); break; case ActiveDatabase.LocalDb: case ActiveDatabase.SqlServer: optionsBuilder.UseSqlServer( connectionString , serverDbContextOptionsBuilder => { var minutes = (int)TimeSpan.FromMinutes(3).TotalSeconds; serverDbContextOptionsBuilder.CommandTimeout(minutes); serverDbContextOptionsBuilder.EnableRetryOnFailure(); }); break; default: throw new NotSupportedException("Please set the ActiveDatabase in appsettings.json file."); } optionsBuilder.ConfigureWarnings(warnings => { warnings.Log(CoreEventId.IncludeIgnoredWarning); }); }
public void Init() { var container = new Container(); container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle(); var mockIdentityContext = new MockIdentityContext(); container.RegisterSingleton <IIdentityContext>(mockIdentityContext); container.Register <DbContext>(() => { var options = new DbContextOptionsBuilder <DbContext>(); options.ConfigureWarnings(x => x.Ignore(InMemoryEventId.TransactionIgnoredWarning)); options.UseInMemoryDatabase(Guid.NewGuid().ToString()); return(new DataContext(mockIdentityContext, options.Options)); }, Lifestyle.Scoped); container.ConfigureCore(null); Container = container; container.Register(typeof(IValidator <>), new[] { typeof(AssemblySetup).Assembly }); container.Register(typeof(IRequestHandler <,>), new[] { typeof(AssemblySetup).Assembly }); AutoMapperConfiguration.Configure(typeof(AssemblySetup).Assembly); FluentValidationConfiguration.Configure(); }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { optionsBuilder.ConfigureWarnings(builder => builder.Ignore(InMemoryEventId.TransactionIgnoredWarning)); optionsBuilder.UseInMemoryDatabase(Guid.NewGuid().ToString()); base.OnConfiguring(optionsBuilder); }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { if (optionsBuilder.IsConfigured) { return; } optionsBuilder.ConfigureWarnings(warnings => warnings.Throw(CoreEventId.IncludeIgnoredWarning)); switch (this.Provider) { case DatabaseProvider.PostgreSQL: optionsBuilder.UseNpgsql(this.ConnectionString); break; case DatabaseProvider.SQLite: optionsBuilder.UseSqlite(this.ConnectionString); break; case DatabaseProvider.SQLServer: optionsBuilder.UseSqlServer(this.ConnectionString); break; default: throw new NotSupportedException("Provider not supported!"); } }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { optionsBuilder.UseSqlServer(_connectionString); optionsBuilder.ConfigureWarnings(x => { x.Ignore(); }); base.OnConfiguring(optionsBuilder); }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { optionsBuilder.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking); optionsBuilder.ConfigureWarnings(warnings => warnings.Throw(RelationalEventId.QueryClientEvaluationWarning)); base.OnConfiguring(optionsBuilder); }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { base.OnConfiguring(optionsBuilder); optionsBuilder.UseLoggerFactory(_loggerFactory); optionsBuilder.ConfigureWarnings(warnings => warnings.Ignore(CoreEventId.ContextInitialized)); OnCayaConfiguring(optionsBuilder); }
public virtual KntDbContext GetOpenConnection() { if (SingletonConnection != null) { return(SingletonConnection); } var optionsBuilder = new DbContextOptionsBuilder <KntDbContext>(); if (_repositoryRef.Provider == "Microsoft.Data.SqlClient") { optionsBuilder.UseSqlServer(_repositoryRef.ConnectionString); } else if (_repositoryRef.Provider == "Microsoft.Data.Sqlite") { optionsBuilder.UseSqlite(_repositoryRef.ConnectionString); // Entity framework core for Sqlite no support AmbientTransaction optionsBuilder.ConfigureWarnings(x => x.Ignore(RelationalEventId.AmbientTransactionWarning)); } else { throw new Exception("Data provider not suported (KntEx)"); } return(new KntDbContext(optionsBuilder.Options)); }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { optionsBuilder.UseSqlServer(ConnectionString); optionsBuilder.ConfigureWarnings(x => x.Ignore(new Microsoft.Extensions.Logging.EventId[] { RelationalEventId.AmbientTransactionWarning })); base.OnConfiguring(optionsBuilder); }
private static void ConfigureDbContext( IServiceProvider p, DbContextOptionsBuilder o, bool enableCaching, Action <IServiceProvider, DbContextOptionsBuilder> customOptionsAction) { var appContext = p.GetRequiredService <IApplicationContext>(); var appConfig = appContext.AppConfiguration; var dbFactory = DataSettings.Instance.DbFactory; o = dbFactory.ConfigureDbContext(o, DataSettings.Instance.ConnectionString, appContext); o.ConfigureWarnings(w => { // EF throws when query is untracked otherwise w.Ignore(CoreEventId.DetachedLazyLoadingWarning); // To identify the query that's triggering MultipleCollectionIncludeWarning. //w.Throw(RelationalEventId.MultipleCollectionIncludeWarning); //w.Ignore(RelationalEventId.MultipleCollectionIncludeWarning); }); if (enableCaching) { o.UseSecondLevelCache(); } // Custom action from module or alike customOptionsAction?.Invoke(p, o); }
public AxwayHomeworkAppContext CreateDbContext(string[] args) { //var configuration = new ConfigurationBuilder() // .SetBasePath(Directory.GetCurrentDirectory()) // .AddJsonFile($"appsettings.json", optional: false, reloadOnChange: true) // .Build(); TODO: // Need to fix the specific path for appssetings file . Error i get when trying to add migration - // The configuration file 'appsettings.json' was not found and is not optional. The physical path is .. " var builder = new DbContextOptionsBuilder <AxwayHomeworkAppContext>(); var connectionString = "Server=DESKTOP-F8FBRNH\\SQLEXPRESS;Database=AxwayHomeworkApp;Integrated Security=True;"; //var connectionString = "Server=DESKTOP-F8FBRNH\\SQLEXPRESS;Database=AxwayHomeworkApp;Integrated Security=True;"; builder.UseSqlServer(connectionString); // Stop client query evaluation builder.ConfigureWarnings(w => w.Throw(RelationalEventId.QueryClientEvaluationWarning)); return(new AxwayHomeworkAppContext(builder.Options)); }
public StoreContext CreateDbContext(string[] args) { var optionsBuilder = new DbContextOptionsBuilder <StoreContext>(); #if SQL2017 //use sqllocaldb to update/create localdb instances var path = Environment.GetEnvironmentVariable("APPDATA"); var connectionString = $@"Data Source=(localdb)\mssqllocaldb2017;Initial Catalog=SpyStore2.2_2017;Trusted_Connection=True;MultipleActiveResultSets=true;AttachDbFileName={path}\SpyStore2.2_2017.mdf;"; #elif LOCALDB var connectionString = @"Server=(localdb)\mssqllocaldb;Database=SpyStoreHol;Trusted_Connection=True;MultipleActiveResultSets=true;"; #else var connectionString = @"Server=.,6433;Database=SpyStoreHol;User ID=sa;Password=P@ssw0rd;MultipleActiveResultSets=true;"; #endif //optionsBuilder // .UseSqlServer(connectionString, options => options.EnableRetryOnFailure()); optionsBuilder .UseSqlServer(connectionString); optionsBuilder .ConfigureWarnings(warnings => warnings.Throw(RelationalEventId.QueryClientEvaluationWarning)); Console.WriteLine(connectionString); return(new StoreContext(optionsBuilder.Options)); }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { if (optionsBuilder.IsConfigured) { return; } //optionsBuilder.EnableSensitiveDataLogging(true); //optionsBuilder.UseLazyLoadingProxies(); //optionsBuilder.ConfigureWarnings(wb => wb.Ignore(CoreEventId.DetachedLazyLoadingWarning)); optionsBuilder.ConfigureWarnings(warnings => warnings.Throw(CoreEventId.IncludeIgnoredWarning)); switch (this.Provider) { case DatabaseProvider.PostgreSQL: optionsBuilder.UseNpgsql(this.ConnectionString); break; case DatabaseProvider.SQLite: optionsBuilder.UseSqlite(this.ConnectionString); break; case DatabaseProvider.SQLServer: optionsBuilder.UseSqlServer(this.ConnectionString); break; default: throw new NotSupportedException("Provider not supported!"); } }
public static void UseConfiguredSqLite ( this DbContextOptionsBuilder optionsBuilder, AppSettings appSettings, IServiceProvider serviceProvider) { var connectionString = appSettings.GetSQLiteDbConnectionString(); optionsBuilder.UseSqlite ( connectionString, sqlServerOptionsBuilder => { sqlServerOptionsBuilder.CommandTimeout((int)TimeSpan.FromMinutes(3).TotalSeconds); sqlServerOptionsBuilder.MigrationsAssembly(typeof(SqLiteServiceCollectionExtensions).Assembly .FullName); } ); optionsBuilder.UseInternalServiceProvider(serviceProvider); // It's added to access services from the dbcontext, remove it if you are using the normal `AddDbContext` and normal constructor dependency injection. optionsBuilder.AddInterceptors(new PersianYeKeCommandInterceptor()); optionsBuilder.ConfigureWarnings(warnings => { // ... }); }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { optionsBuilder. ConfigureWarnings(warn => warn.Ignore(InMemoryEventId.TransactionIgnoredWarning)); base.OnConfiguring(optionsBuilder); }
/// <inheritdoc /> protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { base.OnConfiguring(optionsBuilder); #if DEBUG optionsBuilder.ConfigureWarnings(warnings => warnings.Throw(RelationalEventId.QueryClientEvaluationWarning)); #endif }
/// <summary> /// Configure context options<br/> /// 配置上下文选项<br/> /// </summary> /// <param name="optionsBuilder">Options builder</param> protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { var pathConfig = Application.Ioc.Resolve <LocalPathConfig>(); if (string.Compare(DatabaseName, "MSSQL", true) == 0) { optionsBuilder.UseSqlServer( ConnectionString, option => option.UseRowNumberForPaging()); } else if (string.Compare(DatabaseName, "SQLite", true) == 0) { optionsBuilder.UseSqlite( ConnectionString.Replace("{{App_Data}}", pathConfig.AppDataDirectory)); } else if (string.Compare(DatabaseName, "MySQL", true) == 0) { optionsBuilder.UseMySql(ConnectionString); } else if (string.Compare(DatabaseName, "PostgreSQL", true) == 0) { optionsBuilder.UseNpgsql(ConnectionString); } else if (string.Compare(DatabaseName, "InMemory", true) == 0) { optionsBuilder.UseInMemoryDatabase( string.IsNullOrEmpty(ConnectionString) ? GuidUtils.SequentialGuid(DateTime.UtcNow).ToString() : ConnectionString); } else { throw new ArgumentException($"unsupported database type {Database}"); } // EF 2.0 make some warnings as error, just ignore them optionsBuilder.ConfigureWarnings(w => w.Ignore(CoreEventId.IncludeIgnoredWarning)); }
public static void SetDbContextOptions( this DbContextOptionsBuilder optionsBuilder, SiteSettings siteSettings) { switch (siteSettings.ActiveDatabase) { case ActiveDatabase.InMemoryDatabase: optionsBuilder.UseInMemoryDatabase(siteSettings.ConnectionStrings.LocalDb.InitialCatalog); break; case ActiveDatabase.LocalDb: case ActiveDatabase.SqlServer: optionsBuilder.UseSqlServer( siteSettings.GetDbConnectionString() , serverDbContextOptionsBuilder => { var minutes = (int)TimeSpan.FromMinutes(3).TotalSeconds; serverDbContextOptionsBuilder.CommandTimeout(minutes); serverDbContextOptionsBuilder.EnableRetryOnFailure(); }); break; default: throw new NotSupportedException("Please set the ActiveDatabase in appsettings.json file."); } optionsBuilder.ConfigureWarnings(warnings => { warnings.Log(CoreEventId.IncludeIgnoredWarning); warnings.Log(RelationalEventId.QueryClientEvaluationWarning); }); }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { optionsBuilder.ConfigureWarnings(warn => warn.Ignore(CoreEventId.DetachedLazyLoadingWarning)); base.OnConfiguring(optionsBuilder); }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { optionsBuilder.ConfigureWarnings(w => w.Ignore(RelationalEventId.AmbientTransactionWarning)); optionsBuilder.UseSqlite(new SqliteConnectionStringBuilder { DataSource = "test.db" }.ConnectionString); }
public void OnConfiguring(DbContextOptionsBuilder optionsBuilder, DbConnection dbConnectionForReusing) { switch (_dataBaseOption.DbType) { case Easy.DbTypes.MsSql: { if (dbConnectionForReusing != null) { optionsBuilder.UseSqlServer(dbConnectionForReusing); } else { optionsBuilder.UseSqlServer(_dataBaseOption.ConnectionString); } break; } case Easy.DbTypes.MsSqlEarly: { if (dbConnectionForReusing != null) { optionsBuilder.UseSqlServer(dbConnectionForReusing, option => option.UseRowNumberForPaging()); } else { optionsBuilder.UseSqlServer(_dataBaseOption.ConnectionString, option => option.UseRowNumberForPaging()); } break; } case Easy.DbTypes.Sqlite: { if (dbConnectionForReusing != null) { optionsBuilder.UseSqlite(dbConnectionForReusing); } else { optionsBuilder.UseSqlite(_dataBaseOption.ConnectionString); } break; } case Easy.DbTypes.MySql: { if (dbConnectionForReusing != null) { optionsBuilder.UseMySql(dbConnectionForReusing); } else { optionsBuilder.UseMySql(_dataBaseOption.ConnectionString); } break; } } optionsBuilder.ConfigureWarnings(warnings => warnings.Throw(RelationalEventId.QueryClientEvaluationWarning)); optionsBuilder.UseLoggerFactory(_loggerFactory); }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { optionsBuilder.ConfigureWarnings(warnings => { warnings.Throw(CoreEventId.ManyServiceProvidersCreatedWarning); }); }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { optionsBuilder.UseInMemoryDatabase("test"); optionsBuilder.ConfigureWarnings(warningOptions => { warningOptions.Ignore(CoreEventId.ManyServiceProvidersCreatedWarning); }); }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { optionsBuilder .UseSqlite($"Data Source={dbConfig.DatabaseName};"); optionsBuilder.ConfigureWarnings(x => x.Ignore(RelationalEventId.AmbientTransactionWarning)); }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { base.OnConfiguring(optionsBuilder); // Suppresses a warning about DbContext.Genres.Select(g => g.Name).Take(9).ToListAsync() optionsBuilder.ConfigureWarnings(w => w.Ignore(CoreEventId.RowLimitingOperationWithoutOrderByWarning)); }
protected override void OnConfiguring(DbContextOptionsBuilder builder) { //CUI.Print($"WWWingsContext #{num:00}: OnConfiguring", ConsoleColor.Magenta); //CUI.Print("WWWingsContext # " + num + ": OnConfiguring", ConsoleColor.Blue); // Provider und Connectring String festlegen! //if (this._DbConnection != null) builder.UseSqlServer(this._DbConnection); //else builder.UseSqlServer(ConnectionString); if (_DbConnection != null) { builder.UseSqlServer(_DbConnection); } else { builder.UseSqlServer(ConnectionString); } //builder.UseOracle(@"User ID=System; Password=sa+123; Direct=true; Host=localhost; SID=OraDoc; Port=1521;"); // at client evaluation force exception! //builder.ConfigureWarnings(warnings => warnings.Throw(RelationalEventId.QueryClientEvaluationWarning)); builder.ConfigureWarnings(warnings => warnings.Ignore(RelationalEventId.AmbientTransactionWarning)); // Optional: print extensions //foreach (var extension in builder.Options.Extensions) //{ // Console.WriteLine("Aktive option: " + extension); //} //Other stores, e.g. //builder.UseInMemoryStore(); }
private static void _ConfigureCommon(this DbContextOptionsBuilder optionsBuilder) { // Changing default behavior when client evaluation occurs to throw. // Default in EF Core would be to log a warning when client evaluation is performed. optionsBuilder.ConfigureWarnings(warnings => warnings.Throw(RelationalEventId.QueryClientEvaluationWarning)); //Check Client vs. Server evaluation: https://docs.microsoft.com/en-us/ef/core/querying/client-eval }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { base.OnConfiguring(optionsBuilder); optionsBuilder.ConfigureWarnings(warningOptions => { warningOptions.Ignore(CoreEventId.ManyServiceProvidersCreatedWarning); }); if (UseSqlLiteConnection != null) { optionsBuilder.UseSqlite(UseSqlLiteConnection); } else { optionsBuilder.UseInMemoryDatabase("test"); } optionsBuilder.UseTriggers(triggerOptions => { triggerOptions.AddTrigger(TriggerStub); }); if (_stubService) { optionsBuilder.ReplaceService <ITriggerService, TriggerServiceStub>(); } }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { // options.UseSqlServer(@"Data Source=.\SQL2014;Initial Catalog=POC_DDD;Integrated Security=False;User ID=srvelicheti;Password=Secret@123;MultipleActiveResultSets=true;Trusted_Connection=true;"); //.SuppressAmbientTransactionWarning(); //var extension = new SqlServerOptionsExtension(options.Options.GetExtension<SqlServerOptionsExtension>()) //{ // ThrowOnAmbientTransaction = false // }; //var optionsBuilder = new Microsoft.EntityFrameworkCore.DbContextOptionsBuilder(); //var extension = // new SqlServerOptionsExtension(optionsBuilder.Options.GetExtension<SqlServerOptionsExtension>()); //extension optionsBuilder.ConfigureWarnings(x => x.Ignore(RelationalEventId.AmbientTransactionWarning)); //((IDbContextOptionsBuilderInfrastructure)optionsBuilder).AddOrUpdateExtension(extension); //var ex = new RelationalEventId //{ //}; }
protected override DbContextOptionsBuilder ConfigureOptions( DbContextOptionsBuilder dbContextOptionsBuilder) => dbContextOptionsBuilder.ConfigureWarnings(c => c.Throw(RelationalEventId.QueryClientEvaluationWarning));
protected override DbContextOptionsBuilder ConfigureOptions(DbContextOptionsBuilder dbContextOptionsBuilder) => dbContextOptionsBuilder.ConfigureWarnings(c => c.Default(WarningBehavior.Throw));