Depois de atualizar para o ASP.NET Core 2.0, não consigo mais criar migrações.

Estou entendendo

"Ocorreu um erro ao chamar o método 'BuildWebHost' na classe 'Programa'. Continuando sem o provedor de serviços do aplicativo. Erro: Ocorreu um ou mais erros. (Não é possível abrir o banco de dados" ... "solicitado pelo login. O login falhou. Login falhou para o usuário '...' "

e

"Não é possível criar um objeto do tipo 'MyContext'. Adicione uma implementação de 'IDesignTimeDbContextFactory' ao projeto ou consulte https://go.microsoft.com/fwlink/?linkid=851728 para padrões adicionais suportados em tempo de design."

O comando que executei anteriormente era $ dotnet ef migrations add InitialCreate --startup-project "..\Web"(do projeto / pasta com o DBContext).

String de conexão: "Server=(localdb)\\mssqllocaldb;Database=database;Trusted_Connection=True;MultipleActiveResultSets=true"

Este é meu Program.cs

 public class Program
{
    public static void Main(string[] args)
    {
        BuildWebHost(args).Run();
    }

    public static IWebHost BuildWebHost(string[] args) =>
       WebHost.CreateDefaultBuilder(args)
           .UseStartup<Startup>()
           .Build();
}

Você pode adicionar uma classe que implemente IDesignTimeDbContextFactory dentro de seu projeto da Web.

Aqui está o código de exemplo:

public class DesignTimeDbContextFactory : IDesignTimeDbContextFactory<CodingBlastDbContext>
{
    public CodingBlastDbContext CreateDbContext(string[] args)
    {
        IConfigurationRoot configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json")
            .Build();
        var builder = new DbContextOptionsBuilder<CodingBlastDbContext>();
        var connectionString = configuration.GetConnectionString("DefaultConnection");
        builder.UseSqlServer(connectionString);
        return new CodingBlastDbContext(builder.Options);
    }
}

Em seguida, navegue até seu projeto de banco de dados e execute o seguinte na linha de comando:

dotnet ef migrations add InitialMigration -s ../Web/

dotnet ef database update -s ../Web/

-s stands for startup project and ../Web/ is the location of my web/startup project.

recurso

Não há necessidade IDesignTimeDbContextFactory.

Corre

add-migration initial -verbose

que irá revelar os detalhes sob

Ocorreu um erro ao acessar o IWebHost na classe 'Programa'. Continuando sem o provedor de serviços de aplicativo.

aviso, que é a causa raiz do problema.

No meu caso , o problema era ter ApplicationRole : IdentityRole<int>e invocar o services.AddIdentity<ApplicationUser, IdentityRole>()que estava causando o erro abaixo

System.ArgumentException: GenericArguments[1], 'Microsoft.AspNetCore.Identity.IdentityRole', 
on 'Microsoft.AspNetCore.Identity.EntityFrameworkCore.UserStore`9[TUser,TRole,TContext,
TKey,TUserClaim,TUserRole,TUserLogin,TUserToken,TRoleClaim]' violates the constraint of type 'TRole'.
---> System.TypeLoadException: GenericArguments[1], 'Microsoft.AspNetCore.Identity.IdentityRole', 
on 'Microsoft.AspNetCore.Identity.UserStoreBase`8[TUser,TRole,TKey,TUserClaim,
TUserRole,TUserLogin,TUserToken,TRoleClaim]' violates the constraint of type parameter 'TRole'.

Solução 1: (Encontre o problema em 99% dos casos)

Definir projeto de aplicativo da Web como projeto de inicialização

Execute os seguintes comandos com -verboseopção.

Add-Migration Init -Verbose

-verbose opção ajuda a realmente descobrir o problema real, contém erros detalhados.

Solução 2:

Renomeie BuildWebHost()para CreateWebHostBuilder(), porque Entity Framework Core toolsespere encontrar um CreateHostBuildermétodo que configure o host sem executar o aplicativo.

.NET Core 2.2

public class Program
{
    public static void Main(string[] args)
    {
        CreateWebHostBuilder(args).Build().Run();
    }

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

.NET Core 3.1

Renomear BuildWebHost()paraCreateHostBuilder()

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<Startup>();
            });
}

Solução 3:

Certifique-se de que adicionou Dbcontextà injeção de dependência: AddDbContext<TContext>tornará seu tipo DbContext TContext, e o correspondente DbContextOptions<TContext>disponível para injeção no contêiner de serviço. Isso requer a adição de um argumento construtor ao seu DbContexttipo que aceita DbContextOptions<TContext>.

Exemplo: In Startup.cs

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<AppDbContext>(options => options.UseSqlServer(connectionString));
}

Código AppDbContext :

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

}

public class Program
{
    public static void Main(string[] args)
    {
        BuildWebHost(args).Run();
    }

    public static IWebHost BuildWebHost(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>()
            .Build();
    }
}

Basta renomear BuildWebHost()para CreateWebHostBuilder(), porque as migrações usam esse método por padrão.

No meu caso, a causa do problema foram vários projetos de inicialização. Tenho três projetos em minha solução: Mvc, Api e Dal. DbContext e Migrações no projeto Dal.

Eu havia configurado vários projetos de inicialização. Ambos os projetos Mvc e Api estavam em execução quando cliquei em Iniciar. Mas, neste caso, eu estava recebendo esse erro.

"Não é possível criar um objeto do tipo 'MyContext'. Adicione uma implementação de 'IDesignTimeDbContextFactory' ao projeto ou consulte https://go.microsoft.com/fwlink/?linkid=851728 para padrões adicionais suportados em tempo de design."

Pude adicionar migração com sucesso após definir Mvc como o único projeto de inicialização e selecionar Dal no Console do gerenciador de pacotes.

No AppContext.cs, além da classe AppContext, adicione outra classe:

// required when local database deleted
public class ToDoContextFactory : IDesignTimeDbContextFactory<AppContext>
{
    public AppContext CreateDbContext(string[] args)
    {
        var builder = new DbContextOptionsBuilder<AppContext>();
          builder.UseSqlServer("Server=localhost;Database=DbName;Trusted_Connection=True;MultipleActiveResultSets=true");
        return new AppContext(builder.Options);
    }
}

Isso resolverá seu segundo problema:

"Não é possível criar um objeto do tipo 'MyContext'. Adicione uma implementação de 'IDesignTimeDbContextFactory' ao projeto,

Depois disso, você poderá adicionar a migração Initial e executá-la executando o comando update-database . No entanto, se executar esses comandos quando ainda não houver um banco de dados em seu SqlServer local, você receberá o aviso como o seu primeiro erro: "Um erro

ocorreu ao chamar o método 'BuildWebHost' na classe 'Program' ... O login falhou. Login falhou para o usuário '...' "

Mas não é um erro porque a migração será criada e pode ser executada. Portanto, ignore este erro pela primeira vez, e depois, como o Db existirá, não acontecerá novamente.

verifique se você tem a referência

<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.0.0" />

Você pode tentar essa solução a partir desta discussão , que foi inspirada neste post .

public static IWebHost MigrateDatabase(this IWebHost webHost)
{
    using (var scope = webHost.Services.CreateScope())
    {
        var services = scope.ServiceProvider;

        try
        {
            var db = services.GetRequiredService<MyContext>();
            db.Database.Migrate();
        }
        catch (Exception ex)
        {
            var logger = services.GetRequiredService<ILogger<Program>>();
            logger.LogError(ex, "An error occurred while migrating the database.");
        }
    }

    return webHost;
}
public static void Main(string[] args)
{
    BuildWebHost(args)
        .MigrateDatabase()
        .Run();
}

Algo que realmente me ajudou foi este artigo: https://elanderson.net/2017/09/unable-to-create-an-object-of-type-applicationdbcontext-add-an-implementation-of-idesigntimedbcontextfactory/

A ideia básica é que, na mudança de .net core 1 para 2, toda a inicialização do banco de dados deve ser movida de StartUp.cs para Program.cs. Caso contrário, as tarefas EF tentam executar seus comandos DB ao fazer as tarefas.

"Há uma boa seção nos documentos oficiais de migração ( https://docs.microsoft.com/en-us/ef/core/misc Miscellaneous/1x-2x- upgrade ) intitulada“ Mover código de inicialização do banco de dados ”que eu parecia ter falhou. Portanto, antes de descer qualquer buraco de coelho como eu, certifique-se de que não é isso que está causando a necessidade de adicionar uma implementação de IdesignTimeDbContextFactory. "

De

https://docs.microsoft.com/en-us/ef/core/misc Miscellaneous/cli/dbcontext-creation

Quando você cria um novo aplicativo ASP.NET Core 2.0, esse gancho é incluído por padrão. Nas versões anteriores do EF Core e ASP.NET Core, as ferramentas tentam invocar Startup.ConfigureServices diretamente para obter o provedor de serviços do aplicativo, mas esse padrão não funciona mais corretamente em aplicativos ASP.NET Core 2.0. Se você estiver atualizando um aplicativo ASP.NET Core 1.x para 2.0, poderá modificar sua classe de programa para seguir o novo padrão.

Adicionar fábrica em .Net Core 2.x

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);
        }
    }

Eu tive esse problema e isso foi resolvido por Set -> Web Application (included Program.cs) Project to -> "Set as Startup Project"

Em seguida, execute -> add-migration initial -verbose

no console do gerenciador de pacotes

Definir como projeto inicial

Se você quiser evitar essa coisa de IDesignTimeDbContextFactory: Apenas certifique-se de não usar nenhum método Seed em sua inicialização. Eu estava usando um método de semente estática na minha inicialização e estava causando esse erro para mim.

Anteriormente, você configurava os dados de semente no método Configure em Startup.cs. Agora é recomendado que você use o método Configure apenas para configurar o pipeline de solicitação. O código de inicialização do aplicativo pertence ao método Main.

O método Main refatorado. Adicione as seguintes referências ao Program.cs:

using Microsoft.Extensions.DependencyInjection;

using MyProject.MyDbContextFolder;

public static void Main(string[] args)
{
    var host = BuildWebHost(args);

    using (var scope = host.Services.CreateScope())
    {
        var services = scope.ServiceProvider;
        try
        {
            var context = services.GetRequiredService<MyDbConext>();
            DbInitializer.Initialize(context);
        }
        catch (Exception ex)
        {
            var logger = services.GetRequiredService<ILogger<Program>>();
            logger.LogError(ex, "An error occurred while seeding the database.");
        }
    }

    host.Run();
}

Há um problema com ef semeando db de Startup.Configure in 2.0 ... você ainda pode fazer isso com esta solução alternativa. Testado e funcionou bem

https://garywoodfine.com/how-to-seed-your-ef-core-database/

No meu caso, tive o problema porque tinha um método chamado SeedData.EnsurePopulated () sendo chamado no meu arquivo Startup.cs .

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

    public void ConfigureServices(IServiceCollection services)
    {
        //
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        app.UseDeveloperExceptionPage();
        app.UseStatusCodePages();
        app.UseStaticFiles();
        app.UseSession();
        app.UseMvc(routes =>
        {
            //
        });

        SeedData.EnsurePopulated(app);
    }
}

O trabalho da classe SeedData é adicionar dados iniciais à tabela do banco de dados. Seu código é:

public static void EnsurePopulated(IApplicationBuilder app)
    {
        ApplicationDbContext context = app.ApplicationServices.GetRequiredService<ApplicationDbContext>();
        context.Database.Migrate();
        if (!context.Products.Any())
        {
            context.Products.AddRange(
            new Product
            {
                Name = "Kayak",
                Description = "A boat for one person",
                Category = "Watersports",
                Price = 275
            },
            ....
            );
            context.SaveChanges();
        }
    }

SOLUÇÃO

Antes de fazer a migração, simplesmente comente a chamada da classe SeedData no arquivo Startup.cs.

// SeedData.EnsurePopulated(app);

Isso resolveu meu problema e espero que seu problema também seja resolvido da mesma maneira.

Eu tive o mesmo problema. Tenho dois projetos na solução. qual

1. API
2. Serviços e repo, que contêm modelos de contexto

Inicialmente, o projeto de API foi definido como projeto de inicialização.

Mudei o projeto de inicialização para aquele que contém classes de contexto. se estiver usando o Visual Studio, você pode definir um projeto como projeto de inicialização:

abra o explorador de soluções >> clique com o botão direito no projeto de contexto >> selecione Definir como projeto de inicialização

Antes de mais nada, certifique-se de ter configurado seu banco de dados em Startup.cs No meu caso, eu estava recebendo este erro porque não especifiquei o seguinte emStartup.cs

    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(
            Configuration.GetConnectionString("DefaultConnection"), x => x.MigrationsAssembly("<Your Project Assembly name where DBContext class resides>")));

Usando ASP.NET Core 3.1 e EntityFrameWorkCore 3.1.0. Substituindo OnConfiguring da classe de contexto por um construtor sem parâmetros apenas

```protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        if (!optionsBuilder.IsConfigured)
        {
            IConfigurationRoot configuration = new ConfigurationBuilder()
               .SetBasePath(Directory.GetCurrentDirectory())
               .AddJsonFile("appsettings.json")
               .Build();
            var connectionString = configuration.GetConnectionString("LibraryConnection");
            optionsBuilder.UseSqlServer(connectionString);
        }
    }
```

Eu estava enfrentando o erro

"Não é possível criar um objeto do tipo 'MyContext'. Adicione uma implementação de 'IDesignTimeDbContextFactory' ao projeto ou consulte https://go.microsoft.com/fwlink/?linkid=851728 para padrões adicionais suportados em tempo de design."

Foi assim que meu problema foi resolvido. Execute o comando abaixo enquanto estiver no diretório da solução

 dotnet ef migrations add InitialMigration --project "Blog.Infrastructure" --startup-project "Blog.Appication"

Aqui, Application é meu projeto de inicialização contendo a classe Startup.cs e Infrastructure é meu projeto contendo a classe DbContext.

em seguida, execute a atualização usando a mesma estrutura.

dotnet ef database update --project "Blog.Infrastructure" --startup-project "Blog.Application"

Tive o mesmo problema porque estava me referindo a old- Microsoft.EntityFrameworkCore.Tools.DotNet

<DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="1.0.0" />

Depois de atualizar para a versão mais recente, foi resolvido

No arquivo appsettings.json do projeto principal, configurei 'Copiar para o diretório de saída' como "Copiar sempre" e funcionou.

Amostra de classe de contexto de banco de dados para aplicativos de console principal .net

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Design;
using Microsoft.Extensions.Configuration;
using System.IO;

namespace EmailServerConsole.Data
{
    public class EmailDBContext : DbContext
    {
        public EmailDBContext(DbContextOptions<EmailDBContext> options) : base(options) { }
        public DbSet<EmailQueue> EmailsQueue { get; set; }
    }

    public class ApplicationContextDbFactory : IDesignTimeDbContextFactory<EmailDBContext>
    {
        EmailDBContext IDesignTimeDbContextFactory<EmailDBContext>.CreateDbContext(string[] args)
        {
            IConfigurationRoot configuration = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json")
                .Build();
            var builder = new DbContextOptionsBuilder<EmailDBContext>();
            var connectionString = configuration.GetConnectionString("connection_string");
            builder.UseSqlServer(connectionString);
            return new EmailDBContext(builder.Options);
        }
    }
}

Você também pode usar no construtor da classe de inicialização para adicionar o arquivo json (onde está a string de conexão) à configuração. Exemplo:

    IConfigurationRoot _config;
    public Startup(IHostingEnvironment env)
    {
        var builder = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json");

        _config = builder.Build();
    }

Para mim, foi porque mudei o Output Typedo meu projeto de inicialização de Console Applicationpara Class Library.

Reverter para Console Applicationfazer o truque.

Tive esse problema em uma solução que tem:

• um projeto .NET Core 2.2 MVC
• um projeto .NET Core 3.0 Blazor
• O contexto do banco de dados em um projeto de biblioteca de classes .NET Standard 2.0

Recebo a mensagem "não foi possível criar um objeto ..." quando o projeto Blazor é definido como o projeto de inicialização, mas não se o projeto MVC está definido como o projeto de inicialização.

Isso me intriga, porque no console do gerenciador de pacotes (que é onde estou criando a migração) eu tenho o projeto padrão definido para uma biblioteca de classes C # que realmente contém o contexto do banco de dados, e também estou especificando o contexto do banco de dados em minha chamada para adicionar-migração add-migration MigrationName -context ContextName , então parece estranho que o Visual Studio se importe com o projeto de inicialização que está definido no momento.

Acho que o motivo é que quando o projeto Blazor é o projeto de inicialização, o PMC está determinando a versão do .NET como Core 3.0 a partir do projeto de inicialização e, em seguida, tentando usar isso para executar as migrações na classe .NET Standard 2.0 biblioteca e encontrando algum tipo de conflito.

Seja qual for a causa, mudar o projeto de inicialização para o projeto MVC que visa o Core 2.2, em vez do projeto Blazor, corrigiu o problema

Para mim, o problema era que estava executando os comandos de migração dentro do projeto errado. Executar os comandos dentro do projeto que continha o Startup.cs, em vez do projeto que continha o DbContext, me permitiu superar esse problema específico.

No meu caso, a configuração do projeto StartUp no init ajuda. Você pode fazer isso executando

dotnet ef migrations add init -s ../StartUpProjectName

Eu tive o mesmo problema. Apenas alterei o ap.jason para application.jason e corrigiu o problema