O modelo que suporta o contexto <Database> mudou desde que o banco de dados foi criado

A mensagem de erro:

"O modelo que suporta o contexto 'AddressBook' mudou desde que o banco de dados foi criado. Exclua / atualize manualmente o banco de dados ou chame Database.SetInitializer com uma instância de IDatabaseInitializer. Por exemplo, a estratégia RecreateDatabaseIfModelChanges excluirá e recriará automaticamente o banco de dados, e opcionalmente, propague-o com novos dados ".

Estou tentando usar o recurso de primeiro código e a seguir é o que escrevi:

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

A classe 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; }
}

e a cadeia de conexão:

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

Portanto, o nome do banco de dados é "AddressBook" e o erro ocorre quando tento adicionar o objeto de contato ao contexto. Estou perdendo alguma coisa aqui?

Agora é:

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

no seu arquivo YourDbContext.cs.

Aqui estão algumas informações do Blog de Scott Gu postadas por Jeff sobre o que realmente está acontecendo:

Para quem está vendo essa exceção:

"O modelo que suporta o contexto 'Produção' mudou desde que o banco de dados foi criado. Exclua / atualize manualmente o banco de dados ou chame Database.SetInitializercom uma IDatabaseInitializerinstância."

Aqui está o que está acontecendo e o que fazer sobre isso:

Quando um modelo é criado pela primeira vez, executamos um DatabaseInitializer para fazer coisas como criar o banco de dados se ele não estiver lá ou adicionar dados iniciais. O DatabaseInitializer padrão tenta comparar o esquema do banco de dados necessário para usar o modelo com um hash do esquema armazenado em uma tabela EdmMetadata criada com um banco de dados (quando Code First é quem cria o banco de dados). Os bancos de dados existentes não terão a tabela EdmMetadata e, portanto, não terão o hash ... e a implementação hoje será lançada se essa tabela estiver ausente. Vamos trabalhar para alterar esse comportamento antes de enviar a versão fial, pois é o padrão. Até então, os bancos de dados existentes geralmente não precisam de nenhum inicializador de banco de dados para que ele possa ser desativado para o seu tipo de contexto chamando:

Database.SetInitializer<YourDbContext>(null);

Jeff

Para o Entity Framework 5.0.0.0 - 6.1.3

Você NÃO fato quer fazer o seguinte:

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

Sim, Matt Frear está correto. UPDATE -EDIT: Advertência é que eu concordo com os outros, em vez de adicionar esse código ao global.asax adicionado à sua classe DbContext

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

Como outros mencionaram, isso também é bom para lidar com o teste de unidade.

Atualmente, estou usando isso com o Entity Framework 6.1.3 /.net 4.6.1

Voltarei para fornecer um snippet CORE no futuro próximo.

Basta executar o comando followng sql no SQL Server Management Studio:

delete FROM [dbo].[__MigrationHistory]

Essa correção não funciona mais após o CTP5.

Você tem que fazer Database.SetInitializer<YourContext>(null);

Acabei de descobrir a resposta e pensei em atualizar aqui. Só precisa fazer o seguinte.

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

Ou você pode colocar esta linha no seu arquivo Global.asax.cs em Application_Start ():

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

Certifique-se de alterar ProjectName.Path.Context para seu espaço para nome e contexto. Se você usar o código primeiro, isso excluirá e criará um novo banco de dados sempre que forem feitas alterações no esquema.

Passei muitos dias para resolver esse problema, analisei muitas postagens diferentes, tentei muitas opções e finalmente consertei. Este 2 projetos em minha solução usando primeiras migrações de código EF:

• Aplicativo de console "DataModel" que utiliza principalmente como assembly que contém todas as minhas entidades de código primeiro, DbContext, Mirgations e repositório genérico. Eu incluí neste projeto um arquivo de banco de dados local vazio separado (na pasta DataModel / App_Data) para poder gerar migrações do Package Manager Console.
• WebApi, que faz referência ao projeto DataModel e usa o arquivo de banco de dados local da pasta WebApi / App_Data, que não está incluído no projeto

Recebi este erro quando solicitado WebApi ...

Meu ambiente:

• Windows 8.1 x64
• Visual Studio 2015 Professional com atualização 1
• todos os meus projetos direcionados para o .NET Framework 4.6.1
• EntityFramework 6.1.3 do NuGet

Aqui coletei todas as observações que você deve prestar atenção e todas as condições / requisitos que devem ser atendidos, para evitar a exceção mencionada:

1. Você deve usar apenas uma versão do pacote EntityFramework Nuget para todos os projetos em sua solução.
2. Banco de dados, criado pela execução seqüencial de todos os scripts de migração, deve ter a mesma estrutura / esquema que você segmenta o banco de dados e corresponde ao modelo de entidade. As três coisas a seguir devem corresponder / refletir / combinar exatamente:
   • Seu script de migração completo até o último
   • Estado atual do primeiro modelo de entidade do código (DbContext, entidades)
   • Banco de dados de destino
3. O banco de dados de destino (arquivo mdf) deve ser atualizado / corresponder até o último script de migração. Verifique se a tabela "__MigrationHistory" no banco de dados de destino contém registros para todos os scripts de migração que você possui, isso significa que todos os scripts de migração foram aplicados com êxito nesse banco de dados. Eu recomendo que você use o Visual Studio para gerar as primeiras entidades de código correto e o contexto que correspondem ao seu banco de dados, Projeto -> Adicionar novo item -> Modelo de dados de entidade ADO.NET -> Código primeiro do banco de dados: é claro, como alternativa, se você não possui um banco de dados, pode escrever o modelo manualmente (codificar as primeiras entidades e o contexto) e gerar a migração e o banco de dados iniciais.

4. Nome da cadeia de conexão, por exemplo, MyConnectionString no arquivo de configuração do projeto de inicialização (Web.config / App.config):

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

   deve ser igual ao parâmetro passado no construtor do seu DbContext:

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

5. Antes de usar o Package Manager Console , verifique se você está usando o banco de dados correto para atualizar ou gerar migração e se o projeto necessário está definido como projeto de inicialização da solução. Para conectar ao banco de dados, ele usará a cadeia de conexão desse arquivo .config, que no projeto é definido como projeto de inicialização.

6. E o principal, que corrigiu meu problema: é estranho, mas na minha pasta WebApi / bin, o DataModel.exe era antigo, não atualizado desde a última compilação. Desde que as migrações foram incorporadas no meu assembly DataModel.exe, meu WebApi atualizou o banco de dados usando mirgations antigos. Fiquei confuso porque, após atualizar o banco de dados no WebApi, ele não corresponde ao script de migração mais recente do DataModel. O código a seguir cria automaticamente (se não existir) ou atualiza o banco de dados local da migração mais recente na minha pasta WebApi / App_Data.

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

   Tentei limpar e reconstruir a solução, mas não ajudou, removi completamente as pastas bin e obj do WebApi, excluí os arquivos de banco de dados do WebApi / App_Data, construí, reiniciei o WebApi, fiz o pedido e criei o banco de dados correto - inicialização lenta (usando linhas acima), que corresponde à migração mais recente e a exceção não apareceu mais. Portanto, isso pode resolver seu problema:

   1. remova manualmente as pastas bin e obj do seu projeto de inicialização (que gera / atualiza seu banco de dados)
   2. crie seu projeto de inicialização ou, melhor, limpe e reconstrua toda a sua solução.
   3. recrie o banco de dados iniciando o projeto (executará as linhas acima) ou use o comando "update-database" do Console do Gerenciador de Pacotes.
   4. verifique manualmente se o db e __MirgationHistory gerados correspondem ao script de migração mais recente.

Para mim, com a atualização para 4.3.1, apenas trunco ​​a tabela EdmMetaData ou a excluo completamente.

Para desenvolvedores do VB.NET:

Adicione a seguinte linha ao arquivo Glabal.asax.vb, no final do método Application_Start ()

Database.SetInitializer(Of ApplicationDbContext)(Nothing)

Altere ApplicationDbContext para o seu contexto Db específico.

Eu tive esse problema e verificou-se que um projeto estava apontando para o SQLExpress, mas aquele com o problema estava apontando para o LocalDb. (em seus respectivos web.config). Supervisão tola, mas vale a pena mencionar aqui caso outras pessoas estejam solucionando esse problema.

Isso significa que houve algumas mudanças no contexto que não foram executadas. Execute Add-Migration primeiro para gerar as alterações que fizemos (as que talvez não saibamos) e, em seguida, execute o Update-Database

Eu tive o mesmo problema - adicionar novamente a migração e atualizar o banco de dados não funcionou e nenhuma das respostas acima parecia correta. Então a inspiração me atingiu - estou usando várias camadas (uma web, um dado e uma empresa). A camada de dados possui o contexto e todos os modelos. A camada da web nunca lançou essa exceção - era a camada de negócios (que eu defini como aplicativo de console para teste e depuração). Acontece que a camada de negócios não estava usando a cadeia de conexão correta para obter o banco de dados e criar o contexto. Então, adicionei a string de conexão à configuração do aplicativo da camada de negócios (e da camada de dados) e o viola funciona. Colocando isso aqui para outras pessoas que podem encontrar o mesmo problema.

Eu uso o método Database.CompatibleWithModel (disponível no EF5) para testar se o modelo e o banco de dados correspondem antes de eu usá-lo. Eu chamo esse método logo após criar o 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

        }

Boa sugestão, no entanto, não é tão precisa em todos os casos. Eu descobri um. Por favor, certifique-se de executar "habilitar-migrações" usando janelas do PM no Visual Studio, e a pasta Migração será adicionada ao seu projeto.

Verifique se os dois arquivos de classe c # adicionados à pasta on conterão todos os seus modelos e suas respectivas propriedades.

Se você tem tudo o que constrói a solução e publica para implantação.

A lógica é que os metadados existentes não podem ser substituídos porque seu aplicativo não possui metadados para substituir os atuais. Como resultado, você está recebendo este erro "O modelo de backup do contexto foi alterado desde que o banco de dados foi criado"

Apenas no caso de alguém ter o mesmo cenário que o meu.

Eu tenho primeiro banco de dados EF e, ao mesmo tempo, usando a identidade asp.net

então eu tenho duas connectionStrings no meu webconfig, e não há problema com isso. Aconteceu que eu criei / executei os scripts para gerar manualmente as tabelas de identidade do asp.net que eu não deveria.

portanto, solte primeiro todas as tabelas de identidade asp.net criadas por você manualmente / a partir de scripts.

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

Nenhuma dessas soluções funcionaria para nós (além de desabilitar completamente a verificação do esquema). No final, tivemos uma falha na nossa versão do Newtonsoft.json

Nosso AppConfig não foi atualizado corretamente:

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

A solução foi corrigir a versão do assembly para a que estávamos realmente implantando

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

Após algumas pesquisas sobre esse tópico, descobri que o erro ocorreu basicamente se você tiver uma instância do db criada anteriormente no seu servidor sql local express. Portanto, sempre que você tiver atualizações no db e tentar atualizar o db / execute algum código no db sem executar o Update Databasecomando using Package Manager Console; Em primeiro lugar, você deve excluir o banco de dados anterior no nosso sql express local manualmente.

Além disso, esta solução funciona a menos que você tenha AutomaticMigrationsEnabled = false;na sua configuração.

Se você trabalha com um sistema de controle de versão (git, svn, etc.) E alguns outros desenvolvedores atualizam objetos db na fase de produção, esse erro aumenta sempre que você atualiza sua base de códigos e executa o aplicativo.

Como afirmado acima, existem algumas soluções para isso na base de código. No entanto, este é o mais prático para alguns casos.

Também estou lendo o livro Pro ASP.NET MVC 4 e tive o mesmo problema que você estava tendo. Para mim, comecei a ter o problema depois de fazer as alterações prescritas na seção 'Adicionando validação de modelo' do livro. A maneira como resolvi o problema é movendo meu banco de dados do localdb para o servidor SQL Server 2012 completo. (BTW, eu sei que tenho sorte de poder mudar para a versão completa; portanto, não me odeie. ;-))) Deve haver algo na comunicação com o banco de dados que está causando o problema.

Verifique os seguintes passos

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

2)

1. seu nome de classe de contexto deve corresponder a verificá-lo

Modifique Global.asax.cs, incluindo o Application_Startevento com:

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

Este erro pode indicar um problema com a cadeia de conexão e se o nome da cadeia de conexão corresponde à declaração de contexto do Banco de Dados.

Eu tive esse erro porque havia nomeado o banco de dados local incorretamente (erro bobo) e o nome da cadeia de conexão no web.config de "DefaultConnection" não correspondia ao MyDbContext, ou seja,

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


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

Tente usar o Database SetInitializer, que pertence ao uso System.Data.Entity;

Em Global.asax

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

Isso criará um novo banco de dados toda vez que seu modelo for alterado. Mas seu banco de dados ficaria vazio. Que você pode implementar como:

Semeadura ::

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

}

É estranho, mas todas as respostas aqui foram inúteis para mim. Para mim trabalhou inicializador

MigrateDatabaseToLatestVersion

Aqui está a minha solução (eu sei, pode ser muito mais simples, mas é como eu a 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 apenas herda de DropCreateDatabaseAlways, portanto, em alguns casos específicos (testes), todo o banco de dados é reconstruído. Caso contrário, é migrado para a versão mais recente.

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

Eu tive o mesmo problema quando usamos um banco de dados para dois aplicativos. Definir disableDatabaseInitialization="true"na seção de tipo de contexto funciona para mim.

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

Veja mais detalhes https://msdn.microsoft.com/en-us/data/jj556606.aspx

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

Observe que Migrations.Configuration é uma classe gerada pela linha de comando da migração no Package Manager Console. Pode ser necessário alterar o modificador interno para público da classe Migrations.Configuration.

E registre-o no seu OmModelCreating:

public partial class MyDbContext : DbContext
{

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

        //other code for creating model
    }
}

Aqui, quero compartilhar outro método que evite o erro do backup do modelo quando o contexto for alterado:

1) Abra seu arquivo DbContext

2) Adicione espaço para nome usando Microsoft.AspNet.Identity.EntityFramework;

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