Slides 3

Fazer download em pdf ou txt
Fazer download em pdf ou txt
Você está na página 1de 9

Aula 3

Programação I Conversa Inicial

Prof. Alan Matheus Pinheiro Araya

1 2

LINQ

Nesta aula vamos abordar um recurso da Introdução ao LINQ e Lambda


linguagem C# muito comum no dia a dia do Functions
desenvolvedor .NET, independentemente da
plataforma/versão: O Language Integrated
Query (LINQ)

3 4

Introdução ao LINQ

“Os recursos do LINQ (Language Integrated


Query) permitem que você consulte qualquer O LINQ possui duas “notações” ou “sintaxes”
coleção que implemente IEnumerable <T>, distintas no C#:
seja uma Array, Lista ou XML DOM, bem como
Fluent Syntax
fontes de dados remotas, como tabelas em
um banco de dados SQL. O LINQ unifica os Query Expression
benefícios ‘tipagem’ em tempo de compilação
e composição de consultas dinâmicas em
coleções” (Albahari, 2017, p. 369)

5 6
Introdução à Lambda Functions
São expressões que representam métodos
sem nome e sem modificadores de acesso.
Muitas vezes com o corpo (body)
Dentro do universo de expressões lambdas,
representado em uma única linha. Uma
vamos utilizar dois Types especiais
expressão lambda possui a seguinte
(delegates) no C#
anatomia:
(input-parameters)  expression
(input-parameters)  { <sequência de
códigos> }

7 8

Action e Action<T> – Encapsula métodos que


podem receber parâmetros e não retornam
valores Vamos ver na prática os delegates
funcionando!
Func<T> – Encapsula métodos que podem
receber parâmetros e retornam valores

9 10

Sintaxe e operadores

Podemos entender a Fluent Syntax LINQ com


a seguinte definição: “faz o uso de Lambdas
LINQ – Fluent Syntax Functions e da concatenação de métodos
formando uma “pipeline” de processamento.
Provê uma sintaxe típica de linguagens
funcionais” (Griffiths, 2019, p. 444)
Formalmente, nos referimos aos métodos
LINQ como “operadores” LINQ

11 12
var listaValores = new List<int>();
Podemos encadear os operadores uns com os
outros de forma que eles representem uma
//popula a lista com alguns valores
for (int i = 0; i < 10; i++)
{
listaValores.Add(i); “pipeline” (esteira ou caminho de fluxo).
}
Com os operadores LINQ podemos:
//Exemplo de filtro com o operador WHERE:
var listaFiltradaWhere = listaValores.Where(p => p > 5); //6,7,8,9 Filtrar
//Exemplo do operador First, encontrando o elemento:
var elemento2 = listaValores.First(v => v == 2); // 2 Ordenar
//Exemplo do operador FirstOrDefault, em um elemento não existente:
var elementoDefault = listaValores.FirstOrDefault(v => v > 10); // 0
Agregar
(valor default do int)
Agrupar
//Exemplo dos operadores: Any e Max
if (listaValores.Any())
{
Unir
var maxValue = listaValores.Max(); // 9
} Converter

13 14

Vejamos um exemplo de pipeline utilizando


Fluent Syntax: No exemplo anterior, o operador “Where”
recebe um Lambda Function, com a seguinte
//Exemplo Query encadeada ‐ Where + OrderBy + Select
assinatura:
string[] nomes = { "Tom", “Huck", "Harry", "Mary", "Jay" };
Where<TSource>(Func<TSource, bool>
IEnumerable<string> query = nomes.Where(n => n.Contains("a"))
.OrderBy(n => n.Length)
//Output no console:
JAY predicate);
.Select(n => n.ToUpper());
MARY
foreach (string nome in query)
HARRY O seu resultado é uma nova lista do mesmo
{
Console.WriteLine(nome);
Type, contendo apenas os elementos que
}
deram “match”

15 16

Depois temos o operador “OrderBy” que Depois temos o operador “Select” que realiza
produz uma nova versão da lista ordenada: um projeção para os elementos da lista. Para
cada elemento, ele executa uma Lambda
OrderBy<TSource>(Func<TSource, TKey> Function que pode transformar o valor do
keySelector); elemento (trataremos dos detalhes dele mais
O seu resultado é uma nova lista do mesmo adiante)
Type, com seus elementos ordenados, O seu resultado é uma nova lista, com os
segundo o valor retornado pela Func: elementos convertidos para maiúsculo
“keySelector” (ToUpper())

17 18
Entendendo a pipeline Quando os operadores de consulta LINQ são
encadeados, a consulta completa se assemelha a
uma esteira de linha de produção (pipeline),
onde a coleção de saída de um operador é a
“Um operador de consulta nunca altera a
coleção de entrada para o próximo:
sequência de entrada; ao invés disso retorna
uma nova sequência (coleção). Isso é
consistente com o paradigma funcional de
programação, a partir do qual o LINQ foi
inspirado” (Albahari, 2017, p. 355)

19 20

O Select pode receber uma Lambda de um


Type “T” e pode retornar um Type “Y”:
Um dos operadores mais versáteis e
complexos é o operador Select. Isso string[] nomes = { "Tom", "Huck", "Harry", "Mary", "Jay" };

porque seu resultado pode ser de um Type //Utilizando o select para fazer uma Projeção (modificando o tipo de retorno da lista)
diferente do Type da coleção original //de uma lista de string, transformamos em uma lista de inteiros
IEnumerable<int> queryResultSelect = nomes.Select(n => n.Length);

O operador Select pode realizar uma foreach (int length in queryResultSelect)


{
transformação do elemento para outro Type Console.Write(length + "|"); //Output no console: 3|4|5|4|3|
}

21 22

A sintaxe Query Expression

LINQ – Query Expression O C# também provê uma outra sintaxe para a


escrita de querys LINQ, chamada de “Query
Expression”. Essa sintaxe, ao contrário do
que muita gente imagina à primeira vista,
não é como escrever SQL no C# (...)

23 24
Vamos entender melhor: uma das diferenças
Vejamos o mesmo exemplo de query LINQ que
notáveis entre as sintaxes nesse nosso exemplo é o
fizemos anteriormente em Fluent Syntax agora uso do “from” seguido por uma variável, em nosso
em Query Expression caso o “n”. Essa variável recebe o nome formal de:
“variável de intervalo”. Ela representa um elemento
string[] nomes = { "Tom", "Huck", "Harry", "Mary", "Jay" };
do array, assim como no “foreach”:
IEnumerable<string> query = from n in nomes
where n.Contains("a") // Filtra os elementos foreach(var n in nomes){...}
orderby n.Length // Ordena pelo tamanho
select n.ToUpper(); // Converte para string ToUpper (projeção)
from n in nomes // n é nossa variável de intervalo
foreach (string nome in query) where n.Contains("a") // n = elemento direto do array
{ orderby n.Length // n = elemento já filtrado pelo where
Console.WriteLine(nome); //Output no console:
} JAY select n.ToUpper() // n = elemento já ordenado pelo orderby
MARY
HARRY
nomes.Where(n => n.Contains("a")) // variável de escopo local n
.OrderBy(n => n.Length) // variável de escopo local n
.Select(n => n.ToUpper()) // variável de escopo local n

25 26

Veja um exemplo de mix de sintaxes:

string[] nomes = { "Tom", “Huck", "Harry", "Mary", "Jay" };

Toda query escrita em Query Expression pode var quantidadeLetraA = (from n in nomes
where n.Contains("a")
ser convertida em uma query usando Fluent select n).Count(); // 3

Syntax – o próprio compilador do C# faz isso var primeiroElementoDescrescente = (from n in nomes

durante o build do código. O contrário,


orderby n descending
select n).First(); // Tom

porém, não é verdadeiro (...) // Query mais complexa com mix entre as sintaxes, subqueries e projection
var mixQueries = (from n in nomes
join nomeY in nomes.Where(y => y.Contains("y")) on n equals nomeY
where n.Count() > 3
select n.ToUpper()).OrderByDescending(x=> x); // MARY, HARRY

27 28

Deffered exectuion

Execução tardia Uma das funcionalidades mais importantes


dos operadores de query LINQ é sua
capacidade de execução tardia (deferred
execution/lazy execution)

29 30
Reavaliação/reexecução
A execução tardia traz outras consequências
interessantes, como uma query LINQ não
executa no momento que é construída, podemos
Vamos ver na prática o comportamento de reutilizá-la várias vezes!
“Defered Execution/Lazy Execution” var numeros2 = new List<int>() { 1, 2 };
var queryExemplo2 = numeros2.Select(n => n * 10);

funcionando! foreach (int n in query)


{
Console.Write(n + "|"); //Output no console: 10|20|
}

//Limpamos a lista!
numeros2.Clear();

foreach (int n in query)


{
Console.Write(n + "|"); //Output no console: <nada>
}

31 32

Para “contornar” a execução tardia, chamamos


os operadores de conversão, como “ToList” ou
“ToArray”. Esses operadores forçam a
enumeração imediata da query, produzindo uma
O comportamento de execução tardia nem nova coleção
sempre é desejado. Seja por que a query var numeros3 = new List<int>() { 1, 2 };

pode ser computacionalmente intensiva, seja // o ToList força a enumeração e executa a query imediatamente
var listaMultiplicadaPor10 = numeros3.Select(n => n * 10).ToList();

porque queremos “congelar” os resultados // limpamos a lista


numeros3.Clear();
em “certo ponto no tempo” (...) //Observe que a listaMultiplicadaPor10 continua com 2 elementos
Console.WriteLine(listaMultiplicadaPor10.Count); // 2

foreach (int n in query)


{
Console.Write(n + "|"); //Output no console: 10|20|
}

33 34

Categorias de operadores

O LINQ possui três principais categorias de


Operadores LINQ operadores:
“Coleção in”, “coleção out”
“Coleção in”, “elemento out”
Sem parâmetros de entrada, “coleção out”

35 36
Método Descrição Equivalência em SQL
Operadores de filtro Retorna um subset (subcoleção) de elementos que
Where WHERE
satisfazem uma determinada condição

Retorna os primeiros N elementos e descarta o WHERE ROW_NUMBER()


Take
Os operadores/métodos de filtro recebem restante or TOP n subquery

um Type “TSource” como input e retornam Ignora os primeiros N elementos e retorna o


WHERE
ROW_NUMBER()...
o mesmo Type como output
Skip
restante or NOT IN (SELECT TOP
n...)

Uma característica desse tipo de operador é: TakeWhile


Retorna elementos até que a sua função
N/A
condicional retorne falso
sempre vão lhe retornar uma coleção com Ignora os primeiros elementos até que a condição
menos elementos ou igual à coleção original, SkipWhile retorne falso, a partir de então enumera e retorna
o restante dos elementos
N/A

nunca com mais elementos! Distinct


Retorna uma coleção excluindo elementos
SELECT DISTINCT ...
duplicados
Fonte: O autor, 2021

37 38

Operadores de projeção Método Descrição Equivalência em SQL


Transforma cada elemento de entrada em
Select outro elemento de saída utilizando uma SELECT
Lambda Function

Transforma cada elemento de entrada em


outro elemento de saída utilizando uma
Lambda Function. Além disso, concatena
Os operadores de projeção podem os elementos e uma única coleção de
saída, utilizando uma técnica chamada de INNER JOIN,
transformar o tipo do elemento de entrada SelectMany “flattern”. O resultado é similar ao de LEFT OUTER JOIN,
em um novo elemento na saída uma query SQL com JOIN, onde se CROSS JOIN
unificam os resultados de duas tabelas
em única tabela de saída. Esta podendo
conter duplicatas causadas pelo
“flattern”

Fonte: O autor, 2021

39 40

var queryCulturas = CultureInfo.GetCultures(CultureTypes.AllCultures).Select(culture => new


{
Nome = culture.DisplayName,
NomeTecnico = culture.Name,
O operador Select pode ainda retornar um NomeEmIngles = culture.EnglishName,
HashCode = culture.GetHashCode()
objeto especial que chamamos de “tipo });

anônimo” (anonymous type). Um tipo foreach (var cultura in queryCulturas)


{
anônimo é um objeto (Sytem.Object) cuja Console.WriteLine($"Nome: {cultura.Nome} ‐ Cultura:
{cultura.NomeTecnico} ‐ HashCode: {cultura.HashCode}");
classe não possui nome nem método, apenas }
//Exemplo de output do console:

propriedades criadas em tempo de execução //Nome: Portuguese ‐ Cultura: pt ‐ HashCode: ‐1525760948


//Nome: português(Angola) ‐ Cultura: pt ‐ AO ‐ HashCode: 2058183436
//Nome: Portuguese(Brazil) ‐ Cultura: pt ‐ BR ‐ HashCode: ‐96748476
pelo operador Select quando combinado com //Nome: português(Suíça) ‐ Cultura: pt ‐ CH ‐ HashCode: 1345421020
//Nome: português(Cabo Verde) ‐ Cultura: pt ‐ CV ‐ HashCode: 67000352

a palavra-chave “new {...}”


//Nome: português(Guiné Equatorial) ‐ Cultura: pt ‐ GQ ‐ HashCode: 504403706
//Nome: português(Guiné ‐ Bissau) ‐ Cultura: pt ‐ GW ‐ HashCode: ‐1070921970
//Nome: português(Luxemburgo) ‐ Cultura: pt ‐ LU ‐ HashCode: ‐2086256120
//Nome: português(RAE de Macau) ‐ Cultura: pt ‐ MO ‐ HashCode: 625552102
//Nome: português(Moçambique) ‐ Cultura: pt ‐ MZ ‐ HashCode: ‐1039145068
//Nome: Portuguese(Portugal) ‐ Cultura: pt ‐ PT ‐ HashCode: ‐1789600550

41 42
Operadores de combinação (Join) Método Descrição Equivalência em SQL
Join Aplica um estratégia chamada de “Lookup” INNER JOIN
para dar match em elementos das duas
coleções, produzindo como output um coleção
“plana” (flat)

Os operadores/métodos de “Join” do LINQ GroupJoin Similar ao Join, com a diferença que produz
um output de coleção hierárquica
INNER JOIN, LEFT
OUTER JOIN
podem ser muito úteis para combinar Zip Enumera duas coleções simultaneamente, N/A
aplicando uma técnica conhecida como
resultados de coleções diferentes. Você deve “Zipper” (por lembrar um zíper de roupa);
usá-los em situações nas quais o resultado aplicando uma Lambda Function que combina
os elementos das coleções. Produz um
que precisa seja fruto da combinação entre retorno utilizando tuplas, no qual cada tupla é
a combinação do elemento da primeira
coleções coleção com o elemento da segunda coleção,
conforme a Lambda fornecida

Fonte: O autor, 2021

43 44

Operadores de ordenação
Retornam sempre os mesmos elementos,
porém em ordens diferentes
Para operações de combinação (Join), o Método Descrição Equivalência
em SQL
uso da sintaxe de consulta LINQ Query OrderBy, ThenBy Ordena a coleção em ORDER BY
Expression é muito simples, vamos um forma descendente
OrderByDescending, Ordena a coleção em= ORDER
string[] nomes BY ... "Paulo", "Antonio", "Maria"
{ "João", "Silva",

exemplo prático ThenByDescending


, "Joana" };
forma descendente DESC
Reverse Retorna uma nova
//exemplo N/A ascendente
de ordenação
var listaAsc = nomes.OrderBy(a=> a).ToList();
coleção com seus
elementos//exemplo
em ordemde ordenação descendente
var listaDesc = nomes.OrderByDescending(a=> a).ToList();
reversa
//exemplo de ordenação pelo tamanho da string e depois por orde
Fonte: O autor, 2021 m alfabética
var ordenacao2 = nomes.OrderBy(a => a.Length).ThenBy(l => l);

45 46

Operadores de conversão Método Descrição


Enumera a coleção para cada membro de origem Tsoruce,
OfType convertendo-os usando CAST para o Type de destino
TResult. Descarta o elemento quando o Cast falha

Os operadores de conversão LINQ podem ser Cast


Enumera a coleção para cada membro de origem Tsoruce,
convertendo-os usando CAST para o Type de destinho
aplicados a todos os tipos de coleção, pois TResult. Lança um exceção quando o Cast falha

sumariamente são heranças de ToArray Converte a coleção para T[] (array do type T)
ToList Converte a coleção para List<T>
IEnumerable<T>. Existem alguns operadores ToDictionary Converte a coleção para Dictionary<Tkey,Tvalue>

que podem modificar o Type de “destino” ToLookup Converte a coleção para um Ilookup<Tkey,Telement>

(target) das coleções de origem AsEnumerable Retorna um IEnumerable<T> de uma coleção


Executa um Cast ou converte a coleção para um
AsQueryable
IQueryable<T>
Fonte: O autor, 2021

47 48
Operadores de agregação Método Descrição
Equivalência em
SQL
Retorna a quantidade de elementos na
Count, coleção. Pode executar um "Where"
Count(....)
LongCount interno, se for passado uma Lambda
Function de filtro como parâmetro
Retorna o menor ou maior elemento de
Min, Max MIN (...), MAX(...)
uma coleção
Sempre retornaram um valor discreto, isto é,
string[] nomes = { "João", "Silva", "Paulo", "Antonio", "Maria",
"Joana"
Calcula a };
somatória ou a média dos valores
Sum, Average SUM (...), AVG(...)
um valor numérico simples (nunca uma de elementos de umaaocoleção
// equivalente Lenght ou Count
Executaint
umaqtdColecao
agregação= nomes.Count();
matemática,
coleção) como resultado recebendo uma os
// Conta Lambda Function como
a minusculos
Aggregate N/A
parâmetro
int para computá-la
qtdLetraA a cada
= nomes.Sum(n => n.Count(c => c == 'a'));
elemento
// Max e Min
Fonte: O autor, 2021 int[] numeros = { 28, 32, 14 };
int menor = numeros.Min(); // 14;
int maior = numeros.Max(); // 32

49 50

Você também pode gostar