Delen via

Ontwerptijd dbContext maken

Voor sommige van de EF Core Tools-opdrachten (bijvoorbeeld de migrations-opdrachten ) moet een afgeleid DbContext exemplaar worden gemaakt tijdens het ontwerp om details te verzamelen over de entiteitstypen van de toepassing en hoe deze worden toegewezen aan een databaseschema. In de meeste gevallen is het wenselijk dat de DbContext daardoor gemaakte configuratie op een vergelijkbare manier wordt geconfigureerd als tijdens runtime.

Er zijn verschillende manieren waarop de hulpprogramma's proberen het DbContextvolgende te maken:

Vanuit toepassingsservices

Als uw opstartproject gebruikmaakt van de ASP.NET Core-webhost of .NET Core Generic Host, proberen de hulpprogramma's het DbContext-object te verkrijgen van de serviceprovider van de toepassing.

De hulpprogramma's proberen eerst de serviceprovider te verkrijgen door aan te Program.CreateHostBuilder()roepen, aan te roepen Build()en vervolgens toegang te krijgen tot de Services eigenschap.

public class Program
{
    public static void Main(string[] args)
        => CreateHostBuilder(args).Build().Run();

    // EF Core uses this method at design time to access the DbContext
    public static IHostBuilder CreateHostBuilder(string[] args)
        => Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(
                webBuilder => webBuilder.UseStartup<Startup>());
}

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
        => services.AddDbContext<ApplicationDbContext>();

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
    }
}

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }
}

Note

Wanneer u een nieuwe ASP.NET Core-toepassing maakt, wordt deze hook standaard opgenomen.

De DbContext zelf- en eventuele afhankelijkheden in de constructor moeten worden geregistreerd als services in de serviceprovider van de toepassing. Dit kan eenvoudig worden bereikt door een constructor te hebben op de DbContext instantie van DbContextOptions<TContext> een argument en de AddDbContext<TContext> methode te gebruiken.

Een constructor zonder parameters gebruiken

Als dbContext niet kan worden verkregen van de toepassingsserviceprovider, zoeken de hulpprogramma's naar het afgeleide DbContext type in het project. Vervolgens proberen ze een exemplaar te maken met behulp van een constructor zonder parameters. Dit kan de standaardconstructor zijn als de DbContext methode is geconfigureerd OnConfiguring .

Vanuit een ontwerptijdfactory

U kunt ook de hulpprogramma's vertellen hoe u uw DbContext maakt door de Microsoft.EntityFrameworkCore.Design.IDesignTimeDbContextFactory<TContext> interface te implementeren: Als een klasse die deze interface implementeert, wordt gevonden in hetzelfde project als het afgeleide DbContext project of in het opstartproject van de toepassing, omzeilen de hulpprogramma's de andere manieren om dbContext te maken en in plaats daarvan de ontwerptijdfactory te gebruiken.

public class BloggingContextFactory : IDesignTimeDbContextFactory<BloggingContext>
{
    public BloggingContext CreateDbContext(string[] args)
    {
        var optionsBuilder = new DbContextOptionsBuilder<BloggingContext>();
        optionsBuilder.UseSqlite("Data Source=blog.db");

        return new BloggingContext(optionsBuilder.Options);
    }
}

Een ontwerptijdfactory kan vooral handig zijn als u de DbContext ontwerptijd anders moet configureren dan tijdens runtime, als de DbContext constructor aanvullende parameters niet in DI registreert, als u helemaal geen DI gebruikt, of als u om een of andere reden liever CreateHostBuilder geen methode in de klasse van Main uw ASP.NET Core-toepassing hebt.

Args

Beide IDesignTimeDbContextFactory<TContext>.CreateDbContext en Program.CreateHostBuilder accepteren opdrachtregelargumenten.

U kunt deze argumenten opgeven vanuit de hulpprogramma's:

dotnet ef database update -- --environment Production

Het -- token leidt dotnet ef om alles dat volgt als argument te behandelen en deze niet als opties te parseren. Eventuele extra argumenten die niet door dotnet ef worden gebruikt, worden doorgestuurd naar de app.

  • Last updated on