Curso Entity Framework - Change Tracking (Rastreando mudanças) - XV

  Nesta aula vamos falar sobre Change Tracking no Entity Framework.(aula anterior)

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

O EF suporta o controle de alterações automático 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.

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

No controle de alterações instantâneo, um instantâneo da entidade é tomada quando ele carregada, ou anexada pelo contexto e este 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 esta adicionando novo registro(s) para a coleção da entidade, alterando ou removendo entidades existentes.

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

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

Se esta 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("---------------------------------------");
        }
    }
}
Código para exibir o rastreamento de entidades em um contexto

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 a irei tratar dos possíveis cenários de persistências no Entity Framework.

Há um só corpo e um só Espírito, como também fostes chamados em uma só esperança da vossa vocação;
Um só Senhor, uma só fé, um só batismo;
Um só Deus e Pai de todos, o qual é sobre todos, e por todos e em todos vós.
Efésios 4:4-6

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

 

             Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter
 

Referências:

José Carlos Macoratti