/// <summary>
/// this help in frequent updating of database each time a new migration is done
/// It help to apply a new database if it does't exist
/// </summary>
/// <param name="args"></param>
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
// this mean once the method in it is done with its task it get disposed
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occur during migration");
}
}
host.Run();
}
public async static Task Main(string[] args)
{
//outside scope of services container
//no control over lifetime of this instance ofcontext
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var serviceProvider = scope.ServiceProvider;
var loggerFactory = serviceProvider.GetRequiredService <ILoggerFactory>();
try
{
var context = serviceProvider.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "Failed to migrate/create db using dotnet core migrations.");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
//CreateHostBuilder(args).Build().Run(); original only line
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try {
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An Error occured during migration");
}
}
host.Run();
/*
* we need to do is go and get access to our datacontext but what we can do is because we're outside of our services container
* in the startup class where we don't have control over the lifetime of when we create this particular instance of our context
* we're going to see this inside a "using" statement and a using statement means that any code that runs inside of this is going to be disposed of as soon as
* we've finished with the methods inside that we don't need to worry about cleaning up after ourselves
* and because we're not relying on asp.net core to handle the lifetime of when this is created and disposed We need to do this inside of a a using statement.
*
*/
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
// Get access to data context, outside of the startup class.
using (var scope = host.Services.CreateScope())
{
var Services = scope.ServiceProvider;
var loggerFactory = Services.GetRequiredService <ILoggerFactory>();
// We're outisde of startup so we need to catch any exceptions.
try
{
var context = Services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
// Seed and migrate identity context.
var userManager = Services.GetRequiredService <UserManager <AppUser> >();
var identityContext = Services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUserAsync(userManager);
}
catch (Exception ex)
{
// Create instance of the logger, need to specify the class we are logging against.
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var logger = services.GetRequiredService <ILogger <Program> >();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, services.GetRequiredService <ILoggerFactory>());
}
catch (Exception e)
{
logger.LogError($"{e.Message} {e}");
}
}
await host.RunAsync();
}
public static async Task Main(string[] args)
{
// override method to apply migrations
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync(); // create database if not exists
await StoreContextSeed.SeedAsync(context, loggerFactory); // seed db with data
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
identityContext.Database.Migrate();
await AppIdentityDbContextSeed.SeedUsersAsync(userManager);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An errror occured during migrations");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = scope.ServiceProvider.GetRequiredService <ILoggerFactory> ();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
//context.Database.ExecuteSqlCommand("SET IDENTITY_INSERT ProductBrands ON");
await StoreContextSeed.SeedAsync(context, loggerFactory);
//context.Database.ExecuteSqlCommand("SET IDENTITY_INSERT ProductBrands OFF");
//context.Database.ExecuteSqlCommand("SET IDENTITY_INSERT ProductTypes OFF");
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
host.Run();
}
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
////the settings for doing migration and database creation when we run the application
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
//now seed data if data not there in table. already added logic in storecontextseed class
await StoreContextSeed.SeedAsync(context, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
//////////////////////////////////////////////////////////////////////////////////////
host.Run();
}
public static async Task Main(string[] args)
{
//creates a host for the server kestrel server
//configures default loggin, read in app.setting
// What microsoft recommends
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
//exception handling
try
{
var context = services.GetRequiredService <StoreContext>();
//Will create the database if it does not exist!
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
}
catch (Exception ex)
{// if Will create the database if it does not exist! GOES WRONG THEN LOG AN ERROR
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration!");
}
}
host.Run();
}
// DB is gonna be created when we start the App (no manual migrations are required)
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
// Getting access to our DataContext (because we are outside "services container" in the startup.cs)
// using {} - to control over the lifetime of the instance of DataContext.
using (var scope = host.Services.CreateScope())
{
// get our services to resolve dependencies from the scope.
var services = scope.ServiceProvider;
// register a service to log information out into the console
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
// handle any exceptions manually (since we're outside Startup.cs)
try
{
var context = services.GetRequiredService <StoreContext>();
// apply any pending (ожидаемые) migrations for the context to the DB & create DB if it doesn't exist
await context.Database.MigrateAsync();
// seed the data into the DB
await StoreContextSeed.SeedAsync(context, loggerFactory);
}
catch (Exception ex)
{
// create the instance of the logger service (Program - the class that we wanna log against)
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
// assign createHostBuider to a variable and remove '.Run()
var host = CreateHostBuilder(args).Build();
// code inside the 'using' will be disposed afterwards
using (var scope = host.Services.CreateScope()) // createScope for the lifetime
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
// run host to execute
host.Run();
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
// Allow us to create instances of the logger class
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
// Apply pending migrations to the DB & or create DB
// We are using migrations that we have
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured while migrating the database");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
#region 3.27 Applying migrations and updating database
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync(); //applyes pending migrations
//3.28.2 Adding Seed method ->
await StoreContextSeed.SeedAsync(context, loggerFactory);
#region 15.167 Seeding data and automatic migrations for identity -> AccountController
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUserAsync(userManager);
#endregion
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
host.Run();
#endregion
}
public static async Task Main(string[] args)
{
//Here we will generate the database if it was not generated yet and we will also migrate the new changes
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUserAsync(userManager);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred during migation");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
// adiciona migrations pendentes ou cria a BD no caso de ainda nao existir
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "Ocorreu um erro durante a migration");
}
}
host.Run();
}
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
StoreContextSeed.SeedAsync(context, loggerFactory).Wait();
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var IdentityContext = services.GetRequiredService <AppIdentityDbContext>();
AppIdentityDbContextSeed.SeedUsersAsync(userManager).Wait();
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
// CreateHostBuilder(args).Build().Run();
//this is changed from the upper line because
//this will automatically make the database if
//it isn't already made
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred during migration");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
// uso el using porque esta wea no tiene inyeccion de dependencias asi que asi nos aseguramos que al arrancar la app se saquen alv los
// recursos utilizados para crear las migraciones y actualizar la bd
using (var scope = host.Services.CreateScope()) {
// hace referencia a los servicios
var services = scope.ServiceProvider;
// crear un logger para hacer los logs si hay pedos
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try {
// crea el contexto de tipo StoreContext que es la clase que cree que trae todo el contexto de las conexiones a las bd
var context = services.GetRequiredService <StoreContext>();
// crea las migraciones y crea la bd
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
}catch (Exception ex) {
// si hay pedos hace los logs
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError("An error ocurred during migrations!");
}
// despues de esto arranca la app
host.Run();
}
}
public static async Task Main(string[] args)
{
//CreateHostBuilder(args).Build().Run(); // migration yapısı için kendimiz ozel olarak degistirdik.
// Eklenen migration varsa burda direk db ye otomatik olarak migrate eder
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory); // SeedDatayı yükler
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
host.Run();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
await StoreContextSeed.SeedAsync(context, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex.Message);
}
finally
{
host.Run();
}
}
}
//async 가 오면 다음에 Task를 해줘야 한다
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
//asp.net이 라이프타임을 관리안해주기 때문에 이거는 using을 써줘야한다
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
//프로그램에는 에러핸들링하는게 없기 때문에 트라이캣치를 써준다
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUserAsync(userManager);
}
catch (System.Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migrations");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
//CreateHostBuilder(args).Build().Run();
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUsersAsync(userManager);
}
catch (System.Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "هنگام ایجاد دیتابیس خطایی رخ داده است");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
//Insted of using the command of dotnet ef database update, we will create our databse inside our main method here
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
//Because we are out of StartUp class which means we are not gonna have any exception handling where we are now, so we will add try{} catch{}
try
{
var context = services.GetRequiredService <StoreContext>();
//This method MigrateAsync() is what we are looking for, because we 've dropped our databse and we 've got a migration(InitialCreate) and when we start our application then we want to create our database using any migrations that we have
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUsersAsync(userManager);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>(); //We specify the class that we want to log against
logger.LogError(ex, "An error occured during migration");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
//olası hataları yakalamak ıcın logger factory servisi çağırılıyor. catch blogunda da olası hata durumunda hata geliştiriciye gösteriliyor.
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
//alttaki kod migration oluşturulacak context'i bulup context değişkenine atıyor.
var context = services.GetRequiredService <StoreContext>();
//üst tarafta açıklanan context ile data base oluşturmak için bağlantı adresi nokta database nokta migration kullanılıyor tabiki işlemin süresi boyunca program durdurulmaması için async olarak yapılıyor.
await context.Database.MigrateAsync();
//Burada hazır verileri data base e yolluyoruz.
await StoreContextSeed.SeedAsync(context, loggerFactory);
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred during migration");
}
}
host.Run();
}
//Video 27
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
/* We want when we start the app then we want
* to create our database using any migrations that
* we have. */
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUserAsync(userManager);
} catch (Exception ex) {
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "an error occured during migration");
}
}
host.Run();
}
//public static async void Main(string[] args)
public static async Task Main(string[] args)
{
//CreateHostBuilder(args).Build().Run();
var host = CreateHostBuilder(args).Build();
// benefit of using dispose after use
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
// Create the database if it is not exicst
await context.Database.MigrateAsync();
// Seeddata
await StoreContextSeed.SeedAsync(context, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occure during Migration");
}
}
host.Run();
}
public async static Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error ocurred during migrations!");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
//CreateHostBuilder(args).Build().Run();
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope()) // using is a run once only conditional where methods run here are disposed of immediately after use
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>(); // we create an instance of the LoggerFactory class
try {
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync(); // applies pending migrations to database or create database if it does not exist
await StoreContextSeed.SeedAsync(context, loggerFactory); // applies our seeded database data on program startup
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUserAsync(userManager);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred during migration");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
//automated migration for db.
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
var usermanager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUsersAsync(usermanager);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occurred during migration");
}
}
host.Run();
}
public static async Task Main(string[] args)
{
// Apply migration and create database at startup
var host = CreateHostBuilder(args).Build();
// using means any code runs inside of this is going to be disposed once finished
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService <ILoggerFactory>();
try
{
var context = services.GetRequiredService <StoreContext>();
await context.Database.MigrateAsync();
await StoreContextSeed.SeedAsync(context, loggerFactory);
var userManager = services.GetRequiredService <UserManager <AppUser> >();
var identityContext = services.GetRequiredService <AppIdentityDbContext>();
await identityContext.Database.MigrateAsync();
await AppIdentityDbContextSeed.SeedUserAsync(userManager);
}
catch (Exception ex)
{
var logger = loggerFactory.CreateLogger <Program>();
logger.LogError(ex, "An error occured during migration");
}
}
host.Run();
}
