ASP - Core Migrer EF Base SQL DB au Démarrage

Est-il possible d'avoir mon ASP Web de Base de l'API de s'assurer de la DB est migré vers la dernière migration à l'aide de EF de Base? Je sais que cela peut être fait par le biais de la ligne de commande, mais je veux le faire par programmation.

Mise à jour

Basé sur la réponse de Janshair Khan, je suis venu avec cette classe d'assistance:

using Microsoft.AspNetCore.Builder;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using MyWebApi.Models;

namespace MyWebApi
{
    public static class DataSeeder
    {
        public static void SeedData(this IApplicationBuilder app)
        {
            var context = app.ApplicationServices.GetService<MyContext>();

            if (!context.Database.EnsureCreated())
                context.Database.Migrate();
        }
    }
}

Vous pouvez appeler à partir de la Configure méthode dans votre Startup.cs comme ceci:

app.SeedData();

pas encore fait devraient être mises en œuvre avec la prochaine version. Vous pouvez utiliser la solution de contournement qui est affiché ci-dessous à partir de Khan.
Voir les réponses ci-dessous. Vous devez utiliser EnsureCreated ou de Migrer. Pas les deux.
La documentation officielle dit: "N'appelez pas EnsureCreated() avant de Migrer(). EnsureCreated() ignore les Migrations afin de créer le schéma et la cause de Migrer() à l'échec.' : docs.microsoft.com/en-us/ef/core/managing-schemas/migrations/...

InformationsquelleAutor Zeus82 | 2016-06-12

asp.net-core c#entity-framework-core

26

Vous pouvez utiliser
```
db.Database.EnsureCreated();
```
pour obtenir votre base de données à jour avec votre modèle actuel. Si vous souhaitez activer les migrations (Si, à la suite de migrations sont soupçonnés), puis utilisez
```
db.Database.Migrate();
```
et de mettre votre migrations de plus de temps.
- EnsureCreated() fonctionne bien, Mais "le contexte.La base de données.Migrer() " il n'y a pas de Migrer() la méthode pourquoi est-ce ? EF Core
- Je pense que vous êtes absent using Microsoft.EntityFrameworkCore;.
- Oui!! j'ai oublié de mentionner que Merci en tout cas !! <3
InformationsquelleAutor Janshair Khan
34

Une note de la documentation sur l'appel à db.Database.EnsureCreated():

Noter que cette API ne pas utiliser les migrations pour créer la base de données. Dans
outre, la base de données qui est créé ne peut pas être mis à jour ultérieurement à l'aide de
les migrations. Si vous visez une base de données relationnelle et à l'aide de
migrations, vous pouvez utiliser le DbContext.La base de données.Migrer() la méthode de
s'assurer de la base de données est créée et toutes les migrations sont appliquées.

Vous voulez juste l'appel db.Database.Migrate().

Commentaire prises à partir de la source se trouve au-dessus de la déclaration de ici.

InformationsquelleAutor steamrolla

Utilisez code ci-dessous pour exécuter la migration à

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

InformationsquelleAutor chintan310

Basé sur la réponse de @steamrolla je propose les améliorations suivantes:

public static class EnsureMigration
{
    public static void EnsureMigrationOfContext<T>(this IApplicationBuilder app) where T:DbContext
    {
        var context = app.ApplicationServices.GetService<T>();
        context.Database.Migrate();
    }
}

Avec cela, vous pouvez également assurer la migration de différents contextes, par exemple, si vous avez une base de données d'Identité.

Utilisation:

app.EnsureMigrationOfContext<context>();

InformationsquelleAutor pisker

Basé sur chintan310 réponse, voici comment j'ai migrer la base de données. Cela garantit la séparation de la base de données des tâches liées à Program.cs:

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

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

            try
            {
                var context = services.GetService<AppDbContext>();
                context.Database.Migrate();

                var seeder = scope.ServiceProvider.GetService<AppSeeder>();
                seeder.Seed().Wait();
            }
            catch (Exception ex)
            {
                var logger = services.GetRequiredService<ILogger<Program>>();
                logger.LogError(ex, "An error occurred seeding the DB.");
            }
        }

        host.Run();
    }

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

InformationsquelleAutor uex

Je l'ai fait à migrer par programme avec les objectifs EF de Base 2.1.2 & SQL Server, sur la base des réponses ici et bailando bailando réponse sur "Comment et où, à l'appel de la Base de données.EnsureCreated et de la Base de données.Migrer?":

De démarrage.cs

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.EntityFrameworkCore;

namespace MyApp
{
    public class Startup
    {
        //... (only relevant code included) ...

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddDbContext<MyAppContext>(options => 
                options.UseSqlServer(Configuration.GetConnectionString("MyAppContext")));
            //...
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            using (var serviceScope = app.ApplicationServices.CreateScope())
            {
                var context = serviceScope.ServiceProvider.GetService<MyAppContext>();
                context.Database.Migrate();
            }
            //...
        }
    }
}

Le projet à l'aide de ce code est disponible sur Github.

InformationsquelleAutor Lauri Harpf

C'est une légère correction de la réponse précédente qui a créé une méthode d'extension. Il corrige l'erreur qui est jeté à la façon dont elle est écrite.

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.AspNetCore.Builder;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;

namespace MyApp.Extensions
{
    public static class IApplicationBuilderExtensions
    {
        public static void SyncMigrations<T>(this IApplicationBuilder app) where T : DbContext
        {
            using (var serviceScope = app.ApplicationServices.GetRequiredService<IServiceScopeFactory>().CreateScope())
            {
                var context = serviceScope.ServiceProvider.GetService<DbContext>();
                context.Database.Migrate();
            }
        }
    }
}

InformationsquelleAutor Dblock247

Vous devez vous connecter pour publier un commentaire.