Curso Entity Framework - Consultando o modelo de entidades - V

 Nesta aula vamos mostrar como podemos consultar o modelo de entidades.(aula anterior)

Podemos consultar o modelo de entidades de 3 formas distintas usando:

  1. LINQ to Entities

  2. Entity SQL

  3. Native SQL

1- LINQ to Entities

LINQ to Entities é uma versão especializada da LINQ que opera em modelos do Entity Framework sendo a sua principal linguagem de consulta. Através dela podemos realizar projeções, agrupar, ordenar e realizar junções no modelo de entidades.

LINQ-to-Entities é diferente de LINQ-to-SQL.

Se você conhece LINQ to SQL deve estar pensando que afinal LINQ to Entities é a mesma coisa. Mas não é.

O LINQ To SQL esta restrito ao SQL Server, já o LINQ To Entities é mais flexível e pode ser usado com qualquer banco de dados relacional (como já faz hoje o nHibernate). Na verdade LINQ To SQL pode ser visto como um subconjunto do LINQ to Entities.

Veja a seguir a comparação de algumas características entre os dois LINQs :

Característica

LINQ to SQL

LINQ to Entities
Language Extensions Support

Sim

Sim
Language Integrated Database Queries

Sim

Sim
Many-to-Many (3way Join/Payload relationship)

Não

Não
Many-to-Many

Não

Sim
Stored Procedures

Sim

Não
Entity Inheritance

Não

Sim
Single Entity from Multiple Tables

Não

Sim
Identity Management / CRUD features

Sim

Sim

A sintaxe usada pela LINQ to Entities é mais fácil de aprender e assimilar que a Entity SQL. Existem dois tipos de sintaxe que podemos usar com LINQ-to-Entities:

  1. A sintaxe do método LINQ com expressões lambdas;

    Using ctx As New EscolaDBEntities
        Dim consulta = ctx.Alunos.Where(Function(a) a.AlunoNome = "Macoratti")
   End Using

  1. A sintaxe de consulta LINQ;

    Using ctx As New EscolaDBEntities

      Dim consulta = From _aluno In ctx.Alunos
                          Where _aluno.AlunoNome = "Macoratti"
                          Select _aluno
   End Using

Nota: As consultas acima foram feitas usando o modelo de entidades criado na aula 3

O que são Expressões Lambda ?

As expressões lambda foram incluídas na plataforma .NET para dar suporte a consultas LINQ onde as cláusulas Where são assim compiladas como expressões lambdas. Elas podem ser consideradas uma forma de delegate que pode passar ou retornar outra função.

Nota: Delegates permitem que uma classe use métodos de outra classe. Para saber mais sobre delegates leia o meu artigo: Usando Delegates

Assim, as expressões lambdas são funções ou rotinas, sem nome, que calculam e retornam um valor único; elas podem ser usadas em qualquer lugar que um tipo delegate for válido.

Na linguagem C# todas as expressões lambda usam o operador lambda =>, que é lido como "vai para".
  • O lado esquerdo do operador lambda especifica os parâmetros de entrada (se houver)
  • o lado direito contém a expressão ou o bloco de instruções

 A expressão lambda x => x * x é lida assim : " x recebe x vezes x. "

Primeiro, criamos o objeto da classe de contexto que é EscolaDBEntities.  Devemos inicializá-lo usando a cláusula using de modo que assim que sua utilização estiver fora do escopo ele irá chamar automaticamente o método Dispose() da classe DBContext liberando os recursos usados. O retorno será do tipo IQueryable.

LINQ-to-Entities e LINQ-to-Objects não são a mesma coisa ?

LINQ-to-Objects é um conjunto de métodos de extensão em IEnumerable<T> que permitem a realização de operações de consulta em memória em seqüências arbitrárias de objetos. Os métodos aceitam delegados simples, quando necessário.

LINQ-to-Entities é um provedor LINQ que tem um conjunto de métodos de extensão em IQueryable<T>. Os métodos constroem uma árvore de expressão (é por isso que os delegados são passados como Expression<>s), e o provedor vai construir uma consulta SQL com base na análise desta árvore de expressão.
 http://msdn.microsoft.com/en-us/library/bb386964.aspx

2- Entity SQL

A Entity SQL é outra forma de criar uma consulta. Ela é processada diretamente pelo Object Services do Entity Framework e retorna um ObjectQuery ao invés de um IQueryable. Ela é uma derivação da Transact-SQL, projetada para consultar e manipular entidades definidas no EDM, e dá suporte a herança e associação sendo que tanto os componentes Object Services como os componentes Entity Client podem executar instruções Entity SQL.

A linguagem Entity SQL é semelhante à SQL e permite que você consulte modelos conceituais no Entity Framework. Os modelos conceituais representam dados como entidades e relações, e a linguagem Entity SQL permite que você consulte essas entidades e relações em um formato que seja familiar às pessoas que já conhecem a SQL

Nota: O Object Services permite realizar consultas, atualizações, inclusões e exclusões nos dados, expressados como objetos CLR fortemente tipados que são instâncias de entity types. Ele da suporte tanto a consultas Entity SQL como LINQ to Entities.

Abaixo temos uma figura onde vemos os Object Services na composição do Entity Framework:

Para criar consultas com Entity SQL precisamos do ObjectContext.

Imports System.Data.Entity.Infrastructure
Imports System.Data.Entity.Core.Objects
        Dim consulta As String = "SELECT VALUE alu FROM EscolaDBEntities.Alunos AS alu WHERE alu.AlunoNome = 'Macoratti'"
        Dim objctx = TryCast(ctx, IObjectContextAdapter).ObjectContext
        Dim _aluno As ObjectQuery(Of Aluno) = objctx.CreateQuery(Of Aluno)(consulta)
        Dim novoAluno As Aluno = _aluno.First(Of Aluno)()

Podemos ainda usar o EntityConnection e EntityCommand para executar uma consulta Entity SQL:

Imports System.Data.Entity.Core.EntityClient
        Using con = New EntityConnection("name=EscolaDBEntities")
            con.Open()
            Dim cmd As EntityCommand = con.CreateCommand()
            cmd.CommandText = "SELECT VALUE alu FROM EscolaDBEntities.Alunos AS alu where alu.AlunoNome='Macoratti'"
            Dim dict As New Dictionary(Of Integer, String)()
            Using rdr As EntityDataReader = cmd.ExecuteReader(CommandBehavior.SequentialAccess Or CommandBehavior.CloseConnection)
                While rdr.Read()
                    Dim a As Integer = rdr.GetInt32(0)
                    Dim b = rdr.GetString(1)
                    dict.Add(a, b)
                End While
            End Using
        End Using

Um EntityDataReader não retorna um ObjectQuery, ele retorna dados em linhas e colunas.

Uma EntityConnection não é uma conexão com um banco de dados. Embora você possa abrir e fechar uma EntityConnection, isso não significa que você esta abrindo e fechando uma conexão com um banco de dados. Se você usar o EntityClient diretamente ou deixar que os Object Services executem os seus comandos e consultas, a EntityConnection será apenas um caminho para a conexão com o banco de dados.

Uma EntityConnection é composto por 4 partes:

  1. MetaData - O ponteiro para os arquivos de metadados CSDL, MSL e SSDL;
  2. Provider Connection - a string de conexão com o banco de dados;
  3. Provider Name - O namespace do provedor do banco de dados;
  4. Name - O nome da string de conexão;

Você pode definir a EntityConnection declarativamente no arquivo de configuração (app.config ou web.config) .

Um EntityCommand representa um comando para ser executado em um modelo de dados de entidades (EDM).

2- Native SQL

Às vezes executar um SQL nativo customizado é a maneira mais eficiente de realizar uma consulta diretamente no banco de dados. Abaixo vemos uma consulta usando SQL nativo sendo executada via método SqlQuery:

        Using ctx = New EscolaDBEntities()
            Dim nomeDoAluno = ctx.Alunos.SqlQuery("Select alunoId, alunoNome, padraoId from Alunos where alunoNome='Macoratti'").FirstOrDefault(Of Aluno)()
        End Using

O método SqlQuery cria uma consulta SQL puro que irá retornar elementos do tipo genérico dado. O tipo pode ser qualquer tipo que tem propriedades que correspondem aos nomes das colunas retornadas da consulta, ou pode ser um tipo primitivo simples. O tipo não tem que ser um tipo de entidade. Os resultados desta consulta nunca são rastreados pelo contexto, mesmo que o tipo de objeto retornado é um tipo de entidade.

Nota: A partir do Entity Framework 5 temos o método ExecuteSqlCommand que pode ser usado para executar comandos SQL puros. Em versões anteriores do Entity Framerwork  você poderá usar o seguinte método da ObjectContext:  objectContext.ExecuteStoreQuery <return-type> (SQL puro);

Obs: Nas aulas futuras veremos como executar SQL puro usando o DBContext.

Na próxima aula vamos tratar da abordagem Code-First no Entity Framework.

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