Dica: Extrair SQL de consultas LINQ / Lambda

Para saber qual foi a query Sql gerada ao executar uma instrução LINQ, basta usar o seguinte código:

string strQuery = (qLinq as ObjectQuery).ToTraceString();
// é necessário: using System.Data.Objects;

Exemplo:

Linq:

var qLinq = from t in c.TABELAs
            where t.CAMPO1 < i
            select t;

Lambda:

var qLambda = c.TABELAs.Where(t => t.CAMPO1 < i);

Query SQL Gerada:

SELECT
       [Extent1].[CAMPO1] AS [CAMPO1],
       [Extent1].[CAMPO2] AS [CAMPO2]
  FROM [dbo].[TABELA] AS [Extent1]
 WHERE [Extent1].[CAMPO1] < @p__linq__1

OBS: A Sql gerada é igual tanto para a Query Linq quanto para a Lambda Expression.

Essa dica foi o Marquinhos que me passou.

Entity Framework + TransactionScope

Antes de unir os dois assuntos, falarei um pouco de cada um para entendermos melhor a ideia deste artigo.

TransactionScope

Presente no .Net Framework desde a versão 2.0, TransactionScope fica disponível após adicionar referencia para System.Transactions, e fornece uma maneira simples de marcar um bloco de código como participante em uma transação, sem a necessidade de interagir com a transação em si. Um TransactionScope pode gerenciar o ambiente da transação automaticamente, inclusive transações de bancos de dados, como o Sql Server. A sintaxe de utilização é algo como isto:

// C#
using (TransactionScope scope = new TransactionScope())
{
    // Código que participa da transação

    scope.Complete();
} // Commit ou RollBack

' VB.NET
Using scope As New TransactionScope()
    ' Código que participa da transação

    scope.Complete()
End Using ' Commit ou RollBack

Mais detalhes sobre TransactionScope:
• Classe TransactionScope
• Enumerador TransactionScopeOption


Entity Framework

Acho que aqui não é necessário definir ou conceituar o Entity Framework, e sim, expor os motivos de usar o TransactionScope junto a ele. Se tiver interesse em ler conceitos sobre Entity Framework, clique aqui, aqui ou aqui.

Trabalhar com Entity Framework e um banco de dados de tamanho pequeno é simples, pois criamos o Modelo Objeto-Relacional (MOR) e já podemos sair desenvolvendo.  Quando temos um banco de dados muito grande, se colocarmos tudo em um único modelo, podemos ter diversos problemas, entre eles, desempenho e dificuldade em organização. Em geral, é recomendado ter modelos com até 100 entidades. Passando disso, já devemos começar a pensar em dividir em vários modelos.

NOTA: Utilizando apenas um modelo, todas as atualizações feitas através do Entity Framework já acontecem em uma transação, ou seja, se ocorrer algum erro antes que o método SaveChanges() esteja concluído, o RollBack é garantido. Neste caso, não é necessário usar uma transação explícita.

Aí vem a pergunta: E para controlar transações usando mais de um modelo? O intuído de escrever esse artigo é justamente estudar um pouco mais este assunto.


Transações usando mais de um Modelo Objeto-Relacional

Uma das maneiras de termos a mesma transação para mais de um modelo é usarmos o TransactionScope. A aplicação é simples e muito útil. Melhor do que escrever, é ir direto para o código.

// C#
using System;
using System.Transactions;
using EntityTransactionCS.Model1;
using EntityTransactionCS.Model2;

namespace EntityTransactionCS
{
    class Program
    {
        static void Main(string[] args)
        {
            bool bolSucesso = false;

            // Instanciando o Modelo1
            Modelo1 context1 = new Modelo1();

            // Instanciando o Modelo2
            Modelo2 context2 = new Modelo2();

            try
            {
                // Envolvendo o processo por um TransactionScope
                using (TransactionScope scope = new TransactionScope())
                {
                    // Inserindo Cliente com o Modelo1
                    Model1.CLIENTES cliente = new Model1.CLIENTES()
                    {
                        NM_CLIENTE = "Fernando Ottoboni",
                        NR_IDADE = 28
                    };

                    //context1.AddToCLIENTES(cliente);
                    context1.CLIENTES.AddObject(cliente);

                    // Inserindo Produto com o Modelo2
                    Model2.PRODUTOS produto = new Model2.PRODUTOS()
                    {
                        NM_PRODUTO = "Notebook DELL Inspiron 1564 4G 320GB.",
                        VL_PRECO = 2699
                    };
                    //context2.AddToPRODUTOS(produto);
                    context2.PRODUTOS.AddObject(produto);

                    try
                    {
                        // Salva as alterações realizadas no Contexto
                        context1.SaveChanges();
                        context2.SaveChanges();

                        bolSucesso = true;
                    }
                    catch
                    {
                        bolSucesso = false;
                    }

                    if (bolSucesso)
                    {
                        // Completa a transação (Fará o Commit)
                        scope.Complete();
                    }

                    // Somente depois de passar pelo Complete() que o
                    // TransactionScope fará o Commit.
                    // Caso contrário, o RollBack será executado.

                } // Commit ou RollBack

                if (bolSucesso)
                    Console.WriteLine("Dados gravados.");
                else
                    Console.WriteLine("Problemas ao gravar.");
            }
            finally
            {
                context1.Dispose();
                context2.Dispose();
            }

            Console.ReadKey();
        }
    }
}

' VB.NET
Imports EntityTransactionVB.EntityTransactionVB
Imports EntityTransactionVB.EntityTransactionVB.Model1
Imports EntityTransactionVB.EntityTransactionVB.Model2
Imports System.Transactions

Module Module1

    Sub Main()
        Dim bolSucesso As Boolean = False

        ' Instanciando o Modelo1
        Dim context1 As New Modelo1()

        ' Instanciando o Modelo2
        Dim context2 As New Modelo2()

        Try
            ' Envolvendo o processo por um TransactionScope
            Using scope As New TransactionScope()

                ' Inserindo Cliente com o Modelo1
                Dim cliente As New Model1.CLIENTES() With { _
                    .NM_CLIENTE = "Fernando Ottoboni", _
                    .NR_IDADE = 28 _
                }
                'context1.AddToCLIENTES(cliente)
                context1.CLIENTES.AddObject(cliente)

                ' Inserindo Produto com o Modelo2
                Dim produto As New Model2.PRODUTOS() With {
                    .NM_PRODUTO = "Notebook DELL Inspiron 1564 4G 320GB.", _
                    .VL_PRECO = 2699 _
                }
                'context2.AddToPRODUTOS(produto)
                context2.PRODUTOS.AddObject(produto)

                Try
                    ' Salva as alterações realizadas no Contexto
                    context1.SaveChanges()
                    context2.SaveChanges()

                    bolSucesso = True
                Catch
                    bolSucesso = False
                End Try

                If bolSucesso Then
                    ' Completa a transação (Fará o Commit)
                    scope.Complete()
                End If

                ' Somente depois de passar pelo Complete() que o
                ' TransactionScope fará o Commit.
                ' Caso contrário, o RollBack será executado.

            End Using ' Commit ou RollBack

            If bolSucesso Then
                Console.WriteLine("Dados gravados.")
            Else
                Console.WriteLine("Problemas ao gravar.")
            End If
        Finally
            context1.Dispose()
            context2.Dispose()
        End Try

        Console.ReadKey()
    End Sub

End Module

NOTA 1: Para excluir da transação uma determinada camada do código, utilize TransactionScopeOption.Supress na chamada ao construtor da classe TransactionScope.

// C#
using (TransactionScope scope =
    new TransactionScope(TransactionScopeOption.Suppress))
{
    // Código a ser suprimido
}

' VB.NET
Using scope As _
    New TransactionScope(TransactionScopeOption.Suppress)
    ' Código a ser suprimido
End Using

NOTA 2: TransactionScope pode ser utilizada com vários modelos de acesso a dados, inclusive providers que não são distribuídos pela Microsoft. Veja um exemplo utilizando SqlConnection:

// C#
using (TransactionScope scope = new TransactionScope())
{
    using (SqlConnection connection1 = new SqlConnection(connectString1))
    {
        connection1.Open();

        // Operações com connection1

        using (SqlConnection connection2 = new SqlConnection(connectString2))
        {
            connection2.Open();

            // Operações com connection2
        }
    }

    scope.Complete();
}

' VB.NET
Using scope As New TransactionScope()
    Using connection1 As New SqlConnection(connectString1)
        connection1.Open()

        ' Operações com connection1

        Using connection2 As New SqlConnection(connectString2)
            connection2.Open()

            ' Operações com connection2
        End Using
    End Using

    scope.Complete()
End Using

Conclusão

É de suma importância (e também uma boa prática) controlarmos transações em nossa aplicações. A classe TransactionScope nos fornece as ferramentas idais para isso e, quando aplicada em situações em que temos que quebrar o Modelo Objeto-Relacional e várias partes, facilita muito a nossa vida e dá todo o suporte que precisamos para manipulação de transações.


O download do código fonte pode ser feito aqui.


Obrigado

LINQ e Lambda Expression: OrderBy em vários campos

OBS: Para este artigo, estou levando em consideração o seguinte cenário:

Ordenar uma query por vários campos é algo comum e que todos nós, se já não precisamos, um dia precisaremos. Fazer isso com o LINQ é relativamente simples e pode ser algo desse tipo:

// C#
var produtos = from p in context.PRODUTOS
               orderby p.VL_PRECO, p.NM_PRODUTO
               select p;
foreach (var p in produtos)
{
    Console.WriteLine("{0}: {1}",
                      p.NM_PRODUTO,
                      ((decimal)p.VL_PRECO).ToString("N2"));
}

' VB.NET
Dim produtos = From p In context.PRODUTOS _
               Order By p.VL_PRECO, p.NM_PRODUTO _
               Select p
For Each p As PRODUTOS In produtos
    Console.WriteLine("{0}: {1}",
                      p.NM_PRODUTO,
                      CDec(p.VL_PRECO).ToString("N2"))
Next

No exemplo acima, é possível ver que basta enfileirar os campos que desejar ordenar, separados por vírgula, no Order By.

Como seria essa mesma ordenação usando Lambda Expression? A Lambda Expression nos oferece o extension method OrderBy(). Muita gente imagina que usando essa extensão seguidas vezes, ou seja, OrderBy().OrderBy(), resolverá o problema de ordenar por vários campos. Isso não acontece, pois as opções de ordem informadas no segundo OrderBy() substituem as opções do primeiro.

Ou então, usar o operador “&&” ou “And” entre as condições de ordenação. Isso também não funciona.

// C#
// forma errada: o segundo OrderBy substitui o primeiro
var produtos = context.PRODUTOS
                      .OrderBy(p => p.VL_PRECO)
                      .OrderBy(p => p.NM_PRODUTO);

// forma errada: colocar && entre as opções de ordenação não resolve
// essa forma gera erros em tempo de compilação e não executa a aplicação
var produtos = context.PRODUTOS
                      .OrderBy(p => p.VL_PRECO &&
                                    p.NM_PRODUTO);

' VB.NET
' forma errada: o segundo OrderBy substitui o primeiro
Dim produtos = context.PRODUTOS _
                      .OrderBy(Function(p) p.VL_PRECO) _
                      .OrderBy(Function(p) p.NM_PRODUTO)

' forma errada: colocar And entre as opções de ordenação não resolve
' essa forma gera erros em tempo de compilação e não executa a aplicação
Dim produtos = context.PRODUTOS _
                      .OrderBy(Function(p) p.VL_PRECO And _
                               Function(p) p.NM_PRODUTO)

O importante neste caso é saber o que a Lambda Expression com OrderBy() retornará um objeto do tipo IQueriable. A interface IQueriable implementa a interface IEnumerable que é normalmente utilizada ao criar um ObjectQuery. Já o OrderBy(), retorna um objeto IOrderedEnummerable que, por sua vez, disponibiliza novos extension methods, entre eles, ThenBy() e ThenByDescending().Isto significa que podemos ordenar com vários campos pela utilização de OrderBy() e ThenBy() juntos.

Veja no exemplo abaixo como seria a ordenação correta:

// C#
// forma correta: OrderBy().ThenBy()
var produtos = context.PRODUTOS
                      .OrderBy(p => p.VL_PRECO)
                      .ThenBy(p => p.NM_PRODUTO);

foreach (var p in produtos)
{
    Console.WriteLine("{0}: {1}",
        p.NM_PRODUTO,
        ((decimal)p.VL_PRECO).ToString("N2"));
}

' VB.NET
' forma correta: OrderBy().ThenBy()
Dim produtos = context.PRODUTOS _
                      .OrderBy(Function(p) p.VL_PRECO) _
                      .ThenBy(Function(p) p.NM_PRODUTO)

For Each p As PRODUTOS In produtos
    Console.WriteLine("{0}: {1}",
                      p.NM_PRODUTO,
                      CDec(p.VL_PRECO).ToString("N2"))
Next

É interessante ressaltar que essas mesmas regras valem para OrderByDescending() e ThenByDescending().

 

Código fonte

Este código fonte pode ser baixado aqui.

LINQ com Entity Framework – INCLUDE

Há algum tempo, publiquei no meu perfil no UPPERTeam, uma dica sobre o comando Include do LINQ / Entity Framework.

Apesar de ter sido feito antes de começar usar o Visual Studio 2010 com .Net Framework 4, a dica é interessante.

Para quem quiser conferir, basta clicar aqui.

Obrigado