What is use of WebApplication class in ASP.NET Core

Objectives:

• Look at WebApplication Create and CreateBuilder methods of WebApplication
• Understanding use of WebApplication in ASP.NET Core
• Setup web application in ASP.NET Core
• It will help you to convert console app into ASP.NET Core

In ASP.NET Core, the WebApplication class provides several overloads for the Create and CreateBuilder methods, which are designed to initialize and configure an ASP.NET Core application in different ways, depending on the application's needs. 

Here’s an explanation of the different overloads for each:

1. WebApplication.CreateBuilder() Overloads

The CreateBuilder method is used to initialize a WebApplicationBuilder, which helps configure the services and middleware pipeline before building the actual WebApplication. 

Overloads:

• WebApplication.CreateBuilder()
• WebApplication.CreateBuilder(string[] args)
• WebApplication.CreateBuilder(WebApplicationOptions options)

Now look at each method separately.

• WebApplication.CreateBuilder():
It initializes the WebApplicationBuilder without passing any command-line arguments. This overload is often used when you don't need to access or use command-line arguments during app configuration.
• Usage:

var builder = WebApplication.CreateBuilder();

• WebApplication.CreateBuilder(string[] args):
This overload takes an array of strings, typically args from Main(), which contain command-line arguments. These arguments can be used to configure the application (for example, setting environment variables or custom settings).
• Usage:

var builder = WebApplication.CreateBuilder(args);

• WebApplication.CreateBuilder(WebApplicationOptions options):
This overload allows you to pass in a WebApplicationOptions object, which can be used to set specific options like content root, environment, or application name. It offers more granular control over how the application is set up.
• Usage:

var options = new WebApplicationOptions
{
    ContentRootPath = "/my/custom/path",
    ApplicationName = "MyApp"
};
var builder = WebApplication.CreateBuilder(options);

• WebApplication.CreateBuilder(WebApplicationOptions options, string[] args):
This overload combines the WebApplicationOptions object with the command-line arguments args. It allows you to control the application settings via options and pass additional configuration through command-line arguments.
• Usage:

var options = new WebApplicationOptions
{
    EnvironmentName = "Development"
};
var builder = WebApplication.CreateBuilder(options, args);

WebApplication.Create() Overloads

The Create method builds the WebApplication from an already configured IHostBuilder. It is typically used when you need more control over the host setup than what CreateBuilder() provides. Overloads:

• WebApplication.Create():
This method doesn't take any arguments. It creates a basic WebApplication instance by setting up default services, configuration, and the request pipeline.
• Usage:

var app = WebApplication.Create();

• WebApplication.Create(IHostBuilder hostBuilder):
This overload allows you to pass an existing IHostBuilder. It is useful if you need to customize the host builder before creating the WebApplication. It offers more control over the creation process, allowing for advanced scenarios like customizing hosting or configuration before the app is created.
• Usage:

var hostBuilder = Host.CreateDefaultBuilder(args)
                      .ConfigureWebHostDefaults(webBuilder =>
                      {
                          webBuilder.UseStartup<Startup>();
                      });
var app = WebApplication.Create(hostBuilder);

Summary of Overloads

CreateBuilder() Overloads:
1. CreateBuilder(): It initializes the WebApplicationBuilder with no or minimal configuration.
2. CreateBuilder(string[] args): It allows passing command-line arguments to influence configuration.
3. CreateBuilder(WebApplicationOptions options): It gives you more control over app configuration through options like content root and environment.
4. CreateBuilder(WebApplicationOptions options, string[] args): It combines options and command-line arguments.
Create() Overloads:
1. Create(): It sets up a basic WebApplication.
2. Create(IHostBuilder hostBuilder): It allows you to use a custom host builder for more advanced configuration. The choice of overload depends on whether you need to pass arguments, configure app settings, or require advanced control over hosting and configuration.