UNIVERSIDADE SÃO TOMÁS DE MOÇAMBIQUE

FACULDADE DE TECNOLOGIAS E CIÊNCIAS DE INFORMAÇÃO

DEPARTAMENTO DE TECNOLOGIAS E SISTEMAS DE INFORMAÇÃO DESENVOLVIMENTO DE SOFTWARE

DISCIPLINA: PROGRAMAÇÃO WEB AVANÇADA(ASP.NET)

FICHA 1:

Expressões Lambda, delegates e Linq

Conteúdo

1. Conceitos ASP, ASP.NET, MVC, Entity Framework

2. Paradigmas de Programação
3. Expressões Lambda, delegates e Linq
4. Exercícios de demonstração e fixação

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE

 1. Conceitos ASP, ASP.NET, MVC, Entity Framework

ASP. NET

ASP.NET é a plataforma da Microsoft para o desenvolvimento de aplicações Web e é o sucessor da

tecnologia ASP. Permite, através de uma linguagem de programação integrada na .NET Framework, criar
páginas dinâmicas. Não é nem uma linguagem de programação como VBScript, PHP, nem um servidor
web como IIS ou Apache.

O ASP.NET é baseado no Framework .NET herdando todas as suas características, por isso, como
qualquer aplicação .NET, as aplicações para essa plataforma podem ser escritas em várias linguagens,
como C#, F# e Visual Basic.NET.

ASP. NET Core

O ASP.NET Core é uma estrutura de software livre, multiplataforma, para a criação de aplicativos Web
modernos e baseados em nuvem, no Windows, no macOS ou no Linux.

A tabela a seguir compara o ASP.NET Core com o ASP.NET 4. x.

Seleção de estrutura
ASP.NET Core ASP.NET 4.x
Build para Windows, macOS ou Linux Build para Windows
Razor Páginas é a abordagem recomendada para criar uma Usar Web Forms, SignalR , MVC,
interface do usuário da Web a partir do ASP.NET Core 2. x. API da Web, WebHooksou
Consulte também MVC, API da Webe SignalR . páginas da Web
Várias versões por computador Uma versão por computador
Desenvolva com o Visual Studio, Visual Studio para Mac ou Desenvolva com o Visual Studio
Visual Studio Code usando C# ou F# usando C#, vb ou F #
Desempenho superior ao do ASP.NET 4.x Bom desempenho
Use o runtime do .NET
Usar o runtime do .NET Core
Framework

MVC?

A arquitetura/padrão MVC - (Modelo Visualização Controle) fornece uma maneira de dividir a

funcionalidade envolvida na manutenção e apresentação dos dados de uma aplicação. A arquitetura
MVC não é nova e foi originalmente desenvolvida para mapear as tarefas tradicionais de entrada,

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE

processamento e saída para o modelo de interação com o usuário. Usando o padrão MVC fica fácil
mapear esses conceitos no domínio de aplicações Web multicamadas.

Na arquitetura MVC o modelo representa os dados da aplicação e as regras do negócio que governam o
acesso e a modificação dos dados. O modelo mantém o estado persistente do negócio e fornece ao
controlador a capacidade de aceder as funcionalidades da aplicação encapsuladas pelo próprio modelo.

Um componente de visualização renderiza o conteúdo de uma parte particular do modelo e encaminha

para o controlador as ações do usuário; aceder também os dados do modelo via controlador e define
como esses dados devem ser apresentados.

Um controlador define o comportamento da aplicação, é ele que interpreta as ações do usuário e as

mapeia para chamadas do modelo. Em um cliente de aplicações Web essas ações do usuário poderiam
ser cliques de botões ou seleções de menus. As ações realizadas pelo modelo incluem ativar processos
de negócio ou alterar o estado do modelo.

Com base na ação do usuário e no resultado do processamento do modelo, o controlador seleciona uma
visualização a ser exibida como parte da resposta a solicitação do usuário. Há normalmente um
controlador para cada conjunto de funcionalidades relacionadas.

A arquitetura de 3 camadas que esta representada abaixo é uma implementação do modelo MVC. O
modelo MVC esta preocupado em separar a informação de sua apresentação.

Nota: A visualização e o controlador dependem do modelo. No entanto, o modelo não depende da

visualização nem do controlador. Esse é um dos principais benefícios da separação. Essa separação
permite que o modelo seja criado e testado de forma independente da apresentação visual.

ASP.NET MVC

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE

O ASP.NET MVC é um padrão de arquitetura que provê uma alternativa ao ASP.NET Web Forms, para
criação de aplicações Web baseadas no MVC (Model View Controller). O Framework MVC é definido
pelo namespace System.Web.Mvc.

Algumas aplicações Web podem se beneficiar do framework MVC, enquanto outras podem continuar a
usar o padrão tradicional ASP.NET, que é baseado em Web Forms e postbacks. Nenhuma abordagem,
seja MVC ou Web Forms, exclui a outra, podendo inclusive serem utilizadas ao mesmo tempo.

Vantagens e desvantagens do ASP .NET MVC

Vantagens:

• Como o modelo MVC gerencia múltiplos visualizadores usando o mesmo modelo é fácil manter,
testar e atualizar sistemas múltiplos;
• É muito simples incluir novos clientes apenas incluindo seus visualizadores e controles;
• Torna a aplicação escalável;
• É possível ter desenvolvimento em paralelo para o modelo, visualizador e controle, pois são
independentes;
• É mais fácil gerenciar a complexidade da aplicação dividindo-a em modelo, visualizador e
controlador (MVC);

Desvantagens:

• Requer uma quantidade maior de tempo para analisar e modelar o sistema;

• Requer pessoal com conhecimento especializado;
• Não é aconselhável para pequenas aplicações;

Vantagens do modelo WebForms:

• Suporta um modelo de eventos que preserva o estado sobre HTTP;

• Usa o padrão Page Controller que adiciona funcionalidade a páginas individuais;
• É muito fácil para trabalhar com equipes pequenas disponibilizando um grande número de
componentes que agiliza o desenvolvimento;
• Possui uma complexidade menor;
• Fornece meios de gerenciar o estado da informação de uma forma bem simples;

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE

 2. Programação Funcional e cálculo Lambda

Paradigmas de programação

• Imperativo (C, Pascal, Fortran, Cobol)

• Orientado a objetos (C++, Object Pascal, Java (< 8), C# (< 3))

• Funcional (Haskell, Closure, Clean, Erlang)

• Lógico (Prolog)

• Multiparadigma (JavaScript, Java (8+), C# (3+), Ruby, Python, Go)

Paradigma funcional de programação

Baseado no formalismo matemático Cálculo Lambda (Church 1930)

Transparência referencial

Uma função possui transparência referencial se seu resultado for sempre o mesmo

para os mesmos dados de entrada. Benefícios: simplicidade e previsibilidade.

public static int globalValue = 3;
static void Main(string[] args) {
int[] vect = new int[] { 3, 4, 5 };
ChangeOddValues(vect);
Console.WriteLine(string.Join(" ", vect));
}
public static void ChangeOddValues(int[] numbers) {
for (int i = 0; i < numbers.Length; i++) {
if (numbers[i] % 2 != 0) {
numbers[i] += globalValue;
}
}
}

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE

Ao verificarmos a função ChangeOddValues, não é possível entender o que ela faz sem que se verifique
o valor da variável globalValue que está fora dela para perceber o que será executado nesta função,
sendo assim, este tipo de programação imperativa torna difícil a sua percepção, por isso diz-se que
possui funções com fraca transparência referencial.

Funções são objetos de primeira ordem (ou primeira classe)

Isso significa que funções podem, por exemplo, serem passadas como parâmetros de métodos, bem
como retornadas como resultado de métodos.

Class Program {
static int CompareProducts(Product p1, Product p2) {
return p1.Name.ToUpper().CompareTo(p2.Name.ToUpper());
}
static void Main(string[] args) {
List<Product> list = new List<Product>();
list.Add(new Product("TV", 900.00));
list.Add(new Product("Notebook", 1200.00));
list.Add(new Product("Tablet", 450.00));
list.Sort(CompareProducts);
(...)

Inferência de tipos

List<Product> list = new List<Product>();

list.Add(new Product("TV", 900.00));
list.Add(new Product("Notebook", 1200.00));
list.Add(new Product("Tablet", 450.00));
list.Sort((p1, p2) => p1.Name.ToUpper().CompareTo(p2.Name.ToUpper()));
foreach (Product p in list) {
Console.WriteLine(p);
}

Expressividade / "como" vs. "o quê"

int sum = 0;
foreach (int x in list) {
sum += x;
}

VS

int sum = list.Aggregate(0, (x, y) => x + y);

3. Expressões Lambda, delegates e Linq

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE

O que são "expressões lambda"?

Em programação funcional, expressão lambda corresponde a uma função anônima de primeira classe.

Uma expressão Lambda é uma função anônima que você pode usar para criar delegates ou tipos de
árvore de expressão. Ao usar expressões lambda, você pode escrever funções locais que podem ser
passadas como argumentos ou retornadas como o valor de chamadas de função. Essas expressões são
particularmente úteis para escrever expressões de consulta LINQ.

class Program {
static int CompareProducts(Product p1, Product p2) {
return p1.Name.ToUpper().CompareTo(p2.Name.ToUpper());
}
static void Main(string[] args) {
(...)
list.Sort(CompareProducts);
list.Sort((p1, p2) => p1.Name.ToUpper().CompareTo(p2.Name.ToUpper()));
(...)

Cálculo Lambda = formalismo matemático base da programação funcional

Expressão lambda = função anônima de primeira classe.

Nota: Delegates permitem que uma classe use métodos de outra classe.

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.

Como criar expressões lambda:

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) e o 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. "

Você pode atribuir essa expressão a um tipo delegate da seguinte forma:

delegate int delegado(int i);

static void Main(string[] args)

{
delegado meuDelegate = x => x * x;
int valor = meuDelegate(5);
}

Introdução aos Delegates

Delegates

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE

• https://docs.microsoft.com/en-us/dotnet/standard/delegates-lambdas

• É uma referência (com type safety) para um ou mais métodos

• É um tipo referência

Usos comuns:

• Comunicação entre objetos de forma flexível e extensível (eventos / callbacks)

• Parametrização de operações por métodos (programação funcional)

Demo
namespace Course.Services {
class CalculationService {
public static double Max(double x, double y) {
return (x > y) ? x : y;
}
public static double Sum(double x, double y) {
return x + y;
}
public static double Square(double x) {
return x * x;
}
}
}

Demo
using System;
using Course.Services;
namespace Course {
delegate double BinaryNumericOperation(double n1, double n2);
class Program {
static void Main(string[] args) {
double a = 10;
double b = 12;
// BinaryNumericOperation op = CalculationService.Sum;
BinaryNumericOperation op = new BinaryNumericOperation(CalculationService.Sum);
// double result = op(a, b);
double result = op.Invoke(a, b);
Console.WriteLine(result);
}
}
}

Multicast delegates

• Delegates que guardam a referência para mais de um método

• Para adicionar uma referência, pode-se usar o operador +=
• A chamada Invoke (ou sintaxe reduzida) executa todos os métodos na ordem em que foram
adicionados
• Seu uso faz sentido para métodos void

Demo
using System;

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE

namespace Course.Services {
class CalculationService {
public static void ShowMax(double x, double y) {
double max = (x > y) ? x : y;
Console.WriteLine(max);
}
public static void ShowSum(double x, double y) {
double sum = x + y;
Console.WriteLine(sum);
}
}
}

using System;
using Course.Services;
namespace Course {
delegate void BinaryNumericOperation(double n1, double n2);
class Program {
static void Main(string[] args) {
double a = 10;
double b = 12;
BinaryNumericOperation op = CalculationService.ShowSum;
op += CalculationService.ShowMax;
op(a, b);
}
}
}

Delegates pré-definidos

• Action

• Func

• Predicate

Predicate (exemplo com RemoveAll)

Predicate (System)

• Representa um método que recebe um objeto do tipo T e retorna um valor booleano

• https://msdn.microsoft.com/en-us/library/bfcke1bz%28v=vs.110%29.aspx

public delegate bool Predicate<in T>(T obj);

Problema exemplo
Fazer um programa que, a partir de uma lista de produtos, remova da lista somente aqueles cujo preço
mínimo seja 100.

using System;
using ExpressoesLambda.Entities;

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE

using System.Collections.Generic;

namespace ExpressoesLambda
{
class Program
{

static void Main(string[] args)

{
List<Product> list = new List<Product>();
list.Add(new Product("Tv", 900.00));
list.Add(new Product("Mouse", 50.00));
list.Add(new Product("Tablet", 350.50));
list.Add(new Product("HD Case", 80.90));

//list.RemoveAll(p => p.Price >= 100.0);

list.RemoveAll(ProductTest);

foreach(Product p in list)
{
Console.WriteLine(p);
}
}
public static bool ProductTest(Product p)
{
return p.Price >= 100.0;
}

}
}

using System;
using System.Collections.Generic;
using System.Text;

namespace ExpressoesLambda.Entities
{
class Product
{
public string Name { get; set; }
public double Price { get; set; }

public Product (string name, double price){

Name = name; Price = price;
}

public override string ToString()

{
return Name + ", "+ Price.ToString("F2");
}
}
}

Action (exemplo com ForEach)

Action (System)

• Representa um método void que recebe zero ou mais argumentos

• https://msdn.microsoft.com/en-us/library/system.action%28v=vs.110%29.aspx

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE

public delegate void Action();
public delegate void Action<in T>(T obj);
public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);
public delegate void Action<in T1, in T2, in T3>(T1 arg1, T2 arg2, T3 arg3);
(16 sobrecargas)

Problema exemplo

Fazer um programa que, a partir de uma lista de produtos, aumente o preço dos produtos em 10%.

using System;
using ExpressoesLambda.Entities;
using System.Collections.Generic;

namespace ExpressoesLambda
{
class Program
{

static void Main(string[] args)

{
List<Product> list = new List<Product>();
list.Add(new Product("Tv", 900.00));
list.Add(new Product("Mouse", 50.00));
list.Add(new Product("Tablet", 350.50));
list.Add(new Product("HD Case", 80.90));

// list.ForEach(p=> {p.Price += p.Price * 0.1});

list.ForEach(UpdatePrice);

foreach(Product p in list)
{
Console.WriteLine(p);
}
}
//deve-se eliminar esta função caso fosse usar o código com lambda comentado acima
static void UpdatePrice (Product p)
{
p.Price += p.Price * 0.1;
}

}
}

Func (exemplo com Select)

Func (System)

• Representa um método que recebe zero ou mais argumentos, e retorna um valor

https://msdn.microsoft.com/en-us/library/bb534960%28v=vs.110%29.aspx

public delegate TResult Func<out TResult>();

public delegate TResult Func<in T, out TResult>(T obj);

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE

public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2);
public delegate TResult Func<in T1, in T2, in T3, out TResult>(T1 arg1, T2
arg2, T3 arg3);
(16 sobrecargas)

Problema exemplo

Fazer um programa que, a partir de uma lista de produtos, gere uma nova lista contendo os
nomes dos produtos em caixa alta.

using System;
using ExpressoesLambda.Entities;
using System.Collections.Generic;
using System.Linq;

namespace ExpressoesLambda
{
class Program
{

static void Main(string[] args)

{
List<Product> list = new List<Product>();
list.Add(new Product("Tv", 900.00));
list.Add(new Product("Mouse", 50.00));
list.Add(new Product("Tablet", 350.50));
list.Add(new Product("HD Case", 80.90));

//usando um delegate
//Func<Product, string> func = NameUpper;
//List<string> result = list.Select(func).ToList();

// ou com expressao lambda

// deve-se eliminar o método NameUpper
// Func<Product, string> func = p => p.Name.ToUpper();

List<string> result = list.Select(NameUpper).ToList();

foreach(string s in result)
{
Console.WriteLine(s);
}
}
static string NameUpper (Product p)
{
return p.Name.ToUpper();
}

}
}

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE

Resumo:

• removeAll(Predicate)

• ForEach(Action)

• Select(Func)

Exercícios:

Fazer um programa que, a partir de uma lista de produtos, calcule a soma dos preços somente dos
produtos cujo nome começa com "T".

List<Product> list = new List<Product>();

list.Add(new Product("Tv", 900.00));
list.Add(new Product("Mouse", 50.00));
list.Add(new Product("Tablet", 350.50));
list.Add(new Product("HD Case", 80.90));

Resultado: 1250.50

Introdução ao LINQ

LINQ - Language Integrated Query

• É um conjunto de tecnologias baseadas na integração de funcionalidades de consulta diretamente na

linguagem C#

• Operações chamadas diretamente a partir das coleções

• Consultas são objetos de primeira classe

• Suporte do compilador e IntelliSense da IDE

• Namespace: System.Linq

• Possui diversas operações de consulta, cujos parâmetros tipicamente são expressões lambda ou
expressões de sintaxe similar à SQL.

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE

• Referência:

• https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/linq/index

Três passos para uso de Linq

• Criar um data source (coleção, array, recurso de E/S, etc.)

• Definir a query

• Executar a query (foreach ou alguma operação terminal)

Demo

// Specify the data source.

int[] numbers = new int[] { 2, 3, 4, 5 };
// Define the query expression.
IEnumerable<int> result = numbers
.Where(x => x % 2 == 0)
.Select(x => 10 * x);
// Execute the query.
foreach (int x in result) {
Console.WriteLine(x);
}

Operações do LINQ

• Filtering: Where, OfType • Generational: Empty

• Sorting: OrderBy, OrderByDescending, • Equality: SequenceEquals

ThenBy, ThenByDescending, Reverse • Element: ElementAt, First, FirstOrDefault

• Set: Distinct, Except, Intersect, Union Last, LastOrDefault, Single, SingleOrDefault

• Quantification: All, Any, Contains • Conversions: AsEnumerable, AsQueryable

• Projection: Select, SelectMany • Concatenation: Concat

• Partition: Skip, Take • Aggregation: Aggregate, Average, Count,

• Join: Join, GroupJoin LongCount, Max, Min, Su

• Grouping: GroupBy

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE

Referências

• https://code.msdn.microsoft.com/101-LINQ-Samples-3fb9811b/view/SamplePack/1?sortBy=Popularity

• https://code.msdn.microsoft.com/101-LINQ-Samples-3fb9811b/view/SamplePack/2?sortBy=Popularity

• https://odetocode.com/articles/739.aspx

Demo: LINQ com Lambda

Classe Category

using System;
using System.Collections.Generic;
using System.Text;

namespace ExpressoesLambda.Entities
{
class Category
{
public int Id { get; set; }
public string Name { get; set; }
public int Tier { get; set; }
}
}
Classe Product

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text;

namespace ExpressoesLambda.Entities
{
class Product
{
public int Id { get; set; }
public string Name { get; set; }
public double Price { get; set; }
public Category Category { get; set; }

public override string ToString()

{
return Id
+ ", "
+ Name
+ ", "
+ Price.ToString("F2", CultureInfo.InvariantCulture)
+ ", "
+ Category.Name
+ ", "
+ Category.Tier;
}
}
}

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE

Program

using System;
using ExpressoesLambda.Entities;
using System.Collections.Generic;
using System.Linq;

namespace ExpressoesLambda
{
class Program
{
static void Print<T>(string message, IEnumerable<T> collection)
{
Console.WriteLine(message);
foreach(T obj in collection)
{
Console.WriteLine(obj);
}
Console.WriteLine();
}
static void Main(string[] args)
{
Category c1 = new Category() { Id = 1, Name = "Tools", Tier = 2 };
Category c2 = new Category() { Id = 2, Name = "Computers", Tier = 1 };
Category c3 = new Category() { Id = 3, Name = "Electronics", Tier = 1 };

List<Product> products = new List<Product>()

{
new Product(){Id = 1, Name = "Computer", Price = 1100.0, Category = c2},
new Product() { Id = 2, Name = "Hammer", Price = 90.0, Category = c1 },
new Product() { Id = 3, Name = "TV", Price = 1700.0, Category = c3 },
new Product() { Id = 4, Name = "Notebook", Price = 1300.0, Category = c2 },
new Product() { Id = 5, Name = "Saw", Price = 80.0, Category = c1 },
new Product() { Id = 6, Name = "Tablet", Price = 700.0, Category = c2 },
new Product() { Id = 7, Name = "Camera", Price = 700.0, Category = c3 },
new Product() { Id = 8, Name = "Printer", Price = 350.0, Category = c3 },
new Product() { Id = 9, Name = "MacBook", Price = 1800.0, Category = c2 },
new Product() { Id = 10, Name = "Sound Bar", Price = 700.0, Category = c3 },
new Product() { Id = 11, Name = "Level", Price = 70.0, Category = c1 }

};
//Poderiamos ter usado este trecho de codigo, mas por questoes de economia de codigo
//usamos uma funcao que faz a impressao e apenas chamamos a funcao em cada resultado
//Console.WriteLine("TIER 1 AND PRICE < 900:");
//foreach(Product x in r1)
//{
// Console.WriteLine(x);
//}
var r1 = products.Where(p => p.Category.Tier == 1 && p.Price < 900.0);
Print("TIER 1 AND PRICE < 900:", r1);

var r2 = products.Where(p => p.Category.Name == "Tools").Select(p => p.Name);

Print("NAMES OF PRODUCTS FROM TOOLS", r2);

var r3 = products.Where(p => p.Name[0] == 'C').Select(p => new { p.Name, p.Price, CategoryName = p.Category.Name });
Print("NAMES STARTED WITH 'C' AND ANONYMOUS OBJECT", r3);

var r4 = products.Where(p => p.Category.Tier == 1).OrderBy(p => p.Price).ThenBy(p => p.Name);

Print("TIER 1 ORDER BY PRICE THEN BY NAME", r4);

var r5 = r4.Skip(2).Take(4);
Print("TIER 1 ORDER BY PRICE THEN BY NAME SKIP 2 TAKE 4", r5);

var r6 = products.FirstOrDefault();
Console.WriteLine("First test1: "+r6);
var r7 = products.Where(p => p.Price > 3000.0).FirstOrDefault();

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE

 Console.WriteLine("First or default test2: " + r7);
Console.WriteLine();

var r8 = products.Where(p => p.Id == 3).SingleOrDefault();

Console.WriteLine("Single or default teste1: " + r8);
var r9 = products.Where(p => p.Id == 30).SingleOrDefault();
Console.WriteLine("Single or default teste2: " + r9);
Console.WriteLine();

var r10 = products.Max(p => p.Price);

Console.WriteLine("Max price: " + r10);
var r11 = products.Min(p => p.Price);
Console.WriteLine("Min price: " + r11);
var r12 = products.Where(p => p.Category.Id == 1).Sum(p => p.Price);
Console.WriteLine("Category 1 Sum prices: " + r12);
var r13 = products.Where(p => p.Category.Id == 1).Average(p => p.Price);
Console.WriteLine("Category 1 Average prices: " + r13);
var r14 = products.Where(p => p.Category.Id == 5).Select(p => p.Price).DefaultIfEmpty(0.0).Average();
Console.WriteLine("Category 5 Average prices: " + r14);
var r15 = products.Where(p => p.Category.Id == 1).Select(p => p.Price).Aggregate(0.0, (x, y) => x + y);
Console.WriteLine("Category 1 aggregate sum: " + r15);
Console.WriteLine();

var r16 = products.GroupBy(p => p.Category);

foreach (IGrouping<Category, Product> group in r16)
{
Console.WriteLine("Category " + group.Key.Name + ":");
foreach(Product p in group)
{
Console.WriteLine(p);
}
Console.WriteLine();
}
}

}
}

FICHA 1 – EXPRESSÕES LAMBDA, DELEGATES E LINQ DOCENTE: GRAÇANE MUHATE