Après la mise à niveau vers ASP.NET Core 2.0, je n'arrive plus à créer de migrations.

Je suis en train

"Une erreur s'est produite lors de l'appel de la méthode 'BuildWebHost' sur la classe 'Program'. Poursuite sans le fournisseur de services d'application. Erreur: une ou plusieurs erreurs se sont produites. (Impossible d'ouvrir la base de données" ... "demandée par la connexion. La connexion a échoué. Connexion a échoué pour l'utilisateur '...' "

et

"Impossible de créer un objet de type 'MyContext'. Ajoutez une implémentation de 'IDesignTimeDbContextFactory' au projet ou consultez https://go.microsoft.com/fwlink/?linkid=851728 pour des modèles supplémentaires pris en charge au moment du design."

La commande que j'ai précédemment exécutée était $ dotnet ef migrations add InitialCreate --startup-project "..\Web"(à partir du projet / dossier avec le DBContext).

Chaîne de connexion: "Server=(localdb)\\mssqllocaldb;Database=database;Trusted_Connection=True;MultipleActiveResultSets=true"

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

Vous pouvez ajouter une classe qui implémente IDesignTimeDbContextFactory à l'intérieur de votre projet Web.

Voici l exemple de code:

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

Ensuite, accédez à votre projet de base de données et exécutez ce qui suit à partir de la ligne de commande:

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.

Ressource

Pas besoin de IDesignTimeDbContextFactory.

Courir

add-migration initial -verbose

qui révélera les détails sous

Une erreur s'est produite lors de l'accès à IWebHost sur la classe 'Programme'. Continuer sans le fournisseur de services d'application.

avertissement, qui est la cause première du problème.

Dans mon cas , le problème était d'avoir ApplicationRole : IdentityRole<int>et d'invoquer services.AddIdentity<ApplicationUser, IdentityRole>()ce qui causait l'erreur ci-dessous

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

Solution 1: (Trouvez le problème dans 99% des cas)

Définir le projet d' application Web comme projet de démarrage

Exécutez les commandes suivantes avec -verboseoption.

Add-Migration Init -Verbose

-verbose L'option permet de découvrir le vrai problème, elle contient des erreurs détaillées.

Solution 2:

Renommez BuildWebHost()en CreateWebHostBuilder(), car Entity Framework Core toolsattendez - vous à trouver une CreateHostBuilderméthode qui configure l'hôte sans exécuter l'application.

.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

Renommer BuildWebHost()enCreateHostBuilder()

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

Solution 3:

Assurez-vous que vous avez ajouté Dbcontextà l'injection de dépendances: AddDbContext<TContext>rendra votre type DbContext TContext, et le correspondant DbContextOptions<TContext>disponible pour injection à partir du conteneur de service. Cela nécessite l'ajout d'un argument de constructeur à votre DbContexttype qui accepte DbContextOptions<TContext>.

Exemple: dans Startup.cs

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

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

Renommez simplement BuildWebHost()en CreateWebHostBuilder(), car les migrations utilisent cette méthode par défaut.

Dans mon cas, la cause du problème était plusieurs projets de démarrage. J'ai trois projets dans ma solution: Mvc, Api et Dal. DbContext et Migrations dans le projet Dal.

J'avais configuré plusieurs projets de démarrage. Les projets Mvc et Api étaient en cours d'exécution lorsque j'ai cliqué sur Démarrer. Mais dans ce cas, j'obtenais cette erreur.

"Impossible de créer un objet de type 'MyContext'. Ajoutez une implémentation de 'IDesignTimeDbContextFactory' au projet ou consultez https://go.microsoft.com/fwlink/?linkid=851728 pour des modèles supplémentaires pris en charge au moment du design."

J'ai pu ajouter avec succès la migration après avoir défini Mvc comme seul projet de démarrage et sélectionné Dal dans la console du gestionnaire de package.

Dans AppContext.cs en plus de la classe AppContext, ajoutez une autre 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);
    }
}

Cela résoudra votre deuxième problème:

"Impossible de créer un objet de type 'MyContext'. Ajoutez une implémentation de 'IDesignTimeDbContextFactory' au projet,

Après cela, vous pourrez ajouter-migration Initial et l'exécuter en exécutant la commande update-database . Cependant, si vous exécutez ces commandes alors qu'il n'y a pas encore de DataBase dans votre SqlServer local, vous obtiendrez l'avertissement comme votre première erreur: "Une erreur

s'est produite lors de l'appel de la méthode 'BuildWebHost' sur la classe 'Program' ... La connexion a échoué. La connexion a échoué pour l'utilisateur '...' "

Mais ce n'est pas une erreur car la migration sera créée et peut être exécutée. Alors ignorez simplement cette erreur pour la première fois, et ce dernier étant donné que Db existera, cela ne se reproduira plus.

veuillez vérifier que vous avez la référence

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

Vous pouvez essayer cette solution à partir de cette discussion , qui a été inspirée par ce 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();
}

Quelque chose qui m'a vraiment aidé était cet article: https://elanderson.net/2017/09/unable-to-create-an-object-of-type-applicationdbcontext-add-an-implementation-of-idesigntimedbcontextfactory/

L'idée de base est que lors du passage de .net core 1 à 2, toute l'initialisation de base de données doit être déplacée hors de StartUp.cs et dans Program.cs. Sinon, les tâches EF essaient d'exécuter vos inits DB lors de l'exécution de tâches.

"Il y a une belle section dans la documentation officielle sur la migration ( https://docs.microsoft.com/en-us/ef/core/miscellaneous/1x-2x-upgrade ) intitulée" Move database initialization code "que je semblait avoir Donc, avant de vous diriger vers les terriers comme moi, assurez-vous que ce n'est pas ce qui vous oblige à ajouter une implémentation de IdesignTimeDbContextFactory. "

De

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

Lorsque vous créez une nouvelle application ASP.NET Core 2.0, ce hook est inclus par défaut. Dans les versions précédentes d'EF Core et ASP.NET Core, les outils tentent d'appeler Startup.ConfigureServices directement afin d'obtenir le fournisseur de services de l'application, mais ce modèle ne fonctionne plus correctement dans les applications ASP.NET Core 2.0. Si vous mettez à niveau une application ASP.NET Core 1.x vers 2.0, vous pouvez modifier votre classe Program pour suivre le nouveau modèle.

Ajouter Factory dans .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);
        }
    }

J'ai eu ce problème et cela a été résolu par Set -> Web Application (Included Program.cs) Project to -> "Set as Startup Project"

Puis exécutez -> add-migration initial -verbose

dans la console du gestionnaire de package

Définir comme projet de démarrage

Si vous voulez éviter ces choses IDesignTimeDbContextFactory: Assurez-vous simplement que vous n'utilisez aucune méthode Seed dans votre démarrage. J'utilisais une méthode de démarrage statique dans mon démarrage et cela provoquait cette erreur pour moi.

Auparavant, vous configuriez les données d'amorçage dans la méthode Configure dans Startup.cs. Il est maintenant recommandé d'utiliser la méthode Configure uniquement pour configurer le pipeline de requêtes. Le code de démarrage de l'application appartient à la méthode Main.

La méthode Main refactorisée. Ajoutez les références suivantes à 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();
}

Il y a un problème avec ef semant db à partir de Startup.Configure dans 2.0 ... vous pouvez toujours le faire avec cette solution. Testé et a bien fonctionné

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

Dans mon cas, j'ai eu le problème parce que j'avais une méthode appelée SeedData.EnsurePopulated () appelée sur mon fichier 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);
    }
}

Le travail de la classe SeedData consiste à ajouter des données initiales à la table de base de données. Son code est:

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

SOLUTION

Avant de procéder à la migration, commentez simplement l'appel de la classe SeedData dans le fichier Startup.cs.

// SeedData.EnsurePopulated(app);

Cela a résolu mon problème et j'espère que votre problème sera également résolu de la même manière.

J'ai rencontré le même problème. J'ai deux projets dans la solution. lequel

1. API
2. Services et repo, qui contiennent des modèles de contexte

Initialement, le projet API était défini comme projet de démarrage.

J'ai changé le projet Startup pour celui qui contient des classes de contexte. si vous utilisez Visual Studio, vous pouvez définir un projet en tant que projet de démarrage en:

ouvrir l'explorateur de solutions >> cliquer avec le bouton droit sur le projet contextuel >> sélectionner Définir comme projet de démarrage

Tout d'abord, assurez-vous d'avoir configuré votre base de données dans Startup.cs Dans mon cas, j'obtenais cette erreur car je n'ai pas spécifié ce qui suit dansStartup.cs

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

Utilisation d'ASP.NET Core 3.1 et EntityFrameWorkCore 3.1.0. Remplacement de OnConfiguring de la classe de contexte avec un constructeur sans paramètre uniquement

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

Je faisais face à l'erreur

"Impossible de créer un objet de type 'MyContext'. Ajoutez une implémentation de 'IDesignTimeDbContextFactory' au projet ou consultez https://go.microsoft.com/fwlink/?linkid=851728 pour des modèles supplémentaires pris en charge au moment du design."

C'est ainsi que mon problème a été résolu. Exécutez la commande ci-dessous pendant que vous êtes dans votre répertoire de solution

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

Ici, l'application est mon projet de démarrage contenant la classe Startup.cs et l'infrastructure est mon projet contenant la classe DbContext.

puis exécutez la mise à jour en utilisant la même structure.

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

J'ai eu le même problème depuis que je faisais référence à l'ancien - Microsoft.EntityFrameworkCore.Tools.DotNet

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

Après la mise à niveau vers la nouvelle version, le problème a été résolu

Dans le fichier appsettings.json du projet principal, j'avais défini «Copier dans le répertoire de sortie» sur «Copier toujours» et cela fonctionnait.

Exemple de classe de contexte de base de données pour les applications de la console principale .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);
        }
    }
}

Vous pouvez également utiliser dans le constructeur de classe de démarrage pour ajouter un fichier json (où se trouve la chaîne de connexion) à la configuration. Exemple:

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

        _config = builder.Build();
    }

Pour moi, c'est parce que j'ai changé le Output Typede mon projet de démarrage de Console Applicationà Class Library.

Revenir a Console Applicationfait l'affaire.

J'ai eu ce problème dans une solution qui a:

• un projet MVC .NET Core 2.2
• un projet Blazor .NET Core 3.0
• Le contexte de base de données dans un projet de bibliothèque de classes .NET Standard 2.0

J'obtiens le message "Impossible de créer un objet ..." lorsque le projet Blazor est défini comme projet de démarrage, mais pas si le projet MVC est défini comme projet de démarrage.

Cela me laisse perplexe, car dans la console du gestionnaire de packages (où je crée la migration), j'ai le projet par défaut défini sur une bibliothèque de classes C # qui contient réellement le contexte de base de données, et je spécifie également le contexte de base de données dans mon appel à add-migration add-migration MigrationName -context ContextName, il semble donc étrange que Visual Studio se soucie du projet de démarrage actuellement défini.

Je suppose que la raison est que lorsque le projet Blazor est le projet de démarrage, le PMC détermine la version de .NET comme Core 3.0 à partir du projet de démarrage, puis essaie de l'utiliser pour exécuter les migrations sur la classe .NET Standard 2.0 bibliothèque et frapper un conflit de quelque sorte.

Quelle que soit la cause, le changement du projet de démarrage en projet MVC qui cible Core 2.2, plutôt que le projet Blazor, a résolu le problème

Pour moi, le problème était que j'exécutais les commandes de migration dans le mauvais projet. L'exécution des commandes à l'intérieur du projet qui contenait le Startup.cs plutôt que le projet qui contenait le DbContext m'a permis de passer outre ce problème particulier.

Dans mon cas, la configuration du projet StartUp dans init aide. Vous pouvez le faire en exécutant

dotnet ef migrations add init -s ../StartUpProjectName

J'ai eu le même problème. Je viens de changer le ap.jason en application.jason et cela a résolu le problème