Il modello che supporta il contesto <Database> è cambiato da quando è stato creato il database

Il messaggio di errore:

"Il modello che supporta il contesto 'Rubrica' è cambiato da quando è stato creato il database. O eliminare / aggiornare manualmente il database o chiamare Database.SetInitializer con un'istanza IDatabaseInitializer. Ad esempio, la strategia RecreateDatabaseIfModelChanges eliminerà e ricreare automaticamente il database, e facoltativamente esegui il seeding con nuovi dati. "

Sto provando a utilizzare la funzione di primo codice e di seguito è quello che ho scritto:

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 classe di contesto:

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

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

e la stringa di connessione:

<?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>

Quindi, il nome del database è "Rubrica" ​​e l'errore si verifica quando provo ad aggiungere l'oggetto contatto al contesto. Mi manca qualcosa qui?

Adesso è:

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

nel tuo file YourDbContext.cs.

Ecco alcune informazioni dal blog di Scott Gu pubblicato da Jeff su ciò che sta realmente accadendo:

Per coloro che vedono questa eccezione:

"Il modello che supporta il contesto 'Produzione' è cambiato da quando è stato creato il database. Eliminare / aggiornare manualmente il database o chiamare Database.SetInitializercon IDatabaseInitializerun'istanza."

Ecco cosa sta succedendo e cosa fare al riguardo:

Quando un modello viene creato per la prima volta, eseguiamo DatabaseInitializer per fare cose come creare il database se non è presente o aggiungere dati seed. DatabaseInitializer predefinito tenta di confrontare lo schema del database necessario per utilizzare il modello con un hash dello schema archiviato in una tabella EdmMetadata creata con un database (quando Code First è quello che crea il database). I database esistenti non avranno la tabella EdmMetadata e quindi non avranno l'hash ... e l'implementazione oggi verrà lanciata se quella tabella manca. Lavoreremo sulla modifica di questo comportamento prima di spedire la versione di fial poiché è l'impostazione predefinita. Fino ad allora, i database esistenti non necessitano generalmente di alcun inizializzatore di database, quindi può essere disattivato per il tipo di contesto chiamando:

Database.SetInitializer<YourDbContext>(null);

Jeff

Per Entity Framework 5.0.0.0 - 6.1.3

Si SI anzi desidera effettuare le seguenti operazioni:

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

Sì, Matt Frear ha ragione. AGGIORNAMENTO -EDIT: L'avvertimento è che sono d'accordo con gli altri in questo invece di aggiungere questo codice a global.asax aggiunto alla tua classe DbContext

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

Come altri hanno già detto, anche questo è utile per gestire i test unitari.

Attualmente sto usando questo con Entity Framework 6.1.3 /.net 4.6.1

Tornerò per fornire uno snippet CORE nel prossimo futuro.

Basta eseguire il comando sql seguente in SQL Server Management Studio:

delete FROM [dbo].[__MigrationHistory]

Questa correzione non funziona più dopo CTP5.

Devi fare Database.SetInitializer<YourContext>(null);

Ho appena scoperto la risposta e ho pensato di aggiornare qui. Devo solo fare quanto segue.

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

Oppure puoi inserire questa riga nel tuo file Global.asax.cs in Application_Start ():

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

Assicurati di cambiare ProjectName.Path.Context nello spazio dei nomi e nel contesto. Se si utilizza prima il codice, questo eliminerà e creerà un nuovo database ogni volta che vengono apportate modifiche allo schema.

Ho trascorso molti giorni a risolvere questo problema, analizzato molti post diversi e ho provato molte opzioni e infine risolto. Questo 2 progetti nella mia soluzione utilizzando le prime migrazioni del codice EF:

• Applicazione console "DataModel" che utilizza principalmente come assembly che contiene tutte le mie prime entità di codice, DbContext, Mirgations e repository generico. Ho incluso in questo progetto un file di database locale vuoto separato (nella cartella DataModel / App_Data) per poter generare migrazioni dalla console di Package Manager.
• WebApi, che fa riferimento al progetto DataModel e utilizza il file di database locale dalla cartella WebApi / App_Data, che non è incluso nel progetto

Ho ricevuto questo errore quando richiesto WebApi ...

Il mio ambiente:

• Windows 8.1 x64
• Visual Studio 2015 Professional con aggiornamento 1
• tutti i miei progetti mirati per .NET Framework 4.6.1
• EntityFramework 6.1.3 di NuGet

Qui ho raccolto tutte le osservazioni che dovresti prestare attenzione e tutte le condizioni / requisiti che devono essere soddisfatti, per evitare la menzionata eccezione:

1. È necessario utilizzare solo una versione del pacchetto Nuget EntityFramework per tutti i progetti nella soluzione.
2. Il database, creato eseguendo in sequenza tutti gli script di migrazione, deve avere la stessa struttura / schema del database di destinazione e corrispondere al modello di entità. Le seguenti 3 cose devono corrispondere / riflettere / corrispondere esattamente:
   • Il tuo script di migrazione completo fino all'ultimo
   • Stato modello prima entità codice corrente (DbContext, entità)
   • Database di destinazione
3. Il database di destinazione (file mdf) deve essere aggiornato / corrispondente all'ultimo script di migrazione. Verificare che la tabella "__MigrationHistory" nel database di destinazione contenga record per tutti gli script di migrazione in uso, significa che tutti gli script di migrazione sono stati applicati correttamente a quel database. Ti consiglio di utilizzare Visual Studio per generare prima le entità e il contesto del codice corretto che corrispondono al tuo database, Progetto -> Aggiungi nuovo elemento -> Modello dati entità ADO.NET -> Codice prima dal database: Naturalmente, in alternativa, se non si dispone di database, è possibile scrivere manualmente il modello (codificare prima entità e contesto) e quindi generare la migrazione e il database iniziali.

4. Nome della stringa di connessione, ad es. MyConnectionString nel file di configurazione del progetto di avvio (Web.config / App.config):

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

   dovrebbe essere uguale al parametro passato nel costruttore del tuo DbContext:

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

5. Prima di utilizzare la console di Package Manager , assicurarsi di utilizzare il database corretto per l'aggiornamento o generare la migrazione e che il progetto necessario sia impostato come progetto di avvio della soluzione. Per connettersi al database utilizzerà la stringa di connessione dal file .config, che nel progetto è impostato come progetto di avvio.

6. E il principale, che ha risolto il mio problema: è strano, ma nella mia cartella WebApi / bin DataModel.exe era vecchio, non aggiornato dall'ultima build. Poiché le migrazioni sono state incorporate nel mio DataModel.exe di assembly, il mio database WebApi ha aggiornato le vecchie mirgazioni. Ero confuso perché dopo l'aggiornamento del database in WebApi non corrisponde all'ultimo script di migrazione da DataModel. Il codice seguente crea automaticamente (se non esiste) o aggiorna all'ultimo database locale di migrazione nella mia cartella WebApi / App_Data.

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

   Ho provato a ripulire e ricostruire la soluzione ma non mi ha aiutato, quindi ho rimosso completamente le cartelle bin e obj da WebApi, cancellato i file di database da WebApi / App_Data, creato, riavviato WebApi, fatto richiesta, creato database corretto - inizializzazione pigra righe sopra), che corrisponde all'ultima migrazione e l'eccezione non è stata più visualizzata. Quindi, questo potrebbe risolvere il tuo problema:

   1. rimuovere manualmente bin, obj cartelle dal progetto di avvio (che genera / aggiorna il database)
   2. crea il tuo progetto di avvio o pulisci e ricostruisci meglio tutta la tua soluzione.
   3. ricrea il database avviando il progetto (eseguirà le righe sopra) o usa il comando "update-database" della console di Package Manager.
   4. controllare manualmente se il db generato e __MirgationHistory corrispondono all'ultimo script di migrazione.

Per me, con l'aggiornamento alla 4.3.1, ho semplicemente troncato la tabella EdmMetaData o semplicemente eliminata.

Per gli sviluppatori VB.NET:

Aggiungi la seguente riga al file Glabal.asax.vb, alla fine del metodo Application_Start ()

Database.SetInitializer(Of ApplicationDbContext)(Nothing)

Cambia ApplicationDbContext nel tuo specifico contesto Db.

Ho riscontrato questo problema e si è scoperto che un progetto puntava a SQLExpress ma quello con il problema puntava a LocalDb. (nel rispettivo web.config). Sorveglianza sciocca ma vale la pena notare qui nel caso in cui qualcun altro stia risolvendo questo problema.

Significa che ci sono stati alcuni cambiamenti nel contesto che non sono stati eseguiti. Eseguire prima Add-Migration per generare le modifiche che abbiamo apportato (le modifiche che potremmo non conoscere), quindi eseguire Update-Database

Ho avuto lo stesso problema: la nuova aggiunta della migrazione e l'aggiornamento del database non hanno funzionato e nessuna delle risposte precedenti sembrava corretta. Poi l'ispirazione mi ha colpito: sto usando più livelli (un web, un dato e un business). Il livello dati ha il contesto e tutti i modelli. Il livello Web non ha mai gettato questa eccezione: era il livello aziendale (che ho impostato come applicazione console per test e debug). Si scopre che il livello aziendale non utilizzava la stringa di connessione corretta per ottenere il db e creare il contesto. Quindi ho aggiunto la stringa di connessione alla configurazione dell'app del livello aziendale (e del livello dati) e viola funziona. Mettendo questo qui per gli altri che potrebbero riscontrare lo stesso problema.

Uso il metodo Database.CompatibleWithModel (disponibile in EF5) per verificare se il modello e il DB corrispondono prima di utilizzarlo. Chiamo questo metodo subito dopo aver creato il contesto ...

        // 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

        }

Un buon suggerimento, tuttavia, non è così accurato in tutti i casi. Ne capisco uno. Si prega di assicurarsi di eseguire "enable-migrations" utilizzando le finestre PM in Visual Studio e che la cartella Migration verrà aggiunta al progetto.

Assicurarsi che i due file di classe c # aggiunti alla cartella conterranno tutti i modelli e le rispettive proprietà.

Se hai tutto ciò che crea la soluzione e pubblica per la distribuzione.

La logica è che i metadati esistenti non possono essere sovrascritti perché l'applicazione non ha metadati per sostituire quelli correnti. Di conseguenza viene visualizzato questo errore "Il modello che supporta il contesto è cambiato da quando è stato creato il database"

Nel caso in cui qualcuno abbia lo stesso scenario del mio.

Ho prima il database EF e allo stesso tempo utilizzo l'identità asp.net

quindi ho due stringhe di connessione nel mio webconfig, e non c'è nessun problema. È successo che ho creato / eseguito gli script per generare manualmente le tabelle di identità asp.net che non avrei dovuto.

quindi GOCCIA prima tutte le tabelle di identità asp.net create da te manualmente / dagli script.

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

Nessuna di queste soluzioni funzionerebbe per noi (oltre a disabilitare del tutto il controllo dello schema). Alla fine abbiamo avuto un miss-match nella nostra versione di Newtonsoft.json

Il nostro AppConfig non è stato aggiornato correttamente:

<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 soluzione era correggere la versione dell'assemblaggio con quella che stavamo effettivamente 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>

Dopo alcune ricerche su questo argomento, ho scoperto che l'errore si è verificato sostanzialmente se hai un'istanza di db creata in precedenza sul tuo server sql locale espresso. Quindi ogni volta che hai aggiornamenti su db e prova ad aggiornare db / esegui un po 'di codice su db senza eseguire il Update Databasecomando usando Package Manager Console; prima di tutto, devi cancellare manualmente il precedente db sul nostro sql express locale.

Inoltre, questa soluzione funziona a meno che non sia presente AutomaticMigrationsEnabled = false;nella configurazione.

Se lavori con un sistema di controllo della versione (git, svn, ecc.) E alcuni altri sviluppatori aggiornano oggetti db in fase di produzione, questo errore aumenta ogni volta che aggiorni la tua base di codice ed esegui l'applicazione.

Come detto sopra, ci sono alcune soluzioni per questo su base di codice. Tuttavia, questo è il più pratico per alcuni casi.

Sto leggendo anche il libro Pro ASP.NET MVC 4 e ho riscontrato lo stesso problema riscontrato. Per me, ho iniziato ad avere il problema dopo aver apportato le modifiche prescritte nella sezione "Aggiunta della convalida del modello" del libro. Il modo in cui ho risolto il problema è spostando il mio database da Localdb al server SQL Server 2012 completo. (A proposito, so di essere fortunato a poter passare alla versione completa, quindi non odiarmi. ;-))) Ci deve essere qualcosa con la comunicazione con il db che sta causando il problema.

Controlla i seguenti passaggi

1. Database.SetInitializer (null); -> in Global.asax.cs

2.

1. il nome della classe di contesto deve corrispondere a verificarlo

Modifica Global.asax.cs, incluso l' Application_Startevento con:

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

Questo errore può indicare un problema con la stringa di connessione e se il nome della stringa di connessione corrisponde alla dichiarazione di contesto del database.

Ho avuto questo errore perché avevo erroneamente chiamato il database locale (errore sciocco) e il nome della stringa di connessione in web.config di "DefaultConnection" non corrispondeva a MyDbContext, ad es.

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


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

Prova a utilizzare Database SetInitializer che appartiene all'utilizzo di System.Data.Entity;

In Global.asax

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

Questo creerà un nuovo database ogni volta che il tuo modello viene modificato, ma il tuo database sarebbe vuoto. Per riempirlo con dati fittizi puoi usare Seeding. Che puoi implementare come:

Semina ::

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

}

È strano, ma tutte le risposte qui sono state inutili per me. Per me ha funzionato l'inizializzatore

MigrateDatabaseToLatestVersion

Ecco la mia soluzione (lo so, può essere molto più semplice, ma è come 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 eredita appena da DropCreateDatabaseAlways, quindi in alcuni casi specifici (test), l'intero database viene ricostruito. Altrimenti viene migrato all'ultima versione.

La mia fonte: https://msdn.microsoft.com/en-us/data/jj591621.aspx#specific

Ho avuto lo stesso problema quando abbiamo usato un database per due applicazioni. L'impostazione disableDatabaseInitialization="true"nella sezione del tipo di contesto funziona per me.

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

Vedi maggiori dettagli https://msdn.microsoft.com/en-us/data/jj556606.aspx

Crea inizializzatore di contesto personalizzato:

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

Si noti che Migrations.Configuration è una classe generata dalla riga di comando di migrazione nella console di Package Manager. Potrebbe essere necessario modificare il modificatore da interno a pubblico della classe Migrations.Configuration.

E registralo dal tuo OmModelCreating:

public partial class MyDbContext : DbContext
{

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

        //other code for creating model
    }
}

Qui voglio condividere un altro metodo che impedisce l'errore del supporto del modello quando il contesto è cambiato:

1) Apri il tuo file DbContext

2) Aggiungi spazio dei nomi utilizzando Microsoft.AspNet.Identity.EntityFramework;

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