criar banco de dados automaticamente no Entity Framework Core

Meu aplicativo que está sendo portado para o .NET core usará o novo EF Core com SQLite. Desejo criar automaticamente o banco de dados e as estruturas de tabela quando o aplicativo é executado pela primeira vez. De acordo com a documentação do núcleo EF, isso é feito usando comandos manuais

dotnet ef migrations add MyFirstMigration

dotnet ef database update

No entanto, não quero que o usuário final insira esses comandos e prefiro que o aplicativo crie e configure o banco de dados para o primeiro uso. Para EF 6, há funcionalidades como

Database.SetInitializer(new CreateDatabaseIfNotExists<MyContext>());

Mas no EF Core eles não parecem existir. Não consigo encontrar nenhum exemplo ou documentação sobre algo equivalente para o núcleo EF e isso não é mencionado na lista de recursos ausentes na documentação do núcleo EF. Eu já tenho as classes do modelo configuradas, então eu poderia escrever algum código para inicializar o banco de dados com base nos modelos, mas seria muito mais fácil se o framework fizesse isso automaticamente. Não quero construir automaticamente o modelo ou migrar, apenas criar as estruturas da tabela em um novo banco de dados.

Estou faltando alguma coisa aqui ou a função de criação automática de tabela está faltando no núcleo EF?

Se você criou as migrações, pode executá-las no Startup.cs da seguinte maneira.

 public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
 {
      using (var serviceScope = app.ApplicationServices.GetService<IServiceScopeFactory>().CreateScope())
      {
            var context = serviceScope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
            context.Database.Migrate();
      }

      ...

Isso criará o banco de dados e as tabelas usando suas migrações adicionadas.

Se você não estiver usando o Entity Framework Migrations e, em vez disso, apenas precisar que seu modelo DbContext seja criado exatamente como está em sua classe de contexto na primeira execução, você pode usar:

 public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
 {
      using (var serviceScope = app.ApplicationServices.GetService<IServiceScopeFactory>().CreateScope())
      {
            var context = serviceScope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
            context.Database.EnsureCreated();
      }

      ...

Em vez de.

Se você precisar excluir seu banco de dados antes de garantir que ele seja criado, chame:

            context.Database.EnsureDeleted();

Um pouco antes de você ligar EnsureCreated()

Adaptado de: http://docs.identityserver.io/en/latest/quickstarts/7_entity_framework.html?highlight=entity

Minha resposta é muito semelhante à de Ricardo, mas sinto que minha abordagem é um pouco mais direta simplesmente porque há tanta coisa acontecendo em sua usingfunção que nem tenho certeza de como funciona exatamente em um nível inferior.

Portanto, para aqueles que desejam uma solução simples e limpa que crie um banco de dados onde você saiba exatamente o que está acontecendo nos bastidores, isto é para você:

public Startup(IHostingEnvironment env)
{
    using (var client = new TargetsContext())
    {
        client.Database.EnsureCreated();
    }
}

Isso significa basicamente que dentro do DbContextque você criou (neste caso, o meu é chamado TargetsContext), você pode usar uma instância de DbContextpara garantir que as tabelas definidas com na classe sejam criadas quando Startup.cs for executado em seu aplicativo.

Se você obtiver o contexto por meio da lista de parâmetros de Configure em Startup.cs, você pode fazer o seguinte:

public void Configure(IApplicationBuilder app, IHostingEnvironment env,  LoggerFactory loggerFactory,
    ApplicationDbContext context)
 {
      context.Database.Migrate();
      ...

Para EF Core 2.0+ eu tive que adotar uma abordagem diferente porque eles mudaram a API. A partir de março de 2019, a Microsoft recomenda que você coloque o código de migração do banco de dados na classe de entrada do aplicativo, mas fora do código de compilação do WebHost.

public class Program
{
    public static void Main(string[] args)
    {
        var host = CreateWebHostBuilder(args).Build();
        using (var serviceScope = host.Services.CreateScope())
        {
            var context = serviceScope.ServiceProvider.GetRequiredService<PersonContext>();
            context.Database.Migrate();
        }
        host.Run();
    }

    public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>();
}

Se você não criou migrações, existem 2 opções

1. criar o banco de dados e as tabelas do aplicativo principal:

var context = services.GetRequiredService<YourRepository>();
context.Database.EnsureCreated();

2. criar as tabelas se o banco de dados já existir:

var context = services.GetRequiredService<YourRepository>();
context.Database.EnsureCreated();
RelationalDatabaseCreator databaseCreator =
(RelationalDatabaseCreator)context.Database.GetService<IDatabaseCreator>();
databaseCreator.CreateTables();

Graças à resposta do Bubi