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