Entity Framework–CodeBase Configuration (Interception)

Carlos dos Santos

Dn630210.060DE5057573180CEC6D227C6D3E2207(pt-br,MSDN.10).png

Março, 2014

Uma das novidades do Entity Framework 6 é a possibilidade de fazermos as configurações do nosso modelo usando código ao invés dos tradicionais arquivos de configuração (app.config/web.config). Além disto, temos agora muitas outras configurações que podem ser modificadas através da classe DbConfiguration.

Dentre as várias opções de configuração que temos através do DbConfiguration, existe uma chamada Interception (veja mais aqui), onde podemos interceptar várias operaçoes que são enviadas ao banco de dados pelo Entity Framework. Neste exemplo iremos interceptar o envio de comandos para o banco de dados e gerar um arquivo texto de log.

Criando o projeto de exemplo:

Para começar, vamos criar um projeto do tipo Console usando o Visual Studio 2013 e em seguida iremos adicionar o Entity Framework através do NuGet:

Dn630210.2BBE15BCD1127221E19B181923841DC5(pt-br,MSDN.10).png

Adicionando o Entity Framework Code First:

Após criado o projeto, vamos adicionar o Entity Framework através do NuGet. Para isto abra o menu Tools/Library Package Manager/Package Manager Console e depois digite o comando abaixo:

PM> Install-Package EntityFramework

Neste exemplo estou utilizando também o Entity Framework PowerTools, pois vamos fazer uma engenharia reversa do banco de dados NorthWind, que é disponibilizado pela Microsoft aqui. O recurso de engenharia reversa permite que possamos pegar um banco de dados existente e gerar as classes para o Entity Framework a partir dele.

Para fazer a engenharia reversa, clique com o botão direito do mouse em cima do nome da sua solution e no menu de contexto escolha: Entity Framework/Reverse Engineer Code First, conforme a figura abaixo:

Dn630210.AD2707F3F21456BF332EBB106CB3F8B7(pt-br,MSDN.10).png

Este comando irá abrir uma janela solicitando as informações do banco de dados. Complete com as suas informações, no meu caso a tela é a seguinte:

Dn630210.4D6DF514323EB06D74553EA5BC25DC38(pt-br,MSDN.10).png

Iniciando a implementação do Interception

Agora que já temos o banco de dados mapeado, vamos implementar a classe de configuração. Adicione ao projeto uma nova classe chamada Configuracao.cs e vamos colocar o código abaixo:

1: public class Configuracao : DbConfiguration
   2:     {
   3:         public Configuracao()
   4:         {
   5:             
   6:         }
   7:     }

Esta é a classe base para a configuração. Nenhum código é necessário para chamar esta classe, pois o Entity Framework irá identificá-la desde que esteja no mesmo Assembly da aplicação, ou seja, você não precisa chamar esta classe diretamente em nenhuma parte do seu código.

Como vamos interceptar os comandos enviados para o banco de dados e iremos gerar um log, vamos implementar a nossa classe que irá gerar os logs. Para isto vamos criar uma outra classe chamada InterceptaSQL, veja o código abaixo:

   1: public class InterceptaSQL: IDbCommandInterceptor
   2:     {
   3:  
   4:         private string arquivoLog;
   5:         public InterceptaSQL()
   6:         {
   7:             string caminho = Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetModules()[0].FullyQualifiedName);
   8:             arquivoLog = Path.Combine(caminho, "Log.txt");
   9:         }
  10:  
  11:         private void EscreveLog(string s)
  12:         {
  13:             StreamWriter log = File.AppendText(arquivoLog);
  14:             log.WriteLine(string.Format("{0} - {1}n", DateTime.Now.ToString(), s));
  15:             log.Close();
  16:         }
  17:         public void NonQueryExecuting(
  18:             DbCommand command, DbCommandInterceptionContext<int> interceptionContext)
  19:         {
  20:             GravaLog("Executando SQL",command, interceptionContext);
  21:         }
  22:  
  23:         public void NonQueryExecuted(
  24:             DbCommand command, DbCommandInterceptionContext<int> interceptionContext)
  25:         {
  26:             GravaLog("SQL executado",command, interceptionContext);
  27:         }
  28:  
  29:         public void ReaderExecuting(
  30:             DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext)
  31:         {
  32:             GravaLog("Executando Reader",command, interceptionContext);
  33:         }
  34:  
  35:         public void ReaderExecuted(
  36:             DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext)
  37:         {
  38:             GravaLog("Reader executado",command, interceptionContext);
  39:         }
  40:  
  41:         public void ScalarExecuting(
  42:             DbCommand command, DbCommandInterceptionContext<object> interceptionContext)
  43:         {
  44:             GravaLog("SQL Scalar executando",command, interceptionContext);
  45:         }
  46:  
  47:         public void ScalarExecuted(
  48:             DbCommand command, DbCommandInterceptionContext<object> interceptionContext)
  49:         {
  50:             GravaLog("SQL Scalar executado",command, interceptionContext);
  51:         }
  52:  
  53:         private void GravaLog<TResult>(string TipoComando,
  54:             DbCommand command, DbCommandInterceptionContext<TResult> interceptionContext)
  55:         {
  56:             if (interceptionContext.Exception != null)
  57:             {
  58:                 EscreveLog(string.Format("ERRO - Comando SQL: {0},  falhou com exceção: {1}",
  59:                     command.CommandText, interceptionContext.Exception));
  60:             }
  61:             else
  62:             {
  63:                 EscreveLog(string.Format("{0}: {1}",TipoComando, command.CommandText));
  64:             }
  65:         }
  66:     }

Nesta classe estamos implementando todos os métodos da interface IDbCommandInterceptor, e também o nosso método para a geração do arquivo texto com o log (linhas 11 a 16). Neste exemplo eu escolhi gravar o arquivo de log no mesmo diretório da aplicação e para isto eu peguei o diretório dentro do assembly usando reflection (linha 7). A gravação do log é bem simples e armazenamos a data/hora, o tipo da operação e o comando executado. Você pode modificar o método GravaLog() e tratar qualquer outra informação que achar necessária.

Ativando a Interceptação

Agora que já implementamos a nossa classe para interceptar os comandos, precisamos informar ao Entity Framework da existência desta classe. Para isto vamos voltar a nossa classe Configuracao.cs e adicionar o código abaixo ao construtor:

   1: public class Configuracao : DbConfiguration
   2:     {
   3:         public Configuracao()
   4:         {
   5:             this.AddInterceptor(new InterceptaSQL());
   6:         }
   7:     }

O método AddInterceptor() informa ao Entity Framework que iremos interceptar as operações descritadas na classe InterceptaSQL.

Testando a implementação

Para testamos a nossa classe, vamos executar algumas operações no Entity Framework. Veja abaixo o código que utilizamos em Program.cs:

   1: static void Main(string[] args)
   2:         {
   3:             var db = new NorthwindContext();
   4:  
   5:             foreach(var p in db.Products)
   6:             {
   7:                 Console.WriteLine(p.Category.CategoryName+", "+p.ProductName);
   8:             }
   9:  
  10:             var altera = db.Products.Where(p => p.ProductID == 1).FirstOrDefault();
  11:             if(altera != null)
  12:             {
  13:                 altera.UnitPrice = 10;
  14:                 db.SaveChanges();
  15:             }
  16:         }

Ao executarmos o programa o seguinte arquivo Log.txt é gerado (apenas uma parte do arquivo foi colada aqui):

   1: 29/12/2013 23:51:38 - Executando Reader: select serverproperty('EngineEdition')
   2:  
   3: 29/12/2013 23:51:38 - Reader executado: select serverproperty('EngineEdition')
   4:  
   5: 29/12/2013 23:51:39 - Executando Reader: SELECT 
   6:     [Extent1].[ProductID] AS [ProductID], 
   7:     [Extent1].[ProductName] AS [ProductName], 
   8:     [Extent1].[SupplierID] AS [SupplierID], 
   9:     [Extent1].[CategoryID] AS [CategoryID], 
  10:     [Extent1].[QuantityPerUnit] AS [QuantityPerUnit], 
  11:     [Extent1].[UnitPrice] AS [UnitPrice], 
  12:     [Extent1].[UnitsInStock] AS [UnitsInStock], 
  13:     [Extent1].[UnitsOnOrder] AS [UnitsOnOrder], 
  14:     [Extent1].[ReorderLevel] AS [ReorderLevel], 
  15:     [Extent1].[Discontinued] AS [Discontinued]
  16:     FROM [dbo].[Products] AS [Extent1]
  17:  
  18: 29/12/2013 23:51:39 - Reader executado: SELECT 
  19:     [Extent1].[ProductID] AS [ProductID], 
  20:     [Extent1].[ProductName] AS [ProductName], 
  21:     [Extent1].[SupplierID] AS [SupplierID], 
  22:     [Extent1].[CategoryID] AS [CategoryID], 
  23:     [Extent1].[QuantityPerUnit] AS [QuantityPerUnit], 
  24:     [Extent1].[UnitPrice] AS [UnitPrice], 
  25:     [Extent1].[UnitsInStock] AS [UnitsInStock], 
  26:     [Extent1].[UnitsOnOrder] AS [UnitsOnOrder], 
  27:     [Extent1].[ReorderLevel] AS [ReorderLevel], 
  28:     [Extent1].[Discontinued] AS [Discontinued]
  29:     FROM [dbo].[Products] AS [Extent1]

Conclusão

O novo recurso de interceptação de comandos do Entity Framework pode ser bastante útil para você fazer depurações e análises dos comandos enviados ao banco de dados, inclusive testes de performance, já que gravamos a data/hora do início da execução e também do final.

Logicamente que este é um log bem mais aprofundado do que eu já mostrei neste outro post, mas a idéia principal é você entender o novo mecanismo de configuração do Entity Framework, que abre muitas possibilidades, incluindo a que acabamos de explorar.

Baixe o código fonte do exemplo: http://www.carloscds.net/artigos/EFInterception.zip

Mostrar: