Dopo l'aggiornamento ad ASP.NET Core 2.0, non riesco più a creare migrazioni.

Sto ottenendo

"Si è verificato un errore durante la chiamata al metodo" BuildWebHost "sulla classe" Program ". Continuazione senza il provider di servizi dell'applicazione. Errore: si sono verificati uno o più errori. (Impossibile aprire il database" ... "richiesto dall'account di accesso. Accesso non riuscito. Accesso non riuscito per l'utente "..." "

e

"Impossibile creare un oggetto di tipo" MyContext ". Aggiungere un'implementazione di" IDesignTimeDbContextFactory "al progetto o vedere https://go.microsoft.com/fwlink/?linkid=851728 per ulteriori modelli supportati in fase di progettazione."

Il comando che ho eseguito in precedenza era $ dotnet ef migrations add InitialCreate --startup-project "..\Web"(dal progetto / cartella con DBContext).

Stringa di connessione: "Server=(localdb)\\mssqllocaldb;Database=database;Trusted_Connection=True;MultipleActiveResultSets=true"

Questo è il mio 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();
}

Puoi aggiungere una classe che implementa IDesignTimeDbContextFactory all'interno del tuo progetto Web.

Ecco il codice di esempio:

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

Quindi, vai al tuo progetto di database ed esegui quanto segue dalla riga di 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.

risorsa

Non ce n'è bisogno IDesignTimeDbContextFactory.

Correre

add-migration initial -verbose

che rivelerà i dettagli sotto

Si è verificato un errore durante l'accesso a IWebHost sulla classe "Program". Continuare senza il fornitore di servizi dell'applicazione.

avviso, che è la causa principale del problema.

Nel mio caso , il problema era, avere ApplicationRole : IdentityRole<int>e invocare services.AddIdentity<ApplicationUser, IdentityRole>()che causava l'errore di seguito

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'.

Soluzione 1: (trova il problema nel 99% dei casi)

Imposta il progetto dell'applicazione Web come progetto di avvio

Esegui i seguenti comandi con -verboseopzione.

Add-Migration Init -Verbose

-verbose opzione aiuta a scoprire effettivamente il vero problema, contiene errori dettagliati.

Soluzione 2:

Rinomina BuildWebHost()in CreateWebHostBuilder(), perché Entity Framework Core toolsaspettati di trovare un fileCreateHostBuilder metodo che configuri l'host senza eseguire l'app.

.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

Rinomina BuildWebHost()inCreateHostBuilder()

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

Soluzione 3:

Assicurati di aver aggiunto all'inserimento delle Dbcontextdipendenze: AddDbContext<TContext>renderà sia il tuo tipo DbContext TContext, sia il corrispondente DbContextOptions<TContext>disponibile per l'inserimento dal contenitore del servizio. Ciò richiede l'aggiunta di un argomento del costruttore al DbContexttipo che accetta DbContextOptions<TContext>.

Esempio: in Startup.cs

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

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

Rinomina semplicemente BuildWebHost()in CreateWebHostBuilder(), perché le migrazioni utilizzano questo metodo per impostazione predefinita.

Nel mio caso, la causa del problema erano più progetti di avvio. Ho tre progetti nella mia soluzione: Mvc, Api e Dal. DbContext e Migrations nel progetto Dal.

Avevo configurato più progetti di avvio. Entrambi i progetti Mvc e Api erano in esecuzione quando ho fatto clic su Start. Ma in questo caso stavo ottenendo questo errore.

"Impossibile creare un oggetto di tipo" MyContext ". Aggiungere un'implementazione di" IDesignTimeDbContextFactory "al progetto o vedere https://go.microsoft.com/fwlink/?linkid=851728 per ulteriori modelli supportati in fase di progettazione."

Ho potuto aggiungere correttamente la migrazione dopo aver impostato Mvc come unico progetto di avvio e selezionando Dal nella console di Gestione pacchetti.

In AppContext.cs oltre alla classe AppContext aggiungi un'altra 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);
    }
}

Questo risolverà il tuo secondo problema:

"Impossibile creare un oggetto di tipo" MyContext ". Aggiungi un'implementazione di" IDesignTimeDbContextFactory "al progetto,

Dopodiché sarai in grado di aggiungere la migrazione iniziale ed eseguirla eseguendo il comando update-database . Tuttavia, se esegui questi comandi quando non c'è ancora un DataBase nel tuo SqlServer locale, riceverai l'avviso come il tuo primo errore: "Un errore

si è verificato durante la chiamata al metodo "BuildWebHost" sulla classe "Program" ... Accesso non riuscito. Accesso non riuscito per l'utente "..." "

Ma non è un errore perché la migrazione verrà creata e potrà essere eseguita. Quindi ignora questo errore per la prima volta, e l'ultima poiché Db esisterà non si verificherà più.

verifica di avere il riferimento

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

Puoi provare questa soluzione da questa discussione , che è stata ispirata da questo 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();
}

Qualcosa che mi ha davvero aiutato è stato questo articolo: https://elanderson.net/2017/09/unable-to-create-an-object-of-type-applicationdbcontext-add-an-implementation-of-idesigntimedbcontextfactory/

L'idea di base è che nel passaggio da .net core 1 a 2 tutte le inizializzazioni del db dovrebbero essere spostate da StartUp.cs e in Program.cs. In caso contrario, le attività EF tentano di eseguire gli init del database durante l'esecuzione delle attività.

"C'è una bella sezione nei documenti ufficiali di migrazione ( https://docs.microsoft.com/en-us/ef/core/miscellaneous/1x-2x-upgrade ) intitolata" Spostare il codice di inizializzazione del database "che mi sembrava di avere perso. Quindi, prima di andare in giro per le tane del coniglio come ho fatto io, assicurati che questo non sia ciò che sta causando la tua necessità di aggiungere un'implementazione di IdesignTimeDbContextFactory. "

A partire dal

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

Quando crei una nuova applicazione ASP.NET Core 2.0, questo hook è incluso per impostazione predefinita. Nelle versioni precedenti di EF Core e ASP.NET Core, gli strumenti tentano di richiamare direttamente Startup.ConfigureServices per ottenere il provider di servizi dell'applicazione, ma questo modello non funziona più correttamente nelle applicazioni ASP.NET Core 2.0. Se si aggiorna un'applicazione ASP.NET Core 1.x alla 2.0, è possibile modificare la classe Program per seguire il nuovo modello.

Aggiungi Factory in .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);
        }
    }

Ho avuto questo problema e questo è stato risolto da Set -> Web Application (Included Program.cs) Project su -> "Set as Startup Project"

Quindi esegui -> aggiungi-migrazione iniziale -verbose

nella console di Gestione pacchetti

Imposta come progetto di avvio

Se vuoi evitare quelle cose IDesignTimeDbContextFactory: assicurati solo di non utilizzare alcun metodo Seed all'avvio. Stavo usando un metodo seed statico nel mio avvio e stava causando questo errore per me.

In precedenza, hai configurato i dati di inizializzazione nel metodo Configure in Startup.cs. Si consiglia ora di utilizzare il metodo Configure solo per impostare la pipeline delle richieste. Il codice di avvio dell'applicazione appartiene al metodo Main.

Il metodo Main refactoring. Aggiungere i seguenti riferimenti a 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();
}

C'è un problema con ef seeding db da Startup.Configure in 2.0 ... puoi ancora farlo con questo lavoro. Testato e funzionato bene

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

Nel mio caso ho riscontrato il problema perché avevo un metodo chiamato SeedData.EnsurePopulated () che veniva chiamato sul mio file 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);
    }
}

Il lavoro della classe SeedData consiste nell'aggiungere i dati iniziali alla tabella del database. Il suo codice è:

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

SOLUZIONE

Prima di eseguire la migrazione, commentare semplicemente la chiamata della classe SeedData nel file Startup.cs.

// SeedData.EnsurePopulated(app);

Questo ha risolto il mio problema e spero che anche il tuo problema venga risolto allo stesso modo.

Ho incontrato lo stesso problema. Ho due progetti nella soluzione. quale

1. API
2. Servizi e repo, che contengono modelli di contesto

Inizialmente, il progetto API era impostato come progetto di avvio.

Ho cambiato il progetto di avvio con quello che contiene le classi di contesto. se stai usando Visual Studio puoi impostare un progetto come progetto di avvio tramite:

apri Esplora soluzioni >> fai clic con il pulsante destro del mouse sul progetto contestuale >> seleziona Imposta come progetto di avvio

Prima di tutto assicurati di aver configurato il tuo database nel Startup.cs mio caso, ho ricevuto questo errore poiché non ho specificato quanto segue inStartup.cs

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

Utilizzando ASP.NET Core 3.1 e EntityFrameWorkCore 3.1.0. Sostituzione di OnConfiguring della classe di contesto solo con un costruttore senza parametri

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

Stavo affrontando l'errore

"Impossibile creare un oggetto di tipo" MyContext ". Aggiungi un'implementazione di" IDesignTimeDbContextFactory "al progetto oppure consulta https://go.microsoft.com/fwlink/?linkid=851728 per ulteriori modelli supportati in fase di progettazione."

Ecco come è stato risolto il mio problema. Esegui il comando seguente mentre ti trovi nella directory della soluzione

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

Qui Application è il mio progetto di avvio contenente la classe Startup.cs & Infrastructure è il mio progetto contenente la classe DbContext.

quindi eseguire l'aggiornamento utilizzando la stessa struttura.

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

Ho avuto lo stesso problema da quando mi riferivo al vecchio Microsoft.EntityFrameworkCore.Tools.DotNet

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

Dopo l'aggiornamento alla versione più recente è stato risolto

Nel file appsettings.json del progetto principale, avevo impostato "Copia nella directory di output" su "Copia sempre" e ha funzionato.

Classe di contesto DB di esempio per applicazioni console .net core

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

È inoltre possibile utilizzare nel costruttore della classe di avvio per aggiungere il file json (dove si trova la stringa di connessione) alla configurazione. Esempio:

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

        _config = builder.Build();
    }

Per me è stato perché ho cambiato il Output Typedel mio progetto di avvio da Console ApplicationaClass Library .

Tornare a ha Console Applicationfatto il trucco.

Ho riscontrato questo problema in una soluzione che ha:

• un progetto .NET Core 2.2 MVC
• un progetto .NET Core 3.0 Blazor
• Il contesto del database in un progetto di libreria di classi .NET Standard 2.0

Ottengo il messaggio "impossibile creare un oggetto ..." quando il progetto Blazor è impostato come progetto di avvio, ma non se il progetto MVC è impostato come progetto di avvio.

Questo mi lascia perplesso, perché nella console di Gestione pacchetti (che è dove sto creando la migrazione) ho il progetto predefinito impostato su una libreria di classi C # che contiene effettivamente il contesto DB e sto anche specificando il contesto DB in la mia chiamata a add-migration add-migration MigrationName -context ContextName, quindi sembra strano che Visual Studio si preoccupi del progetto di avvio attualmente impostato.

Immagino che il motivo sia che quando il progetto Blazor è il progetto di avvio, il PMC determina la versione di .NET come Core 3.0 dal progetto di avvio e quindi cerca di usarlo per eseguire le migrazioni sulla classe .NET Standard 2.0 biblioteca e colpire un conflitto di qualche tipo.

Qualunque sia la causa, la modifica del progetto di avvio nel progetto MVC che ha come target Core 2.2, piuttosto che il progetto Blazor, ha risolto il problema

Per me il problema era che stavo eseguendo i comandi di migrazione all'interno del progetto sbagliato. L'esecuzione dei comandi all'interno del progetto che conteneva Startup.cs piuttosto che il progetto che conteneva DbContext mi ha permesso di superare questo particolare problema.

Nel mio caso l'impostazione del progetto StartUp in init aiuta. Puoi farlo eseguendo

dotnet ef migrations add init -s ../StartUpProjectName

Ho avuto lo stesso problema. Ho appena cambiato ap.jason in application.jason e il problema è stato risolto