Fundamentos LINQ .NET - Language Integrated Query

Fundamentos LINQ - Language Integrated Query
--------------------------------------------

https://dotnettutorials.net/lesson/introduction-to-linq/

// Funções Lambda - Muito bom
https://geeks.ms/adiazmartin/2010/03/23/operadores-linq/

// Paginação
https://www.macoratti.net/08/01/aspn_lqp.htm

// LINQ
https://www.educba.com/linq-left-join/



Instalação AspNetCore
---------------------

    . Instalçao para as versões do Ubuntu 20.04

        . Localize a versão do Ubuntu que está sendo utilizado, copie e execute os comandos no 
            terminal:

            wget https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
            sudo dpkg -i packages-microsoft-prod.deb

            sudo dpkg --purge packages-microsoft-prod && sudo dpkg -i packages-microsoft-prod.deb
            sudo apt-get update

            sudo apt-get install -y gpg
            wget -O - https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor -o microsoft.asc.gpg
            sudo mv microsoft.asc.gpg /etc/apt/trusted.gpg.d/
            wget https://packages.microsoft.com/config/ubuntu/20.04/prod.list
            sudo mv prod.list /etc/apt/sources.list.d/microsoft-prod.list
            sudo chown root:root /etc/apt/trusted.gpg.d/microsoft.asc.gpg
            sudo chown root:root /etc/apt/sources.list.d/microsoft-prod.list

            # Comando para o Ubuntu 22.04 em diante
            # wget http://archive.ubuntu.com/ubuntu/pool/main/o/openssl/libssl1.1_1.1.0g-2ubuntu4_amd64.deb
            # sudo dpkg -i libssl1.1_1.1.0g-2ubuntu4_amd64.deb
            
            sudo apt-get update; \
            sudo apt-get install -y apt-transport-https && \
            sudo apt-get update && \
            sudo apt-get install -y dotnet-sdk-5.0

            sudo apt-get install -y apt-transport-https && \
            sudo apt-get update && \
            sudo apt-get install -y aspnetcore-runtime-5.0

            sudo apt-get install -y dotnet-runtime-5.0

        . Para testar a instalação execute os comandos abaixo:

            dotnet --version
            dotnet --help
            dotnet --list
            dotnet --list-runtimes
            dotnet --list-sdks
    
    . Instalação para as versões acima do Ubuntu 22.04

        https://www.how2shout.com/linux/how-to-install-net-core-dotnet-on-ubuntu-22-04-lts/

        wget http://archive.ubuntu.com/ubuntu/pool/main/o/openssl/libssl1.1_1.1.0g-2ubuntu4_amd64.deb
        sudo dpkg -i libssl1.1_1.1.0g-2ubuntu4_amd64.deb

        wget https://dot.net/v1/dotnet-install.sh
        chmod +x dotnet-install.sh
        ./dotnet-install.sh -c 5.0
        ./dotnet-install.sh -c 6.0
        dotnet --version
        echo 'export PATH="/home/$USER/.dotnet:/home/$USER/.dotnet/tools:$PATH"' >> ~/.bashrc
        source ~/.bashrc
        dotnet --version
        dotnet --list-runtimes
        dotnet --list-sdks

Instalação das extensões do VSCode
----------------------------------

        C# 
        C# Extensions
        C# XML Documentation Comments
        Docker
        vscode-icons (Opcional)
        NuGet Gallery
        VZ Dotnet File Template
        Dotnet Project References
        Auto-Using for C#
        Bracket Pair Colorization Toggler
        Error Lens
        RapidApi


    Testar
        Dotnet Solution Explorer
        Dotnet New Extension
        Net Core Extension Pack
        C# Utilities
        Nuget Package Manager
        Visual Nuget
        C# Developer Extension Package
        Auto closet tag
        C# Snippets


    . Atalhos:

        Ctrl + K + D ou Shit + Alt + F:             Identa todo o seu código automaticamente;
        Ctrl + K + C:                               comenta um bloco de linhas;
        Ctrl + K + U:                               descomenta um bloco de linhas;
        Alt + Left Arrow:                           durante a programação, volta um método que você estava navegando;
        Alt + Right Arrow:                          durante a programação, avança um método que você estava navegando;
        Ctrl + .:                                   implementa o método/classe inexistente que você acabou de escrever;
        Ctrl + M + O:                               esconde todas as regions da classe atual;
        Ctrl + Shift + B:                           compila todos os projetos;
        F5:                                         manda depurar um projeto;
        Ctrl + F5:                                  manda executar um projeto;
        F10:                                        durante a depuração, avança uma linha;
        F11:                                        durante a depuração, avança uma linha entrando nos detalhes da mesma;


Configurar Visual Studio Code para .NETCore
-------------------------------------------

    . Acesse File / Preferences / Settings

    . Digite C#

    . Acesse "C# Configuration / CSharp Format Enabled" e habilite a configuração

    . Digite "Format on save" e habilite a configuração

    . Digite "Final" e habilite a configuração "Files: Insert final newline" e habilite a configuração


.NET Core Command-Line Interface (CLI)    
--------------------------------------

    . Digite no terminal "dotnet --info" para apresentar informações variadas da instação do dotnet

    . Digite no terminal "dotnet new" irá apresentar as várias possibilidades de criar diversos projetos, exemplo:

        dotnet new mvc

        dotnet run

        #Acesse o navegador e digite a URL: https://localhost:5001/ para ver o resultado do projeto criado.

    . Ctrl + C no terminal acaba com a execução do projeto:

https://www.infoq.com/br/articles/netcore-cli/    


    . Comandos dotnet cli:

        dotnet new console          => Novo Console Application
        dotnet new classlib         => Nova Class Library
        dotnet new web              => Novo projeto ASP.NET Core
        dotnet new mvc              => Novo projeto ASP.NET Core
        dotnet new webapi           => Novo projeto ASP.NET Core
        dotnet new mstest           => Novo projeto Microsoft Test









Aula 1 - C# - Introdução ao LINQ
--------------------------------

    . O que é o LINQ?

        . Conjunto de tecnologias com base na integração de recursos de consulta diretamente na 
            linguagem C#.

        . Como as consulta são feitas? Geralmente são expressas como cadeias de caracteres, sem 
            verificação de tipos no tempode compilação ou suporte ao InteliSense.

        . Tem a necessidae de se aprender uma linguagem de consulta, exemplo: SQL.

    . Vantagens:

        . Sintaxe unificada. Independente da fonte de dados que estiver utilizando.

        . Verificação de tipo no tempo de compilação.Suporte ao IntelliSense.

        . Sintaxe unificada. Independente da fonte de dados que esitver utilizando.

    
    . Operações LINQ consistem em 3 operações:

        . Obter a fonte de dados:

            . Banco de Dados
            . XML
            . JSON
            . Objetos em Memória
            . ADO.NET Data Set
            . Entity Framework

        . Criar a consulta

        . Executar a consulta:

            . Execução adiada:

                . A variável armazena apensa os comandos da consulta.

                . A execução real da consulta é adiada até que você itere sobre a variável.

            . Execução imediata:

                . Funções de agregação (Firs, Max, Sum)

                . Para forçar a execução imediata e armazedo na memória, basta utilizar:

                    . ToList()
                    . ToArray()

    . Como sei que posso executar uma consulta LINQ?

        . Implementar a interface genérica IEnumerable<T> ou uma interface derivada. São chamados 
            de "Tipos passiveis de consulta".
                
        
            Baseados em métodos            Sintaxe de expressão de 
                de extensão                  de consulta c#
            --------------------           -----------------------

            Where-------------->+           +<----------from
                                |           |
            First-------------->|           |<----------Where
                                |           |
            Last--------------->|-> LINQ <--|<----------select
                                |           |
            GroupBy------------>|           |<----------group
                                |           |
            OrderBy------------>+           |            | join
                                            |            | in
                                            |<-----------| on
                                            |            | equals  
                                            |
                                            +<----------- order by / descending                                       

Aula 2 - C# LINQ - Criando a primeira consulta
----------------------------------------------

    . Acesse a pasta raiz de projetos e execute a linha abaixo:

        dotnet new console -o FundamentoLINQ -n FundamentoLINQ -f net5.0

    . Acesse a pasta do projeto criado e altere o conteúdo da classe "Program.cs" pelas linhas abaixo:

        ...
        static void Main(string[] args)
        {
            // Fonte de Dados (Datasource)
            var listaProdutos = new List<Produto>()
            {
                new Produto {Id = 9, CategoriaId = 2, Nome = "Geladeira", Status = true, Valor = 10},
                new Produto {Id = 2, CategoriaId = 3, Nome = "Short", Status = true, Valor = 1},
                new Produto {Id = 4, CategoriaId = 1, Nome = "Maquina de lavar", Status = false, Valor = 32},
                new Produto {Id = 3, CategoriaId = 1, Nome = "Video Game", Status = true, Valor = 99},
                new Produto {Id = 6, CategoriaId = 2, Nome = "Arroz", Status = true, Valor = 55},
                new Produto {Id = 8, CategoriaId = 1, Nome = "TV", Status = true, Valor = 45},
                new Produto {Id = 1, CategoriaId = 3, Nome = "Camiseta", Status = true, Valor = 100},
                new Produto {Id = 5, CategoriaId = 1, Nome = "Microondas", Status = true, Valor = 90},
                new Produto {Id = 7, CategoriaId = 2, Nome = "Feijão", Status = true, Valor = 12},
            };

            var listaCategorias = new List<Categoria>(){
                new Categoria(){ Id = 1, Status = true, Nome = "Eletronicos"},
                new Categoria(){ Id = 2, Status = true, Nome = "Alimentos"},
                new Categoria(){ Id = 3, Status = true, Nome = "Vestuario"}
            };

            // Criar Consulta LINQ  (Query)
            var resultado = from produto in listaProdutos
                            select produto;

            // Executar a consulta  (Execution)
            resultado.ToList().ForEach( item => {
                System.Console.WriteLine($"{item.Id} | {item.Nome} | {item.Valor} | {item.CategoriaId}");
            });

        }
        ...

    . Crie a pasta "Model" e as classes abaixo dentro dela:

        namespace FundamentoLINQ.Model
        {

            public class Categoria
            {
                
                public int Id { get; set; }
                public string Nome { get; set; }
                public bool Status { get; set; }
                    

            }
        }    




        namespace FundamentoLINQ.Model
        {

            public class Produto
            {
                public int Id { get; set; }
                public string Nome { get; set; }
                public bool Status { get; set; }
                public decimal Valor { get; set; }
                public int CategoriaId { get; set; }

            }

        }

    . Execute o projeto e veja se saiu o resultado da lista de produtos corretamente.

    . Altere na classe "Program.cs" a chamada LINQ como abaixo:

        ...
        var resultado = from produto in listaProdutos
                        where produto.Valor > 50            // Linha inserida
                        select produto;
        ...

    . Execute o projeto e veja se saiu o resultado da lista de produtos com valores superiores a 50.

    . Importante: Se tivermos somente uma expressão LINQ, conseguiremos itera-la somente com o comando "foreach( var item in resultado){ ... }".
                    Caso queiramos utilizar funções Lambda, como ".ForEach(...)" precisamos fazer com que o resultado seja um List, ou Array. O
                    mais fácil para isso seria acrescenter parenteses na expressão LINQ e fazermos a chamada do método "ToList()".

                ...
                var resultado = (   from produto in listaProdutos
                                    select produto
                                }).ToList();

                resultado.ForEach( item => {
                    System.Console.WriteLine($"{item.Id} | {item.Nome} | {item.Valor} | {item.CategoriaId}");
                });
                ...

            ou, podemos deixar a expressão LINQ intacta e chamar o "ToList()" no momento da iteração:

                ...
                var resultado = from produto in listaProdutos
                                select produto;

                // Executar a consulta
                resultado.ToList().ForEach( item => {
                    System.Console.WriteLine($"{item.Id} | {item.Nome} | {item.Valor} | {item.CategoriaId}");
                });
                ...


        . Caso não queira trabalhar com Lambda, podemos iterar o resultado diretamente num "foreach( var item in resultado){ ... }"

                ...
                var resultado = from produto in listaProdutos
                                where produto.Valor > 50            
                                select produto;

                foreach( var item in resultado ){
                    System.Console.WriteLine($"{item.Id} | {item.Nome} | {item.Valor} | {item.CategoriaId}");
                }


    . Sintaxe LINQ Query:


        from <object> in <datasource>       <--- Initialization     

        where <condition>                   <--- Condition

        select <object>                     <--- Selection


        . Exemplo:

            from id in fonteDados
            { from id in fonteDados |
            join id in fonteDados on expressão equals expressão [ into id ] |
            let id = expressão |
            where condição |
            orderby id1, id2, … [ascending | descending] }
            select expressão | group expressão by chave
            [ into id ]

            . As expressões de consulta devem iniciar com from, depois podem ter um ou mais from, join, let, where ou orderby e 
                deve terminar com select ou group by.

    . Palavras-chaves (cláusulas) de C# para consultas LINQ

        Cláusula	    Descrição
        --------        ---------
        from	        Especifica a fonte de dados e uma variável de série (similar a uma variável de iteração num laço).

        where	        Filtra elementos da fonte de dados baseada em uma ou mais expressões booleanas.

        select	        Faz projeções, permitindo especificar o tipo e o formato dos elementos do resultado da consulta. 
                        Frequentemente usada em conjunto com o recurso de tipos anônimos.

        join	        Junta duas fontes de dados baseado em comparações de igualdade entre dois elementos de comparação 
                        especificados.

        in              Palavra-chave contextual usada numa cláusula join.

        on	            Palavra-chave contextual usada numa cláusula join.

        equals	        Palavra-chave contextual usada numa cláusula join. Observe que se deve usar a palavra-chave equals 
                        ao invés do operador == na comparação da cláusula join.

        group	        Agrupa os resultados de uma consulta de acordo com valores específicos de uma chave.

        by	            Palavra-chave contextual usada numa cláusula group.

        into	        Fornece um identificador para servir de referência para os resultados de uma cláusula de junção (join), 
                        agrupamento (group) ou projeção (select).

        orderby	        Classifica os resultados em ordem ascendente ou descendente.

        ascending	    Palavra-chave contextual usada numa cláusula orderby para determinar a classificação em ordem ascendente, 
                        que é a classificação padrão em caso de omissão.

        descending	    Palavra-chave contextual usada numa cláusula orderby para determinar a classificação em ordem descendente.

        let	            Introduz uma variável para armazenar resultados de expressões intermediárias numa expressão de consulta. 
                        Deste modo, o resultado armazenado na variável pode ser reutilizado na consulta.

        && ||           Operadores lógicos E OU

https://www.devmedia.com.br/expressoes-de-consulta-linq-net-magazine-78/18217
https://www.devmedia.com.br/linq-e-csharp-efetuando-consultas-com-lambda-expressions/38863



// PAREI AQUI
Aula 3 - C# - LINQ - Where e OrderBy
------------------------------------

    . Altere a expressão LINQ como abaixo:

        ...
        var resultado = from produto in listaProdutos
                        where produto.Nome == "arroz"   // Linha Alterada
                        select produto;
        ...

    . Ao executar o projeto veremos que não trouxe nenhum registro, porque na coleção não existe "arroz"
        e sim "Arroz". Para que possamos considerar ambas, vamos utilizar a expressão "ToLower()".

        ...
        var resultado = from produto in listaProdutos
                        where produto.Nome.ToLower() == "arroz"   // Linha Alterada
                        select produto;
        ...

    . Para selecionar somente os itens que iniciam com a letra "a" o código ficaria:

        ...
        var resultado = from produto in listaProdutos
                        where produto.Nome.ToLower().Substring(0,1) == "a"   // Linha Alterada
                        select produto;
        ...

    . Para selecionar itens de uma coluna "Boolean":

        ...
        var resultado = from produto in listaProdutos
                        where produto.Nome.ToLower().Substring(0,1) == "a" 
                            && produto.Status == true                              // Linha Alterada
                        select produto;
        ...

    . Para ordenar a saída:

        ...
        var resultado = from produto in listaProdutos
                        orderby produto.Id                          // Linha Alterada
                        select produto;
        ...

        ou 

        ...
        var resultado = from produto in listaProdutos
                        orderby produto.Id descending                // Linha Alterada
                        select produto;
        ...

    . Ordenando e filtrando:

        ...
        var resultado = from produto in listaProdutos
                        where produto.Id > 1 && produto.Id < 6      // Linha Alterada
                        orderby produto.Id descending                // Linha Alterada
                        select produto;
        ...


Aula 4 - C# - LINQ - Projetando dados com Select
------------------------------------------------

    . Altere a expressão LINQ como abaixo para criarmos uma lista anonima e execute o projeto:

        ...
        var resultado = from produto in listaProdutos
                        where produto.Id > 1 && produto.Id < 6      
                        select new { produto.Nome, produto.Valor }    

        foreach( var item in resultado ){
            System.Console.WriteLine($"{item.Nome} | {item.Valor} | {item.CategoriaId}");
        }

        ...

    . Se quisermos dar um nome para cada coluna do "select" faça como abaixo, execute o projeto:

        ...
        var resultado = from produto in listaProdutos
                        where produto.Id > 1 && produto.Id < 6      
                        select new { NomeProduto = produto.Nome, ValorProduto = produto.Valor }    

        foreach( var item in resultado ){
            System.Console.WriteLine($"{item.NomeProduto} | {item.ValorProduto}");
        }
        ...

    . Crie a classe abaixo:

        namespace FundamentoLINQ.Model
        {

            public class ProdutoDto
            {
                public string Nome { get; set; }
                public bool Status { get; set; }
                public decimal Valor { get; set; }
            }

        }

    . Altere a expressão LINQ como abaixo para criarmos uma lista anonima e execute o projeto:

        ...
        var resultado = from produto in listaProdutos
                        where produto.Id > 1 && produto.Id < 6      
                        select new ProdutoDto { Nome = produto.Nome, Valor = produto.Valor, Status = produto.Status }    
        ...

        . No exemplo acima o lista "resultado" deixou de ser anônima

        . É possível fazermos mudança dos dados no "select", como por exemplo:

            ...
            select new ProdutoDto { Nome = produto.Nome.ToUpper(), Valor = produto.Valor * 1.10, Status = produto.Status }    
            ...


Aula 5 - C# - LINQ - Trabalhando com join e group by
----------------------------------------------------

    . Altere a expressão LINQ como abaixo para criarmos uma lista agrupada e execute o projeto:

        ...
        var resultado = from prod in listaProdutos
                        group prod by prod.CategoriaId into produtosAgrupado
                        select produtosAgrupados;

        foreach( var item in resultados){
            Console.Write({item.key});
        });
        ...

    . Acrescente as linhas abaixo no corpo do código acima e execute o projeto:

        ...
        var resultado = from prod in listaProdutos
                        group prod by prod.CategoriaId into produtosAgrupado
                        select produtosAgrupados;

        foreach( var item in resultados){
            Console.Write({item.key});

            // Loop Incluido
            foreach( var prod in item ){
                Console.Write($"Produto: {prod.Nome} | Categoria: {prod.CategoriaId}");
            }
        });
        ...

    . Refaça o código da expressão LINQ como abaixo para criarmos uma lista com Join e execute o projeto

        ...
        var resultados = from prod in listaProdutos
                         join cat in listaCategorias
                            on prod.CategoriaId equals cat.Id
                         select new {
                            Produto = prod,
                            Categoria = cat
                         }

        foreach( var item in resultados){
                Console.Write($"Produto: {item.Produto.Nome} | Categoria: {item.Categoria.Nome}");
        });
    
    . Altere o código da categoria de algum produto para um código inexistente e execute o projeto.

        . Neste caso, não veio a ocorrência com a categoria inválida.
    
    . Refaça o código da expressão LINQ como abaixo para criarmos uma lista com Join e execute o projeto

        ...
        var resultados = from prod in listaProdutos
                         join cat in listaCategorias
                            on prod.CategoriaId equals cat.Id   into catFinal
                         from catEncontrada in catEncontrada.DefaultIfEmpty()
                         select new {
                            ProdutoNome = Produto.Nome,
                            CategoriaNome = catEncontrada?.Nome
                         }

        foreach( var item in resultados){
                Console.Write($"Produto: {item.ProdutoNome} | Categoria: {item.CategoriaNome}");
        });
    
Aula 6. C# - LINQ - First, FirstOrDefault, Last, LastOrDefault, Single, SingleOrDefault
---------------------------------------------------------------------------------------

    . First - Traz o primeiro item da lista, caso não exista é levantado uma "exception".

        . Altere o código da expressão LINQ como abaixo para trazermos a primeira ocorrência da lista:

            ...
            static void Main(string[] args)
            {
                // Fonte de Dados (Datasource)
                var listaProdutos = new List<Produto>()
                {
                    ...
                };

                var listaCategorias = new List<Categoria>(){
                    ...
                };

                // Resgasta somente a primeira ocorrência da lista
                var resultado = listaProdutos.First();                  // Linha Inserida

                Console.WriteLine($"Nome: {resultado.Nome} | ID: {resultado.Id}" ); // Linha inserida

                Console.ReadLine();     // Linha Inserida

            }
            ...

    . FirstOrDefault - Traz o valor padrão da lista, no nosso caso se não houver nenhum item na lista, o retorno será um
                        objeto nulo do tipo "Produto".

        . Altere o código da expressão LINQ, substituindo o "First" pelo "FirstOrDefault" como abaixo para 
            trazermos a primeira ocorrência da lista, independente se a lista tem conteúdo ou não.

                ...
                // Resgasta somente a primeira ocorrência da lista
                var resultado = listaProdutos.FirstOrDefault();                  // Linha Alterada
                ...

    . Tanto "First" como "FirstOrDefault" podem receber parâmetros do tipo "Lambda":

        .First( x => x.Id == 70 );

        .FirstOrDefault( x => x.Id == 70 );

        . Em ambos os casos o LINQ tentará trazer o primeiro item com o "Id == 70". No "First" senão encontrar levantará uma
            "Exception", no "FirstOrDefault" trará um objeto nulo.

    . "Last" e "LastOrDefault" funcionam de forma semelhante ao "First" e o "FirstOrDefault". Porém, traz a última 
        ocorrência da lista.

    . Tanto as funções "First"s quanto as "Last"s, caso exista mais de uma ocorrência com o código solicitado "...( x => x.Id == 70 )"
        ele trará a primeira, ou a última ocorrência da lista respectivamente.

    . "Single" ou "SingleOrDefault" funcionam semelhantemente aos "First"s e "Last"s, porém ele levantará uma "Exception" caso
        exista na lista mais de uma ocorrência com a mesma chave pesquisada.

        . Suponha que exista dois produtos com o mesmo "Id", seu usarmos o "Single" ou o "SingleOrDefault" haverá um erro e uma "exception"
            será levantada.

Aula 7. C# - LINQ - .Where() .OrderBy() .OrderByDescending() - Sintaxe de método
-------------------------------------------------------------------------------------------

    . Where - Função para filtrar os itens da coleção.

        . Altere o código da expressão LINQ como abaixo para trazermos a primeira ocorrência da lista:

            ...
            static void Main(string[] args)
            {
                // Fonte de Dados (Datasource)
                var listaProdutos = new List<Produto>()
                {
                    ...
                };

                var listaCategorias = new List<Categoria>(){
                    ...
                };

                // Resgasta os produtos com "Id" >= 2 e <= 5
                var resultado = listaProdutos.Where( prod => prod.Id >=2 && prod.Id <= 5);                  // Linha Inserida

                foreach( var item in resultado ){
                    Console.WriteLine($"Nome: {item.Nome} | ID: {item.Id}" ); // Linha inserida
                }

                Console.ReadLine();     // Linha Inserida

            }
            ...

        . Os operadores condicionais que podem ser utilizado && ou ||
    
        . Métodos auxiliares para facilitar a filtragem:

            . Crie o método abaixo na classe "Program.cs":

                ...
                static bool FiltraProdutoPorValor( Produto produto ){
                    return produto.Valor > 50;
                }
                ..

            . Altere a expressão LINQ como abaixo:

                ...
                static void Main(string[] args)
                {
                    // Fonte de Dados (Datasource)
                    var listaProdutos = new List<Produto>()
                    {
                        ...
                    };

                    var listaCategorias = new List<Categoria>(){
                        ...
                    };

                    var resultado = listaProdutos.Where( prod => prod.FiltrProdutoPorValor( prod ));                  // Linha Alterada

                    foreach( var item in resultado ){
                        Console.WriteLine($"Nome: {item.Nome} | ID: {item.Id}" ); 
                    }

                    Console.ReadLine();     

                }
                ...

    . OrderBy

        . Altere o código da expressão LINQ como abaixo para trazermos a primeira ocorrência da lista:

            ...
            static void Main(string[] args)
            {
                ...
                var resultado = listaProdutos.OrderBy( x => x.Id );

                foreach( var item in resultado ){
                    Console.WriteLine($"Nome: {item.Nome} | ID: {item.Id}" ); // Linha inserida
                }

                Console.ReadLine();     // Linha Inserida

            }
            ...

    . OrderByDescending

        . Altere o código da expressão LINQ como abaixo para trazermos a primeira ocorrência da lista:

            ...
            var resultado = listaProdutos.OrderByDescending( x => x.Id );
            ...

Aula 8. C# - LINQ - Select e SelectMany
---------------------------------------

    . Select

        . Forma simples de trabalhar com "Select":

            ...
            var resultado = listaProdutos.Select( prod => prod.Nome );

            foreach( var produto in resultado ){
                Console.WriteLine($"Nome: {produto}" ); // Linha alterada
            }

            Console.ReadLine();     
            ...

        . Gerando objetos anônimos:

            ...
            var resultado = listaProdutos.Select( prod => new { 
                                                                prod.Id,
                                                                prod.Nome,
                                                                prod.Valor
                                                            });

            foreach( var produto in resultado ){
                Console.WriteLine($"Nome: {produto.Id} {produto.Nome} {Produto.Valor}"); // Linha alterada
            }

            Console.ReadLine();     
            ...

    . SelectMany

        . Acrescente na classe "Produto" a propriedade abaixo:

            ...
            public List<Categoria> Categorias { get; set; }
            ...

        . Se basear no link abaixo para desenvolver os exemplos do curso

        https://www.tektutorialshub.com/entity-framework-core/selectmany-in-entity-framework-core/


Aula 9. C# - LINQ - .Skip() e .Take()
-------------------------------------

https://www.youtube.com/watch?v=gEan2v0ehCw&list=PLelKrgw43Tu2A2hCLMtrrS_Ox6ds-p7jw&index=9

    . Skip e Take

        . Take - O operador Take é usado para selecionar os primeiros n objetos de uma coleção

            ...
            var tresPrimeiros = listaProdutos.Take(3);

            Console.WriteLine(" --------------- Três Primeiros ------------------");

            foreach( var prod in tresPrimeiros ){
                Console.WriteLine($"ID: {prod.Id} NOME: {prod.Nome}")
            }

        . Skip - O operador Skip ignora o(s) primeiro(s) n objetos de uma coleção.

            ..
            var ignorarTresPrimeiros = listaProdutos.Skip(3);

            Console.WriteLine(" --------------- A partir do 4o. Item ------------------");

            foreach( var prod in ignorarTresPrimeiros ){
                Console.WriteLine($"ID: {prod.Id} NOME: {prod.Nome}")
            }

        . Podemos utilizar ambas funções em conjunto. Suponha que eu queira pegar a segunda página de registro,
            sendo que cada página tem 3 itens:

            ... 
            var pagina = 2;
            var itensPorPagina = 3;

            var resultado = listaProdutos.Skip( itensPorPagina * (pagina - 1) ).take( itensPorPagina );

            Console.WriteLine(" --------------- Registros da 2a. Página ------------------");

            foreach( var prod in resultado ){
                Console.WriteLine($"ID: {prod.Id} NOME: {prod.Nome}")
            }

Aula 10. C# - LINQ - Sum, Average, Count, Range e Repeat
--------------------------------------------------------
https://www.youtube.com/watch?v=JXoSZpR9_aw&list=PLelKrgw43Tu2A2hCLMtrrS_Ox6ds-p7jw&index=10