# Perguntas e Respostas de Interview em C# (09-01-2025) ## Lista de Videos 1. [Perguntas de Interview sobre C# Top - Preparação de Interview em C# - Treinamento em C# - Simplilearn](https://www.youtube.com/watch?v=1u5E_GiXF9M) 2. [O que é C#? | Linguagem de Programação C# - Tutorial de Início Rápido - Simplilearn](https://www.youtube.com/watch?v=BcMQavJd-tY) 3. [Básicos de C# - C# Para Iniciantes - O Que é a Linguagem de Programação C# - Tutorial - Simplilearn](https://www.youtube.com/watch?v=Z3EpnGi52tE) 4. [Tipos Primítivos e Variáveis em C# - Tipos de Variáveis e Literal Datatype - Tutorial - Simplilearn](https://www.youtube.com/watch?v=rS2rGqW9pPM) 5. [C# OOPS | Programação Orientada a Objetos em C# - Tutorial de Início Rápido - Simplilearn](https://www.youtube.com/watch?v=iA0XZwFqqKI) 6. [Coleções em C# - Coleções em C# - Para Iniciantes - Tutorial - Simplilearn](https://www.youtube.com/watch?v=j9N2YOyInRE) 7. [Árvore e Grafos em C# - Estruturas de Dados e Algoritmos em C# - Tutorial - Simplilearn](https://www.youtube.com/watch?v=IqQ7QpmiBJ0) 8. [Dicionário, Hash Tabelas e Conjuntos em C# - Estruturas de Dados em C# - Tutorial - Simplilearn](https://www.youtube.com/watch?v=iJRx3vs1v54) 9. [Async e Await em C# - Sincronização Async/Await em C# - Tutorial - Simplilearn](https://www.youtube.com/watch?v=B8n-a2qS4Gg) 10. [Espera em C# - Exemplo de Espera em C# - Tutorial - Simplilearn](https://www.youtube.com/watch?v=KezYq745G64) 11. [C# MVC (Model-View-Controller) - Tutorial de C# MVC CRUD Completo usando Entity Framework - Simplilearn](https://www.youtube.com/watch?v=xFeDCD4si3U) 12. [C# REST API (Representational State Transfer) - C# Tutorial - API REST - Tutorial para Iniciantes - Simplilearn](https://www.youtube.com/watch?v=BqDvnDQoMVo) 13. [Web Services em C# - Web Services em C# - Explicado - Tutorial - Simplilearn](https://www.youtube.com/watch?v=cb1_HrhYodI) 14. [Web API em C# - O Que É Web API em C#? - Tutorial - Simplilearn](https://www.youtube.com/watch?v=Ic_bviHY3Qo) 15. [Padrões de Desenho em C# - Padrões de Desenho Tutorial para Iniciantes - Simplilearn](https://www.youtube.com/watch?v=OP1tBC6dBW0) 16. [Injeção de Dependências em C# - Injeção de Dependências - Exemplo em C# - Tutorial - Simplilearn](https://www.youtube.com/watch?v=GRLidsP3O2M) 17. [Delegados em C# - Explicados - Tutorial Delegados e Eventos - C# Delegado - Exemplo - Simplilearn](https://www.youtube.com/watch?v=vOlLd2SsKM4) 18. [Expressões Lambda C# - LINQ C# - C# Tutorial para Iniciantes - Simplilearn](https://www.youtube.com/watch?v=K_62nX2z5As) 19. [Laços em C# - Laços de Repetição em C# - Instruções de Iteração em C# - Tutorial - Simplilearn](https://www.youtube.com/watch?v=yMOjBupmP2A) 20. [Arrays em C# - C# Tutorial para Iniciantes - Como Programar Arrays em C# - Tutorial - Simplilearn](https://www.youtube.com/watch?v=fHDuf1ARC70) 21. [Declarações Condicionais em C# - Se-Destinador-Senao em C# - C# Tutorial - Simplilearn](https://www.youtube.com/watch?v=LwIULGTxs-I) 22. [Operadores e Expressões em C# - Operadores Lógicos em C# - Tutorial C# para Iniciantes - Simplilearn](https://www.youtube.com/watch?v=n6YoXxLZeSU) 23. [C# vs Java: Qual é melhor? - C# vs Java diferenças - C# vs Java 2021 para Iniciantes - Simplilearn](https://www.youtube.com/watch?v=w8WQ3u9MmyE) 24. [C++ vs C#: O que eu devo aprender? - Diferença entre C++ e C# - C++ & C# Comparação - Simplilearn](https://www.youtube.com/watch?v=P08qvNSxMus) 25. [Programação em C# de Jogo - Entrando na Programação de Jogos com C# - Tutorial - Simplilearn](https://www.youtube.com/watch?v=xIUGIq09UlM) 26. [Como construir um Jogo em Unity usando C# - Criando um Jogo em Unity para Iniciantes - Simplilearn](https://www.youtube.com/watch?v=RqO-y3hCR1s) ## Transcrições ### Perguntas de Interview sobre C# Top - Preparação de Interview em C# - Treinamento em C# - Simplilearn URL: [Perguntas de Interview sobre C# Top - Preparação de Interview em C# - Treinamento em C# - Simplilearn](https://www.youtube.com/watch?v=1u5E_GiXF9M) Idioma: en Se você quisesse aprender a responder perguntas de C# do intervalo de perguntas e respostas de entrevista da C#, este é o lugar certo. Ola todos, seja bem-vindo ao nosso canal de vídeo Simplilearn. Hoje vamos falar de um dos assuntos mais excitantes em C# - as perguntas de entrevista de C#. Mas antes de entrar em qualquer pergunta de entrevista, eu gostaria de revelar o primeiro tipo de perguntas que são de entrevista gravadas. É óbvio que em qualquer entrevista técnica, você será perguntado a codificação de algum programa ou o outro. Então, colocamos as perguntas de código fonte mais frequentemente associadas ao C#, que são: 1. Escreva um programa em C# para reveressa uma string 2. Escreva um programa em C# para encontrar se uma cadeia de caracteres é um anagrama ou não 3. Escreva um programa em C# para encontrar a substring de uma string 4. Escreva um programa em C# para verificar se um número inteiro positivo é um número primo ou não 5. Escreva uma implementação do padrão singleton e como implementar em C# Essas são as perguntas de código fonte mais frequentemente associadas ao C#, e se desejar, desejamos compartilhar essas respostas com vocês. Sinta-se à vontade para compartilhar seus ids de email nos comentários abaixo então que podemos compartilhar todas essas respostas com vocês. Agora vamos começar com as perguntas de nível básico. # Diferenças entre Class e Struct em C# ## Segunda Diferença A classe é passada por tipo de referência, enquanto que o struct é passado por tipo de valor. ## Quarta Diferença A classe é adequada para operações complexas e objetos de grande escala, embora o struct seja adequado para modelos pequenos e isolados. ## Quinta Diferença Os membros da classe são privados por padrão, enquanto que, nos struct, os membros são públicos por padrão. ## Sexta Diferença A classe pode utilizar um coletor de lixo para gerenciar memória, enquanto o struct não pode utilizar um coletor de lixo e não pode gerenciar memória. ## Sétima Diferença A próxima questão é: O que é a diferença entre o método virtual e o método abstrato? ### Método Virtual O método virtual é uma implementação padrão de um processo virtual que é sempre necessária. Pode ser porém substituído na classe derivada, embora isso não seja obrigatório. Por exemplo, o `override` pode ser utilizado para substituí-lo. ### Método Abstrato O método abstrato não tem implementação. Ele pertence à classe abstrata, portanto a classe derivada deve implementar a forma abstrata. Embora o `override` não seja necessário neste caso, ele pode ser utilizado. ## Décima Segunda Questão Explique os namespaces em C#. Os namespaces são empregados na organização de projetos de código grande. Por exemplo, no C#, o namespace mais comum é `System`. Podemos criar nossos namespaces e usar um namespace com outro (conhecido como namespaces aninhados). O keyword `namespace` é utilizado para identificá-los. ## Décima Quinta Questão Explique a abstração. Uma das conceitos do orientado a objetos é a abstração. É utilizado para apresentar apenas as características essenciais da classe e ocultar informação innecessária. Usaremos um carro como exemplo. Um motorista deve ser familiar com os detalhes do veículo, como a cor, o nome, o espelho, a direção, a marcha, o freio, etc. Não precisa saber sobre a combustão interna e o sistema de escape. Portanto, a abstração ajuda a saber o que é necessário e a ocultar detalhes internos da fora. A informação interna pode ser ocultada declarando-a como privada e utilizando o `private` keyword. ## Décima Sexta Questão Explique a polimorfismo. A polimorfismo no programa significa a mesma função, mas implementações diferentes. É classificada em dois tipos: polimorfismo na compilação e polimorfismo em tempo de execução. O polimorfismo na compilação resulta na chamada sendo resolvida em polimorfismo na compilação, que também é referido como binding estático, binding inicial e sobrecarga. O compilador não resolve a chamada de polimorfismo em tempo de execução e é também referido como binding dinâmico, binding tardio ou sobrecarga. Por exemplo, um homem atua simultaneamente como pai, marido e funcionário. ## Décima Sétima Questão Como é implementada a manipulação de exceções em C#? Em C#, a manipulação de exceções é feita usando quatro keywords: `try`, `catch`, `finally` e `throw`. O `try` é um bloco de código que será verificado para exceções. O `catch` é um programa que captura uma exceção com a ajuda do manipulador de exceção. O `finally` é um bloco de código escrito para executar independentemente se uma exceção for lançada ou não. O `finally` é usado para limpar recursos. # Documentação Técnica ## Comparação de strings Na dot net, a comparação de strings é usada para comparar dois strings de forma caso-insensitiva ou não. Ela requer dois parâmetros: a string original e a string a ser comparada. A operação final é uma operação de pesquisa usada para encontrar strings específicas usando os `startWith` e `endsWith` métodos. **Pergunta** O que, precisamente, é o Parsing? Como você passa uma string de data e hora? **Resposta** O Parsing é um processo de converter uma string em outro tipo de dados. Por exemplo, considere a string `"100"` que estamos tentando converter em uma variável de `Number` do tipo inteiro usando a função `Parse`. Como resultado, a função `Parse` converte a string `"100"` em seu tipo básico, ou seja, inteiro. Seguindo o mesmo método, para converter uma string de data e hora, a string seria igual a `"date: 24 de Julho de 2011"` e o tipo `DateTime`. ## Nível Avançado de Perguntas de entrevistas ### Delegados Um delegate é uma variável que armazena a referência a um método, portanto, é um tipo de ponteiro ou de referência de função. Todos os delegados são derivados do namespace `System. Delegate`. Ambo o delegate e a coisa que ele refere podem ter a mesma assinatura. Para declarar um delegate: ```csharp public delegate void SomeNumbers(int number); ``` Depois de uma declaração do delegate, o representante deve criar um objeto usando a palavra-chave `new`. Algumas Números `sn1` é igual a `new SomeNumbers(number)`. O delegate atua como uma encapsulamento para a referência do método que é chamado internamente quando o delegate é chamado. Delegates podem ser usados com eventos. A autoridade delegada é usada para iniciar e gerenciar eventos. Um delegate deve sempre ter uma especificação de evento a seguir. ### Eventos Os eventos são ações do usuário que causam a aplicação a receber notificações para as quais deve responder. As ações de usuário podem incluir movimentos do mouse, pressionamento de teclas, etc. Uma classe que emite um evento é conhecida como o editor, e uma classe que responde ou recebe o evento é conhecida como um assinante. Se um evento não tiver um assinante, ele não será levantado. Os eventos são declarados usando delegados. Neste exemplo, temos delegados como `Print` e `OS`, e nomes de evento como `myEvent`. ### Tipos de Delegados 1. Delegado único: Um delegado que pode chamar apenas um método 2. Delegado multicast: Um delegado que pode chamar múltiplos métodos é conhecido como um delegado multicast 3. Delegado genérico: Ele não requer uma definição de instância e é classificado em três tipos: `Action`, `Func`, `Predicate` ### Delegados Multicast Em C#, um delegado multicast é um delegado que mantém as referências a múltiplas funções. Quando invocamos o delegado multicast, coletamos todas as tarefas que o delegado prefeito. Veja um exemplo de código para o delegado multicast: ```csharp namespace Delegate { delegate void MultiDelegate(int a, int b); public class Program { public static void Add(int a, int b) { Console. WriteLine(a + b); } public static void Subtract(int a, int b) { Console. WriteLine(a - b); } static void Main(string[] args) { Program p1 = new Program(); MultiDelegate md1 = new MultiDelegate(p1. Add); MultiDelegate md2 = new MultiDelegate(p1. Subtract); MultiDelegate multiDelegate = md1 + md2; multiDelegate(100, 200); } } } ``` ### Operações Sincrônicas e Asincrônicas A sincronização é uma técnica para escrever código thread-safe em que apenas um thread pode acessar um recurso a qualquer momento antes de continuar com o fluxo do programa. Em modo assincrono, o método chamado retorna imediatamente, de sorte que o programa possa executar outras operações enquanto o método conclui sua tarefa. As palavras-chave `async` e `await` são usadas para obter programação assincrona em C#. ### Reflection A reflexão é a habilidade de um código de acessar os metadados do assembly durante a execução. Um programa reflette a si mesmo e usa informações de metadados para informar ou mudar seu comportamento. O namespace `System. Reflection` inclui métodos e classes para gerenciar informações de todos os tipos carregados e recursos, principalmente usados em aplicações Windows como visualização das propriedades de um botão em uma janela de Windows Form. ### Generics Generics, também conhecidos como classes généricas, criam classes ou objetos sem tipo específico. Por exemplo, o tipo poderá ser atribuído em temps de execução. Veja um código simples para uma classe genérica: ```csharp namespace GenericClass { public class Test<T> { private T[] myArray; private int count; public Test(int arrLength) { this. myArray = new T[arrLength]; this. count = 1; } public void AddItem<U>(U item) { this. myArray[count++] = item; } public U GetItem(int index) { return this. myArray[index]; } } class Program { static void Main(string[] args) { Test<int> intObj = new Test<int>(5); intObj. AddItem<int>(1); intObj. AddItem<int>(2); intObj. AddItem<int>(3); intObj. AddItem<int>(4); intObj. AddItem<int>(5); Console. WriteLine(intObj. GetItem(2)); } } } ``` ### Acesso às propriedades GET e SET `GET` e `SET` são referidos a accessos de propriedades para fazer uso destes, a propriedade implementa um mecanismo para ler e alterar o valor de um campo privado. Estes accessos são usados para obter acesso a um campo privado. A propriedade `get` é usada para recuperar o valor de uma propriedade para alterar o valor, use a propriedade de acesso `set`. ### Thread e Multithreading Um thread é uma coleção de instruções que pode ser executada para permitir que nossa aplicação possa processar concorrentemente. Em C#, uma thread é criada para executar código em paralelo com o código original. Isso é conseguido tendo diferentes threads handles diferentes processos, refém a multi-threading. ### Serialização e Deserialização Converter códigos em formato binário é conhecido como serialização. Depois de convertido em binário, é simples armazenar e escrever em dispositivos de armazenamento de dados. A serialização é mais importante quando não queremos perder o formato original do código e quisermos recuperá-lo em qualquer momento no futuro. A deserialização refere-se a recuperar códigos C# de formato binário. ### Tipos de Serialização 1. Serialização XML 2. Serialização SOAP 3. Serialização binária ### Arquivo XSD O XSD file é uma abreviatura para XML Schema Definition. Ele define a estrutura de um arquivo XML. Ele determina se um elemento é obrigatório, opcional ou repetindo no arquivo XML. Ele também determina o tipo de dado, formato e ordenação dos elementos. Título principal: C#: Introdução para Iniciantes | Título do curso em Português ================================================================ --- Introdução ---------- O C# é uma linguagem de programação que combina simplicidade, modernidade e versatilidade. Foi criada por Anders Hejlsberg em 2000 pela Microsoft, conhecida pelo seuosto emprego na criação de jogos e aplicações Windows e de desenvolvimento web. Porque usar C#? -------------- ### Vantagens de C# para código e desenvolvimento de jogos: - Linguagem de propósito geral e moderna: C# possui uma linguagem de propósito geral e moderna que suporta a maioria das funções de desenvolvimento de software moderno. - Rápido e fácil: C# é uma linguagem rápida e fácil de aprender em comum SVN. - Versátil: Como parte da plataforma Microsoft . NET, C# pode ser usada ao lado de várias outras linguagens de programação, como JavaScript, Python e Ruby, fornecendo uma solução completa para o desenvolvimento de software e game development. - Cross-platform: C# é suportada por plataformas múltiplas, incluindo Windows, Mac, Linux e Android. Isso significa que você pode criar jogos e aplicativos que sejam executados em várias plataformas. - Multithreading suportado: C# fornece suporte para o multithreading, augmentando a eficiência do código. - Compilado automaticamente (Just-In-Time): O C# é um linguagem de programação compilada just-in-time (JIT), isso significa que o código armazenado na memória é convertido em memória da computadora no momento em que é necessário. - WYSIWYG: C# funciona de maneira WYSIWYG (What You See Is What You Get), isso significa que o que você vê é o que se tornará. ### Alguns exemplos de perguntas de entrevista de programação C# 1. Como iniciar um projeto C# na Microsoft Visual Studio? 2. O que significa "await" em um projeto C#? 3. Qual é a diferença entre async e await no C#? 4. Comandos para criação dos seguintes tipos de objetos: Método, Evento, Propriedade, Construtor, enumeração. 5. Diferença entre uma função no C# ( método ) e uma função no JavaScript ( script ). 6. Como async e await se relacionam com o arms-worker no C#? 7. Como acessar e editar código C# incompatível depois que o seu projeto já tenha sido compilado? 8. Quais as diferenças entre delegate e interface no C# ? 9. C# forneces um método chamado "yield", explique o seu funcionamento. Agenda ------ Aula 1: Introdução e instalação do Visual Studio e outras ferramentas de YAML - Instalando o ambiente de desenvolvimento (IDE) - Introdução ao Visual Studio - Criando e executando o primeiro programa Aula 2: Tipos de Dados & Operadores - Variáveis (var . int . float . double . char) - Tipos de variáveis (primitive . reference) - Operadores aritméticos . de atribuição . lógicos . de comparação . de memória Aula 3: Strings e ConsoleInput - Strings basicas . Strings aninhadas . Funções de manipulação de strings . ConsoleInput Aula 4: Arrays e Listas - Introdução à listas . Introdução ao array (multidimensional . array de strings) . Ordenação internos . Atribuição dinâmica . Conceitos particulares Aula 5: Coleções Genéricas & Interfaces - Crê-la uma coleção personalizada (interfaceCollection. txt) . Interfaces . Armazenamento genérico (list, queue, stack) . Nuget Aula 6: Métodos - Funções post . Funções instancia . Funções static . Funções de propriedades Aula 7: Strings . StringBuilder . Lista linha de comando - Utilizando StringBuilder . Propriedade Length . Método Equals . Parâmetros printf . Criando prompt de comando personalizado Aula 8: Comandos e palavras-chave do C# - Operadores (bitwise . relacionais . aritméticos . lógicos . aritmético avançado . nameof) . Cadeias de caracteres . Listas . entres implícitas Aula 9: Gerenciamento de exceções - catch . reverse . herança de exceções . finally . filtro de exceção Aula 10: Interfaces, classes e herança - Aspectos de base . Implementando a interface . Fórmula de herança . Personalizar a interface . Interface múltipla Aula 11: Enumerações - Introdução à enumeração . Enumerações com projetos particulares Aula 12: Namespace - Arquivos de Namespace . Theusing . Theinternal . Propriedades públicas versus privadas . Terminologia de namespace Aula 13: Entendendo o namespace para desenvolver um jogo usando o Unity - O que é o Unity e como criar um projeto . Interface Unity-editor . Criando vários objetos 3D: GameObjects, prefabs, UserInput, Camera, etc . Funcionamento das camadas . Colisão 2D e 3D Aula 14: Windows . Form (GUI) . Controles - Layout de form . Preset liquidação . Herança de Controles . Gratuita da variável . Vazio . Disposing Aula 15: Interacting with the user . MessageBox . Dialogs - Mensagens de caixa de diálogo . Funcionalidades avançadas . TheMessageBoxResult . Usando as classes MessageBoxIcon e MessageBoxButtons Aula 16: Integrando a ferramenta de desenvolvimento - Linkando cuáles referência . Configurando acesso público do código . Linkando Arduino e Placa de revealamento Finalmente, tenha em mente que qualquerUPDATEs futuros a este curso podem conter perguntas adicionais e exemplos de código para facilitar o seu aprendizado. Fontes: - ACME : [https://dampog.com/en/csharp](https://dampog.com/en/csharp) - Microsoft Visual Studio: [https://docs.microsoft.com/pt-pt/visualstudio/get-started/](https://docs.microsoft.com/pt-pt/visualstudio/get-started/) - MSDN : [https://www.asp.net/](https://www.asp.net/) - Csharp tutoriel : [https://www.c-sharpcorner.com/](https://www.c-sharpcorner.com/) - EdX : [https://www.edx.org/professional-certificate/escalona-university-csharp-programming](https://www.edx.org/professional-certificate/escalona-university-csharp-programming) # Linguagem de Programação C#: Entendendo os Tipos de Dados, Variáveis, Operadores e Estrutura Básica C# é uma linguagem de programação amplamente utilizada devido a sua simplicidade, intensa apoio comunidade e sua natureza orientada a objetos, que lhe dá uma estrutura limpa e que incentiva o reaproveitamento de código, reduzindo os custos de desenvolvimento. Embora tenha semelhanças com idiomas como C, C++ e Java, oferece várias características únicas que a tornam atraente para os desenvolvedores. ## Tipos de Dado em C# Os tipos de dados em C# podem ser classificados em três categorias: **Tipos de Valor**, **Tipos de Referência** e **Ponteiros**. * **Tipos de Valor** armazenam seus dados diretamente no espaço de memória de uma variável. Exemplos de tipos de valor incluem `boolean`, `byte`, `char`, `decimal`, `double`, `enum`, `float`, `int`, `long`, `short` e `struct`. ```csharp // Exemplo de um tipo de valor (inteiro) int i = 200; ``` * **Tipos de Referência** não armazenam seus valores diretamente, mas sim salvar um ponteiro para onde o seu valor está armazenado. Exemplos de tipos de referência incluem `string`, `array`, `class` e `delegate`. ```csharp // Exemplo de um tipo de referência (string) string anime = "Simply Learn"; ``` * **Ponteiros** armazenam a posição de outro ponteiro, similar aos ponteiros em C. Não são comumente utilizados em programação moderna em C#. ## Variáveis em C# As variáveis são contêineres de valores de dados. Há vários tipos de variáveis definidos com diferentes palavras-chave em C#: * **Inteiro**: Armazena valores inteiros como 1, 2, 3, ou -1, -2, -3. * **Double**: Armazena valores com casas decimais como 19. 99 ou -19. 99. * **Caracter**: Armazena caracteres únicos como 'a' ou 'b'. * **String**: Armazena valores de cadeia de caracteres como "olá" ou "mundo". * **Boolean**: Armazena valores como `true` ou `false`. ## Declarando Variáveis em C# Para declarar uma variável em C#, deve-se primeiro especificar o seu tipo e atribuir um valor. A sintaxe para declarar variáveis é: ```csharp dataType variávelName; ``` ```csharp int x; // Declarando uma variável inteira x string y; // Declarando uma variável de string y char z; // Declarando uma variável de caractere z ``` ## Operadores em C# Os operadores são usados para manipular variáveis e valores em C#. Há quatro tipos de operadores: 1. **Operadores Automáticos**: Inclui adição (`+`), subtração (`-`), multiplicação (`*`), divisão (`/`), resto da divisão (`%`), incremento (`++`) e decremento (`--`). ```csharp int a = 5; int b = 3; int resultado = a + b; // 8 int resultado = a - b; // 2 int resultado = a * b; // 15 double resultado = a / b; // 1. 666666666667 int resultado = a % b; // 1 a++; // Incrementa o valor de a em 1, a agora é 6 ``` 2. **Operadores de Atribuição**: Inclui `=` para atribuir valores e `+=`, `-=`, `*=`, `/=`, `%=` para atribuição abreviada. 3. **Operadores de Comparação**: Inclui `==`, `! =`, `<`, `<=`, `>`, e `>=`. Eles são usados para comparar duas variáveis ou valores. 4. **Operadores Lógicos**: Inclui `&&`, `||`, e `! `. São usados para combinar expressões condicionais baseadas nos operadores lógicos. ## Declarações Condicionais em C# Em C#, as declarações condicionais (`if`, `else if`, `else`, e `switch`) são usadas para testar se uma determinada condição é verdadeira ou falsa e executar código de acordo. Vamos discutir cada uma destas declarações em detalhe. ```csharp // Exemplo de declaração condicional int idade = 18; if (idade >= 18) { Console. WriteLine("Você é velhinho o suficiente para votar. "); } else { Console. WriteLine("Você é muito novo para votar. "); } ``` ## Estruturas de Controle em C# As estruturas de controle em C# são usadas para controlar a execução da programação. Isso inclui laços (`for`, `foreach`, `while`, e `do-while`) e declarações saltar (`break`, `continue`, `return`, e `throw`). ## Resumo Neste tutorial, abordamos os fundamentos da programação em C#, centrados em tipos de dados, variáveis, operadores, declarações condicionais e estruturas de controle. Também tocou em laços e declarações saltar, mas vamos explorá-las em detalhes em aulas futuras. A medida que continuas a aprender C#, faça sure de realizar exercícios de código e projetos para consolidar o seu entendimento e desenvolver suas habilidades. Boa sorte no seu código! # Declaração de Instrução Condicional Switch e Laços em C# Este documento fornece um diagrama de fluxo detalhado mostrando como a declaração condicional switch funciona em C#, seguido por explicações sobre os diferentes tipos de laços em C#. ## Declaração Condicional Switch O diagrama de fluxo da declaração condicional switch é o seguinte: 1. Início 2. Inicializar 3. Verificar a condição * Se a condição for verdadeira, continue de acordo * Se a condição for falsa, termine o processo ### Sintaxe da declaração switch: ```csharp switch (expressão) { case valor1: // código a ser executado se a expressão for igual a valor1 break; case valor2: // código a ser executado se a expressão for igual a valor2 break; // Adicione mais casos conforme necessário default: // código a ser executado se a expressão não corresponder a nenhum caso } ``` ## Laços em C# O C# fornece três tipos diferentes de laços: o laço For, o laço While, e o laço Do While. ### Laço For A sintaxe para o laço For é a seguinte: ```csharp for (inicialização; condição; incremento ou decremento) { // código a ser executado no laço } ``` O diagrama de fluxo do laço For é apresentado abaixo: 1. Inicializar 2. Verificar a condição * Se a condição for verdadeira, prosseguir 3. Executar o corpo do laço 4. Incrementar ou decrementar 5. Retornar para o passo 2 ### Laço While A sintaxe para o laço While é simples porque há apenas uma condição: ```csharp while (condição) { // código a ser executado no laço } ``` O diagrama de fluxo do laço While é o seguinte: 1. Iniciar o laço 2. Verificar a condição * Se a condição for verdadeira, execute o corpo do laço * Se a condição for falsa, encerrar o laço 3. Retornar ao passo 2 ### Laço Do While O laço Do While é um alternative ao laço While. Este laço executa o bloco de código uma vez antes de verificar a condição e, em seguida, loopa enquanto a condição for verdadeira. Se a condição for falsa, então o laço termina. O diagrama de fluxo para o laço Do While é o seguinte: 1. Executar o corpo do laço 2. Verificar a condição * Se a condição for verdadeira, retornar ao passo 1 * Se a condição for falsa, encerrar o laço ## Arrays em C# Em C#, arrays com tamanho fixo e sequência de elementos do mesmo tipo de dados são armazenados em arrays. Um array representa uma coleção de dados, mas é mais útil pensar em um array como uma coleção de variáveis do mesmo tipo armazenadas em contíguas localizações de memória. ```csharp int[] array = new int[100]; // Declare um array chamado array com 100 elementos do tipo inteiro ``` Em um array, array[0] é o primeiro elemento e array[99] é o último elemento do array. ## Strings em C# Uma string em C# é uma string de objeto com o valor de texto. O texto é internamente armazenado como uma coleção lida não sequencial de objetos de caracter. Porque não há um caractere final nulo no fim de uma string C#, ela pode conter qualquer número de caracteres nulos embutidos. ```csharp string a = "abc"; // Declare uma variável de string chamada a ``` Existem várias funções de string disponíveis em C#, como as funções Clone, Compare, Concat, Contains, CopyTo, Equals, e Trim. ## Métodos ou Funções em C# Em C#, um método é uma coleção de declarações de código que trabalham em conjunto para completar uma tarefa. ### Definição de um método: ```csharp public int FindMin(int a, int b) // Defina um método que encontra o número mínimo entre a e b { int min = a < b ? a : b; return min; } ``` ### Chamada de um método: ```csharp int result = FindMin(5, 3); // Chame o método FindMin e atribua o resultado a variável result ``` ## Coleções em C# C# fornece várias classes de coleção, incluindo ArrayList, HashTable, SortedList, Stack, Queue, e BitArray. Estas classes servem várias funções, tais como alocando memória dinamicamente aos elementos e acessar uma lista de itens via um índice. ### BitArray ```csharp using System. Collections; BitArray bitArray = new BitArray(100); // Declare um BitArray chamado bitArray com 100 elementos bitArray[0] = true; // Defina o valor do primeiro elemento para true ``` ## Enums em C# Um enum em C# é um tipo de classe que representa uma coleção de limites de variáveis que não podem ser alteradas ou lidas. Use o enum keyword em vez de class ou interface para criar um enum, e separar os itens do enum com uma vírgula. ```csharp enum Direção { Leste, Oeste, Norte, Sul } ``` ## Programação Orientada a Objetos (OOP) em C# A Programação Orientada a Objetos (OOP) é sobre a criação de objetos que contêm tanto dados quanto métodos. A OOP tem várias vantagens sobre a programação procedural, incluindo Implementação mais rápida e fácil, estrutura mais clara, tornando o código mais manutenível, modificável e depurável, permitindo a criação de aplicações inteiramente reutilizáveis com menos código e menos tempo de desenvolvimento. Os quatro conceitos fundamentais da OOP em C# são: 1. Abstractação 2. Encapsulamento 3. Hereditamento 4. Polimorfismo Estes conceitos serão explicados detalhadamente nas seções seguintes. ## Operações de Arquivos em C# Em C#, os enumerações de modos de arquivo define várias maneiras de abrir arquivos. Os membros das enumerações de modos de arquivo são descritos como segue: 1. Anexar: Texto é anexado a um arquivo existente. 2. Copiar: Duplica um arquivo. 3. Criar: Cria ou substitui um arquivo. 4. Excluir: Exclui um arquivo. 5. Existe: Determina se um arquivo existe. 6. Leitura de Todo o Texto: Lê o conteúdo do arquivo. 7. Replace: Substitui os conteúdos de um arquivo por outros conteúdos. 8. Leitura de Todo o Texto e Escrita de Todo o Texto: Lê e escreve o conteúdo de um arquivo. 9. WriteAllLines: Cria um arquivo e escreve suas linhas de conteúdo em ele. ## Manipulação de Exceções em C# A manipulação de exceções trata dos erros e exceções que ocorrem durante a execução em tempo de execução devido a erros de código ou entrada de usuário inválida na linguagem de programação C#. Usamos quatro palavras-chave no manuseio de exceções: try, catch, finally, e throw. ```csharp try { // código que pode lançar uma exceção } catch (ExceptionType exception) { // código para tratar a exceção } finally { // código de limpeza para ser executado independente do resultado do bloco try } ``` Neste vídeo, vamos aprender sobre as novas funcionalidades do C#, com ênfase na sintaxe de async / await e tipos nulos, e vamos explorar sua utilização na otimização de código concorrente e na gestão de valores nulos. $Reference(s): $ * [Guia de Programação do C# - Microsoft Docs](https://docs.microsoft.com/pt-pt/dotnet/csharp/programming-guide/) * [Manipulação de Exceções do C# - Microsoft Docs](https://docs.microsoft.com/pt-pt/dotnet/csharp/programming-guide/concepts/error-handling/) * [Programação Assincrona - Microsoft Docs](https://docs.microsoft.com/pt-pt/dotnet/csharp/programming-guide/concepts/async/) * [Tipos de Valor Nulos - Microsoft Docs](https://docs.microsoft.com/pt-pt/dotnet/csharp/nullable-value-types/) # Tipos Primários e Variáveis em C# | Literais de Datatype e Variáveis | Tutorial em C# | Simplilearn Olá a todos, sou Pepper Khandelwal, e bem-vindos à nossa canal do YouTube Simplilearn. Hoje vamos falar sobre um dos tópicos interessantes: Tipos Primários e Variáveis em C#. Antes de começarmos, gostaria de dizer à você que temos atualizações diárias em várias tecnologias. Então, se você é um *tech geek* em constante procura por avançamentos tecnológicos, considere assinar se nossa canal YouTube e não esqueça de clicar no ícone de "sinal" para nunca perder uma atualização no Simplilearn. Agora, sem mais demora, vamos reforçar a agenda para o dia de hoje. começaremos com a discussão sobre variáveis, em seguida, vamos avançar para os tipos de variáveis, seguida por uma discussão detalhada sobre tipos primários de variáveis. Por fim, vamos encerrar esta sessão com uma implementação em variáveis em C#. Agora, vamos começar a explicações de que é uma variável. Uma variável é simplesmente o nome fornecido para um local de armazenamento que nossos programas podem acessar. Em C#, cada variável tem um tipo que governa o tamanho e layout da memória do variável, o range de valores que pode ser armazenado nesse espaço de memória, e um conjunto de operações que podem ser aplicadas para esse variável. Cada variável deve armazenar o mesmo tipo de dados que está armazenado naquela variável. Quando declaramos uma variável, o sistema reserva um pedaço de memória de tamanho igual ao tamanho da variável. Vamos ter um olhar nos tipos de variáveis em C#. Há duas tipos de variáveis: 1. Tipos Primários de Variáveis (Vamos focar nos tipos primários de variáveis nesta sessão e discutiremos strings a parte dos tipos de variáveis baseados em objetos. ) 2. Referência ou Variáveis de Objetos Agora, vamos discutir mais detalhes. Começamos por tipos primários. Esses tipos de dados são construídos na função principal e chamados de tipos de dados primários. Esses tipos de dados podem ser divididos em números e valores lógicos. Os números são então divididos em tipos assinados e não assinados. Vamos ter um olhar mais detalhado. 1. Tipos Com Sinal - Byte: Sua faixa de valor vai de -128 a 127. - Int (Short): Este tipo possui uma grande quantidade de espaço na memória, e sua faixa de valor vai de -32k a positive 32k. - Int (Integer): É o tipo de dado mais utilizado em quaisquer linguagens de programação. Seu valor vai de -2 bilhões a positive 2 bilhões. - Long: Pode armazenar um valor extremamente grande. 1. Tipos Não Assinados - Byte: Sua faixa de valor vai de 0 a 255. - Int (uShort): Este tipo possui uma grande quantidade de espaço na memória, e sua faixa de valor vai de 0 a 65k. - Int (UInt): Seu valor vai de 0 a 4 bilhões. - ULong (Unsigned Long): Pode armazenar um valor extremamente grande. Esses foram os tipos básicos de tipos inteiros. Vamos dar um olhar nos tipos de pontos flutuantes: - Float: Este tipo armazena dados aprximados. - Double: Este tipo possui uma maior precisão do que o Float. - Decimal: Este tipo é útil ao realizar cálculos monetários. Agora, vamos discutir poucos mais tipos de tipos de dados: 1. Char: Este tipo armazena dados de caracteres. 2. Boolean: Essa variável armazena valores verdadeiros e falsos. Estes são usualmente utilizados em declarações condicionais. 3. String: Este tipo é um honorário tipo primitivo que não é considerado um tipo permitido em maioria das linguagens de programação, mas no C#, isto não é o caso. A string pode conter uma palavra ou uma frase. Agora, vamos tentar estas variáveis em uma aplicação de console: ```csharp Console. WriteLine(sb); // imprime -120 para o sByte Console. WriteLine(s); // imprime 30000 para short Console. WriteLine(i); // imprime 2000000000 para int Console. WriteLine(l); // imprime um número grande para Long ``` Agora, vamos tentar algumas variáveis diferentes de inteiros: ```csharp byte a = 122; ushort b = 60123; uint ui = 400000000; ulong ur = 9000000000; ``` Esses foram os tipos básicos de tipos inteiros. Vamos dar um olhar nos tipos de ponto flutuantes: ```csharp float f = 12. 7F; // O f é opcional no valor da definição double d = 23. 67; decimal dm = 99. 1079M; // O m é opcional no final, mas é uma boa prática utiliza-lo ``` Agora, vamos discutir sobre os valores de caráter e string: ```csharp char c = 't'; bool flag = true; string str = "Bem-vindo à Simplilearn"; Console. WriteLine(c); // imprime o mesmo que é sua letra Console. WriteLine(flag); // imprime true Console. WriteLine(str); // imprime Bem-vindo à Simplilearn ``` E assim chegamos ao fim deste vídeo. Se tiver alguma dúvida relacionado a seus de algum tópico discutido neste vídeo, agora é só falarmos na seção de comentários abaixo, e nossa equipe de especialistas terá bastante prazer em ajudar a resolver as suas dúvidas. Ate a próxima vez, obrigado e abraços! [Assine o canal YouTube do Simplilearn](https://www.youtube.com/c/Simplilearn/subscription) [Assista vídeos semelhantes em C#](https://www.youtube.com/c/Simplilearn/playlists) **Próximo Vídeo: ** [C# OOPS | Programação Orientada a Objetos em C# | Tutorial para iniciantes | C# Tutorial | Simplilearn](https://www.youtube.com/watch?v=iA0XZwFqqKI) **Idioma: ** En Agora, vamos nos mover para o próximo vídeo: Programação Orientada a Objetos em C#. [C# OOPS | Programação Orientada a Objetos em C# | Tutorial para iniciantes | C# Tutorial | Simplilearn](https://www.youtube.com/watch?v=iA0XZwFqqKI) Até a próxima, continue aprendendo! # Encapsulamento no Programação Orientada a Objetos Um dos exemplos mais concretos de encapsulamento é um armário escolar, onde podemos armazenar nossos livros, lápis e outros pertencentes. Agora, para entendê-lo melhor, vamos passar por um exemplo prático. Neste exemplo específico, vamos encapsular as funções para calcular a área de uma forma dada, enfocando o formato retangular. Aqui, na classe `RectangleApplication`, você encontrará todas as funções `getArea` que calculem a área de um retângulo, junto com as variáveis `length` e `width`. ```csharp // RectangleApplication. cs public class RectangleApplication { private double length; private double width; public double GetArea() { return length * width; } public double GetArea(double length, double width) { this. length = length; this. width = width; return GetArea(); } } ``` Agora, vamos executar este programa e ver o resultado: ```csharp // Program. cs using System; class Program { static void Main(string[] args) { RectangleApplication rectangle = new RectangleApplication(); rectangle. GetArea(4. 5, 3. 5); Console. WriteLine("A área do retângulo é: " + rectangle. GetArea()); // 15. 75 } } ``` Agora, vamos passar por um exercício simples. Calcule a área de um quadrado, círculo e também de um triângulo. Por favor, tente esses exercícios por conta própria e compartilhe seus resultados na seção de comentários abaixo. ## Herança no Programação Orientada a Objetos em C# Agora, vamos avançar para o próximo conceito do Programação Orientada a Objetos: Herança. A Herança é um conceito importante no Programação Orientada a Objetos. A Herança é um conceito em que uma classe pai e uma classe filha são definidas, com a classe filha herdando as propriedades e métodos da classe pai. A classe filha também pode alterar o comportamento dos métodos se necessário. Neste exemplo, `ChildClass1` e `ChildClass2` estão herdando as propriedades e comportamentos de seus pais. Aqui está uma representação gráfica da Herança: ``` [Classe Pai] / \ [Classe Filha 1] [Classe Filha 2] ``` Agora, vamos olhar para outro exemplo: ```csharp // BasicClass. cs public class BasicClass { public virtual void FazAlgo() { Console. WriteLine("Classe Básica: Fazendo algo genérico. "); } } // DerivedClass. cs public class DerivedClass : BasicClass { public override void FazAlgo() { Console. WriteLine("Classe Derivada: Sobrescrivendo o comportamento de FazAlgo na Classe Básica. "); } } ``` Neste exemplo, `DerivedClass` herda a `FazAlgo()` do método da classe `BasicClass`. O método fazAlgo() na classe `BasicClass` é definido como virtual, o que significa que em subclasses, ele pode ser sobrescrito. ## Abragação no Programação Orientada a Objetos em C# A Abragação é um processo de apresentação de informações necessárias e ocultação de informações irrelevantes. Simplificando, a Abragação é um processo de representação de recursos essenciais sem representação de detalhes de fundo. ```csharp // Animal. cs public abstract class Animal { public abstract void SomAnimal(); public void Dorme() { Console. WriteLine("Zzz. . . "); } } // Porco. cs public class Porco : Animal { public override void SomAnimal() { Console. WriteLine("O porco faz: Oi-oi! "); } } ``` Neste exemplo, temos uma classe abstrata `Animal` com um método abstrato `SomAnimal()`. `Porco` é uma classe concreta que herda da classe `Animal` e implementa o método `SomAnimal()`. ## Polimorfismo no Programação Orientada a Objetos em C# O Polimorfismo no C# é alcançado através da sobrescrita do método e da sobrecarga do método. Na sobrescrita do método, uma subclasse redefine um método que ocorre em sua superclasse. Na sobrecarga do método, uma classe tem vários métodos com o mesmo nome mas com parâmetros diferentes. Aqui está um exemplo de sobrescrita do método: ```csharp // Forma. cs public abstract class Forma { public abstract double CalculaÁrea(); } // Circulo. cs public class Circulo : Forma { private double raio; public Circulo(double raio) { this. raio = raio; } public override double CalculaÁrea() { return Math. PI * raio * raio; } } // Retângulo. cs public class Retângulo : Forma { private double comprimento; private double largura; public Retângulo(double comprimento, double largura) { this. comprimento = comprimento; this. largura = largura; } public override double CalculaÁrea() { return comprimento * largura; } } ``` Neste exemplo, tanto a classe `Círculo` quanto a classe `Retângulo` herdam da classe abstrata `Forma` e sobrescrevem seu método `CalculaÁrea()`. ## Vantagens da Programação Orientada a Objetos em C# 1. **Abragação**: A Abragação permite que você se concentre em o que um objeto faz, em vez de como ele faz isso. Apresentando informações pertinentes, a Abragação oferece uma visão geral de suas classes ou objetos. 2. **Herança**: A Herança permite que você repça code quando programar. Cada classe derivada tem acesso aos propriedades, métodos e eventos da classe base. 3. **Encapsulamento**: O Encapsulamento pode ajudar a depurar facilmente, pois os campos privados não podem ser acessados diretamente fora da classe. Só os métodos de uma classe que podem ser chamados externamente. 4. **Polimorfismo**: O Polimorfismo fornece flexibilidade e extensibilidade, permitindo que você realize a mesma ação usando diferentes objetos e a mesma ação. Ao mesmo tempo, melhora a legibilidade e manutenibilidade do código. No geral, a Programação Orientada a Objetos em C# oferece muitas vantagens, incluindo melhor organização de código, reutilização mais eficaz e manutenção mais fácil. # Coleções em C# Explicadas | C# Coleções para Iniciantes | C# Tutorial | Simplilearn Idioma: pt-PT ## Introdução Olá a todos, sou Bhabha Khandelwal e bem-vindo a todos ao canal Simply Learn YouTube. Hoje vamos abordar as coleções em C#, mas primeiro lembrar que temos atualizações diárias em várias tecnologias. Então, se você é um entusiasta da tecnologia em busca das mais recentes inovações tecnológicas, pode tentar inscrever-se no nosso canal YouTube e não esqueça de ativar o ícone de sino para que não suba uma atualização do Simplilearn. Agora, sem mais ado, vamos abordar a agenda para a sessão do dia. Começaremos com uma discussão sobre o que são coleções. Após isso, teremos uma breve discussão sobre os tipos de coleções. Depois disso, discutiremos coleções genéricas e coleções não genéricas com a ajuda de um demo. Finalmente, terminaremos esta sessão com alguns pontos importantes sobre coleções. ## O Que São Coleções? As classes de coleção são classes especiais de armazenamento e recuperação de dados. Pilhas, filas, listas e mapas de hash são apoiados por essas classes. As classes de coleção executam várias funções, como alocar dinamicamente memória para componentes e recuperar uma lista de objetos por índice. Por fim, essas classes cram coleções de objetos, que atuam como uma base para todos os tipos de dados em C#. ## Tipos de Coleções Há dois tipos principais de coleções definidos: coleções genéricas e coleções não genéricas. Vamos discutir detalhadamente cada um. ### Coleções Genéricas Uma coleção genérica é uma classe que fornece segurança de tipo sem a necessidade de herança de um tipo de coleção básica e implementação de membros específicos de tipo. As classes de coleção estão localizadas no namespace `System. Collections. Generic`. internamente, a coleção genérica armazena elementos em arrays de tipos correspondentes, o que significa que apenas poderá ter elementos do mesmo tipo da coleção. Aqui estão algumas coleções genéricas disponíveis: - Lista - Dicionário - ListaOrdenada - Pilha - Fila ### Coleções Não Genéricas As coleções não genéricas são classes especiais de armazenamento e recuperação de dados que lidam com pilhas, filas, listas e mapas de hash. O espaço de nomes `System. Collections` contém as classes de coleção não genéricadas. As classes de coleção não gerenciadas armazenam elementos e matrizes de objetos internamente, o que permite-lhes armazenar qualquer tipo de dados, então a mesma coleção pode ter diferentes tipos de dados. Existem vários tipos de coleção não gerenciadas, como ArrayList, HashTable, ListaOrdenada, Pilha e, finalmente, Fila. ## Demo No demo, vamos cobrir exemplos para cada coleção mencionada, discutindo sua sintaxe básica, adição de dados e iteração pela dados. Para obter informações detalhadas, consulte nossa [Tutorial C#](https://www.youtube.com/watch?v=j9N2YOyInRE). ### Lista ```csharp List<int> minhaLista = new List<int>(); minhaLista. Add(30); minhaLista. Add(60); minhaLista. Add(90); minhaLista. Add(120); foreach (int valor in minhaLista) { Console. WriteLine(valor); } ``` ### Dicionário ```csharp Dictionary<string, string> meuDicionário = new Dictionary<string, string>(); meuDicionário. Add("refrescante", "Coca-Cola"); meuDicionário. Add("hamburguer", "Patê emulsificado servido em bolo de pão cortado"); meuDicionário. Add("batata frita", "Pecas finas de batata fritas"); meuDicionário. Add("anéis de cebola fritos", "Anéis ou meio-anéis de cebolas que são bolados e fritas"); foreach (KeyValuePair<string, string> par in meuDicionário) { Console. WriteLine($" {par. Key}: {par. Value}"); } ``` ### ListaOrdenada ```csharp SortedList<string, string> minhaListaOrdenada = new SortedList<string, string>(); minhaListaOrdenada. Add("americana de batata frita", "Fritos de batata feitos com batatas americanas estilo russet"); minhaListaOrdenada. Add("mega hamburguer", "Um hamburguer de carne moída certificado pela American Heart Association como altamente nutritivo"); minhaListaOrdenada. Add("refrescante de limão", "Bebida carbonatada sarapada com suco de limão e açúcar"); minhaListaOrdenada. Add("anéis de cebola frita", "Anéis ou meio-anéis de cebola que são bolados e fritos"); foreach (KeyValuePair<string, string> par in minhaListaOrdenada) { Console. WriteLine($" {par. Key}: {par. Value}"); } ``` ### Pilha ```csharp Stack<string> minhaPilha = new Stack<string>(); minhaPilha. Push("bem-feito"); minhaPilha. Push("mediano"); minhaPilha. Push("mediano cozido"); minhaPilha. Push("cozido"); foreach (string valor in minhaPilha) { Console. WriteLine(valor); } ``` ### Fila ```csharp Queue<string> minhaFila = new Queue<string>(); minhaFila. Enqueue("mark"); minhaFila. Enqueue("bill"); minhaFila. Enqueue("xavier"); minhaFila. Enqueue("michael"); foreach (string valor in minhaFila) { Console. WriteLine(valor); } ``` ## Conclusão geralmente é preferível utilizar coleções genéricas, pois atuam mais rapidamente que coleções não gerenciadas e ajudam a reduzir exceções mostrando um erro de tempo de compilação. As coleções não gerenciadas são encontradas no namespace `System. Collection. Specialized` enquanto as coleções genéricas são encontradas no `System. Collections. Generic` namespace. O C# também possui várias coleções especiais que são equipadas para lidar com um tipo específico de dados, que podem ser encontrados no `System. Collection. Specialized` namespace. Em geral, a classe de coleção suporta um valor nulo como valor de tipo de referência válido e permite elementos redundantes, como permitindo que alguns itens sejam adicionados várias vezes. # C# Árvores e Grafos Explicados | Estruturas de Dados e Algoritmos em C# | Tutorial C# | Simplilearn Idioma: pt-PT ``` Olá todos! Bem-vindos ao canal de YouTube da Simplilearn. Hoje, vamos discutir sobre assuntos interessantes em C#: Árvores e Grafos. Mas antes de começar, gostaria de dizer que temos atualizações diárias em várias tecnologias, então se você é um fã de tecnologia sempre em busca das últimas tendências tecnológicas, considere se inscrever no nosso canal de YouTube e clique no ícone de sino para não perder nenhuma atualização da Simplilearn. Neste tutorial, vamos entender o que temos a seguir no agenda. Primeiro, vamos ver a importância das estruturas de dados de gráficos recentes em C#. Depois disso, vamos passar pelas bases das árvores. Em seguida, vamos olhar para os diferentes tipos de árvores. Seguindo isso, vamos olhar para algumas operações básicas e termos. A seguir, vamos olhar para a traverse da árvore, e em seguida, na estrutura de dados de árvore em C#, vamos olhar para algumas aplicações relacionadas à árvore. Após nossa discussão sobre a estrutura de dados de árvore, vamos aprender sobre a estrutura de dados de gráfico em C#. Começando com uma introdução, depois disso, vamos olhar para os diferentes tipos de gráficos, bem como algumas operações básicas que são executadas em gráficos. Seguindo isso, vamos aprender sobre o vocabulário de gráficos e depois olhar para a traverse do gráfico. Em seguida, vamos olhar para como podemos representar as estruturas de dados de gráficos e depois olhar para alguns exemplos importantes de estruturas de dados de gráficos em mundo real. Começando com as bases, vamos entender a importância das estruturas de dados de árvore e de gráfico em C#. As estruturas de dados de árvore e de gráfico em C# são críticas para a programação moderna. Cada uma dessas estruturas de dados é usada para construir um modelo de problemas do mundo real, que são então resolvidos eficientemente usando esse modelo. Depois de entender a importância das estruturas de dados de árvore e de gráfico, agora vamos entender a estrutura de dados de árvore. Para prosseguir com a introdução, a árvore é um formato de representação hierárquica dos dados. Cada nó em uma árvore tem dois componentes: dados e referências para o nó superior da árvore, conhecido como o nó raiz, e os dois descendentes inferiores são conhecidos como o sub-árvore esquerda e o sub-árvore direita (também conhecidos como filhos). Vamos olhar para um exemplo real do mundo de uma estrutura de dados de árvore: uma estrutura de organização, que funciona como uma hierarquia. Aqui está um exemplo de como uma organização poderia parecer, com o CEO funcionando como o nó raiz da árvore. A hierarquia da organização então se ramifica para os filhos como CEO (Chief Executive Officer), CFO (Chief Financial Officer), e CMO (Chief Marketing Officer). Os filhos do CFO seriam as finanças, e os filhos do CTO (Chief Technical Officer) seriam engenharia de software. Finalmente, temos mídias sociais. Depois deste tutorial, vamos olhar para os diferentes # Gráficos em C# | Estruturas de Dados de Gráficos Explicadas | Tutorial de C# | Simplilearn ## Introdução - Brevemente explique o objetivo deste tutorial e os temas abordados. ## Dicionários, Tabelas Hash e Conjuntos em C# 1. **introdução** - Brevemente explique o que são os dicionários em C# e apresente a sintaxe para declarar um dicionário. 2. **Métodos do dicionário** - Discussão dos quatro principais métodos para manusear um dicionário: add, remove, find e replace. 3. **Tabela de Hastagem** - Explique o que é uma tabela de hashtagem, e relacione-a à classe de dicionário em C#. 4. **Propriedades da tabela de Hastagem do C#** - Descreva as propriedades da tabela de hastagem de C#, como velocidade e uso de memória. 5. **Métodos da tabela de Hastagem do C#** - Detalhe os métodos específicos da tabela de hastagem do C#, como ContainsKey, Get e Add. 6. **Conjuntos de Hash** - Explique o que são os conjuntos de hash e o relacionamento deles com a tabela de hastagem. 7. **Implementações de Conjunto** - Discussão de usos comuns e implementações de conjuntos em C#. --- ```csharp # namespaces using System. Collections. Generic; # Class program class Program { static void Main(string[] args) { # Initialize dictionary Dictionary<string, int> dictionary = new Dictionary<string, int>(); # Add elements dictionary. Add("carro", 32); . . . # Use methods dictionary. Remove("carro"); int value = dictionary["carro"]; // Find or replace } } ``` --- --- ### Visão Geral das Estruturas de Dados de Gráfico Após o conteúdo do dicionário, adicione uma visão geral das estruturas de dados de gráfico. 1. **Gráficos Básicos** - Brevemente discuta a definição, tipos, e usos das estruturas de dados de gráficos. 2. **Representações de Gráficos** - Discussão de formas populares para representar um gráfico, como lista de adjacência, matriz de adjacência, e estrutura de adjacência. 3. **Operações de Gráficos** - Descreva as operações comuns executadas em gráficos, incluindo a navegação, busca e manipulação de arestas e vértices. --- ```csharp # Initiate graph Graph graph = new Graph(); # Add nodes graph. AddNode("1"); graph. AddNode("2"); . . . # Add edges graph. AddEdge("1", "2"); . . . # Perform operations graph. BFS(); // Busca em Largura graph. DFS(); // Busca em Profundidade ``` --- **Observação**: O exemplo acima não é uma implementação completa de um gráfico, mas demonstra como chamar as funções podem parecer. --- --- ### Conclusão e Estudos Adicionais 1. **Aplicações de Estruturas de Dados de Gráficos em Cénarios Reais** - Resalte os exemplos recentes de aplicações de estruturas de dados de gráficos em cenários reais. 2. **Recursos Adicionais** - Forneça recomendações para recursos adicionais de aprendizagem, como livros, cursos on-line e websites. --- ### Referências URL: https://www.youtube.com/watch?v=iJRx3vs1v54 (Link para recursos adicionais de aprendizagem) # Documentação Técnica: Programação Assíncrona em C# e Tabelas de Hash ## 1. Programação Assíncrona em C# com Async e Await ### 1. 1 Introdução Nesta seção, discutiremos a programação assíncrona em C# e o uso das palavras-chave Async e Await. ``` Async e Await em C# permite que a aplicação continue a executar outras tarefas enquanto aguarda que uma tarefa seja concluída. ``` ### 1. 2 Porque programação assíncrona Na programação Síncrona, os compiladores executam um comando e aguardam sua conclusão antes de avançar para o próximo. No contrário, na programação assíncrona, os compiladores executam um comando e continuam a trabalhar no próximo enquanto o comando anterior ainda está sendo executado. > ** Nota: ** Embora a programação Síncrona seja mais fácil de entender, ela pode causar um bloqueio em uma aplicação se houver longas tarefas que demitem muito tempo para serem concluídas. Isso pode levar a uma resposta lenta ou até mesmo a pausas na aplicação. A programação assíncrona soluciona este problema permitindo que outras tarefas sejam executadas enquanto uma tarefa voltde está sendo concluída, o que melhora a performance da aplicação. ### 1. 3 Palavras-chave Async e Await ``` A palavra-chave async é utilizada para marcar um método como assíncrono. A palavra-chave await permite que o método async pausa a execução quando uma operação assíncrona está sendo executada. Ela retorna o resultado da operação assíncrona uma vez que ela for concluída. ** Nota: ** O await pode ser utilizado apenas dentro de um método marcado como async. ``` ### 1. 4 Demonstração ```csharp Neste exemplo, definimos dois métodos, Method1 e Method2, que serão executados simultaneamente. Method1 utiliza Async e Await para torná-lo assíncrono, enquanto Method2 é executado da forma síncrona. A palavra-chave async é utilizada em Method1, e a palavra-chave await junto com Task. Run é utilizado para iniciar uma nova tarefa que roda um loop e imprime uma mensagem. Também adicionamos um atraso para esta tarefa usando Task. Delay para colocar diferentes tarefas em fila. Method2 é uma função simples que roda um loop e imprime uma mensagem. Quando Method1 chega no await, ele suspende a execução, permitindo que Method2 seja executado. Quando a operação de atraso em Method1 termina, ele retoma a execução e continua a ser executado normalmente. ** Nota: ** É recomendado utilizar o await sempre que for possível para melhorar a performance da sua aplicação e evitar bloqueios na tarefa focusada. ``` ## 2. Tabelas de Hash em C# ### 2. 1 Introdução As tabelas de hash em C# são utilizadas para armazenar pares de chave-valor de forma eficiente. As chaves são utilizadas para encontrar a estrutura de armazenamento, pois são imutáveis e uma tabela não pode ter entradas duplicadas. ### 2. 2 Sintaxe ```csharp Para definir uma tabela de hash, utilize a classe Dictionary<TKey, TValue>. A sintaxe seguinte mostra como definir uma tabela de hash: HashTable<TKey, TValue> hashTable = new HashTable<TKey, TValue>(); ``` ### 2. 3 Propriedades ``` - Comparador: retorna ou define o comparador a ser utilizado para definir a tabela de hash. - Count: retorna o número de pares de chave-valor armazenados na tabela de hash. - IsReadOnly: retorna se a tabela de hash é read-only ou não. - Keys: retorna uma coleção contendo as chaves da tabela de hash. - Values: retorna uma coleção contendo os valores da tabela de hash. ``` ### 2. 4 Métodos ``` - Add: insere um par de chave-valor na tabela de hash. - Clear: remove todos os elementos da tabela de hash. - ContainsKey: indica se a chave especificada está presente na tabela de hash. - ContainsValue: indica se o valor especificado está presente na tabela de hash. ``` ## 3. Conjuntos em C# ### 3. 1 Conjuntos de Hash em C# Os conjuntos de Hash em C# são utilizados para garantir que não haja strings ou elementos duplicados em um array. ### 3. 2 Sintaxe ```csharp Para declarar um conjunto, utilize a classe HashSet<T>. A sintaxe seguinte mostra como declarar um conjunto: HashSet<T> hashSet = new HashSet<T>(); ``` ### 3. 3 Exemplo ```csharp Neste exemplo, definimos um array de string arr1 com os valores paper, pencil, eraser, pen e paper (valor duplicado). Nós converteremos arr1 em um conjunto usando a classe HashSet<T>. Isso elimina os valores duplicados. Nós armazenamos a conversão em arr2. Finalmente, impressão arr2, que não contém valores duplicados. ** Nota: ** Usar conjuntos em C# tem vantagens em comparação com arrays normais, pois permite que você garanta que as suas estruturas não contêm valores duplicados, evitando assim erros em aplicações com chances de hora limitadas ou com requisitos de performance elevados. Além disso, um conjunto possui um tempo de consulta mais rápido do que um array. ``` ### 4. Referências * [Async Await em C# |Async Await em C# Explicado com Exemplo | Tutorial de C# para InicianTES | Simplilearn](https://www.youtube.com/watch?v=B8n-a2qS4Gg) * [C# Await Explained | C# Await Exemplo |C# Wait Tutorial | Tutorial de C# para Iniciantes | Simplilearn](https://www.youtube.com/watch?v=KezYq745G64) # Overloads da Função Wait em C# Este documento fornecerá uma visão geral de várias overloads de função Wait em C# e suas aplicações. Examinaremos cinco tipos de overloads de função Wait em C# e explicaremos suas funções, mostraremos exemplos e discutiremos alguns pontos importantes a terem em mente. ## 1. Espã-Tempo Espanha A primeira overload é a `Wait(TimeSpan timeout)` função, que aguarda a finalização da execução de uma tarefa em um intervalo de tempo específico. O parâmetro timeout e o tempoSpan representam o número de milissegundos para aguardar ou `-1`, que significa aguardar indefinidamente. O tipo de retorno desta overload é `bool`, que será `true` se a tarefa terminar dentro do tempo limite, caso contrário, `false`. ### Exceptions - `ObjectDisposedException`: Indica que a tarefa foi despejada. - `ArgumentOutOfRangeException`: Usado quando o timeout é menor do que `-1` milissegundos, representando um timeout infinito ou o timeout excede o valor máximo. - `AggregateException`: Usado para atribuições canceladas. Uma exceção lançada durante a execução da tarefa pode ser encontrada na coleção de exceções internas. ### Manuseio de Exceções Pode lidar com as exceções usando um bloco try-catch, e a informação sobre a exceção ou exceções pode ser encontrada na coleção de exceções internas. ### Exemplo de Código ```csharp Task. Factory. StartNew(() => { for (int i = 0; i < 2000000; i++) Thread. Sleep(10); // Gera 2 milhões de inteiros aleatórios com valor entre 0 e 100 e calcula sua média aritmética }). Wait(TimeSpan. FromMilliseconds(120)); // Se expirar o intervalo de tempo, será exibida uma mensagem antes de sair: Console. WriteLine("Tempo de espera expirou. "); ``` ## 2. Españha de Cancelação Token A segunda overload é a `Wait(CancellationToken cancellationToken)` função, que aguarda a finalização da execução da tarefa se o token de cancelamento não foi cancelado antes que a tarefa seja completada. A tarefa é apagada se o token de cancelamento é cancelado antes que a tarefa seja completada. ### Exceptions - `OperationCanceledException`: O token de cancelamento foi desativado. - `ObjectDisposedException`: Em caso de uso quando a tarefa foi despejada. - `AggregateException`: Usado para atribuições canceladas. ### Manuseio de Exceções Pode lidar com as exceções usando um bloco try-catch. ### Exemplo de Código ```csharp CancellationTokenSource source = new CancellationTokenSource(); Task task = Task. Factory. StartNew(() => { // Código de execução da tarefa. . . }, source. Token); source. CancelAfter(TimeSpan. FromSeconds(2)); task. Wait(); try { task. Wait(source. Token); } catch (OperationCanceledException) { Console. WriteLine("Españha foi cancelada. "); } ``` ## 3. Españha de 32 A terceira overload é a `Wait(int millisecondsTimeout)` função, que aguarda a finalização da execução da tarefa em cada `milliseconds`. O retorno é `bool`, que retorna `true` se a tarefa foi completada dentro do tempo limite, caso contrário, retorna `false`. ### Exceptions - `ObjectDisposedException`: A tarefa foi despejada. - `ArgumentOutOfRangeException`: O número especificado é negativo ou diferente de `-1`. - `AggregateException`: A tarefa foi cancelada, e uma exceção de tipo `TaskCancelledException` pode ser encontrada na coleção de exceções internas. ### Manuseio de Exceções Pode lidar com as exceções usando um bloco try-catch. ### Exemplo de Código ```csharp Task. Factory. StartNew(() => { for (int i = 0; i < 2000000; i++) Thread. Sleep(1); // Gera 2 milhões de inteiros aleatórios com valor entre 0 e 100 e calcula sua média aritmética }). Wait(120); ``` ## 4. Españha de 32 Cancelação Token A quarta overload é a `Wait(int millisecondsTimeout, CancellationToken cancellationToken)` função, que aguarda a finalização da execução da tarefa em `milliseconds` enquanto vigia o token de cancelamento. O token de cancelamento é desativado quando a tarefa se completou, e a chamada à `Wait` função lança uma `OperacãoCanceladaException`. ### Exceptions - `OperationCanceledException`: O token de cancelamento foi desativado. - `ObjectDisposedException`: Em caso de uso quando a tarefa foi despejada. - `AggregateException`: Usado para atribuições canceladas. ### Manuseio de Exceções Pode lidar com as exceções usando um bloco try-catch. ### Exemplo de Código ```csharp CancellationTokenSource source = new CancellationTokenSource(); Task task = Task. Factory. StartNew(() => { // Código de execução da tarefa. . . }, source. Token); source. CancelAfter(TimeSpan. FromSeconds(2)); task. Wait(120, source. Token); try { task. Wait(120, source. Token); } catch (OperationCanceledException) { Console. WriteLine("Españha foi cancelada. "); } ``` ## 5. Españha Int 32 Cancelação Token A quinta e última overload é a `Wait(int millisecondsTimeout, CancellationToken cancellationToken)` função, sem retorno, indicando que a função não retorna nenhum valor. Esta overload funciona de forma similar ao overload `Wait(int millisecondsTimeout)`, mas inclui o token de cancelamento para melhor controle sobre as tarefas executadas. ### Manuseio de Exceções Pode lidar com as exceções usando um bloco try-catch. ### Exemplo de Código ```csharp CancellationTokenSource source = new CancellationTokenSource(); Task task = Task. Factory. StartNew(() => { // Código de execução da tarefa. . . }, source. Token); source. CancelAfter(TimeSpan. FromSeconds(2)); task. Wait(120, source. Token); try { task. Wait(120, source. Token); } catch (OperationCanceledException) { Console. WriteLine("Españha foi cancelada. "); } ``` ## Españhas em Detalhe Por todo o código, nos esforçaremos por explorar as overloads em detalhe, incluindo exemplos e boas práticas em relação à manipulação de exceções. logger-grab. pl # Tutorial sobre C# MVC CRUD | Full ASP. Net MVC Operations CRUD ao usar Entity Framework | Simplilearn [URL] https://www.youtube.com/watch?v=xFeDCD4si3U ## Apresentação O desenho Modelo-Viuwa-Controller (MVC) já passou décadas aplicado extensivamente várias tecnologias. De tamanhas apps simples à Java e C#, até à plataforma ASP. NET da Microsoft. O modo MVC tirou um esforço grandioso quando trabalhar uma descoupling das aplicação e funcionamento lógico destas. **Observe bem porque, ali vocês! Eles acervo aqui, em árabe sou o Pepper Khandelwal e tô com sua beleza à cordas estendidas pelo nosso canal da Youtube simplicleanar. Hoje em dia será mostrado um uso operacional no CRUD [create-retrieve-update-delete/upadation] das Criativorácio C# e como utilizamos em nossos projетos aspNET. Especialmente fariamo usas ao [Azure, a mais grande nivearada solução nas cloud. Ficar-vos inscrevel! Entrezagado nas mais ultimitadas teechnologia encontra toda esta noz! Abre agora teus filheiros ou agregos subscripere o nønos naçoónhe nõ! Desagaze todo teus muituido nesito tasqueu se aqui num táper alerto ou assititei já ou ou ves as 4 e ténos nova, so ou presionis bocinhado azulo seja. Simpliclean ar noun troco ŕ lógia desas conta ¡Quanta louçàtàndone a parte alar a plenite azules tál tennamõa! *][Quinta lembramento! Em quês seguimiento há a diaridala novos desenlöodmos tecenólöggica nnos. ] Nono daçada fázel nès luz dos saís que passan aquedade agornonamos co CRIOPERADÔDEM das operadases básica en ASPECT [APlicatíonneASPi A**bNET ™**. De acaemce no ludoz mais clarição deso nome A**psNet**, os córtaus teccniça’s em tornhe [Visual Lódau da MScifocs Microsoft ár esmamente](https://doc.acadmiya). De todo pónnos e outra caracteristicás pessoalis aquando nos teme à dudamente aqueles tamos pòque á manjo e mais flexiblenás teconoglições existintás dantes. **APSp. Net ár de acao fàccola, una amara dandao nnas apieíne duna ínfrastruátual bastaada ao serviceruário wev à arduia Web](http://go.webaspmvs.org?tut09#Overview&top=Mvc2-arch), aquilo já en césão por unidade teoas à partir das vershoen as piurées existíçis (modelos e lódais nnavitars [https://doc.akademija)(Ações A. SPS-AED07(asp-ef5/). * MAGOSQUARE MASAGATAÇÉ NN O BREACHER PÔKHAIQUE QÎC LUGUNÁ! * Queja nosos pedios se os encondaros. . . ! Aquilegum não veem te nosas soltíndis aoas tánimos: o próbmeos está acelerado o cúmulotec. Désdído não nás quiser achar este, tem as maneras quenk e vazouda ao manju teecólidígi nés tuás síncoloeses para seria dantes: entró aquando por uma plâtano fria o de que voces [quanto está dissié o aquardo tírio ® **SQUASILLYCØYVÍHDO, IGNAS A SALTO DIANNO](http://pinklaveiradeacaiosacoranjar).] No cípalo vérnê # Criando Soluções de Melhor Software Estático com API REST em C# Construa um sistema com várias funções utilizando as tecnologias emergentes. [APIs são essenciais](https://www.w3schools.com/whatis/whatis_api.asp) se você deseja criar um sistema assim, e elas estão [bem documentadas](https://restfulapi.net/oplog/). Olá a todos! Sou o Vavo Khandelwal e bem-vindo a todos a nossa Simply Launch YouTube channel. Aqui falaremos sobre API REST em C#, mas primeiro lembrei-lhe que nós temos atualizações diárias em várias tecnologias. Então, se você é um fã de tecnologia em busca das últimas avançadas técnicas, tente se inscrever em nossa YouTube channel e não se esqueça de clicar no ícone de sino para nunca perder um update na Simply Launch YouTube channel. Agora, vamos começar sem ado ado. Aqui está o agenda para a sessão de hoje: 1. **O que é API REST** 2. Breve discussão sobre os verbos HTTP 3. Examine alguns códigos de status HTTP 4. Vamos olhar para uma API REST com mais detalhes 5. Projeto de API REST 6. Levantamento final ## O que é API REST em C# REST (Transferência de Estado Representativo) é um estilo arquitetônico para sistemas distribuídos, baseado em ideias de Roger Taylor, Roy Fielding e outros. É construído sobre o protocolo HTTP (Protocolo de Transferência de Hipertexto) e utiliza URI (Identificadores de Recursos Uniformes) para identificar recursos. HTTP é usado para comunicar entre serviços RESTful. Depois de entender API REST em C#, vamos discutir como funciona o HTTP. ## HTTP e API REST Web A API REST Web confia fortemente nos verbos HTTP (POST, GET, PUT, e DELETE) para as atividades CRUD (Criar, Ler, Atualizar e Excluir). Agora, vamos discutir cada um em detalhes. ### POST Para inserir dados no banco de dados, utilizamos o método POST. Decoramos esse método com o sinalizador `[HttpPost]`. ### GET Pegar dados ou informação é possível através do método GET, que decoramos com o sinalizador `[HttpGet]`. ### PUT Se necessitar atualizar ou modificar os dados no banco de dados, utilizamos o método PUT, que decoramos com o sinalizador `[HttpPut]`. ### DELETE Se necessitar excluir os dados no banco de dados, utilizamos o método DELETE, que decoramos com o sinalizador `[HttpDelete]`. ## Códigos de Status HTTP Existem cinco séries de códigos de status: 1. Hundred Series: Esses representam os códigos de informações. 2. Two Hundred Series: Esses representam os códigos de sucesso. 3. Three Hundred Series: Esses representam os códigos de redirecionamentos. 4. Four Hundred Series: Esses representam os códigos de erro do cliente. 5. Five Hundred Series: Esses representam os códigos de erro do servidor. Nessa sessão, nossa aplicação de foco será apenas no sucesso (200) e client-side error (400) status codes completos. Veja alguns deles: 1. **200 Series**: 1. OK (200) 2. Created (201) 3. Accepted (202) 4. No Content (204) 2. **400 Series**: 1. Bad Request (400) 2. Unauthorized (401) 3. Forbidden (403) 4. Not Found (404) 3. **500 Series**: 1. Internal Server Error (500) 2. Not Implemented (501) 3. Service Unavailable (503) 4. Gateway Timeout (504) ## Constrangimentos da API REST C# Os constrangimentos da API REST C# são os seguintes: 1. **Interface Uniforme**: Os requisitos de interface uniforme dizem como o cliente e o servidor devem interagir. O modelo simplifica e decacouple a design, permitindo que cada componente possa evoluir independentemente. 2. **Estado Inconsistente**: Um único cliente pode enviar muitas solicitações para o servidor, mas cada solicitação deve ser independente. Cada solicitação deve conter todos os dados essenciais para que o servidor possa interpretar e processar. Nesse cenário, o servidor não salva nenhuma informação de estado do cliente, e apenas os dados devem ficar no cliente. 3. **Cliente-Servidor**: A interface uniforme separa clientes e servidores, por que da separação de concerto. Os clientes, por exemplo, não concorrem com o armazenamento de dados, que fica interno para cada servidor, melhorando a mobilidade dos programas de cliente. Os servidores não se preocupam com a interface do usuário ou status do usuário, permitindo que sejam mais simples e mais escaláveis. 4. **Cacheável**: Muitos clientes visitam o mesmo servidor e frequentemente solicitam as mesmas informações. Esses respostas devem ser armazenadas para economizar processamento desperdiçado e aumentar consideravelmente a velocidade. 5. **Sistema em Camadas**: Normalmente, um cliente não pode saber se está conectado diretamente ao servidor final ou através de um servidor intermediário. Em termos de intermediário de servidores, eles podem melhorar a escalabilidade do sistema facilitando a distribuição de cargas e fornecendo caches compartilhados. As camadas também podem impor políticas de segurança. Agora que entendemos estes constrangimentos, vamos tentar implementá-los com a ajuda de um projeto. Utilizando a Visual Studio, vamos utilizar API Web ASP. NET Core e vamos a chamar de API REST de Alunos. Aqui está como criar e configurar o projeto: 1. Crie um novo projeto usando `dotnet new webapi` 2. Instale pacotes como `Microsoft. EntityFrameworkCore. SqlServer`, `Microsoft. EntityFrameworkCore. Design`, e `Microsoft. EntityFrameworkCore. Tools` utilizando o Gerenciador de Pacotes NuGet. 3. Crie uma base de dados utilizando as Migrações de EntityFramework Core. 4. Crie modelos que representam seus dados, repositórios para se comunicar com os dados, e controllers para lidar com as solicitações HTTP. Com todos esses componentes em lugar, você poderá começar a construir sua própria API REST utilizando C#. Boa sorte! # Tutorial de Web Services em C# Este tutorial aborda Web Services em C#, focando em sua implementação usando o Visual Studio. ## Pré-requisitos - . NET Framework 4. 7. 2 - Visual Studio ## Conteúdo 1. [Introdução a Web Services em C#](#introdução) 2. [Tecnologias que suportam Web Services em C#](#tecnologias) 3. [Implementação de Web Services em C# no Visual Studio](#implementação) 4. [Vantagens e Desvantagens dos Web Services](#vantagens-desvantagens) 5. [Conclusões](#conclusões) --- ### <a name="introdução"></a>Introdução a Web Services em C# Os Web Services são caracterizados como funcionalidades da Web acessíveis por protocolos web e usadas por aplicações na web. Os Web Services não são limitados a plataforma . NET Framework e podem ser invocados por aplicações escritas em línguas diferentes. O requisito para o uso de um serviço é uma ligação a Internet para enviar uma requisição HTTP. --- ### <a name="tecnologias"></a>Tecnologias que suportam Web Services em C# 1. **XML**: especifica os dados como resultado e as aplicações que compreendem o XML em termos de língua de programação ou uma plataforma podem formatar o XML em várias maneiras. 2. **SOAP**: estabelece comunicação entre os serviços e a aplicação. 3. **WSDL**: fornece uma tecnologia consistente para especificar serviços Web a outras aplicações. 4. **UDDI**: permite a busca de registros de serviços Web utilizando UDDI. --- ### <a name="implementação"></a>Implementação de Web Services em C# no Visual Studio #### Criação de um novo projeto 1. Inicie o Visual Studio. 2. Crie um novo projeto e escolha `ASP. NET Web Application com o . NET Framework` no diálogo Novo Projeto. 3. Nomeie o projeto `SimplyLearnWebServices`. 4. Selecione `Vazio` como modelo de projetos e clique em `Criar`. --- ### <a name="vantagens-desvantagens"></a>Vantagens e Desvantagens dos Web Services Vantagens: - Plataforma-independente - Comunicação sem estado - Permite serviços que não estão apenas com o . NET Framework e pode ser invocado por aplicações escritas em várias linguagens diferentes. Desvantagens: - A segurança pode ser um ponto preocupante, devido ao fato de que dados são transmitidos pela internet - A realização adicional de trabalho de desenvolvimento pode ser necessária para garantir a compatibilidade com várias plataformas. --- ### <a name="conclusões"></a>Conclusões - Os Web Services são funcionalidades da Web acessíveis por protocolos web e usadas por aplicações na web. - Eles não são limitados a plataforma . NET Framework e podem ser invocados por aplicações escritas em várias línguas diferentes. - Os Web Services podem ser implementados no Visual Studio utilizando tecnologias XML, SOAP, WSDL e UDDI. - Plataforma-independente e comunicação sem estado são vantagens de serviços Web, mas a preocupação de segurança pode surpreender quando dados são transmitidos via Internet. # C# Web API Tutorial: O Que é Web API em C#? ## Introdução Neste tutorial, discutiremos sobre o C# Web API, suas características, versões, diferenças com WCF, vantagens e desvantagens, e criaremos um projeto de Web API para demonstrar seus recursos. ### Pré-requisitos - Familiaridade com o C# de programação - Visual Studio ou qualquer outra IDE que dê suporte ao desenvolvimento em C# ### Sumário 1. **O Que é Web API? ** 2. **ASP. NET Web API** - Características da ASP. NET Web API 3. **Versões do C# Web API** 4. **Diferenças entre o C# Web API e o WCF** 5. **Quando utilizar o C# Web API e o WCF** 6. **Demonstração Prática do C# Web API** --- ## 1. O Que é Web API? Uma API (Application Programming Interface) é um conjunto de subrotinas definidas, protocolos e ferramentas para o desenvolvimento de software e aplicações. O Web API é uma API web que pode ser acessada via o protocolo HTTP. É uma concepção em vez de uma tecnologia, e podemos criar APIs web com várias tecnologias como Java, . NET e outras. --- ## 2. ASP. NET Web API A ASP. NET Web API é um quadro expansível para a criação de serviços HTTP-based que podem ser acessados em várias aplicações em várias plataformas como web, Windows, ou móvel. Funciona de maneira semelhante a uma aplicação ASP. NET MVC web, exceto que envia dados como resposta em vez de uma visualização HTML. Funciona de maneira semelhante a uma web ou serviço de WCF, exceto que apenas suporta o protocolo HTTP. ### Características da ASP. NET Web API 1. A plataforma do ASP. NET Web API é ideal para a criação de serviços RESTful. 2. ASP. NET Web API é baseado no ASP. NET e apoia o *pipeline* de solicitação-resposta do ASP. NET. Os verbos HTTP são traduzidos em nomes de métodos pela ASP. NET Web API. 3. A ASP. NET Web API aceita um amplo produto de formatos de dados de resposta, incluindo JSON, XML e BSON. O suporte ao formato de dados é pré-instalado. 4. O servidor IIS autohospedado ou qualquer outro servidor que dê suporte ao . NET 4. 0 ou superior poderá servir a ASP. NET Web API. 5. A ASP. NET Web API framework inclui um novo cliente HTTP para a comunicação com o servidor Web API. O cliente HTTP pode ser utilizado na parte de cliente de ASP. NET MVC e aplicações de formulários Windows e outras aplicações. --- ## 3. Versões do C# Web API 1. **Web API 1. 0**: Ele suporta o . NET Framework 4. 0, coincide com o ASP. NET MVC4 e logo o suporte do Visual Studio 2010. 2. **Web API 2. 0**: É a versão atual do ASP. NET Web API. Suporta o . NET Framework 4. 5 e é compatível com o ASP. NET MVC5 e as versões do Visual Studio 2012 e 13. --- ## 4. Diferenças entre o C# Web API e o WCF O WCF (Windows Communication Foundation) é uma biblioteca e conjunto de APIs do framework . NET para a criação de aplicações comuna service-oriented. 1. Web API é aberto fonte e inclui o . NET Framework, enquanto WCF não. 2. O protocolo HTTP é suportado em Web API, enquanto WCF suporta o HTTP, TCP, UDP e protocolos de transporte personalizados. 3. Web API permite o mapeamento de verbos HTTP para métodos, enquanto WCF não. 4. WCF utiliza um modelo de programação através de atributos, enquanto Web API utiliza um conceito de rota e de controlador. 5. WCF suporta a mensagens fiáveis e transações, enquanto Web API não. 6. Nos WCF, a classe de configuração WCF pode configurar serviços da web, mas não funciona para WCF, por outro lado, na Web API, a classe de configuração HTML pode configurar APIs da web, mas não funciona para serviços da web. 7. Web API é ideal para a criação de serviços RESTful, enquanto não há suporte RESTful em WCF, embora esteja disponível com limitações. --- ## 5. Quando utilizar o C# Web API e o WCF 1. Escolha Web API se estiver utilizando o . NET Framework 4. 0 ou superior. 2. Escolha Web API se você só quer construir um servidor afinado que dê suporte ao protocolo HTTP quando criar serviços RESTful ou HTTP-based. 3. Escolha Web API se você preferir Web API, pois WCF é mais complexo e exige um esforço de aprendizado significativamente maior. # Tutorial em C# sobre Entity Framework Core e Design Patterns ## Entity Framework Core em C# Este é um tutorial que aborda a Entity Framework Core em C#. ### Introdução Começaremos criando diferentes propriedades. Iniciaremos criando propriedades públicas e `empId`, obtendo o espaço configurado. Esta será um identificador único, por isso vamos decorar com `key`. Este `key` precisa de um diretório especial. Adicionaremos `System. ComponentModel. DataAnnotations` para isso. Adicionaremos outras propriedades, como `public string Name { get; set }`, `public string Department { get; set }`, `public Print Address { get; set }`. ## Entity Framework Core O Entity Framework Core exige uma classe `Context`. Vamos fazer outra classe em `Models` e vamos chamar `EmployeeContext`. Vamos herdar a classe `DbContext` nessa classe. ## Configuração do Context Nessa classe, vamos ter uma configuração para o `Context`. Vamos criar uma classe chamada `EmployeeContextOptions`. Essa classe herdará a classe `Options` e adicionaremos a seguinte linha para garantir que a base de dados seja criada: `database. EnsureCreated()`. ## Data Source O Entity Framework exige a configuração de um `DataSource`. A configuração é feita na classe `Startup. cs`: ```csharp services. AddDbContext<EmployeeContext>( options => options. UseSqlite("Data Source=employees. db")); ``` ## Repositório Um repositório é uma camada de abstração entre a nossa aplicação e a camada de acesso a dados, que é no nosso caso o `EmployeeContext`. Criaremos uma nova pasta e chamaremos de repositórios. Adicionaremos uma interface em esta pasta e chamaremos de `IEmployeeRepository`. Essa interface representará as operações que vamos fazer na base de dados. ## Implementação do Repositório Agora com as operações definidas, vamos implementar as operações no nosso repositório. Criaremos uma classe chamada `EmployeeRepository`. Essa classe herdará a interface `IEmployeeRepository`. Adicionaremos as operações definidas na interface. No método `Create`, usaremos o método `Add` do `DbSet` para adicionar uma nova entrada, em seguida usaremos o método `SaveChangesAsync` para salvar essa entrada. No método `Delete`, usaremos o método `FindSyncAsync` do `DbSet` para encontrar a entrada, em seguida usaremos o método `Remove` do `DbSet` para remover essa entrada e novamente usaremos o método `SaveChangesAsync` para salvar as alterações. No método `Get` usaremos o método `ToListAsync` do `DbSet` para obter todas as entradas e retorná-las. ## Web API Controller Vamos agora criar um novo controlador que herdará de `ApiController`. Vamos chamar este controlador de `EmployeesController`. No método `GET`, usaremos o método `GetAsync` do nosso repositório para obter as entradas e retorná-las, no método `POST` usaremos o método `CreateAsync` para criar uma nova entrada e no método `PUT` usaremos o método `UpdateAsync` para atualizar uma entrada. No método `DELETE` usaremos o método `DeleteAsync` para remover uma entrada. ## Design Patterns em C# Esta é uma sessão sobre os Padrões de Projetos C#. ### Introdução Esta sessão aborda os Padrões de Projetos C#. Antes de começarmos esta sessão, garanta que você tenha assinado o nossa canal do YouTube e clicado no sino abaixo, para nunca perder nossa atualizações. Vejam o agendamento da nossa sessão: Primeiro, temos a introdução sobre os Padrões de Projetos C#. Depois de discutir sobre o que são os Padrões de Projetos, vamos discutir sobre os três tipos disponíveis: 1. Padrões de Criação 2. Padrões Estruturais 3. Padrões de Comportamento Em seguida, há uma breve discussão sobre as desvantagens dos Padrões de Projetos. Junte-se a esta sessão se gostar. Espero que você tenha gostado desta sessão. SeDeseja obter mais de nossos conteúdos, como este, clique [aqui](https://www.youtube.com/watch?v=OP1tBC6dBW0) e compareça a nossa página de canal do YouTube. Em seguida, vá ao nosso site e faça nosso curso de C# Design Patterns [clicando aqui](https://www.simplilearn.com/tutorials/csharp-tutorial/csharp-design-patterns). Entre em contato conosco se tiver alguma dúvida e não esqueça de curar e compartilhar se gostou da nossa sessão e receba notificações de nossas novas sessões. Obrigada! # Design Patterns Aprenda sobre os principais padrões de projeto, suas descrições e exemplos usando sintaxe Markdown. ## Padrões Creacionais ### Fábrica Método O Fábrica Método fornece uma interface para a criação de objetos em uma superclasse, mas permite que subclasses escolham a implementação concreta. #### Protótipo O Protótipo permite imitar objetos existentes sem fazer com que seu código carregue nas classes deles. #### Singleton O Singleton garante que uma classe tenha apenas uma instância ao mesmo tempo que provê um ponto de acesso global a essa instância. ## Padrões Estruturais ### Adaptador O Adaptador permite que itens com interfaces conflitantes trabalhem um com o outro. #### Ponte O Ponte permite que você divida classes grandiosas ou uma coleção de classes relacionadas em dois conjuntos de hierarquias independentes: abstração e implementação. #### Composite O Composite permite organizá-los em estruturas de árvore e manipulá-las independentemente umas do outras. #### Decorador O Decorator permite adicionar novas funcionalidades a objetos embebendo-os em objetos de envolvente especiais. #### Facade O Facade simplifica as bibliotecas complexas, frameworks e interfaces de classe. #### Proxy O Proxy permite substituir um objeto por outro objeto para controlar o acesso a ele ou atrasar sua carga. ## Padrões Comportamentais ### Cadena de Responsabilidades O Cadena de Responsabilidades permite transmitir requisições à cadeia de interpretadores até que um deles as vá processar. #### Iterador O Iterador fornece um meio de acessar elementos de um objeto agregado sequencialmente sem expor a sua representação interna. #### Memento O Memento permite salvar e restaurar o estado de um objeto sem expô-lar sua implementação. #### Estado O Estado permite que um objeto mude seu comportamento em resposta a mudanças em seu estado interno. #### Estratégia O Estratégia define uma família de algoritmos intercambiáveis e os encapsula em objetos individuais, permitindo alterá-lo ao longo do tempo sem alterar o código do cliente. #### Template Método O Template Método define o esquelão do programa para que as subclasses sejam herdadas. #### Comando O Comando encapsula uma requisição como um objeto, permitindo que o cliente parem de depender do objeto que o envia e do objeto que o processa. #### Mediador O Mediador define um objeto que supervisiona a comunicação entre outros objetos, reduzindo suas dependências umas com as outras. #### Observador O Observador define uma dependência um-para-vários entre objetos, de forma que quando um objeto muda de estado, todos seus dependentes são notificados. #### Estratégia O Estratégia define uma família de algoritmos intercambiáveis e os encapsula em objetos individuais. #### Visitor O Visitor separa um algoritmo de uma estrutura de objeto movendo o algoritmo fora da estrutura de objeto e em um objeto separado, permitindo executar as mesmas operações em vários objetos sem modificar o seu código. ## Vantagens dos Padrões de Projetos Os padrões de projetos apresentam vários benefícios, como: * Melhor reutilização de código, * Melhor separação de responsabilidades, * Melhor extensibilidade, * Melhor tempo de manutenção de código. ### Injeção de Dependência em C# #### Tutorial de Injeção de Dependência em C# Este tutorial fornece uma intro à Injeção de Dependência em C#, suas vantagens e uma implementação de código de exemplo. Espero que esse documento seja útil. Se tiver alguma pergunta, minta-a nos comentários abaixo. Obrigado por assistir e reste longe por mais de Simply Learn! #Explicações de Delegates em C# ## Delegates e Eventos em C# Tutorial ### Exemplos de Delegates em C# URL: [https: //www. youtube. com/watch? v=vOlLd2SsKM4](https://www.youtube.com/watch?v=vOlLd2SsKM4) Idioma: en Agradrina-se a todos, bem-vindos ao canal da Simply Learn! Na sessão de hoje, abordaremos sobre delegates em C#. Antes de começar, permita que eu me introduce: possuímos atualizações diárias em várias tecnologias, por isso se aquecem aos tecnicos em constante busca de tendências tecnológicas recentes, considere assinar o canal do YouTube e não esqueça de dar um toque na l compromida para nunca faltar uma atualização da Simply Learn. Agora, sem mais pausas, vamos começar com a agenda da sessão daquele: 1. Definição de Delegates em C# 2. Por que e quando utilizar delegates em C# 3. Declarar delegates em C# 4. Inicializar e chamar delegates em C# 5. Tipos de delegates diferentes em C# 6. Diferenças principais no funcionamento de Delegates com Lambdas e Métodos Anônimos ### O que são Delegates? Um delegate é um objeto que se refere a um método, ou seja, uma variável de tipo de referência que pode manter uma referência aos métodos. Delegates em C# são analógicos a ponteiros de função em C ou C++, e provê a maneira de especificar o qual método deve ser chamado quando um evento ocorre. Delegates são comumente utilizados para implementar eventos e métodos de chamada. Todos delegates são derivados implicitamente da classe `System. Delegate`. ```csharp delegate int ExampleDelegate(string s); ``` ### Por que e quando utilizar delegates em C#? Os delegates são utilizados quando um método precisa ser chamado como parâmetro para outro método. Aliás, delegates podem ser usados como a base do modelo de tratamento de eventos em C#. Delegates podem ser considerados como dar nome a assinatura de um método. Aqui está um exemplo do delegate na minha tela: ```csharp delegate int ExampleDelegate(string s); ``` O delegate pode ser alocado para qualquer método que coincida com sua assinatura, incluindo o tipo de retorno e parâmetros. ### Declarando Delegates em C# Para definir e usar delegates, siga estes três passos: 1. Use o Palavrachave `delegate` para criar um delegate. 2. Adicione um modificador, o keyword `delegate`, o tipo escrito, o nome do delegate, e, finalmente, o argumento formal. O Modificador pode ser qualquer uma das palavrac syntax: `new`, `public`, `private`, `protected` ou `internal`. Qualquer tipo que vimos previamente pode ser usado como o tipo escrito, isso também pode ser um tipo de retorno `void` ou o mesmo nome da classe. O parâmetro deve ser um nome válido em C# porque um delegate é uma definição de método: você deve usar os parênteses necessários para todos os métodos, deixe os parênteses vazios se o método não aceitar argumentos. ```csharp public delegate int ExampleDelegate(string s); ``` ### Inicializando e Chamando Delegates em C# Para inicializar e usar delegates, siga estes passos: 1. Use o mesmo delegate para inicializá-lo. 2. Crie objetos do tipo delegate usando a palavra-chave `new`. 3. Chame os objetos usando o nome do objeto seguido dos parênteses e, em seguida, um : para encerrar o procedimento de chamada. ```csharp ExampleDelegate ed1 = addition; ExampleDelegate ed2 = subtraction; ed1( "Addition: 10" ); ed2( "Subtraction: 10" ); ``` ### Tipos de delegates diferentes em C# 1. Single Cast Delegate Um single cast delegate pode se referir apenas a um método a um determinado momentado. Por exemplo, single cast delegates se referem a um único método com uma assinatura coerente. O sistema gera single cast delegates. ```csharp delegate int ExampleDelegate(string s); ``` 2. Multi-Delegate Um multi-delegate pode se referir a vários métodos que têm a mesma assinatura a um determinado momentodo. ```csharp delegate void MultiDelegate(string s1, string s2); ``` 3. Delegate Genérico Um delegate genérico pode manter uma referência a qualquer método que coincide com seus seus parâmetros de tipo. ```csharp delegate T ResultDelegate<T>(T arg); ``` Espero que seja suficiente para ilustrar os termos e as funções referenciados no texto original. Eu reduzi um parágrafo em tamanho indented para melhor leitura. As citações de vídeos também foram incluídas em Markdown. # Delegates em C# Este tutorial fornece uma visão geral de delegados em C# com exemplos de código. Entraremos em discussão por três tipos de delegados genéricos: Function, Action e Predicate delegates. ## Delegado Function O `Function` delegate pode ser encontrado no namespace System. Ele aceita um ou mais parâmetros de entrada e devolve um único parâmetro de saída. O parâmetro final é considerado como o valor de retorno em C#. Um `Function<T>` delegate pode aceitar até 16 diferentes parâmetros de entrada, mas ele deve ter apenas um tipo de retorno. O tipo de retorno é obrigatório, mas o parâmetro de entrada é opcional. Dê uma olhada em algumas coisas a se manter em mente sobre `Function` delegados genéricos: você deve utilizá-los em C# sempre que seu delegate retorne um valor, seja qual for o número de parâmetros de entrada ou não. Aqui está um exemplo de um `Function` delegate em C#: ```csharp using System; delegate double Function<T>(T arg1, T arg2, T arg3); class Program { static void Main(string[] args) { Function<double> function = SumNumber1; double result = function(1, 2, 3); Console. WriteLine(result); // Saída: 6. 0 (1 + 2. 15 + 3. 78) } static double SumNumber1(double a, double b, double c) { return a + b + c; } } ``` ## Delegado Action O `Action` delegate também pode ser encontrado no namespace System. Ele aceita um ou mais parâmetros e retorna `void`. Este delegate pode aceitar até 16 parâmetros de diferentes ou mesmos tipos. Algo a lembrar sobre `Action` delegados genéricos é que você deve utilizar em C# quando seu delegate não retorna nenhum valor, independentemente se ele aceita um número qualquer de parâmetros de entrada ou não. Aqui está um exemplo de um `Action` delegate em C#: ```csharp using System; delegate void Action<T>(T arg1, T arg2, T arg3); class Program { static void Main(string[] args) { Action<int, int, int> action = SumNumber2; action(1, 2, 3); } static void SumNumber2(int a, int b, int c) { Console. WriteLine($"A soma de números: {a + b + c}"); // Saída: A soma de números: 6 } } ``` ## Delegado Predicate O `Predicate` delegate também pode ser encontrado no namespace System. Este delegate é usado para validar os critérios de um método e retorna o resultado como um booleano, seja `true` ou `false`. Ela apenas aceita um parâmetro de entrada e sempre retorna um booleano, o que é obrigatório. Ele pode aceitar um máximo de um parâmetro e sempre retornar um valor do tipo booleano. Algo a se manter em mente sobre `Predicate` delegados genéricos é que você deve utilizar em C# sempre que seu delegate retorna um booleano por meio de um único parâmetro de entrada. Aqui está um exemplo de um `Predicate` delegate em C#: ```csharp using System; delegate bool Predicate<T>(T input); class Program { static void Main(string[] args) { Predicate<string> predicate = LengthCheck; bool result = predicate("olá"); // Saída: verdadeiro (porque "olá" tem 4 letras) Console. WriteLine(result); } static bool LengthCheck(string input) { return input. Length < 10; } } ``` ## Operadores de Consulta Padrão Em adição a delegados genéricos, o C# suporta operadores de consulta padrão como Where, OrderBy, Select, GroupBy e outros. Estes operadores podem ser combinados com expressões lambda para criar algorithmos poderosos de consulta. Aqui está um exemplo simples usando o operador Where e um predicado customizado: ```csharp using System; using System. Linq; class Program { static void Main(string[] args) { int[] numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; var oddNumbers = numbers. Where(number => number % 2 ! = 0); foreach (int number in oddNumbers) { Console. WriteLine(number); } } } ``` Este código irá imprimir todos os números ímpar do array numbers: ``` 1 3 5 7 9 ``` ## Expressões Lambda Uma expressão lambda é uma sintaxe abreviada para a criação de funções anônimas avançadas. As expressões lambda consistem em uma lista separada por vírgulas de parâmetros dentro de parênteses e seguida pelo operador lambda `=>` e o corpo da função. Aqui está um exemplo simples de uma expressão lambda que retorna o quadrado de um número dado: ```csharp Func<int, int> squareLambda = n => n * n; Console. WriteLine(squareLambda(5)); // Saída: 25 ``` ### Referências - [Delegado (Guia de Programação C#)](https://docs.microsoft.com/pt-pt/dotnet/csharp/programming-guide/delegates/) - [Lambda Expressions](https://docs.microsoft.com/pt-pt/dotnet/csharp/programming-guide/concepts/linq/lambda-expressions-in-visual-c/) - [Operadores de Consulta de Visão Geral](https://docs.microsoft.com/pt-pt/dotnet/api/system.linq.enumerable?view=netcore-3.1) Title: C# Expressões Lambda e laços de repetição tutorial ## Expressões Lambda As expressões lambda permitem que você crie funções anônimas que podem ser passadas como valores. ### Características - Sem especificar explicitamente os tipos, o compilador usa **infereção de tipos** para deduzir os tipos. Por exemplo, ele infere que `X` é um inteiro nesta expressão examinando os argumentos do Transformer. ```markdown Sem especificar explicitamente os tipos nos casos de expressões lambda, no entanto, a **infereção de tipos** funcionará apenas se cada tipo for fornecido, pois o compilador deve ser satisfeito A **infereção de tipos** deduz que X é um inteiro, o que ele faz examinando os argumentos do Transformer dado abaixo ``` - As expressões lambda podem ter parâmetros e **retornar um valor**. - Uma expressão lambda **pode ser usada para declarar parâmetros** de uma variedade de maneiras. Não há necessidade de chaves se houver apenas uma declaração, mas chaves e o valor de retorno devem ser usados se houver múltiplas declarações. - Um ** recurso chamado closure ** permite que as expressões lambda acessem variáveis que estão disponíveis fora do bloco de expressão lambda. O closure deve ser usado com caution para evitar problemas e **código perigoso não pode ser executado dentro de uma expressão lambda**. As expressões lambda devem evitar ser usadas no lado operador. ### Exemplos de código ```csharp . . . del1 é equivalente a nova Ação<int> (p => { se (p > 10) retornar p > entrada; em vez disso, retornar false; }); . . . func() => { var SRC = new []{3, 8, 4, 6, 2, 10, 19, 2, 4, 8}; para cada j em SRC. Where (x => x > 3 || x <= 7) { Console. Escriba (j); } }; ``` ## Laços As instruções de laço em C# são úteis para repetção e iteração. ### Loop While O laço while checa uma condição antes de cada execução do corpo do laço. ```markdown enquanto (condição) { // código para ser executado } ``` ### Loop Do-While O laço do-while checa a condição depois que o corpo do laço é executado, garantindo pelo menos uma iteração. ```markdown faça { // código para ser executado } enquanto (condição); ``` ### Loop For Uma opção preferida quando os laços de repetição são conhecidos a frente de tempo, o laço for reduz a verbosidade e ajuda na depuração. ```markdown para (inicializar; test; incremento/decremento) { // codigo para ser executado } ``` ## Referências - [Expressões Lambda C#](https://www.youtube.com/watch?v=yMOjBupmP2A) - [Cód schools: tutoriais de C#: laços em C#](https://www.simplilearn.com/tutorials/csharp-tutorial/c-sharp-loops-tutorial) # Loop do C#, Loop Foreach, Loop aninhados, Declaração Continue, Declaração Break e Instrução Switch Este tutorial abordará diversos tipos de loops do C#, declarações condicionais e a Instrução Switch. Analisaremos o Loop For, Loop Foreach, Loop aninhados, Declaração Continue, Declaração Break e Instrução Switch com exemplos e diagrama de fluxo. ## Loop For O Loop For é um dos contrutores de repetição mais comuns no C#. Inicializa uma variável de contador, verifica uma condição e executa um bloco de código caso a condição seja verdadeira. O loop continua até que a condição seja falsa. ```csharp for (int i = 0; i < b; i++) { // Calculate the power of a raised to the power of b // . . . } ``` ### Diagrama de Fluxo 1. Inicialização: Inicialize a variável de contador, tipicamente para controlar o número de iterações. 2. Verificação da Condição: Verificar a condição, que é uma expressão Boolean que retorna true ou false. 3. Execução do Bloco de Código: Executar o bloco de código dentro do loop caso a condição seja verdadeira. Estas iterações serão repetidas até que a condição seja determinada como falsa. 4. Atualização da Variável: Atualizar a variável de contador. ## Loop Foreach O Loop Foreach é utilizado para iterar por uma coleção de itens, como um array ou uma lista. ```csharp foreach (var item in collection) { // Code to execute on each item } ``` ### Diagrama de Fluxo 1. Inicialização do Loop: O loop inicializa a variável inferior do loop, tipicamente do mesmo tipo da coleção. 2. Iteração pela coleção: O loop iterar por elementos dentro da coleção. 3. Execução do Bloco do Loop: Executar o bloco de código dentro do loop por cada item na coleção. ## Loop aninhados Os loops aninhados são loops dentro de outros loops. O loop mais interno é executado mais frequentemente, enquanto o mais externo é executado menos frequentemente. ```csharp for (int i = 0; i < outerLimit; i++) { for (int j = 0; j < innerLimit; j++) { // Nested loop code } } ``` ### Diagrama de Fluxo 1. Inicialização: Inicialize a variável de controle do loop exterior e a variável de controle do loop interno. 2. Verificação da Condição: Verificar a condição do loop exterior e a condição do loop interior. 3. Execução do Bloco do Loop: Executar o bloco de código do loop interno. 4. Atualização da Variável: Atualizar a variável de controle do loop interno. 5. Término do Loop Interio: Se a condição do loop interno for falsa, sair do loop interno e passar para a próxima iteração do loop externo. 6. Término do Loop Externo: Se a condição do loop exterior for falsa, sair do loop. ## Declaração Continue A Declaração Continue é uma declaração condicional que pode ser usada dentro de um bloco de loop condicional para pular a iteração atual e passar para a próxima iteração. ```csharp for (int i = 1; i <= n; i++) { if (i % 9 == 0) { continue; } // Calculate the sum of odd integers in the range 1 to n // . . . } ``` ### Diagrama de Fluxo 1. Início do Loop: Se houver uma declaração continue, ela parará na iteração atual e passará para a próxima iteração passando o controle para o início do loop. ## Declaração Break A Declaração Break é utilizada para interromper um loop. ```csharp int factorial = 1; int x = Convert. ToInt32(Console. ReadLine()); while (true) { if (x <= 1) { break; } factorial *= x--; } ``` ### Diagrama de Fluxo 1. Início do Loop: Se a declaração break estiver presente, o controle será passado para as instruções que fluem após o loop, se houver uma declaração break em um loop aninhado, ela somente interromperá o loop que contém a declaração break. ## Instrução Switch A Instrução Switch é uma instrução de multi-condição que provê um meio eficiente para transferir a execução para diferentes partes de código baseado no valor da expressão. ```csharp char c = Convert. ToChar(Console. ReadLine()); switch (c. ToLower()) { case "a": // Code if c is 'a' break; case "b": // Code if c is 'b' break; // . . . } ``` ### Diagrama de Fluxo 1. Inicialização: Avalie se a instrução switch está aceptando mais de uma expressão. 2. Compilação das opções: Compara a expressão em cada opção da instrução switch. 3. Execução do bloco de código associado à opção correspondente. 4. Faça a execução do bloco associado à opção correspondente até se encontrar um `break` ou o fim da instrução switch. # Guia Compreensivo de Arrays em C# ## Introdução Nesta sessão, discutiremos arrays em C#. Antes de começarmos, certifique-se de que você assinou para nosso canal no YouTube e clique no ícone de sino abaixo para nunca errar uma atualização da nossa página do YouTube, SimplyLearn. Vamos ver a agenda do nosso tópico para hoje: 1. Introdução aos Arrays em C# 2. Tipos de Arrays em C# 3. Vantagens e Desvantagens dos Arrays em C# 4. Vantagens de Usar Arrays em C# 5. Desvantagens de Usar Arrays em C# ## O Que são Arrays em C#? Um array em C# é uma coleção de elementos do mesmo tipo de dados, armazenados em localidades de memória consecutivas. No C#, o índice de erro começa em zero, e podemos manter apenas um número fixo de elementos em um array. ## Tipos de Arrays em C# Os arrays no C# são classificados em três tipos: 1. Array de Dimensão Única 2. Array em Dimensões Múltiplas 3. Array Menisco ### Array de Dimensão Única Um array de uma dimensão única é como uma linha de elementos. Para criar um array de uma dimensão única, usamos a palavra-chave new e colchetes após um tipo. ```csharp using System; public class ArrayExample { public static void Main(string[] args) { int[] arr = new int[5]; arr[0] = 10; arr[1] = 15; arr[2] = 13; arr[3] = 9; arr[4] = 21; for (int i = 0; i < arr. Length; i++) { Console. WriteLine(arr[i]); } } } ``` ### Array em Dimensões Múltiplas Um array em dimensões múltiplas é novamente dividido em dois partes adicionais - matrizes de 2D e 3D. Os dados são mantidos em uma forma estável, ou seja, linha contra coluna, que também é conhecido como uma matriz. ```csharp using System; public class MultiDimensionalArrayExample { public static void Main(string[] args) { int[, ] arr2D = new int[3, 3]; arr2D[0, 0] = 1; arr2D[0, 1] = 2; arr2D[0, 2] = 3; arr2D[1, 0] = 4; arr2D[1, 1] = 5; arr2D[1, 2] = 6; arr2D[2, 0] = 7; arr2D[2, 1] = 8; arr2D[2, 2] = 9; for (int i = 0; i < arr2D. GetLength(0); i++) { for (int j = 0; j < arr2D. GetLength(1); j++) { Console. WriteLine(arr2D[i, j]); } Console. WriteLine(); } } } ``` ### Array Menisco Um array menisco é referido como um array de arrays pois cada um de seus elementos é um array individual e seus elementos podem estar de tamanho diferente. ```csharp using System; public class JaggedArrayExample { public static void Main(string[] args) { int[][] arr = new int[2][] { new int[5] { 42, 61, 37, 41, 59 }, new int[4] { 11, 21, 56, 78 } }; for (int i = 0; i < arr. Length; i++) { Console. WriteLine("Array length of the " + (i + 1) + " array: " + arr[i]. Length); foreach (int j in arr[i]) { Console. Write(j + " "); } Console. WriteLine(); } } } ``` ## Vantagens de Usar Arrays em C# 1. Usados para representar uma grande quantidade de objetos de dados do mesmo tipo sob um único nome. 2. Arrays são usados para implementar estruturas de dados como listas ligadas, árvores, grafos, pilhas e filas. Além disso, matrizes são representadas por arranjos de duas dimensões em C#. 3. Como os arranjos são altamente tipados, não há boxing e unboxing, o que melhora o desempenho da aplicação. ## Desvantagens de Usar Arrays em C# 1. Os arrays têm um tamanho fixo, então devemos declarar o tamanho do array antes de começar. 2. Se alocarmos mais memória do que o requerido, a memória adicional será desperdiçada. 3. Um elemento de array não pode ser inserido no meio dela, é impossível também deletar ou remover elementos do meio do array durante nosso vídeo. Maiores detalhes sobre Arrays em C# podem ser encontrados [aqui](https://www.youtube.com/watch?v=LwIULGTxs-I). ## Comandos Condicionais em C# No próximo período, discutiremos comandos condicionais em C#. Estamos aqui para você! ``` --- Comandos Condicionais em C# | If Else If em C# | C# Tutorial | C# Programming | Simplilearn URL: https://www.youtube.com/watch?v=LwIULGTxs-I Language: en Hey everyone i am peppa khandelwal and i welcome you all to simply learns gtape channel today we will talk about conditional statements in c sharp but before we begin let me tell you guys we have daily updates on multiple technologies so if you are a tech geek in a continuous hunt for our latest technological advancements then consider getting subscribed to our youtube channel and don't forget to hit the bell icon to never miss an update from simply learn. Let's look at the agenda for today's session: 1. Introduction to Conditional Statements 2. Types of Conditional Statements 3. Conditional Branching with Examples 4. Conditional Looping ### Introduction to Conditional Statements Conditional statements in C# are used when we wish to perform certain actions based on a given condition. Decision making statements necessitate a few conditions that the program may assess and a set of statements that can be performed if the condition evaluates as true or another statement that can be run if the statement evaluates as false. Conditional refers to a program's capacity to infer and do various actions based on the conditions of the codes written in that program. Next up, let's discuss the types of conditional statements. ### Types of Conditional Statements Conditional statements are categorized into two types: conditional branching and conditional looping. Let's have a deeper discussion on conditional branching. There are two ways to accommodate conditional branching: if-else statement and switch case statements. Let's discuss if-else statements first. The if statement is made up of a boolean expression followed by a statement. The statement inside the if condition is executed only if the boolean expression returns true. If it returns false then the program will simply execute the else statement if it is available. As you can see in this flowchart, let's try a code to demonstrate if-else statements. Let's start with `degree laying` and `x`, `y` and then `Console. WriteLine` in this we will print the entered number. Now let's get a user input so `x` is equal to `Console. Parse` and we will have `Console. Redline` this will request the `x` input. Let's copy-paste the same function but this time for `y` now let's write an `if` statement so if `x` is greater than `y` then in that case we will print `Console. WriteLine` that `x` is greater than `y`. Let's go for another condition `else` then if we have `x` is less than `y`, now in this case, we will be printing that `y` is greater than `x`. Now let's say they are equal since we have already covered the greater than part and the less than part, so only the condition left is equals, so we don't have to mention another `if` statement for `x` equals to `y`. So we will just write `else` and `print Console. WriteLine both are equal`. Let's save it and execute let's enter value 7 and 5 here it is printing `x` is greater than `y`. Let's try the equal function as well, let's give it value as 3 and 3 and it is printing both are equal. Let's get back to our slides. ``` # C# Tutorial: Switch Case Statement e Laços Condicionais Neste tutorial, vamos discutir o `switch case statement` e `laços condicionais` em C#. ## Switch Case Statement O `switch case statement` é utilizado para analisar diferentes valores e executar um bloco de código específico para cada caso. Neste cenário, temos vários casos definidos e um `default case` para casos não considerados. No início, são apresentados com um número a escolher. O programa irá executar o mesmo número com o caso correspondente. Se não houver um número correspondente, o programa irá executar o caso `default`. **Exemplo de código** ```csharp int x = int. Parse(Console. ReadLine()); switch (x) { case 1: Console. WriteLine("Escolheu vermelho. "); break; case 2: Console. WriteLine("Escolheu azul. "); break; // Adicione mais casos aqui default: Console. WriteLine("Este número não está nas opções oferecidas. "); break; } ``` ## Laços Condicionais Nesta seção, discutiremos quatro métodos para repetição condicional: `for loop`, `while loop`, `do-while loop`, e `foreach loop`. ### `for loop` Um `for loop` executa um bloco de código um número específico de vezes, definidos pelo `for` loop. Ou seja, é uma repetição definida. **Exemplo de código** ```csharp for (int i = 1; i <= 10; i++) { Console. WriteLine(i * i); } ``` ### `while loop` Um `while loop` executa uma repetição enquanto a condição `while` for verdadeira. O loop continuará até que a condição começar a ser falsa. **Exemplo de código** ```csharp int x = 0; while (x <= 10) { Console. WriteLine(x); x++; } ``` ### `do-while loop` Um `do-while loop` primeiro executa o bloco de código e depois valida a condição. O código será executado pelo menos uma vez, independentemente da condição. O loop terminara quando a condição se tornar falsa. **Exemplo de código** ```csharp int x = 11; do { Console. WriteLine(x); x++; } while (x <= 10); ``` ### `foreach loop` Um `foreach loop` itera sobre os elementos de uma lista ou matriz, sempre que se tratar de uma coleção. Em C#, é usado para percorrer uma `List<T>`, `Array`, ou outro tipo de coleção. **Exemplo de código** ```csharp List<string> roupa = new List<string> { "tie", "camisa", "saco", "calças", "meias" }; foreach (string item in roupa) { Console. WriteLine(item); } ``` ### URLs e Referências - https://www.youtube.com/watch?v=n6YoXxLZeSU (C# Operadores e Expressões | C# Operadores Lógicos | C# Tutorial para Iniciantes | Simplilearn) ```markdown # x equals to 30 e y é igual a 10 Iniciaremos testando o operador OR. Vamos copiar isso aqui e colar aqui para que possamos utilizar o valor e operação novamente. Para o operador OR, vamos utilizar o valor `1 é igual a f` e `x é igual a y`. O operador OR é representado por uma barra vertical (`|`). Se `x` for 1 ou `x` for igual a `y`, então voltará `verdadeiro`. Devido ao fato de `x` não ser igual a `y`, o operador OR voltará `falso`. Agora, vamos verificar se o operador AND também. Escolheremos uma variável diferente, digamos `z`. Defina `z` para 10, um valor 2, e um valor booleano `flag` definido como `true`. ### Primeira tentativa Para o operador AND, utilizaremos a equação `2 é igual a 3`. Vamos imprimir `+z é igual a vírgula mais o valor dois` (`+z === comma +2`). Agora, vamos alterar os valores para executar outras operações. Vamos utilizar `minus z` para outra operação. Para a próxima operação, vamos utilizar `duas vezes mais` (`++`). Finalmente, vamos utilizar `console. writeLine` e imprimir a negação de `flag` pois `flag` é definido como `true`. Isso deveria mostrar `flag` como `falso`. Execute este código. Você deve ver `a soma que é igual a dez` e `a subtração que é igual a negativa dez`. A `+2 z` aumentará o valor por um. Em seguida, a `-- z` diminuirá o valor em 1. Desde que `++ z` já era 11, a `-- z` simplesmente reduzirá-o para 10. Agora, a `flag` mostra `true` pois não utilizei o símbolo de negação neste lugar. Adicionaremos agora o símbolo de negação e salvaremos. Em seguida, corram novamente. Agora mostra `false`. --- ### Quebra de diapo Este foi tudo para a sessão do dia. Espero que vocês tenham encontrado isso informativo e útil. - Se você gostou desta sessão, então curta, compartilha e inscreva-se. - Se você tiver alguma dúvida, poderá deixá-las nas seções de comentários abaixo. Obrigado pela atenção, e faça o melhor para mais de Simply Learn! --- ### C# vs Java: Which Is Better? | Differences Between C# e Java | C# versus Java 2021 para Iniciantes | Simplilearn [Transcrição não disponível] --- ### C++ vs C#: What Should I Learn? | Diferenças Entre C++ e C# | Comparação de C++ e C# | Simplilearn [Transcrição não disponível] ``` # Adaptador de Dados e Classes de Sistema em C# Este documento fornece uma visão geral de um objeto adaptador de dados e classes associadas no namespace `System. Drawing`, que é parte da Arquitetura de Gráficos da Segunda Geração (GDI+) da Microsoft. ## Namespace System. Drawing O namespace `System. Drawing` contém classes que constituem o núcleo da Arquitetura de Gráficos da Segunda Geração (GDI+) da Microsoft. Uma das partes mais importantes desta arquitetura é o GDI+, também conhecido como System. Drawing, que fornece suporte para manipulação e renderização de gráficos avançados. ### Encodings, Converters e Classes Auxiliares O namespace `System. Drawing` oferece várias classes que representam codificações ASCII e Unicode de caracteres, classes abstratas para converter blocos de caracteres para e de blocos de bytes, e uma classe auxiliar que manipula e formatos objetos de String sem criar instâncias intermediárias de String. #### Codificação de Caracteres - Classes abstratas para converter caracteres em bytes - `System. Drawing. Text. Encoding` - `System. Drawing. Text. CodePageEncodingProvider` - `System. Drawing. Text. UnicodeEncoding` - `System. Drawing. Text. AsciiEncoding` #### Manipulação e Formatação de String - `System. Drawing. StringBuilder`: Manipula e formatos objetos de String sem criar instâncias intermediárias de String. ### Concorrência e Código Assíncrono O namespace `System. Threading` fornece tipos que tornam mais fácil escrever código concorrente e assíncrono. #### Classes relacionadas à Tarefa - `System. Threading. Tasks. Task` - `System. Threading. Tasks. TaskScheduler` - `System. Threading. Tasks. TaskFactory` - `System. Threading. Tasks. TaskCompletionSource` ### Framework de Interface Gráfica do Usuário O `System. Windows. Forms` namespace representa a biblioteca de classe da Interface Gráfica do Usuário (IGUI) para desenvolver aplicativos de interface gráfica do usuário. É também conhecido como WinForms. O objetivo principal deste framework de IGUI é fornecer uma interface simples para a criação de aplicativos de desktop, tablet e PC. #### Tipos Importantes - `System. Windows. Forms. Form`: Classe da IGUI que representa uma janela em aplicativos WinForms. - `System. Windows. Forms. Control`: Classe base para todos os controles da IGUI (GUI) em WinForms, tais como botões, caixas de texto e rótulos. - `System. Windows. Forms. Label`: Controle da IGUI que exibe texto e opcionais imagens. ## Jogo Corridinha de T-Rex Nas seções seguintes, vamos passar por etapas para a criação de um jogo de corrida simples de T-Rex usando o `System. Windows. Forms` namespace. ### Componentes do Jogo #### Variáveis Os componentes principais e os valores iniciais são: 1. `jump`: Uma variável booleano usada para determinar se o jogador está saltando (`false` por padrão). 2. `jumpingSpeed`: Um inteiro usado para controlar a velocidade na qual o T-Rex salta (10 por padrão). 3. `frc`: Um inteiro usado para calcular a altura que o T-Rex salta (12 por padrão). 4. `score`: Um inteiro variável que representa a pontuação do jogo (0 por padrão). 5. `speed`: Um inteiro que representa a velocidade das obstáculos (10 por padrão). 6. `random`: Uma classe usada para gerar números aleatórios. 7. `pos`: Uma variável que representa a posição do T-Rex. 8. `gameOver`: Uma variável booleano que indica se o jogo está terminado (`false` por padrão). #### Objetos de Formulário - `trx1`: O objeto principal que contém a interface gráfica do jogo. - `scoreTextLabel`: Etiqueta que exibe a pontuação do jogo. - `playerPictureBoxes`: Caixas de imagem que representam os estados de salto do jogador. ### Manipuladores de Eventos #### Eventos KeyDown - `SpaceKeyDown`: Manipula ação de salto do jogador. #### Eventos KeyUp - `TKeyUp`: Reinicia o jogo quando a tecla "t" é pressionada e solta. ### Mecânica do Jogo Este é um resumo das mecânicas do jogo Corridinha de T-Rex: 1. Quando a tecla de espaço é pressionada, o jogador faz um salto baseado na velocidade `jumpingSpeed`. 2. As obstáculos se movem para o jogador com a velocidade de animação `speed`. 3. Quando o jogador colide com uma obstáculo, o jogo termina e a tela exibe uma mensagem para pressionar a tecla "t" para reiniciar. 4. O jogo mantém o registro da pontuação do jogador para evitar as obstáculos, que é exibida na etiqueta de pontuação. 5. A dificuldade aumenta quando o jogador alcança uma pontuação superior a 5 aumentando a velocidade das obstáculos para 15. ### Conclusão Este documento fornece uma visão breve do namespace `System. Drawing` e suas classes associadas, com um foco em codificação de caracteres, converters e classes auxiliares. Além disso, discutimos o jogo Corridinha de T-Rex, incluindo seus componentes, manipuladores de eventos e mecânicas do jogo. # Desenho de Obstáculos: Curso de Obstáculos Este documento descreve o processo de design de um curso de obstáculos em um jogo, com um foco na criação de vários obstáculos e suas propriedades. ## Obstáculo 1 - Obstáculo Cubo Este obstáculo terá forma de cubo, com dimensões semelhantes às do cubo anterior. ```bash - Nome do Obstáculo: Obstáculo 1 - Cubo 1: Dimensões: As mesmas do cubo anterior - Cubo 2: Dimensões: 8 unidades (largura) x 2 unidades (altura) x 2 unidades (fundido) ``` ### Ajustes do Obstáculo Cubo - Um duplo deste obstáculo será feito, e uma abertura será criada no centro para que o jogador possa se ajoelhar ou pular por cima. - As dimensões da abertura serão determinadas com base no tamanho do jogador. ## Obstáculo 2 - Obstáculoburaco Este obstáculo será um cópia do Obstáculoburaco do Obstáculo 1, mas com tamanho menor para acomodar diferentes cenários de jogo. ```bash - Nome do Obstáculo: Obstáculo 2 - Cubo: Dimensões: 4 unidades (largura) x 2 unidades (altura) x 2 unidades (fundido) ``` ## Obstáculo 3 - Obstáculo Combinado Este obstáculo será um arranjo de Obstáculo 1 e Obstáculo 2, fornecendo um desafio mais desafiador para o jogador. ```bash - Nome do Obstáculo: Obstáculo 3 - Cubo 1: Duplo de Obstáculo 1 - Cubo 2: Duplo de Obstáculo 2 ``` ### Ajustes do Obstáculo Combinado - A posição e o arranjo dos cubos serão ajustados para criar um curso de obstáculos mais desafiador. ## Obstáculo 4 - Obstáculo Combo Este obstáculo será um arranjo de Obstáculo 1 e Obstáculo 2, com variações para fornecer um desafio único para o jogador. ```bash - Nome do Obstáculo: Obstáculo 4 - Duplo de Obstáculo 1 - Duplo de Obstáculo 2 ``` ### Ajustes do Obstáculo Combo - A posição e o arranjo dos cubos serão ajustados para criar um curso de obstáculos mais desafiador. ## Obstáculo 5 - Obstáculo Combinado Maior Este obstáculo será um arranjo maior do obstáculo combinado, fornecendo um desafio ainda mais desafiador para o jogador. ```bash - Nome do Obstáculo: Obstáculo 5 - Duplo de Obstáculo 3 ``` ### Ajustes do Obstáculo Combinado Maior - A tamanho deste obstáculo será aumentado para criar um desafio ainda mais desafiador para o jogador. ## Obstáculo 6 - Obstáculo Empilhado Este obstáculo será um montonete de cubos, fornecendo um desafio vertical para o jogador. ```bash - Nome do Obstáculo: Obstáculo 6 - Obstáculo 6 Cubo 1 - Obstáculo 6 Cubo 2 - Obstáculo 6 Cubo 3 - Obstáculo 6 Cubo 4 - Obstáculo 6 Cubo 5 - Obstáculo 6 Cubo 6 - Obstáculo 6 Cubo 7 ``` ### Ajustes do Obstáculo Empilhado - A disposição e tamanho dos cubos serão ajustados para criar um curso de obstáculos desafiador. ## Pontos finais - Cada obstáculo receberá um nome único para fins de depuração e correção de erros. - Os obstáculos serão posicionados de maneira que o jogador tenha um espaço suficiente para se movimentar. - Os obstáculos serão feitos, garantindo que o jogador não possa passar por eles sem interagir com eles. ## Programação - Programas serão criados para gerenciar o pool de objetos e a ativação de obstáculos para criar uma plataforma infinita. - Os programas serão escritos em C#. --- Este documento descreve o processo de design de um curso de obstáculos em um jogo, com um foco na criação de vários obstáculos e suas propriedades. Os obstáculos serão projetados para fornecer um desafio desafiador para o jogador, com cada obstáculo tendo dimensões e arranjos únicos. Programas serão criados para gerenciar o pool de objetos e a ativação de obstáculos para criar uma plataforma infinita. # Criação de Prefab e Configuração de Objetos de Jogo ## Conversão de Objetos Prefab Começaremos convertendo um objeto de jogo em um prefab e removê-lo da cena. Vamos nos moves para a nossa pasta Prefabs, onde dragaremos o prefab `Style` e o colocaremos aqui. Removamos agora o objeto atual. ## Geração de Suolo Simplificado Em seguida, criaremos outro objeto de jogo e o nomearemos `Gerador de Suolo Simplificado`. Clique em `Criar Vazio` e você o chamará `Cadeia de Suolo Simplificada`. Ao isso, adjuntaremos ao `Sim Concentrator` o script. Em seguida, mudaremos a localização da câmera principal: dê-lhe a posição `(10, -9, 0)` e a rotação `(0, -55, 0)`. ## Criação do Ponto de Partida Agora, criaremos um novo objeto de jogo e o chamaremos `Ponto de Partida`. Criaremos outro objeto neste momento, chamado `Ponto de Partida`, e colocaremos sua posição em `(0, -2, -15)`. ## Atribuição de Objetos Selecione o objeto `Gerador de Suolo Simplificado` e, em seguida, no associaremos a câmera principal ao objeto, o `Ponto de Partida`, e o prefab Tile; coloque o prefab aqui. ## Reprodução do Jogo Pressione play e observe. **Observação: ** **Você pode notar algumas questões com a plataforma. ** Vamos abordar essas questões. ## Ajustes de Plataforma Vamos obter a plataforma, realizar algumas alterações e remover as partes desejadas. Geralmente, o problema estár pela plataforma estar muito baixa; tentaremos e testaremos. ## Reprobar e Testar Nessa área, aumentaremos um pouco a altura da plataforma. Após o teste, se o problema persistir, retornaremos para a posição original, removeremos os dados não desejados e colocaremos a plataforma de volta corretamente. ## Jogabilidade com Melhor Condições Após as alterações, a plataforma deverá se sentir mais suave. Nossa plataforma e obstáculos já foram criados e ativados de forma aleatória. ## Criação do Objeto do Jogador Agora, criaremos um objeto de jogo, que será uma esfera capaz de saltar ou varrer. ## Configuração do Objeto do Jogador Crie un objeto de jogo e o chame `Objeto do Jogador`. Inside, create a sphere named `Esfera do Jogador`. Augmente o tamanho da esfera para ficar mais confortável sem causar problemas ao varrer. Give the sphere a color by creating a new material (e. g. , `Blue Matte`). Remove the original sphere and attach the `Simp_Player` script (descrito mais tarde) ao objeto de jogo. ## Salto e Varrição do Jogador O script controla a capacidade do jogador de saltar e varrer. Também aplica a gravidade manualmente para melhor controle. ## Deteção de Colisão e Game Over Na função `OnCollisionStay`, o script para a esfera quando uma colisão ocorre. O `CalculateJumpVerticalSpeed` calcula a velocidade vertical de salto, e em `OnCollisionEnter`, ele detecta objetos com a marca `finalizada` quando uma colisão ocorre, e o jogo termina com uma mensagem "Game Over". ## Adição de Cânvas Agora, vamos adicionar um cânvas com uma UI, aumentá-lo e garantir que esteja no lado direito. ## Posicionamento do Objeto do Jogador Coloque a posição do objeto de jogador conforme exigido pelo jogo. Se necessário, procure correções menores para eliminar erros com os obstáculos. Divirta-se jogando o jogo! Sua criatividade pode adicionar mais obstáculos complexos conforme desejado. Isso marca o fim da nossa sessão do dia. Esperamos que tenha sido informação útil e desejamos-lhe sucesso em seus projetos. Se você gostou desta sessão, goste e inscreva-se. Se tiver alguma pergunta, descr rehela-a na seção de comentários abaixo. Obrigado pela atenção! Que siga o jogo! 