web-dev-qa-db-fra.com

Migrations automatiques EntityFramework Core

Existe-t-il un code permettant d'effectuer une migration automatique dans Entity Framework corecode first dans le projet principal asp.net?

Je le fais simplement dans MVC4/5 en ajoutant

Database.SetInitializer(new MigrateDatabaseToLatestVersion<AppDbContext, MyProject.Migrations.Configuration>());
public Configuration() {
          AutomaticMigrationsEnabled = true;
        }

Cela permet de gagner du temps lorsque les entités ont changé

entity-frameworkasp.net-coreentity-framework-core
17
Lapenkov Vladimir

Vous pouvez appeler context.Database.Migrate()dans votre Startup.cs

par exemple:

using (var context = new MyContext(...))
{
    context.Database.Migrate();
}
17
Frank Odoom

Le cœur EF ne prend pas en chargeautomatic migrations.Vous devez donc le faire manuellement.

Du point de vue des migrations automatiques en tant que fonctionnalité, nous ne sommes pas envisage de l'implémenter dans EF Core, l'expérience ayant montré une base de code les migrations constituent une approche plus gérable.

Vous pouvez lire le récit complet ici: Ne pas implémenter les migrations automatiques

21
Sampath

C’est ce qu’ils font dans IdentityServer4 http://identityserver.io 

public void ConfigureServices(IServiceCollection services)
{
    var connectionString = Configuration.GetConnectionString("DefaultConnection");
    var migrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name;

    // Add framework services.
    services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlServer(connectionString));
    ...
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
    // this will do the initial DB population
    InitializeDatabase(app);
}

private void InitializeDatabase(IApplicationBuilder app)
{
    using (var scope = app.ApplicationServices.GetService<IServiceScopeFactory>().CreateScope())
    {
        scope.ServiceProvider.GetRequiredService<ApplicationDbContext>().Database.Migrate();
        scope.ServiceProvider.GetRequiredService<PersistedGrantDbContext>().Database.Migrate();
        ...
    }
}
15
Matt Morgan

Les migrations automatiques ne sont pas prises en charge dans EF Core. La migration, il est nécessaire de créer des mains. Pour appliquer automatiquement toutes les migrations à la main existantes, vous devez ajouter le code suivant dans DbContext:

public sealed class MyDbContext : DbContext
{
  private static readonly bool[] _migrated = { false };

  public MyDbContext( DbContextOptions<MyDbContext> options ) : base( options )
  {
    if ( !_migrated[0] )
      lock ( _migrated )
        if ( !_migrated[0] )
        {
          Database.Migrate(); // apply all migrations
          _migrated[0] = true;
        }
  }
}

Ce n'est pas élégant, mais ça marche.

Mise à jour pour EFCore 2.1: 

public class Program
{
    public static void Main(string[] args)
    {
        var Host = CreateWebHostBuilder(args).Build();

        using (var scope = Host.Services.CreateScope())
        {
            var services = scope.ServiceProvider;

            try
            {
                var context = services.GetRequiredService<MyDbContext>();
                context.Database.Migrate(); // apply all migrations
                SeedData.Initialize(services); // Insert default data
            }
            catch (Exception ex)
            {
                var logger = services.GetRequiredService<ILogger<Program>>();
                logger.LogError(ex, "An error occurred seeding the DB.");
            }
        }

        Host.Run();
    }

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

Suite à la documentation de Microsoft

https://docs.Microsoft.com/en-us/aspnet/core/data/ef-mvc/intro

Si vous utilisez l'injection de dépendance, vous devez d'abord configurer une classe statique Data/DbInitializer.cs et ajouter le code suivant:

public static class DbInitializer
{
    public static void Initialize(ApplicationDbContext context)
    {
        context.Database.Migrate();

        // Add Seed Data...
    }
}

Notez que c’est également à cet endroit que vous pouvez ajouter des données de départ.

Ensuite, dans votre fichier Program.cs, ajoutez le code suivant

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

        using (var scope = Host.Services.CreateScope())
        {
            var services = scope.ServiceProvider;
            try
            {
                var environment = services.GetRequiredService<IHostingEnvironment>();

                if (!environment.IsDevelopment())
                {
                    var context = services.GetRequiredService<ApplicationDbContext>();
                    DbInitializer.Initialize(context);
                }
            }
            catch (Exception ex)
            {
                var logger = services.GetRequiredService<ILogger<Program>>();
                logger.LogError(ex, "An error occurred while seeding the database.");
            }
        }

        Host.Run();
    }

Dans mon cas, je vérifie l'environnement pour m'assurer que je suis en développement afin de pouvoir contrôler les migrations/mises à jour. Cependant, en production, je veux qu’ils soient automatiques pour une intégration continue. Comme d'autres l'ont mentionné, il ne s'agit probablement pas des meilleures pratiques, mais cela fonctionne très bien dans les petits projets.

3
Amac

Mon code de migration automatique Asp Net Core 2.0.7.

    // startup.cs
    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        // configure app

        SeedData.Initialize(app.ApplicationServices);
    }       

    // dbInitializer.cs
    public static class SeedData
    {
        public static void Initialize(IServiceProvider serviceProvider)
        {
            using (var serviceScope = serviceProvider.CreateScope())
            {
                var context = serviceScope.ServiceProvider.GetService<ApplicationDbContext>();

                // auto migration
                context.Database.Migrate();

                // Seed the database.
                InitializeUserAndRoles(context);
            }
        }

        private static void InitializeUserAndRoles(ApplicationDbContext context)
        {
            // init user and roles  
        }
    }
1
dev-siberia

mon meilleur conseil est de ne pas utiliser la migration automatique. Il est toujours préférable d'ajouter les migrations manuellement, d'éviter également les migrations en bloc et de s'en tenir aux meilleures pratiques d'utilisation de la migration manuelle.

la migration automatique n'est pas un outil magique et il y aura plusieurs occasions où vous voudrez peut-être ajouter quelques modifications supplémentaires à la migration. Vous accomplissez uniquement en utilisant la migration manuelle.

Pour activer la migration, tapez "enable-migrations" dans la console du gestionnaire de packages.

De cette façon, vous aurez le contrôle total de la mise à niveau ou du déclassement de votre base de données et également un suivi facile des migrations.

Juste trois étapes simples dans la console du gestionnaire de paquets.

1) add-migrations [un nom pour votre migration]

2) les migrations sont générées pour les modifications, vous les révisez et pouvez également les modifier

3) la base de données de mise à jour de votre migration est maintenant terminée.

gérer la migration est moins pénible!

0
srini

Vous pouvez appeler Database.Migrate() dans le constructeur de contexte de base de données.

0
Evgeniy K