//Main is the starting point for any application
public static void Main(string[] args)
{
//Creates the host and calls the starter file --> sets up all the services and runs it
//Wants to separate the build and run so that we are able to injerect and seed our data; when the application runs, we ensure that data is there
//Asks the host to get built and calls the startup
var host = CreateHostBuilder(args).Build();
//Need to ensure that catalogcontext service is up and running before seeding data
//Scope asks for how each of the services are doing
using (var scope = host.Services.CreateScope())
{
//If there are 5 services getting start up, and we are only interested in one specifc service, we can call it out via scope
//Ask the scope, provide me the name of the service provider
//For each services, ask for each one of the providers
var serviceProviders = scope.ServiceProvider;
//Out of all the service providers, we are looking for one - looking for a specific provider
//Provider, can you tell me if the catalog context is running; i.e., can you get a reference to my context
//Gives me the pointer to the database
var context = serviceProviders.GetRequiredService <CatalogContext>();
//Once it's available, we can fire the seed method, which requires the context parameter --> pointer of where the database is
CatalogSeed.Seed(context);
}
//Now we have to add the run; in real production this is not needed because we will not need to seed the data
host.Run();
}
public static void Main(string[] args)
{
//CreateHostBuilder(args).Build().Run();
// before run, build services first
// host = startup
var host = CreateHostBuilder(args).Build();
// CreateScope() means how your services are coming along
// using guarantees that object to be disposed
using (var scope = host.Services.CreateScope())
{
// ask for each service providers
var serviceproviders = scope.ServiceProvider;
// get the one provider of providers
// get a reference from the context
// it will wait for this service(CatalogContext) is available then give the pointer to context
var context = serviceproviders.GetRequiredService <CatalogContext>();
// after get context then it is guaranteed that CatalogContext is ready
// then we can push data into tables
CatalogSeed.Seed(context);
}
host.Run();
}
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
// Get service collection from the host object
using (var scope = host.Services.CreateScope())
{
// Get all the services registered in the dependency injection container
var services = scope.ServiceProvider;
try
{
// Register the catalog context
var context = services.GetRequiredService <CatalogContext>();
CatalogSeed.SeedAsync(context).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}
host.Run();
}
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var context = services.GetRequiredService <CatalogContext>();
CatalogSeed.SeedAsync(context).Wait();
}
host.Run();
}
// Entry point
public static void Main(string[] args)
{
// Building VM
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope()) // asking all the dependancies
{
var servieProviders = scope.ServiceProvider;
var context = servieProviders.GetRequiredService <CatalogContext>();
CatalogSeed.Seed(context);
}
host.Run();
}
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
//create scope coming from DI
using (var scope = host.Services.CreateScope())
{
var serviceProviders = scope.ServiceProvider;
var context = serviceProviders.GetRequiredService <CatalogContext>();
CatalogSeed.Seed(context);
}
host.Run();
}
//Notes:IIS - Internet Information service - a piece of software in windows that hosts web application.Similar to Tomcat in Linux
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
//Here we are creating a large object so we need to let garbage colelctor know we dont need this anymore.
//Here when we reach the end of using statement we dont want scope anymore as scope can be alarge object
using (var scope = host.Services.CreateScope())//Wait until my Database is creted before seeding
{
var services = scope.ServiceProvider;
var context = services.GetRequiredService <CatalogContext>();//tell me if DB's created by CatalogContext is there
CatalogSeed.SeedAsync(context).Wait();
}
host.Run();
}
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
//first ask startup file ie host the scope of services which is Add Controller and Add DbContext
using (var scope = host.Services.CreateScope())
//using statement guarantees that whatever is inside the curly braces of using it will be marked for deletion ie behind the scene it will call IDisposable
{
var serviceProviders = scope.ServiceProvider; // it means give me the scope of each service provider
var context = serviceProviders.GetRequiredService <CatalogContext>(); // i am interested only whether sql database is set up or not so only need Catalog Context
//This above line will act as await methos and will wait till sql is up and running.
//Now sql is up and running so we can populate it with data
CatalogSeed.Seed(context);// context has name of sql database
}
host.Run();
}
public static void Main(string[] args)
{
//Breaking up build and run to seed the data, this is only for local data, not in production
var host = CreateHostBuilder(args).Build();
// Add the seed dependancy injection here, before we run - Module 10
// using here is idisposable - design pattern - how an object would be destroyed
using (var scope = host.Services.CreateScope())
{
var serviceProviders = scope.ServiceProvider;
var context = serviceProviders.GetRequiredService <CatalogContext>();
CatalogSeed.Seed(context);
}
// Guranteed that scope.Dispose (createscope has a dispose method) is called here, by calling in Using stmt, finalizer
// not every object can be used inside the using stmt
host.Run();
}
public static void Main(string[] args)
{
//this is my docker
var host = BuildWebHost(args);
//creating the scope, give me a docker image. wrapping in a user statement
//so when the system is killed it kills the docker image
//will call dispose when reaches end of the line
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var context = services.GetRequiredService <CatalogContext>();
CatalogSeed.SeedAsync(context).Wait();
}
host.Run();
}
public static void Main(string[] args)
{
var host = BuildWebHost(args);
using (var scope = host.Services.CreateScope()) // setting up docker destroy docer andclean memory if use in a using loop.
{
var services = scope.ServiceProvider; //docker providing alll the provider one iscatalogcontext
var context =
services.GetRequiredService <CatalogContext>();
CatalogSeed.SeedAsync(context).Wait();
}
host.Run();
}
public static void Main(string[] args)
{
var host = BuildWebHost(args);
using (var scope = host.Services.CreateScope()){
var services = scope.ServiceProvider;
try{
var context = services.GetRequiredService <CatalogContext>();
CatalogSeed.SeedAsync(context).Wait();
}
catch (Exception e) {
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(e, "ERROR SEEDING");
}
}
host.Run();
}
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService <CatalogContext>();
CatalogSeed.Seed(context);
// TODO:
// What is the earliest time that you can receive dependency injection
// into a constructor of a class?
// How soon is too soon?
}
host.Run();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, CatalogSeed seed)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
//app.UseHsts();
}
app.UseSwagger()
.UseSwaggerUI(c => {
c.SwaggerEndpoint($"/swagger/v1/swagger.json", "Product Catlog api version1 ");
});
//seed.SeedAsync();
//app.UseHttpsRedirection();
app.UseMvc();
}
public static void Main(string[] args)
{
//to call "Seed" method from CatalogSeed.cs. We don't call it from Startup.cs because
//when the microservice and database are deployed on different Docker containers
//the "services.AddDbContext.." command starts building the container for db.If seed
//method is called after that line then it might fail if the container for db is not up
//and running yet. So we call it from Program.cs to make sure containers are ready to go.
var host = CreateHostBuilder(args).Build();
//before running the appl, we seed the data by calling the "Seed" method:
using (var scope = host.Services.CreateScope())
{
var serviceProviders = scope.ServiceProvider;
var context = serviceProviders.GetRequiredService <CatalogContext>(); //this line ensures db VM is built and ready to go.
CatalogSeed.Seed(context);
}
host.Run();
}
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <CatalogContext>();
CatalogSeed.SeedAsync(context).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger>();
logger.LogError("Failed to get Database context", ex);
}
}
host.Run();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseHsts();
}
using (var scope = app.ApplicationServices.CreateScope()) {
var ctx = scope.ServiceProvider.GetService <CatalogContext> ();
CatalogSeed.SeedAsync(ctx).Wait();
}
app.UseSwagger()
.UseSwaggerUI(
c => c.SwaggerEndpoint($"/swagger/v1/swagger.json", "ProductCatalogAPI V1")
);
//app.UseHttpsRedirection ();
app.UseMvc();
}
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <CatalogContext>();
CatalogSeed.SeedAsync(context).Wait();
}
catch (Exception e)
{
var logger = services.GetRequiredService <ILogger>();
logger.Log(LogLevel.Error, $"Exception {e.Message}: InnerException: {e.InnerException?.Message}", e.StackTrace);
}
}
host.Run();
}
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
//Host'u alarak service collectiona eriştik. Daha sonra buradan register olmuş olan DbContextimizi alıp seeddata methoduna gönderdik.
var context = services.GetRequiredService <CatalogContext>();
CatalogSeed.SeedAsync(context).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occured while seeding the database");
}
}
host.Run();
}
public static void Main(string[] args)
{
var host = BuildWebHost(args);
using (var scope = host.Services.CreateScope())
{
//get the services collection
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <CatalogContext>();
CatalogSeed.SeedAsync(context).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occured while seeding the database");
}
}
host.Run();
}
public static void Main(string[] args)
{
IWebHost host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
IServiceProvider services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <CatalogContext>();
MigrateDatabase.EnsureCreated(context);
CatalogSeed.SeedAsync(context).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occured while seeding the database.");
}
}
host.Run();
}
public static void Main(string[] args)
{
var webHost = CreateWebHostBuilder(args).Build();
using (var scope = webHost.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <CatalogContext>();
context.Database.Migrate();
CatalogSeed.SeedTestData(context).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occured during data seed.");
}
}
webHost.Run();
}
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
//From the scope, I will get the services
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
//Obtained an instance of catalog context
var context = services.GetRequiredService <CatalogContext>();
CatalogSeed.SeedAsync(context).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error Occured while seeding values");
}
}
host.Run();
}
public static void Main(string[] args)
{
var hostBuilder = CreateHostBuilder(args);
var host = hostBuilder.Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <CatalogContext>();
CatalogSeed.SeedAsync(context).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "Seeding error");
}
}
host.Run();
}
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <CatalogContext>();
context.Database.Migrate();
CatalogSeed.SeedAsync(context).Wait();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
//var logger = services.GetRequiredService<ILogger>();
//logger.LogError(ex, "An error occured while seeding database");
}
}
host.Run();
}
public static void Main(string[] args)
{
//adding of the dummy data in catalog seed
//host is docker image
var host = BuildWebHost(args);
//give me a scope/instance of the docket image
using (var scope = host.Services.CreateScope())
{
//get all the list of services on docker image
var services = scope.ServiceProvider;
//locate the catalog context out of the list of services
var context = services.GetRequiredService <CatalogContext>();
//add dummy data in catalog context, by calling Seed funtion
//call the wait on this async function becuse main cannot be made to async funtion
CatalogSeed.SeedAsync(context).Wait();
}
//run docker image
host.Run();
}
public static void Main(string[] args)
{
// TODO: Refactor to evironment
// CreateWebHostBuilder(args).Build().Run(); ---> Default
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <CatalogContext>();
CatalogSeed.SeedAsync(context).Wait();
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error Occured while seeding the database");
}
}
host.Run();
}
public static void Main(string[] args)
{
// Create host is where docker container gets created
var host = CreateHostBuilder(args).Build();
//Build() returns an IHost Interface, "A program abstraction."
// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.hosting.ihost?view=dotnet-plat-ext-3.1
// Creates a host
// Within the host (see CreateHostBuilder() below)
// Creates a Startup
// Which sets up your services one-by-one
// Then run the microservice
// Create host is the application in which all docker containers are created
// Right after Build() returns, you can guarantee that services are up
// Call Seed() between then and Run()
// host is your host machine that is actually kicking off all these VMs
// WAIT,
// First must check to ensure that the CatalogContext service is running
using (var scope = host.Services.CreateScope())
// The IHost.Services property contains "The programs configured services."
// Services is of type IServiceProvider, whose docs page appears to be
// missing, but here is the ServiceProviderService extension class
// ("Extension methods for getting services from an IServiceProvider.")
//https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.dependencyinjection.serviceproviderserviceextensions?view=dotnet-plat-ext-3.1
// ServiceProviderServiceExtensions.CreateScope(IServiceProvider)
// Or,
// IServiceProvider.CreateScope()
//https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.dependencyinjection.serviceproviderserviceextensions.createscope?view=dotnet-plat-ext-3.1#Microsoft_Extensions_DependencyInjection_ServiceProviderServiceExtensions_CreateScope_System_IServiceProvider_
// "Creates/Returns an IServiceScope that can be used to resolve scoped services."
// IServiceScope Interface
// "The Dispose() method ends the scope lifetime. Once Dispose is called, any scoped services that have been resolved from ServiceProvider will be disposed."
// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.dependencyinjection.iservicescope?view=dotnet-plat-ext-3.1
// Ask Startup about each of the services that are being set up
// Are they set up?
// Scope of each service means its status in setup?
{
// Recall from the using statement above that since CreateScope()
// returned an IServiceScope, var scope is of type IServiceScope
// IServiceScope (the scope) has property ServiceProvider of type IServiceProvider:
// "The IServiceProvider used to resolve dependencies from the scope."
//https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.dependencyinjection.iservicescope.serviceprovider?view=dotnet-plat-ext-3.1#Microsoft_Extensions_DependencyInjection_IServiceScope_ServiceProvider
var serviceProviders = scope.ServiceProvider;
// In this situation, ServiceProvider will be CatalogContext
var context = serviceProviders.GetRequiredService <CatalogContext>();
// Of all the service providers, I'm looking for just one, the CatalogContext
// GetRequiredService<CatalogContext>() won't return until the
// db service is available. This is a wait scenario.
// ServiceProviderServiceExtensions.GetRequiredService()
// GetRequiredService<T>(IServiceProvider)
// Or,
// IServiceProvider.GetRequiredService<CatalogContext>();
//https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.dependencyinjection.serviceproviderserviceextensions.getrequiredservice?view=dotnet-plat-ext-3.1#Microsoft_Extensions_DependencyInjection_ServiceProviderServiceExtensions_GetRequiredService__1_System_IServiceProvider_
// "Returns a service object of type CatalogContext."
// Recall the signature of CatalogSeed.Seed():
// public static void Seed(CatalogContext context)
// Finally seed the db with the data
CatalogSeed.Seed(context);
}
// QUESTION:
// Totally understand why it's important to check and see that the
// CatalogContext service is running. Why is it so involed to do so?
// What is there to clean up from getting the scope?
// Now that data is all set up, finally run the host
host.Run();
// (This used to happen right after the Build() step at the top of Main())
// Brillan's question in-class:
// Only breaking this up: CreateHostBuilder(args).Build().Run();
// because seeding the db with sample data? Answer: yes.
// Unless you want to do something between your creation and your deployment
// In real production, you may not need to break this up.
// Now go back up to using statement:
// using (var scope = host.Services.CreateScope()) {}
// overloading of the term/keyword
// guarantees that the object will be disposed at the end
// of the block. ***ONLY*** if the object type implements IDisposable
// Fellow student's good guess
// Don't have to wait until G0 is running low, G1 is running low
// Calls Dispose() on the object proactively
// Object can be cleaned up without needing to run the finalizer
// QUESTION
// Why do I keep thinking of exception handling with the using
// statement?
// Kal says no relationship between using statement and try/catch/finally
// Am I confuse?
// ---
// Now done here in Program.cs
// Want to see this in action
// See db get created
// Delete any existing CatalogDb from previous runs
// Then, note that there is no CatalogDb in LocalDb
// First! Run Powershell Command
// Need to AddMigrations
// Need to inform EntityFramework of all these changes
// No folder called Migrations in project (yet)
// Open Powershell prompt
// View > Other Windows > Package Manager Console (Ctrl+`)
// (Powershell useful for managing NuGet packages)
// Make sure you're pointing at the right project:
// Default project: src\services\ProductCatalogApi
// PM> Add-Migration Initial
// (Will get warning about CatalogItem.Price column not having type specified
// See how Migrations folder appeared in project
// Contains instructions for EF to create tables
// Converted your code into SQL-like (yet still C#) syntax
// DO NOT EDIT THE AUTOGEN FILE
// We've captured the delta.
// This initial migration goes from nothing to all tables set up.
// **Could** run UpdateDatabase manually
// But already wrote the code to do that from CatalogSeed.Seed()
// So...
// Almost ready to build and run code.
// Program
// Main
// Startup
// CatalogSeed
// CatalogContext.Database.Migrate() (does UpdateDatabase, which applies migrations)
// But first!
// Run chooses Docker because we added docker support, but not configured yet
// Run as IIS Express instead for now (Internet Information Services)
// IIS is a provider that opens up the port for your web applications
// to run (on Windows)
// (On Linux, called tomcat?)
// We are building a microservice, even though not a web application,
// it is still a Web API (haven't written any yet, but we will)
// OK, RUN
// Confirm that seed data was set
// REMEMBER:
// When using the SQL Server Object Explorer to view db tables
// and data, remember to refresh the view/window to see the created db.
// Right click on a table, View Data to see the data in the table.
}
