Nesta aula, você vai aprender como o Entity Framework controla as alterações de entidades durante o seu tempo de vida.

Veja aqui a aula anterior.

O EF suporta o controle automático de alterações das entidades carregadas durante o tempo de vida do contexto. A classe DbChangeTracker lhe dá todas as informações sobre as entidades atuais que estão sendo rastreadas pelo contexto.

Note que cada entidade deve ter uma propriedade EntityKey (chave primária) a fim de ser rastreada pelo contexto.

O EF não vai acrescentar qualquer entidade em modelo conceitual que não tenha uma propriedade EntityKey.

Dessa forma, o Entity Framework é capaz de rastrear as alterações feitas em entidades e suas relações, de modo que as atualizações corretas sejam feitas no banco de dados quando o método SaveChanges de contexto for chamado.

Essa é uma característica fundamental do Entity Framework. O controle de alterações acontece por meio de um instantâneo das mudanças de rastreamento para a maioria dos tipos de entidade POCO.

No controle de alterações instantâneo, um instantâneo da entidade é tomado quando ela é carregada, ou anexada pelo contexto, e esse instantâneo da entidade é usado para rastrear alterações em uma entidade, comparando o valor atual com o valor original.

O controle de alterações rastreia as alterações enquanto está adicionando novo(s) registro(s) à coleção da entidade, alterando ou removendo entidades existentes.

Em seguida, todas as mudanças são mantidas em nível de DbContext. Esses rastreamentos de mudanças são perdidos se não forem salvos antes que o objeto DbContext seja destruído.

O controle de alterações automático é ativado por padrão no Entity Framework. Podemos desativá-lo definindo a propriedade AutoDetectChangesEnabled de DbContext como falsa.

Se essa propriedade é definida como True, então o Entity Framework mantém o estado de entidades.

Preparando o ambiente

Vamos usar a solução criada na aula 11 – Entity Framework – Consultas Projeção –  para mostrar o Change Tracking.

Abra a solução EF6_EscolaDB criada nesta aula.

A seguir, inclua o código abaixo no arquivo Program.cs :

using System;
using System.Data.Entity.Infrastructure;
using System.Linq;

namespace EF6_EscolaDB
{
    class Program
    {
        static void Main(string[] args)
        {
            using (var ctx = new EscolaDBEntities())
            {

                Console.WriteLine("Localiznado Aluno com código igual a 1 ");
                var alu = ctx.Alunos.Find(1);

                Console.WriteLine("Controle de alterações de contexto de {0} entidades.", ctx.ChangeTracker.Entries().Count());

                ExibeEntidadeRastreada(ctx.ChangeTracker);

                Console.WriteLine("Procurar Padrão com código igual a 1 ");

                var padrao = ctx.Padraos.Find(1);

                Console.WriteLine("Controle de alterações de contexto de {0} entidades.", ctx.ChangeTracker.Entries().Count());
                Console.WriteLine("");
                Console.WriteLine("Editando Padrão");

                standard.PadraoNome = "Nome Alterado";
                ExibeEntidadeRastreada(ctx.ChangeTracker);

                Professor prof = new Professor() { ProfessorNome = "Novo Professor" };
                Console.WriteLine("Incluindo um novo professor");

                ctx.Professores.Add(prof);
                Console.WriteLine("");
                Console.WriteLine("Controle de alterações de contexto de {0} entidades.", ctx.ChangeTracker.Entries().Count());
                ExibeEntidadeRastreada(ctx.ChangeTracker);

                Console.WriteLine("Removendo Aluno");
                Console.WriteLine("");

                ctx.Alunos.Remove(alu);
                ExibeEntidadeRastreada(ctx.ChangeTracker);
            }
        }

        private static void ExibeEntidadeRastreada(DbChangeTracker changeTracker)
        {
            Console.WriteLine("");

            var entradas = changeTracker.Entries();
            foreach (var entrada in entradas)
            {
                Console.WriteLine("Nome da Entidade: {0}", entrada.Entity.GetType().FullName);
                Console.WriteLine("Status: {0}", entrada.State);
            }
            Console.WriteLine("");
            Console.WriteLine("---------------------------------------");
        }
    }
}

 

No código acima, estamos realizando algumas alterações nas entidades do contexto criado. Assim temos:

1. A localização de um aluno pelo seu código;
2. A localização de um padrão pelo seu código;
3. A alteração da propriedade nome do padrão localizado;
4. A inclusão de um novo professor no contexto;
5. A exclusão do aluno localizado.

Após cada alteração, chamamos o método ExibirEntidadeRastreada() para exibir o nome da entidade que foi alterada e seu status.

Executando o projeto, teremos o seguinte resultado:

Como você pode ver no trecho exemplo de código acima, analisando a saída, o contexto mantém o controle de entidades sempre que recupera, adiciona, modifica ou exclui qualquer entidade.

Note que o contexto está vivo durante qualquer uma das operações nas entidades.

O contexto não irá acompanhar as alterações se você fizer qualquer operação em entidades fora do escopo do contexto.

Na próxima aula, irei tratar dos possíveis cenários de persistências no Entity Framework.