EF Core 2.1 - SQL Join com LINQ - III

 Neste artigo veremos como realizar consultas SQL Join com LINQ usando o Entity Framework Core 2.1.

Continuando a segunda parte do artigo vamos aplicar agora as demais consultas SQL Join usando o LINQ com Entity Framework Core 2.0.

Vamos continuar a usar o projeto EFCore_Joins  criado no primeiro artigo.

1 - Aplicando o Cross Join ou junção cruzada

Uma Cross Join ou junção cruzada também é conhecida como um produto cartesiano, e, faz a junção de duas sequências ou coleções para obter uma nova coleção onde cada par combinado esta representado. Usando LINQ para realizar um Cross Join podemos evitar o uso de laços foreach aninhados.

Essa associação não requer nenhuma condição na junção, mas o LINQ não permite o uso da palavra-chave "join" sem nenhuma condição.

Assim, temos que usar duas cláusulas from, uma para cada fonte da sequência ou coleção, para poder fazer uma junção cruzada, e a seguir usar a cláusula Select para fazer uma projeção do resultado.

 

 

 

A instrução SQL gerada pelo EF Core foi a seguinte :

SELECT [f].[FuncionarioNome] AS [Nome], [f].[FuncionarioCargo] AS [Cargo], [s].[SetorNome] AS [Setor]
FROM [Funcionarios] AS [f]
CROSS JOIN [Setores] AS [s]

2 - Aplicando o Group Join ou junção agrupada

Podemos realizar um Group Join usando o operador GroupJoin que executa a mesma tarefa que o operador Join, exceto que GroupJoin retorna um resultado no grupo com base na chave de grupo especificada.

O operador GroupJoin une duas seqüências com base na chave e agrupa o resultado pela chave correspondente; em seguida, retorna a coleção de resultado e chave agrupados. O GroupJoin requer os mesmos parâmetros que o Join.
 

  

 

 

A seguir temos consulta SQL gerada pelo EF Core:

SELECT [s].[SetorId], [s].[SetorNome] AS [NomeSetor], [f].[FuncionarioId], [f].[FuncionarioCargo], [f].[FuncionarioNome], [f].[SetorId]
FROM [Setores] AS [s]
LEFT JOIN [Funcionarios] AS [f] ON [s].[SetorId] = [f].[SetorId]
ORDER BY [s].[SetorId]

Geralmente na SQL, uma Group Join ou  junção de grupo pode ser feita usando uma cláusula "Group by".

Assim temos ainda mais duas maneiras de fazer uma junção de grupo usando a LINQ.

1-) Usando a palavra-chave INTO

Na consulta vamos usar a cláusula join para associar os elementos das duas tabelas e usar a palavra chave Into e a seguir usar cláusula select para fazer uma projeção do resultado:

using EFCore_Joins.Models;
using System;
using System.Linq;
namespace EFCore_Joins
{
    class Program
    {
        static void Main(string[] args)
        {
            using (var contexto = new AppDbContext())
            {
                var groupJoin = from s in contexto.Setores
                                         join e in contexto.Funcionarios on s.SetorId equals e.SetorId into funci
                                        select new
                                        {
                                            CodigoSetor = s.SetorId,
                                            NomeSetor = s.SetorNome,
                                            Funcionarios = funci
                                         };
                foreach (var resultado in groupJoin)
                {
                    Console.WriteLine("Setor:" + resultado.CodigoSetor + " - " + resultado.NomeSetor);
                    if (resultado.Funcionarios != null && resultado.Funcionarios.Count() > 0)
                    {
                        Console.WriteLine("Nome\t\t\tCargo");
                        foreach (var funci in resultado.Funcionarios)
                        {
                            Console.WriteLine(funci.FuncionarioNome + "\t\t" + funci.FuncionarioCargo);
                        }
                    }
                    else
                    {
                        Console.WriteLine("Setor não tem funcionários.");
                    }
                    Console.WriteLine("");
                }
            }
            Console.ReadLine();
        }
     }
}
  

 
 

A instrução SQL gerada pelo EF Core foi a seguinte  :

SELECT [s].[SetorId] AS [CodigoSetor], [s].[SetorNome] AS [NomeSetor], [e].[FuncionarioId], [e].[FuncionarioCargo], [e].[FuncionarioNome], [e].[SetorId]
FROM [Setores] AS [s]
LEFT JOIN [Funcionarios] AS [e] ON [s].[SetorId] = [e].[SetorId]
ORDER BY [CodigoSetor]

2-) Usar uma subconsulta

using EFCore_Joins.Models;
using System;
using System.Collections.Generic;
using System.Linq;
namespace EFCore_Joins
{
    class Program
    {
        static void Main(string[] args)
        {
            using (var contexto = new AppDbContext())
            {
                var groupJoin = from s in contexto.Setores
                                        select new
                                        {
                                             CodigoSetor = s.SetorId,
                                             NomeSetor = s.SetorNome,
                                             Funcionarios = (from f in contexto.Funcionarios
                                                                   where f.SetorId == s.SetorId
                                                                   select f)
                                       };
                foreach (var resultado in groupJoin)
                {
                    Console.WriteLine("Setor: " + resultado.CodigoSetor + " - " + resultado.NomeSetor);
                    var funcionarios = resultado.Funcionarios as IEnumerable<Funcionario>;
                    if (funcionarios != null && funcionarios.Count() > 0)
                    {
                        Console.WriteLine("Nome\t\tCargo");
                        foreach (var funci in funcionarios)
                        {
                            Console.WriteLine(funci.FuncionarioNome + "\t\t" + funci.FuncionarioCargo);
                        }
                    }
                    else
                    {
                        Console.WriteLine("Setor não possui funcionários.");
                    }
                    Console.WriteLine("");
                }
            }
            Console.ReadLine();
        }
    }
}
  

 
 

As instruçoes SQL geradas pelo EF Core foram  :

1- Consulta 1:

 SELECT [s].[SetorId] AS [CodigoSetor], [s].[SetorNome] AS [NomeSetor]
FROM [Setores] AS [s]

2- Consulta 2:

SELECT [f].[FuncionarioId], [f].[FuncionarioCargo], [f].[FuncionarioNome], [f].[SetorId]
FROM [Funcionarios] AS [f]
WHERE [f].[SetorId] = @_outer_SetorId

Esta consulta será executada para cada setor.

Vimos assim as principais consultas LINQ usando SQL Join.

Pegue o projeto completo aqui :  EFCore_Joins.zip

Deus nunca foi visto por alguém. O Filho unigênito, que está no seio do Pai, esse o revelou.
João 1:18

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

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Referências:

José Carlos Macoratti