Startup.cs class is missing in .NET 6

Question

I created REST API's in .NET 5 and everything was working perfectly, but recently I moved to .NET 6 and realized that no startup.cs class is present. How do I add the DB Context in .NET 6 since there is no startup.cs?

Answer 1

In .NET 6 Microsoft has removed the Startup.cs class. Just go to the program.cs file and there you can add a connection string then you've to use builder.Services.AddDbContext The old way is services.AddDbContext

Just use builder.Services and then you can achieve what you want.

Answer 2

In .NET 6, they unified Startup.cs and Program.cs into one Program.cs.

Now registering middleware, services and adding DbContext and everything else into the Program.cs file.

Here is an example of a Program.cs file:

using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);
//Register services here
builder.Services.AddDbContext<ApplicationDbContext>(options => options.UseSqlServer(       
builder.Configuration.GetConnectionString("DefaultConnection")       
));
builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
//builder.Services.AddAuthentication(...)
var app = builder.Build();
//app.UseAuthentication();

For more information visit this thread.

Answer 3

Create a new class called "Startup.cs". Paste this template in it;

public class Startup
{
    public IConfiguration Configuration { get; }
    public Startup(IConfiguration configuration)
    {
        this.Configuration = configuration;
    }

    // This method gets called by the runtime. Use this method to add serices to the container.
    public void ConfigureServices(IServiceCollection services)
    {
        //services.AddDbContext...
    }

    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
    public void Configure(WebApplication app, IWebHostEnvironment env)
    {

    }
}

Now, you can Modify your Program.cs class to look like this;

var builder = WebApplication.CreateBuilder(args);
var startup = new Startup(builder.Configuration); // My custom startup class.

startup.ConfigureServices(builder.Services); // Add services to the container.

var app = builder.Build();

startup.Configure(app, app.Environment); // Configure the HTTP request pipeline.

app.Run();

Now, things are better organized, in the old way. People coming from ASP.NET Core 5 will feel right at home. What you put inside ConfigureServices() and Configure() will depend on your project and needs. For example, here is how an example ASP.NET Core 7 MVC project's Startup.cs would look like as a starting point;

public class Startup
{
    public IConfiguration Configuration { get; }
    public Startup(IConfiguration configuration)
    {
        this.Configuration = configuration;
    }

    // This method gets called by the runtime. Use this method to add serices to the container.
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllersWithViews();
    }

    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
    public void Configure(WebApplication app, IWebHostEnvironment env)
    {
        if (!env.IsDevelopment())
        {
            app.UseExceptionHandler("/Home/Error");
            // 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.UseHttpsRedirection();
        app.UseStaticFiles();

        app.UseRouting();

        app.UseAuthorization();

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

Answer 4

To be clear for those trying to add transient, singleton or scoped services...

Previously in Startup.cs, adding a service looked like this:

public void ConfigureServices(IServiceCollection services)
{
    services.AddTransient<IEmailService, EmailService>();
}

Now instead in Program.cs, it looks like this:

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddTransient<IEmailService, EmailService>();

Answer 5

I prefer to create an extension class that can be very clean

public static class HostingExtension
{
    /// <summary>
    /// Add services to the container.
    /// </summary>
    /// <param name="builder"></param>
    /// <returns></returns>
    public static WebApplication ConfigureServices(this WebApplicationBuilder builder)
    {

        builder.Services.AddControllers();
        // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
        builder.Services.AddEndpointsApiExplorer();
        builder.Services.AddSwaggerGen();

        return builder.Build();
    }
    /// <summary>
    ///  Configure the HTTP request pipeline.
    /// </summary>
    /// <param name="app"></param>
    /// <returns></returns>
    public static WebApplication ConfigurePipeline(this WebApplication app)
    {
        
        if (app.Environment.IsDevelopment())
        {
            app.UseSwagger();
            app.UseSwaggerUI();
        }

        app.UseHttpsRedirection();

        app.UseAuthorization();

        app.MapControllers();
        return app;
    }
}

and then just write this to program.cs

var builder = WebApplication.CreateBuilder(args);

builder.ConfigureServices().ConfigurePipeline().Run();

Answer 6

Go to the program.cs, and then you have to use the builder.Services

Here is an example of a Program.cs file:

var connectionString = builder.Configuration.GetConnectionString("AppDb");
builder.Services.AddDbContext<DbContext>(x => x.UseSqlServer(connectionString));