> For the complete documentation index, see [llms.txt](https://huy312100.gitbook.io/software-development/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://huy312100.gitbook.io/software-development/.net-technology/fundamental/startup-file.md).

# Startup file

In ASP.NET Core, the `Startup` class is used to configure the services your application will use and to define the request handling pipeline. The `ConfigureServices` method is used to register services with the dependency injection (DI) container, and the `Configure` method is used to define the middleware pipeline for handling HTTP requests.

#### ConfigureServices

The `ConfigureServices` method is called by the runtime before the `Configure` method to configure the application's services. Inside this method, you register services with the built-in DI container provided by ASP.NET Core, such as repositories, logging services, authentication services, and any other services your application requires.

Here's an example of how you might use `ConfigureServices`:

```csharp
public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
    services.AddScoped<IMyService, MyService>();
    services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
        .AddCookie(options =>
        {
            options.LoginPath = "/Account/Login";
            options.AccessDeniedPath = "/Account/AccessDenied";
        });
    // Other service registrations
}
```

#### Configure

The `Configure` method is where you define the middleware pipeline to handle HTTP requests. Middleware components are added to the pipeline in the order they are registered, and each component can choose to either handle the request or pass it to the next component in the pipeline.

Here's an example of how you might use `Configure`:

```csharp
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseStaticFiles();

    app.UseRouting();

    app.UseAuthentication();
    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");
    });
}
```

#### Summary

* The `ConfigureServices` method in the `Startup` class is used to register services with the dependency injection container.
* The `Configure` method is used to define the middleware pipeline for handling HTTP requests. Each middleware component can choose to handle the request or pass it to the next component.
* The order in which middleware components are added to the pipeline matters, as it determines the sequence in which they handle requests.
* These methods provide a flexible and modular approach to configuring an ASP.NET Core application, allowing you to easily register services and define request handling behavior.
* **Environment-Specific Configuration**: Depending on the environment (development, staging, production), different error handling and security features may be enabled or disabled. For example, in development, the `UseDeveloperExceptionPage` middleware is added to provide detailed error information in the browser.
* **Middleware Registration**: Each call to `app.UseXXX` adds a middleware component to the pipeline. These components perform tasks such as redirecting HTTP requests to HTTPS (`UseHttpsRedirection`), serving static files (`UseStaticFiles`), handling routing (`UseRouting`), and setting up authentication (`UseAuthentication`) and authorization (`UseAuthorization`).
* **Endpoint Routing**: The `UseEndpoints` method configures how endpoints are mapped to controllers and actions. In this example, a default route is defined that matches the controller name, action name, and optional parameter.

### Can we change the name Startup ?

Yes, you can change the name of the `Startup` class in an ASP.NET Core application. The `Startup` class is conventionally named `Startup`, but it's not a reserved keyword or name; it's just a convention.

To change the name of the `Startup` class:

1. Rename the file containing the `Startup` class to match the new name.
2. Update references to the `Startup` class throughout your project, such as in `Program.cs`.

For example, if you rename `Startup.cs` to `MyCustomStartup.cs`, you'll need to update `Program.cs` to reflect the new name:

```csharp
csharpSao chép mãpublic class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<MyCustomStartup>(); // Update Startup class reference here
            });
}
```

Ensure that the renamed `MyCustomStartup` class retains the same structure and methods as the original `Startup` class. This includes methods like `ConfigureServices` and `Configure`, which are crucial for configuring the application's services and request pipeline, respectively.

After renaming and updating references, your application should function as expected with the new `Startup` class name.

### Can we have more than one Startup file?

In an ASP.NET Core application, you can specify multiple startup classes, but you can only specify one at a time in the `WebHostBuilder` configuration. However, you can create multiple `WebHostBuilder` instances in the same application, each with its own startup class, allowing you to have different startup configurations for different scenarios.

Here's how you can specify multiple startup classes using multiple `WebHostBuilder` instances:

1. Define additional startup classes in your project. These classes should follow the same structure as the default `Startup` class and implement the necessary methods like `ConfigureServices` and `Configure`.
2. In your `Program.cs` file, create multiple `WebHostBuilder` instances, each with a different startup class specified using the `UseStartup` method.

Here's an example:

```csharp
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;

namespace YourNamespace
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args, typeof(StartupA)).Build().Run();
            CreateHostBuilder(args, typeof(StartupB)).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args, Type startupType) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup(startupType);
                });
    }
}
```

In this example, `StartupA` and `StartupB` are two different startup classes. `CreateHostBuilder` method is called twice, each time specifying a different startup class using the `UseStartup` method.

This approach allows you to have multiple configurations for different scenarios or environments within the same ASP.NET Core application. You can then choose which configuration to use by running the appropriate `CreateHostBuilder` method in your `Main` method.