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