El modelo que respalda el contexto de <Base de datos> ha cambiado desde que se creó la base de datos

El mensaje de error:

"El modelo que respalda el contexto de 'AddressBook' ha cambiado desde que se creó la base de datos. Elimine / actualice manualmente la base de datos o llame a Database.SetInitializer con una instancia de IDatabaseInitializer. Por ejemplo, la estrategia RecreateDatabaseIfModelChanges eliminará y volverá a crear la base de datos, y opcionalmente sembrarlo con nuevos datos ".

Estoy tratando de usar la función de código primero y lo siguiente es lo que escribí:

var modelBuilder = new ModelBuilder();
var model = modelBuilder.CreateModel();
using (AddressBook context = new AddressBook(model))
{
    var contact = new Contact
    {
        ContactID = 10000,
        FirstName = "Brian",
        LastName = "Lara",
        ModifiedDate = DateTime.Now,
        AddDate = DateTime.Now,
        Title = "Mr."

    };
    context.contacts.Add(contact);
    int result = context.SaveChanges();
    Console.WriteLine("Result :- "+ result.ToString());
}

La clase de contexto:

public class AddressBook : DbContext
{
    public AddressBook()
    { }
    public AddressBook(DbModel AddressBook)
        : base(AddressBook)
    {

    }
    public DbSet<Contact> contacts { get; set; }
    public DbSet<Address> Addresses { get; set; }
}

y la cadena de conexión:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <connectionStrings>
    <add name="AddressBook" providerName="System.Data.SqlClient"  
         connectionString="Data Source=MyMachine;Initial Catalog=AddressBook;
         Integrated Security=True;MultipleActiveResultSets=True;"/>
    </connectionStrings>
</configuration>

Entonces, el nombre de la base de datos es "AddressBook" y el error ocurre cuando intento agregar el objeto de contacto al contexto. ¿Me estoy perdiendo algo aquí?

Ahora es:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    Database.SetInitializer<YourDbContext>(null);
    base.OnModelCreating(modelBuilder);
}

en su archivo YourDbContext.cs.

Aquí hay información del Blog de Scott Gu publicado por Jeff sobre lo que realmente está sucediendo:

Para aquellos que están viendo esta excepción:

"El modelo que respalda el contexto de 'Producción' ha cambiado desde que se creó la base de datos. Elimine / actualice manualmente la base de datos o llame Database.SetInitializercon una IDatabaseInitializerinstancia".

Esto es lo que está sucediendo y qué hacer al respecto:

Cuando se crea un modelo por primera vez, ejecutamos un DatabaseInitializer para hacer cosas como crear la base de datos si no está allí o agregar datos semilla. El DatabaseInitializer predeterminado intenta comparar el esquema de la base de datos necesario para usar el modelo con un hash del esquema almacenado en una tabla EdmMetadata que se crea con una base de datos (cuando Code First es el que crea la base de datos). Las bases de datos existentes no tendrán la tabla EdmMetadata y, por lo tanto, no tendrán el hash ... y la implementación de hoy se lanzará si falta esa tabla. Trabajaremos para cambiar este comportamiento antes de enviar la versión final, ya que es la predeterminada. Hasta entonces, las bases de datos existentes generalmente no necesitan ningún inicializador de base de datos, por lo que se puede desactivar para su tipo de contexto llamando a:

Database.SetInitializer<YourDbContext>(null);

Jeff

Para Entity Framework 5.0.0.0 - 6.1.3

Usted QUÉ realmente desea hacer lo siguiente:

1. using System.Data.Entity;   to startup file (console app --> Program.cs / mvc --> global.asax
2. Database.SetInitializer<YourDatabaseContext>(null);

Sí, Matt Frear está en lo correcto. ACTUALIZACIÓN-EDITAR: La advertencia es que estoy de acuerdo con otros en eso en lugar de agregar este código a global.asax agregado a su clase DbContext

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    // other code 
    Database.SetInitializer<YOURContext>(null);
    // more code here.
}

Como otros mencionaron, esto también es bueno para manejar las pruebas unitarias.

Actualmente estoy usando esto con Entity Framework 6.1.3 /.net 4.6.1

Volveré para proporcionar un fragmento CORE en el futuro cercano.

Simplemente ejecute el comando followng sql en SQL Server Management Studio:

delete FROM [dbo].[__MigrationHistory]

Esta solución ya no funciona después de CTP5.

Tu tienes que hacer Database.SetInitializer<YourContext>(null);

Acabo de encontrar la respuesta y pensé en actualizar aquí. Solo necesito hacer lo siguiente.

public class AddressBook: DbContext
{
   protected override void OnModelCreating(ModelBuilder modelBuilder)
   {
    modelBuilder.IncludeMetadataInDatabase = false;
   }
}

O puede poner esta línea en su archivo Global.asax.cs en Application_Start ():

System.Data.Entity.Database.SetInitializer(new System.Data.Entity.DropCreateDatabaseIfModelChanges<ProjectName.Path.Context>());

Asegúrese de cambiar ProjectName.Path.Context a su espacio de nombres y contexto. Si usa el código primero, esto eliminará y creará una nueva base de datos cada vez que se realicen cambios en el esquema.

Pasé muchos días para resolver este problema, analicé muchas publicaciones diferentes e intenté muchas opciones y finalmente lo solucioné. Estos 2 proyectos en mi solución usan las primeras migraciones de código EF:

• Aplicación de consola "DataModel" que utiliza principalmente como ensamblado que contiene todas mis primeras entidades de código, DbContext, Mirgation y repositorio genérico. He incluido en este proyecto un archivo de base de datos local vacío separado (en la carpeta DataModel / App_Data) para poder generar migraciones desde la consola de Package Manager.
• WebApi, que hace referencia al proyecto DataModel y utiliza un archivo de base de datos local de la carpeta WebApi / App_Data, que no está incluido en el proyecto

Recibí este error cuando solicité WebApi ...

Mi entorno:

• Windows 8.1 x64
• Visual Studio 2015 Professional con Actualización 1
• Todos mis proyectos destinados a .NET Framework 4.6.1
• EntityFramework 6.1.3 de NuGet

Aquí reuní todos los comentarios a los que debe prestar atención y todas las condiciones / requisitos que deben cumplirse, para evitar la excepción mencionada:

1. Debe usar solo una versión del paquete EntityFramework Nuget para todos los proyectos en su solución.
2. La base de datos, creada ejecutando secuencialmente todos los scripts de migración, debe tener la misma estructura / esquema que la base de datos de destino y corresponder al modelo de entidad. Las siguientes 3 cosas deben corresponder / reflexionar / coincidir exactamente entre sí:
   • Su script de migración completo hasta el final
   • Estado actual del modelo de primera entidad de código (DbContext, entidades)
   • Base de datos de destino
3. La base de datos de destino (archivo mdf) debe actualizarse / corresponder hasta el último script de migración. Verifique que la tabla "__MigrationHistory" en su base de datos de destino contenga registros para todos los scripts de migración que tenga, esto significa que todos los scripts de migración se aplicaron con éxito a esa base de datos. Le recomiendo que use Visual Studio para generar el código correcto de las primeras entidades y el contexto que corresponde a su base de datos, Proyecto -> Agregar nuevo elemento -> Modelo de datos de entidad ADO.NET -> Código primero de la base de datos: Por supuesto, como alternativa, si no tiene base de datos, puede escribir manualmente el modelo (codificar primero las entidades y el contexto) y luego generar la migración inicial y la base de datos.

4. Nombre de la cadena de conexión, por ejemplo, MyConnectionString en el archivo de configuración del proyecto de inicio (Web.config / App.config):

   <configuration>
     <connectionStrings>
       <add name="MyConnectionString" connectionString="...">
     </connectionStrings>
   <configuration>

   debe ser igual al parámetro pasado en el constructor de su DbContext:

    public partial class MyDbContext : DbContext
    {
       public MyDbContext()
          : base("name=MyConnectionString"){}
       ...

5. Antes de usar Package Manager Console , asegúrese de estar utilizando la base de datos correcta para actualizar o generar la migración y el proyecto necesario esté configurado como proyecto de inicio de la solución. Para conectarse a la base de datos, usará una cadena de conexión de ese archivo .config, que en el proyecto, que se establece como proyecto de inicio.

6. Y el principal, que solucionó mi problema: es extraño, pero en mi carpeta WebApi / bin DataModel.exe era antiguo, no actualizado desde la última compilación. Dado que las migraciones se incrustaban en mi ensamblaje DataModel.exe, mi base de datos actualizada de WebApi utilizaba antiguas réplicas. Estaba confundido por qué después de actualizar la base de datos en WebApi no corresponde a la última secuencia de comandos de migración de DataModel. El siguiente código crea automáticamente (si no existe) o actualiza la última base de datos local de migración en mi carpeta WebApi / App_Data.

      public class WebApiApplication : System.Web.HttpApplication
      {
          protected void Application_Start()
          {
              Database.SetInitializer(new MigrateDatabaseToLatestVersion<ODS_DbContext, Configuration>()); 
              ...

   Intenté limpiar y reconstruir la solución, pero no sirvió de nada, entonces eliminé por completo las carpetas bin y obj de WebApi, eliminé los archivos de la base de datos de WebApi / App_Data, construí, reinicié WebApi, lo solicité, creó la base de datos correcta: inicialización diferida (usando líneas anteriores), que corresponde a la última migración y la excepción no apareció más. Entonces, esto puede solucionar su problema:

   1. eliminar manualmente las carpetas bin, obj de su proyecto de inicio (que genera / actualiza su base de datos)
   2. construya su proyecto de inicio o mejor limpie y reconstruya toda su solución.
   3. vuelva a crear la base de datos iniciando el proyecto (ejecutará las líneas anteriores) o use el comando "actualizar-base de datos" de Package Manager Console.
   4. compruebe manualmente si db y __MirgationHistory generados corresponden al último script de migración.

Para mí, con la actualización a 4.3.1, simplemente trunco ​​la tabla EdmMetaData o simplemente la elimino por completo.

Para desarrolladores de VB.NET:

Agregue la siguiente línea al archivo Glabal.asax.vb, al final del método Application_Start ()

Database.SetInitializer(Of ApplicationDbContext)(Nothing)

Cambie ApplicationDbContext a su contexto Db específico.

Tuve este problema y resultó que un proyecto apuntaba a SQLExpress pero el que tenía el problema apuntaba a LocalDb. (en su respectivo web.config). Supervisión tonta pero vale la pena señalar aquí en caso de que alguien más esté solucionando este problema.

Significa que hubo algunos cambios en el contexto que no se han ejecutado. Ejecute Add-Migration primero para generar los cambios que hemos realizado (los cambios que quizás no sepamos) Y luego ejecute Update-Database

Tuve el mismo problema: volver a agregar la migración y actualizar la base de datos no funcionó y ninguna de las respuestas anteriores parecía correcta. Entonces la inspiración me golpeó: estoy usando varios niveles (una web, un dato y un negocio). La capa de datos tiene el contexto y todos los modelos. La capa web nunca arrojó esta excepción: era la capa empresarial (que configuré como aplicación de consola para pruebas y depuración). Resulta que la capa empresarial no estaba usando la cadena de conexión correcta para obtener la base de datos y hacer el contexto. Así que agregué la cadena de conexión a la configuración de la aplicación de la capa empresarial (y la capa de datos) y viola funciona. Poniendo esto aquí para otros que puedan encontrar el mismo problema.

Utilizo el método Database.CompatibleWithModel (disponible en EF5) para probar si el modelo y la base de datos coinciden antes de usarlo. Llamo a este método justo después de crear el contexto ...

        // test the context to see if the model is out of sync with the db...
        if (!MyContext.Database.CompatibleWithModel(true))
        {
            // delete the old version of the database...
            if (File.Exists(databaseFileName))
                File.Delete(databaseFileName);
            MyContext.Database.Initialize(true);

            // re-populate database

        }

Buena sugerencia, sin embargo, no es tan precisa en todos los casos. Me imagino uno. Debe asegurarse de ejecutar "enable-migrations" utilizando ventanas PM en Visual Studio, y la carpeta de Migración se agregará a su proyecto.

Asegúrese de que los dos archivos de clase c # agregados a la carpeta contengan todos sus modelos y sus respectivas propiedades.

Si tiene todo eso, cree la solución y publíquela para su implementación.

La lógica es que los metadatos existentes no pueden sobrescribirse porque su aplicación no tiene metadatos para reemplazar el actual. Como resultado, obtiene este error "El modelo que respalda el contexto ha cambiado desde que se creó la base de datos"

Por si acaso alguien tiene el mismo escenario que el mío.

Tengo la primera base de datos EF y al mismo tiempo uso la identidad asp.net

entonces tengo dos stringStrings en mi configuración web, y no hay problema con eso. Sucedió que creé / ejecuté los scripts para generar manualmente las tablas de identidad asp.net que no debería.

así que DROP primero todas las tablas de identidad asp.net creadas por usted manualmente / a partir de scripts.

DROP TABLE __MigrationHistory
DROP TABLE AspNetRoles
DROP TABLE AspNetUserClaims
DROP TABLE AspNetUserLogins
DROP TABLE AspNetUserRoles
DROP TABLE AspNetUsers

Ninguna de estas soluciones funcionaría para nosotros (aparte de deshabilitar la comprobación del esquema por completo). Al final tuvimos una coincidencia errónea en nuestra versión de Newtonsoft.json

Nuestra AppConfig no se actualizó correctamente:

<dependentAssembly>
   <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
    <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
  </dependentAssembly>

La solución fue corregir la versión de ensamblaje a la que realmente estábamos implementando

<dependentAssembly>
   <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
    <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="10.0.0.0" />
  </dependentAssembly>

Después de investigar un poco sobre este tema, descubrí que el error ocurre básicamente si tiene una instancia de db creada previamente en su servidor sql express local. Entonces, cada vez que tenga actualizaciones en db e intente actualizar db / ejecute algún código en db sin ejecutar el Update Databasecomando Package Manager Console; En primer lugar, debe eliminar manualmente la base de datos anterior en nuestro sql express local.

Además, esta solución funciona a menos que tenga AutomaticMigrationsEnabled = false;en su configuración.

Si trabaja con un sistema de control de versiones (git, svn, etc.) y algunos otros desarrolladores actualizan objetos db en la fase de producción, este error aumenta cada vez que actualiza su base de código y ejecuta la aplicación.

Como se indicó anteriormente, hay algunas soluciones para esto en la base del código. Sin embargo, este es el más práctico para algunos casos.

También estoy leyendo el libro Pro ASP.NET MVC 4 y me encontré con el mismo problema que tenía. Para mí, comencé a tener el problema después de hacer los cambios prescritos en la sección 'Agregar Validación de Modelo' del libro. La forma en que resolví el problema es moviendo mi base de datos de localdb al servidor SQL Server 2012 completo. (Por cierto, sé que tengo suerte de poder cambiar a la versión completa, así que no me odies. ;-))) Debe haber algo con la comunicación a la base de datos que está causando el problema.

Revisa los siguientes pasos

1. Database.SetInitializer (nulo); -> en Global.asax.cs

2)

1. su nombre de clase de contexto debe coincidir con verificarlo

Modificar Global.asax.cs, incluido el Application_Startevento con:

Database.SetInitializer<YourDatabaseContext>(
 new DropCreateDatabaseIfModelChanges<YourDatabaseContext>());

Este error puede indicar un problema con su cadena de conexión y si su nombre de cadena de conexión coincide con la declaración de contexto de la base de datos.

Tuve este error porque había nombrado incorrectamente la base de datos local (error tonto) y el nombre de la cadena de conexión en web.config de "DefaultConnection" no coincidía con MyDbContext, es decir

public MyDbContext(): base("DefaultConnection")
{}


<connectionStrings>
    <add name="DefaultConnection" ...
  </connectionStrings>

Intente usar Database SetInitializer que pertenece al uso de System.Data.Entity;

En Global.asax

protected void Application_Start()
{
    Database.SetInitializer(new DropCreateDatabaseIfModelChanges<yourContext>());
}

Esto creará una nueva base de datos cada vez que cambie su modelo, pero su base de datos estará vacía. Para llenarla con datos ficticios, puede usar Seeding. Que puedes implementar como:

Siembra ::

protected void Application_Start()
{
    Database.SetInitializer(new AddressBookInitializer());
                ----rest code---
}
public class AddressBookInitializer : DropCreateDatabaseIfModelChanges<AddressBook>
{
    protected override void Seed(AddressBook context)
    {
        context.yourmodel.Add(
        {

        });
        base.Seed(context);
    }

}

Es extraño, pero todas las respuestas aquí fueron inútiles para mí. Para mí trabajé inicializador

MigrateDatabaseToLatestVersion

Aquí está mi solución (lo sé, puede ser mucho más simple, pero así es como la uso):

class MyDbMigrateToLatest : MigrateDatabaseToLatestVersion<MyDbContext, Configuration>
{
}

public class MyDbContext: DbContext
{
    public MyDbContext() : base("DbName")
    {
        SetInitializer();
    }

    public MyDbContext(string connString) : base(connString)
    {
        SetInitializer();
    }

    private static void SetInitializer()
    {
        if (ConfigurationManager.AppSettings["RebuildDatabaseOnStart"] == "true")
            Database.SetInitializer(new MyDbInitializerForTesting());
        else
            Database.SetInitializer(new MyDbMigrateToLatest());
    }
}

public sealed class Configuration : DbMigrationsConfiguration<MyDbContext>
{
    public Configuration()
    {
        AutomaticMigrationsEnabled = true;
    }

    protected override void Seed(MyDbContext context)
    {
        // Whatever
    }
}

MyDbInitializerForTesting simplemente hereda de DropCreateDatabaseAlways, por lo que en algunos casos específicos (pruebas), se reconstruye toda la base de datos. De lo contrario, se migra a la última versión.

Mi fuente: https://msdn.microsoft.com/en-us/data/jj591621.aspx#specific

Tuve el mismo problema cuando usamos una base de datos para dos aplicaciones. Establecer disableDatabaseInitialization="true"en la sección de tipo de contexto funciona para mí.

<entityFramework>
<providers>
  <provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />
</providers>
<contexts>
  <context type="PreferencesContext, Preferences" disableDatabaseInitialization="true">
    <databaseInitializer type="System.Data.Entity.MigrateDatabaseToLatestVersion`2[[PreferencesContext, Preferences], [Migrations.Configuration, Preferences]], EntityFramework" />
  </context>
</contexts>

Ver más detalles https://msdn.microsoft.com/en-us/data/jj556606.aspx

Crear inicializador de contexto personalizado:

public class MyDbContextInitializer : MigrateDatabaseToLatestVersion<MyDbContext, Migrations.Configuration>
{
    public override void InitializeDatabase(MyDbContext context)
    {
        bool exists = context.Database.Exists();

        base.InitializeDatabase(context);

        if (!exists)
        {         
            MyDbSeed.Seed(context);
        }
    }       
}

Tenga en cuenta que Migrations.Configuration es una clase que genera por línea de comandos de migración en la Consola de Package Manager. Es posible que deba cambiar el modificador interno a público de la clase Migrations.Configuration.

Y regístralo desde tu OmModelCreating:

public partial class MyDbContext : DbContext
{

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        Database.SetInitializer<MyDbContext>(new MyDbContextInitializer());

        //other code for creating model
    }
}

Aquí quiero compartir otro método que evite el error del respaldo del modelo cuando se cambia el contexto:

1) Abra su archivo DbContext

2) Agregar espacio de nombres usando Microsoft.AspNet.Identity.EntityFramework;

3) public MyDbContext (): base ("name = MyDbContext") {Database.SetInitializer (nuevo DropCreateDatabaseAlways ()); }