![Startup and program]()
Introduction
Program.cs is where the application starts. Program.cs file will work the same as the Program.cs file in traditional console application of .NET Framework. Program.cs file is the entry point of the application and will be responsible for registering Startup.cs fill, IISIntegration and Create a host using an instance of IWebHostBuilder, the Main method.
Global.asax is no longer in the ASP.NET Core application. The Startup.cs file is a replacement of the Global.asax file in ASP.NET Core.
Startup.cs file is entry point, and it will be called after Program.cs file is executed at the application level. It handles the request pipeline. The startup class triggers the second the application launches.
Description
What is Program.cs ?
Program.cs is where the application starts. Program.cs class file is the entry point of our application and creates an instance of IWebHost which hosts a web application.
public class Program {
public static void Main(string[] args) {
BuildWebHost(args).Run();
}
public static IWebHost BuildWebHost(string[] args) => WebHost.CreateDefaultBuilder(args).UseStartup < startup > ().Build();
}
WebHost is used to create instances of IWebHost WebHostBuilder and IWebHostBuilder which are pre-configured defaults. The CreateDefaultBuilder() method creates a new instance of WebHostBuilder.
UseStartup<startup>() method specifies the Startup class to be used by the web host. We can also specify our custom class in place of startup.
The build () method returns an instance of IWebHost and Run() starts the web application until it stops.
Program.cs in ASP.NET Core makes it easy for us to set up a web host.
public static IWebHostBuilder CreateDefaultBuilder(string[] args) {
var builder = new WebHostBuilder().UseKestrel().UseContentRoot(Directory.GetCurrentDirectory()).ConfigureAppConfiguration((hostingContext, config) => {
/* setup config */ }).ConfigureLogging((hostingContext, logging) => {
/* setup logging */ }).UseIISIntegration()
return builder;
}
the UseKestrel() specify method is an extension, which specifies Kestrel as an internal web server. The Kestrel is an open-source, cross-platform web server for ASP.NET Core. The application is running with the Asp.Net Core Module and it is necessary to enable IIS Integration (UseIISIntegration()), which configures the application base address and port.
It also configures UseIISIntegration(), UseContentRoot(), UseEnvironment("Development"), UseStartup<startup>(), and other configurations are also available, like Appsetting.json and Environment Variable. UseContentRoot is used to denote the current directory path.
We can also register to log in and set a minimum log level as shown below. It also overrides the log level configured in the appsetting.json file.
ConfigureLogging(logging => {
logging.SetMinimumLevel(LogLevel.Warning);
})
In the same way we can also control the body size of our request and response by enabling in program.cs file as below.
ConfigureKestrel((context, options) => { options.Limits.MaxRequestBodySize = 20000000; });
ASP.net Core is cross-platform and open-source and also it is compatible with hosting on any server other than IIS, external web servers such as IIS, Apache, Nginx, etc.
What is a startup file?
Now the question is, is startup.cs file mandatory or not? Yes, startup.cs is mandatory, it can be decorated with any access modifier like public, private, or internal. Multiple Startup classes are allowed in a single application. ASP.NET Core will select the appropriate class based on its environment.
If a class Startup{EnvironmentName} exists, that class will be called for that EnvironmentName or the Environment-Specific startup file will be executed to avoid frequent changes of code/setting/configuration based on the environment.
ASP.NET Core supports multiple environment variables like Development, Production, and Staging. It reads the environment variable ASPNETCORE_ENVIRONMENT at application startup and stores value into the Hosting Environment interface.
Should we need to define the class name with startup.cs. No, it is not necessary, that class name should be Startup.
We can define two methods in the startup file ConfigureServices and Configure along with the constructor.
Startup file example
public class Startup {
// Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services) {
...
}
// Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app) {
...
}
}
ConfigureServices method
This is an optional method in the Startup class which is used to configure services for the application. When any request comes to the application, the ConfigureService method will be called first.
The ConfigureServices method includes the IServiceCollection parameter to register services. This method must be declared with a public access modifier so that the environment will be able to read the content from metadata.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
}
Configure method
The Configure method is used to specify how the application will respond to each HTTP request. This method is mostly used for registering middleware in the HTTP pipeline. This method accepts the IApplicationBuilder parameter along with some other services like IHostingEnvironment and ILoggerFactory. Once we add some service in the ConfigureService method, it will be available to the Configure method to be used.
public void Configure(IApplicationBuilder app)
{
app.UseMvc();
}
The above example shows how to enable the MVC feature in our framework. We need to register UseMvc() into Configure and also need to register service AddMvc() into ConfigureServices. UseMvc is known as middleware. Middleware is a new concept introduced with Asp.net Core, there are many inbuilt middleware available, and some are as below.
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
UseCookiePolicy();
UseSession();
Middleware can be configured in the HTTP pipeline using Use, Run, and Map.
Run extension
The nature of the Run extension is to short-circuit the HTTP pipeline immediately. It is a shorthand way of adding middleware to the pipeline that does not call any other middleware that is next to it and immediately returns an HTTP response.
Use extension
It will transfer the next invoker so that the HTTP request will be transferred to the next middleware after execution of the current use if the next invoker is present.
Map extension
Map simply accepts a path and a function that configures a separate middleware pipeline..
app.Map("/MyDelegate", MyDelegate);
To get more detailed information about middleware Click here
ASP.net core has built-in support for Dependency Injection. We can configure services to the DI container using this method. The following ways are to configure the method in the startup class.
AddTransient
Transient objects are always different; a new instance is provided to every controller and every service.
Scoped
Scoped objects are the same within a request, but different across different requests.
Singleton
Singleton objects are the same for every object and every request.
Can we remove startup.cs and merge the entire class with Program.cs ?
The answer is Yes we can merge the entire class into to single file.
Summary
Here we have gone through the basic understanding of how to program.cs and startup.cs file is important for our Asp.net Core application and how both can be configured, we have also had a little walk though Environment Variable and middleware and how to configure middleware and dependency injection. Additionally, we have seen how UseIIsintegration() and UseKestrel() can be configured.