├── .github
└── ISSUE_TEMPLATE
│ ├── bug_report.md
│ └── feature_request.md
├── .gitignore
├── README.md
└── docs
├── 1-Introdução
└── 1-Boas-vindas.md
├── 2-Ambiente
├── 1-Editores.md
├── 2-Sistemas-Operacionais.md
├── 3-Windows.md
├── 4-Linux.md
├── 5-MacOS.md
├── 6-Online.md
└── Img
│ ├── ConsoleApp.jpg
│ ├── CreateNewProject.jpg
│ ├── Dotnet6.jpg
│ ├── Executar.jpg
│ ├── HelloWorld.jpg
│ ├── Install.jpg
│ ├── ProjectName.jpg
│ ├── VisualStudio2022.jpg
│ └── WindowsSDK.jpg
├── 3-Básico
├── 01-Declaração-de-variáveis.md
├── 02-Tipos-de-variáveis.md
├── 03-Entrada-e-saida.md
├── 04-Operadores-aritméticos.md
├── 05-Operadores-lógicos.md
├── 06-Instruções-condicionais.md
├── 07-Estruturas-de-repetição.md
├── 08-Funções.md
├── 09-Try-catch.md
├── 10-Conversão-de-tipo.md
├── 11-Enum.md
├── 12-Nullable.md
├── 13-Arrays.md
└── 14-Namespace.md
├── 4-Intermediario
├── 01-Modificadores-de-acesso.md
├── 02-Classes.md
└── 03-Recods.md
├── 5-Avancado
├── 01-Colecoes.md
├── 02-Delegates.md
├── 03-Threads.md
└── 04-Performance.md
├── 6-Referências
└── 01-Referências.md
└── README.md
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
1 | ---
2 | name: Reportar bug
3 | about: Nos informe os problemas que acontecer nessa documentaçao
4 | title: ''
5 | labels: ''
6 | assignees: ''
7 |
8 | ---
9 |
10 | **Explique o problema**
11 | ex: Redirecionamento para o tópico x está dando 404...
12 |
13 | **Como aconteceu**
14 | Explique os passos:
15 | 1. vá até a pagina '...'
16 | 2. Clique em '....'
17 | 3. Acontecerá o erro '...'
18 |
19 | **Screenshots**
20 | Envie-nos algumas imagens do problema
21 |
22 |
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature_request.md:
--------------------------------------------------------------------------------
1 | ---
2 | name: Pedir novos conteúdos
3 | about: Sugira novas informaçoes ou modificaçoes para que possamos melhorar na documentaçao
4 | title: ''
5 | labels: ''
6 | assignees: ''
7 |
8 | ---
9 |
10 | **Sua solicitação de recurso está relacionada a um problema? Por favor descreva.**
11 | Uma descrição clara e concisa de qual é o problema. Ex. Sempre fico frustrado quando [...]
12 |
13 | **Descreva a solução que você gostaria**
14 | Uma descrição clara e concisa do que você deseja que aconteça.
15 |
16 | **Descreva alternativas que você considerou**
17 | Uma descrição clara e concisa de quaisquer soluções ou recursos alternativos que você considerou.
18 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 |
2 | .vs/
3 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | 
6 |
7 |
8 |
9 |
10 |
11 |
12 |
CSharp4Noobs
13 |
14 | 
15 |
16 |
17 |
18 | Explore a documentação »
19 |
20 |
21 | Reportar Problema
22 | ·
23 | Sugerir Novidades/Modificaçoes
24 |
25 |
26 |
27 |
28 |
29 | ## Sobre o Projeto
30 | A ideia deste repositório é ensinar ao leitor os conceitos e aplicaçoes basicas da linguagem de programaçao C# dentro da plataforma .Net Core
31 |
32 |
33 |
34 | ## Como Contribuir
35 |
36 | Contribuições fazem com que a comunidade open source seja um lugar incrível para aprender, inspirar e criar. Todas contribuições
37 | são **extremamente apreciadas**
38 |
39 | 1. Realize um Fork do projeto
40 | 2. Crie um branch com a nova feature (`git checkout -b feature/featureBraba`)
41 | 3. Realize o Commit (`git commit -m 'Adicionado conteudo brabo'`)
42 | 4. Realize o Push no Branch (`git push origin feature/featureBraba`)
43 | 5. Abra um Pull Request
44 |
45 | ## Autor
46 |
47 | - **Bruno Dantas de Paiva** - .Net - [@BDantas](https://dantasb.github.io/)
48 |
49 | ## Colaboradores
50 |
60 |
61 |
62 |
63 | 
64 |
65 |
66 |
--------------------------------------------------------------------------------
/docs/1-Introdução/1-Boas-vindas.md:
--------------------------------------------------------------------------------
1 | # 1.1 Boas Vindas
2 |
3 | Sejam bem-vindos ao curso de C# da He4rt Developers.
4 |
5 | Ficamos muito felizes de você ter chegado até aqui no nosso curso! Estaremos trabalhando nos próximos passos para que você saia desse curso entendendo o básico para começar a programar na linguagem C#.
6 |
7 | Antes de iniciar, contaremos um pouco da história da linguagem, a fim de elucidar todo seu histórico.
8 |
9 | No final da década de 1990 a Microsoft tinha diversas tecnologias e linguagens de programação, assim, toda vez que o programador precisava migrar para uma nova tecnologia e/ou linguagem, era necessário aprender tanto a nova linguagem, quanto suas bibliotecas e conceitos. Portanto, para solucionar esta problemática, a Microsoft recorreu à linguagem Java.
10 | Deste modo, para lançar produtos utilizando esta linguagem, a Empresa em questão teve de assinar um acordo de licenciamento com a Sun para utilizar o Java em ambiente Windows.
11 |
12 | No entanto, a linguagem Java possuia problemas de comunicação com bibliotecas de código nativo já existentes no Windows, então, a Microsoft teve de alterar a linguagem, criando uma implementação de Java chamada J++ (Um dos desenvolvedores esteve por trás da linguagem Delphi), que por possuir extensões proprietárias, resolviam os problemas de comunicação.
13 |
14 | Porém, esta nova implementação da linguagem Java, só poderia ser executado nos ambientes da Microsoft, violando o licenciamento feito com a Sun, levando a Microsoft a receber um processo judicial.
15 |
16 | Agora, o J++, a Microsoft teve que repensar a estratégia de como lidar com diferentes linguagens e tecnologias e começou a trabalhar em uma plataforma base de todas as soluções (Futuramente conhecida como .Net) e, também precisaria de uma linguagem de programação, onde teve como projeto COOL(C-like Object Oriented Language) que deu origem a linguagem C#.
17 |
18 | Esta então nova linguagem teve seu design baseado em diversas outras linguagens do mercado como Java, C, C++, Smallwalk, Delphi e VB, com a ideia de estudar os problemas existentes e incorporar soluções.
19 |
20 | ### Hello World
21 |
22 | #### <= C# 8
23 |
24 | ```cs
25 | using System;
26 |
27 | public class Program
28 | {
29 | public static void Main()
30 | {
31 | Console.WriteLine("Hello World");
32 | }
33 | }
34 | ```
35 |
36 | #### >= C# 9
37 |
38 | ```cs
39 | System.Console.WriteLine("Hello World");
40 | ```
41 |
42 | Para participar do curso é interessante que a pessoa tenha um conhecimento prévio de lógica de programação, contudo não é essencial para o entendimento desse curso.
43 |
44 | Note que possuimos alguns tópicos totalmente opcionais pois o objetivo é basicamente agregar conhecimento. Sugerimos que voce leia todos pois o material é realmente interessante.
45 |
46 | Além disso, como se trata de um curso apenas escrito, terá link's adicionais para te auxiliar futuramente em seus projetos ou com o andamento do curso.
47 |
--------------------------------------------------------------------------------
/docs/2-Ambiente/1-Editores.md:
--------------------------------------------------------------------------------
1 | # 2.1 Editores de Texto / [IDE](https://pt.wikipedia.org/wiki/Ambiente_de_desenvolvimento_integrado)
2 |
3 | A enfase desse curso será a parte básica do C#, portanto, você poderá utilizar qualquer ambiente de desenvolvimento que preferir.
4 | No entanto, é importante ressaltar que em empresas ou pessoas que desenvolvem projetos nessa linguagem tendem a usar o Visual Studio ou o VSCode.
5 | Porém, sintam-se confortável para utilizar qualquer [IDE](https://pt.wikipedia.org/wiki/Ambiente_de_desenvolvimento_integrado) ou editor de texto que se sentir confortável.
6 |
--------------------------------------------------------------------------------
/docs/2-Ambiente/2-Sistemas-Operacionais.md:
--------------------------------------------------------------------------------
1 | # 2.2 Sistemas Operacionais
2 |
3 | Infelizmente, algumas pessoas ainda possuem em suas mentes que "Quem programa em C#, necessariamente programa no Windows".
4 | Para tal, gostaríamos de abrir a sua mente e apresentar duas frameworks que são utilizadas para desenvolver em C#.
5 |
6 | - .Net Framework.
7 | - .Net Core.
8 |
9 | O primeiro, é amplamente utilizado para desenvolvimento de aplicações Windows, usando Windows Forms, WPF e aplicações Web utilizando ASP .NET MVC.
10 |
11 | Já o segundo é [open-source](https://github.com/dotnet/core) e multiplataforma (pode ser utilizado para criar aplicações em Linux, Mac e Windows)
12 |
13 | Portanto, não se preocupe com o sistema operacional que estiver utilizando.
14 |
--------------------------------------------------------------------------------
/docs/2-Ambiente/3-Windows.md:
--------------------------------------------------------------------------------
1 | # 2.3 Sistema Windows
2 |
3 | Para este curso, utilizaremos o [SDK](https://pt.wikipedia.org/wiki/Kit_de_desenvolvimento_de_software) do .Net no decorrer dos tópicos, e por ser multiplataforma, você pode rodar seus projetos desenvolvidos em outros sistemas, no Windows também!
4 |
5 | ## Instalando o .NET
6 |
7 | - Entre [nesse](https://dotnet.microsoft.com/download/dotnet-core/6.0) link e baixe o instalador do [SDK](https://pt.wikipedia.org/wiki/Kit_de_desenvolvimento_de_software) do .Net para o Windows de acordo com a sua arquitetura.
8 | 
9 |
10 | - Para instalar, basta clicar no instalador baixado, e esperar a instalação.
11 |
12 | - Para rodar nossos códigos desenvolvidos nesse curso, recomendamos a utilização do [Visual Studio Code (VSCode)](https://code.visualstudio.com/), por ser leve e simples de utilizar.
13 |
14 | ## Criando o projeto
15 |
16 | Entre na pasta que você guarda seus projetos e use: `dotnet new console -n HelloWorld`
17 |
18 | Irá criar uma pasta HelloWorld com um arquivo `.csproj` que é a configuração do nosso projeto, contendo a versão e em qual framework estamos utilizando nesse projeto, nesse caso, é o .Net 6.0
19 |
20 | Também terá outro arquivo `.cs` que é um exemplo de código que mostra `Hello World!` na tela!
21 |
22 | ## Rodando o projeto
23 |
24 | Depois de tudo instalado e configurado use o comando no terminal do VSCode `dotnet run` para rodar o projeto, um `Hello World!` deve aparecer no console.
25 |
26 | 
27 |
28 | ## Alternativas de Editores / [IDEs](https://pt.wikipedia.org/wiki/Ambiente_de_desenvolvimento_integrado)
29 |
30 | Para desenvolver nossos códigos com C#, tudo que precisamos é um editor de texto/código e um terminal para executar o programa.
31 |
32 | Porem temos ótimas ferramentas mais robustas para melhorar a longo prazo a produtividade do desenvolvimento dos softwares.
33 |
34 | #### Visual Studio
35 |
36 | Essa ferramenta para o Windows é simplesmente incrível, ela exige um hardware um pouco melhor, mas ela é excelente quando precisamos desenvolver aplicativos Web, Desktop (Windows), Mobile e muitos mais.
37 |
38 | > Note: O Visual Studio só é disponibilizado nos sistemas operacionais Windows e Mac OS.
39 |
40 | A instalação dela é bem simples, entre [nesse](https://visualstudio.microsoft.com/pt-br/) link e baixe o instalador do Visual Studio Community (Gratuito).
41 |
42 | 
43 |
44 | Após baixar, selecione a ferramenta de desenvolvimento usando o ASP.NET
45 |
46 | 
47 |
48 | Em seguida, execute o Visual Studio e crie um novo projeto do tipo Console App.
49 |
50 | 
51 |
52 | 
53 |
54 | 
55 |
56 | 
57 |
58 | Use o `CRTL + F5` ou clique na seta verde HeloWorld para executar o programa, e veja a magia!
59 |
60 | 
61 |
62 | #### Rider
63 |
64 | Essa é uma [IDE](https://pt.wikipedia.org/wiki/Ambiente_de_desenvolvimento_integrado) da [JetBrains](https://www.jetbrains.com/rider/) focada no desenvolvimento usando tecnologias suportadas pelo .Net Core para vários sistemas, incluindo o Windows!
65 |
66 | #### MonoDevelop
67 |
68 | Mais uma incrível ferramenta para desenvolvimento multiplataforma usando o .Net Core, e além disso, é uma [IDE](https://pt.wikipedia.org/wiki/Ambiente_de_desenvolvimento_integrado) gratuita e [Open Source](https://github.com/mono/monodevelop)
69 |
70 | #### Notepad++ + Windows Terminal :D
71 |
72 | Como já foi mencionado, é possível programar c# independente da [IDE](https://pt.wikipedia.org/wiki/Ambiente_de_desenvolvimento_integrado) / Editor de texto, uma prova disso, é esse casal maravilhoso.
73 | 
74 |
75 | ## Come on!!!
76 |
--------------------------------------------------------------------------------
/docs/2-Ambiente/4-Linux.md:
--------------------------------------------------------------------------------
1 | # 2.4 Sistema Linux
2 |
3 | Como conversamos anteriormente, sabemos que é possível programar em C# utilizando o linux. Abaixo, teremos um passo a passo de como configurar seu sistema linux para programar em C# sem maiores dificuldades.
4 |
5 | ## Passos
6 |
7 | - [Instalem o SDK](https://docs.microsoft.com/pt-br/dotnet/core/install/linux) neste link terá uma série de códigos disponibilizados pela própria microsoft, para nos ajudar a instalar o [SDK](https://pt.wikipedia.org/wiki/Kit_de_desenvolvimento_de_software) pelo terminal.
8 | - Após instalado, verifique a versão do .Net Core utilizando o seguinte comando em seu terminal: `dotnet --info`. Caso não haja erro na instalação, você verá a versão instalada do .Net Core.
9 | - Instalem um editor de texto de seu interesse. (No geral os desenvolvedores tem um apresso por esse editor, então daremos algumas dicas de extensões para utilizar).
10 | - Como extensões indicaremos 3: (C#, C# Extensions e NuGet Package Manager\*)
11 | - Crie seu projeto dentro da pasta que você preferir\*\*
12 | - Rode seu projeto criado.
13 |
14 | \*: Para este curso básico esta extensão não é necessária. Porém, futuramente pode vir a ser.
15 |
16 | ## Criando seu projeto:
17 |
18 | Para criar seu projeto em C#, devemos utilizar o seguinte comando no terminal:
19 | `dotnet new `
20 |
21 | OBS: Se não definirmos o tipo do projeto, criaremos um console application. (Aconselho este tipo de projeto para o tutorial)
22 |
23 | Além disso, é possível definir qual o tipo de projeto você pretende criar. [E, para facilitar nossas vidas, a microsoft nos disponibilizou uma série de argumentos para utilizar.](https://docs.microsoft.com/pt-br/dotnet/core/tools/dotnet-new)
24 |
25 | ## Executando seu projeto:
26 |
27 | Após criado seu projeto você pode executá-lo pela sua [IDE](https://pt.wikipedia.org/wiki/Ambiente_de_desenvolvimento_integrado) ou utilizando o comando `dotnet run` em seu terminal.
28 |
29 | ## Alternativas de [IDE](https://pt.wikipedia.org/wiki/Ambiente_de_desenvolvimento_integrado)
30 |
31 | Como alternativas ao VSCode, gostaria de sugerir o Rider, uma [IDE](https://pt.wikipedia.org/wiki/Ambiente_de_desenvolvimento_integrado) desenvolvida pela [JetBrains](https://www.jetbrains.com/rider/) e também o [MonoDevelop](https://www.monodevelop.com/), porém, como ressaltei no começo, escolha o editor de texto ou [IDE](https://pt.wikipedia.org/wiki/Ambiente_de_desenvolvimento_integrado) que preferir.
32 |
--------------------------------------------------------------------------------
/docs/2-Ambiente/5-MacOS.md:
--------------------------------------------------------------------------------
1 | # 2.5 MacOS
2 |
3 | Para este curso, utilizaremos o [SDK](https://pt.wikipedia.org/wiki/Kit_de_desenvolvimento_de_software) do .Net Core versão 3.1 no decorrer dos tópicos, e por ser multiplataforma, você pode rodar seus projetos desenvolvidos em outros sistemas, no MacOS também!
4 |
5 | ## Instalando o .NET Core
6 |
7 | Instalar o [SDK](https://pt.wikipedia.org/wiki/Kit_de_desenvolvimento_de_software) do .Net Core em um MacOS chega a ser tão fácil que fica chato, mas antes de tudo você deve conferir se o seu sistema MacOS tem suporte para rodar o .NET Core versão 3.1 que será utilizado nesse projeto, nesse [link](https://docs.microsoft.com/pt-br/dotnet/core/install/MacOS) você pode ver uma tabela com às versões do .Net Core suportada pro cada versão do MacOS.
8 |
9 | Caso o seu sistema MacOS tenha suporte a essa versão do .NET Core 3.1, você pode acessar o site oficial do .NET Core 3.1 e fazer o download do arquivo de instalação para o seu sistema MacOS.
10 |
11 | [https://dotnet.microsoft.com/download](https://dotnet.microsoft.com/download)
12 |
13 | > Nota: Lembre-se de selecionar a opção "macOS" e baixar o arquivo de instalação .pkg
14 |
15 | Após baixar o arquivo de instalação basta executar ele e iniciar a instalação, nenhuma configuração será necessária para fazer o procedimento de instalação, no máximo a instalação deve solicitar a senha do usuário conectado ou o administrador da máquina.
16 |
17 | Finalizado a instalação o MacOS deve propor a remoção do arquivo de instalação e pronto a VM (Virtual Machine) do .Net Core já está instalada no seu sistema e rodando.
18 |
19 | Para garantir que o .Net Core está de fato rodando e instalado em sua máquina basta fazer um teste no seu sistema rodando o comando no seu terminal, o comando `dotnet --version`.
20 |
21 | Esse comando deve solicitar qual é a versão do .Net Core instalada na sua máquina.
22 |
23 | > Nota: Lembre-se que você deve iniciar um terminal após a instalação do dotnet, se não o shell não vai encontra a variável de ambiente dotnet
24 |
25 | ## Instalando o Visual Studio para Mac
26 |
27 | A Microsoft disponibilizar uma versão da sua [IDE](https://pt.wikipedia.org/wiki/Ambiente_de_desenvolvimento_integrado) para MacOS, você pode efetuar o download dessa versão acessado o site oficial do Visual Studio
28 |
29 | [https://visualstudio.microsoft.com/pt-br/](https://visualstudio.microsoft.com/pt-br/)
30 |
31 | Não vamos entrar em deatelhes na sua instalação já que se trata de uma instalação seguindo os padrões de aplicativo da App
32 |
33 | > Nota: A instalação do Visual Studio vai oferecer mais algumas opções de pacotes para desenvolvimento mobile que não são necessária, instalá-los ou não vai de acordo com a sua preferência.
34 |
35 | ## Instalando o Visual Studio Code
36 |
37 | A Microsoft disponibilizar uma versão para MacOS, você pode efetuar o download dessa versão acessado o site oficial do Visual Studio
38 |
39 | [https://visualstudio.microsoft.com/pt-br/](https://visualstudio.microsoft.com/pt-br/)
40 |
41 | No site do VSCode (Visual Studio Code) você deve conseguir o arquivo de aplicativo do VSCode, o arquivo .app, e para instalar o VSCode em seu MacOS, basta arrastar o arquivo para a pasta de aplicativos do MacOS.
42 |
43 | > Nota: Caso você não queira instalar o VSCode em sua máquina você ainda pode utilizá-lo usando o navegador ou executado diretamente o arquivo .app
44 |
45 | Um detalhe que você possa querer em seu VSCode é configurar a variável de ambiente `code` e para isso no MacOS você deve abrir o seu VSCode e executar o comando em seu teclado `Cmd + Shift + P`, deve abrir um caixa de texto na parte superior do VSCode, escrever o comando `shell command` e executar, feito isso o VSCode vai configura essa variável para você.
46 |
47 | Para mais detalhes você pode dar uma olhada na documentação do VSCode em [https://code.visualstudio.com/docs/setup/mac](https://code.visualstudio.com/docs/setup/mac)
48 |
49 | ## Criando seu projeto
50 |
51 | O .Net Core oferece um comando que disponibiliza a criação de alguns projetos usando modelos pré-fabricados por eles.
52 |
53 | Para criar um novo projeto com base em algum modelo, basta executar em seu terminal o comando `dotnet new `.
54 |
55 | Caso você queira dar uma olhada nos tipos de projeto e em outros comandos você pode consultar a documentação do .Net Core.
56 | [https://docs.microsoft.com/pt-br/dotnet/core/tools/dotnet-new#arguments](https://docs.microsoft.com/pt-br/dotnet/core/tools/dotnet-new#arguments)
57 |
58 | ## Executando seu projeto
59 |
60 | Após criado seu projeto você pode executá-lo pelo terminal utilizando o comando `dotnet run`.
61 |
62 | > Nota: Esse comando deve ser executado dentro da pasta raiz do seu projeto
63 |
--------------------------------------------------------------------------------
/docs/2-Ambiente/6-Online.md:
--------------------------------------------------------------------------------
1 | # 2.6 [IDE](https://pt.wikipedia.org/wiki/Ambiente_de_desenvolvimento_integrado) Online
2 |
3 | Note que é possível também adotar sites que possuem compiladores e nos permite programar nesta linguagem.
4 | Para tais recomendarei 2, onde um desses possui a opção de debug para facilitar nossas vidas como desenvolvedor.
5 |
6 | - [onlinegdb](https://www.onlinegdb.com/online_csharp_compiler)
7 | - [dotnetfiddle](https://dotnetfiddle.net/)
8 |
--------------------------------------------------------------------------------
/docs/2-Ambiente/Img/ConsoleApp.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DantasB/CSharp4Noobs/a2f8cbd8af7ad1a6c8aa6b4c38746271c013a821/docs/2-Ambiente/Img/ConsoleApp.jpg
--------------------------------------------------------------------------------
/docs/2-Ambiente/Img/CreateNewProject.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DantasB/CSharp4Noobs/a2f8cbd8af7ad1a6c8aa6b4c38746271c013a821/docs/2-Ambiente/Img/CreateNewProject.jpg
--------------------------------------------------------------------------------
/docs/2-Ambiente/Img/Dotnet6.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DantasB/CSharp4Noobs/a2f8cbd8af7ad1a6c8aa6b4c38746271c013a821/docs/2-Ambiente/Img/Dotnet6.jpg
--------------------------------------------------------------------------------
/docs/2-Ambiente/Img/Executar.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DantasB/CSharp4Noobs/a2f8cbd8af7ad1a6c8aa6b4c38746271c013a821/docs/2-Ambiente/Img/Executar.jpg
--------------------------------------------------------------------------------
/docs/2-Ambiente/Img/HelloWorld.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DantasB/CSharp4Noobs/a2f8cbd8af7ad1a6c8aa6b4c38746271c013a821/docs/2-Ambiente/Img/HelloWorld.jpg
--------------------------------------------------------------------------------
/docs/2-Ambiente/Img/Install.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DantasB/CSharp4Noobs/a2f8cbd8af7ad1a6c8aa6b4c38746271c013a821/docs/2-Ambiente/Img/Install.jpg
--------------------------------------------------------------------------------
/docs/2-Ambiente/Img/ProjectName.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DantasB/CSharp4Noobs/a2f8cbd8af7ad1a6c8aa6b4c38746271c013a821/docs/2-Ambiente/Img/ProjectName.jpg
--------------------------------------------------------------------------------
/docs/2-Ambiente/Img/VisualStudio2022.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DantasB/CSharp4Noobs/a2f8cbd8af7ad1a6c8aa6b4c38746271c013a821/docs/2-Ambiente/Img/VisualStudio2022.jpg
--------------------------------------------------------------------------------
/docs/2-Ambiente/Img/WindowsSDK.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DantasB/CSharp4Noobs/a2f8cbd8af7ad1a6c8aa6b4c38746271c013a821/docs/2-Ambiente/Img/WindowsSDK.jpg
--------------------------------------------------------------------------------
/docs/3-Básico/01-Declaração-de-variáveis.md:
--------------------------------------------------------------------------------
1 | # 3.1 Declaração de Variáveis
2 |
3 | Antes de utilizar uma variável, é necessário, OBRIGATORIAMENTE, declara-la e especificar seu nome e tipo (posteriormente veremos que tem um outro parámetro, porém este opcional).
4 |
5 | O nome de uma variável é referenciado como um identificador. Em C# existem regras específicas na criação de um identificador:
6 |
7 | - Um nome de variével PODE conter apenas letras, números ou underscore.
8 |
9 | - Um nome de variável PRECISA começar com uma letra ou com underscore.
10 |
11 | - Um nome de variável não pode ser uma das palavras reservadas (if, for, while, string, etc), sendo que é possível usando um @ antes da palavra, ex: @if . Mas veremos isso mais a fundo um pouco mas a frente!
12 |
13 | Além disso, é importante frizar que o nome de variável, tal como outras linguagens de programação é case-sensitive, ou seja, a variável valor é diferente da variável Valor.
14 |
15 | É importante também falar que no mundo empresarial a gente utiliza alguns padrões de nomenclatura:
16 |
17 | - Para variáveis utilizamos o camelCase.
18 | - Para classes e funções utilizamos o PascalCase.
19 |
20 | Veja uma nomenclatura mais completa [aqui](https://github.com/Speckoz/Nomenclatura)
21 |
--------------------------------------------------------------------------------
/docs/3-Básico/02-Tipos-de-variáveis.md:
--------------------------------------------------------------------------------
1 | # 3.2 Tipos de Variáveis
2 |
3 | ## Tipos Padrões
4 |
5 | Como toda linguagem de programação, o C# possui alguns tipos de variáveis padrões (tipos internos), onde estes podem ser vistos abaixo:
6 |
7 | | Palavra chave | Intervalo |
8 | | ------------- | ------------------------------------------------------------- |
9 | | bool | true ou false. |
10 | | byte | 0 ..255 |
11 | | sbyte | -128 ..127 |
12 | | short | -32,768 ..32,767 |
13 | | ushort | 0 ..65,535 |
14 | | int | -2,147,483,648 ..2,147,483,647 |
15 | | uint | 0 ..4,294,967,295 |
16 | | long | -9,223,372,036,854,775,808..9,223,372,036,854,775,807 |
17 | | ulong | 0 ..18,446,744,073,709,551,615 |
18 | | float | -3.402823e38 ..3.402823e38 |
19 | | char | U+0000 .. U+ffff |
20 | | decimal | -79228162514264337593543950335..79228162514264337593543950335 |
21 | | double | -1.79769313486232e308 ..1.79769313486232e308 |
22 |
23 | Além de possuir os tipos string e object.
24 |
25 | Uma coisa que vale ressaltar, é sobre o `var` e também o `dynamic` que podem ser facilmente mal entendidos.
26 |
27 | ### var
28 |
29 | Essa paravra-chave do C# é utilizada para 2 contextos.
30 |
31 | 1. Puramente sintático - ou seja, quando voce utiliza **var** no seu código, o tipo atribuido é interpretado pelo compilador pelo resultado da expressao de atribuiçao, ex:
32 |
33 | ```cs
34 | var @int = 10; // isso é entendido pelo compilador como um numero inteiro (int)
35 | var @double = 10.0 // este é visto como o tipo double, ja que nao foi explicitado o tipo flutuante (D, d, m, M, f, F) repectivamente double, decimal e float
36 | ```
37 |
38 | 2. Tipos anonimos - isso ocorre quando o resultado da expressao de atribuiçao não possui um tipo explicitado, e o compilador é o responsavel por gerar um tipo em tempo de compilação, ex:
39 |
40 | ```cs
41 | var value = new { IsValue = true };
42 |
43 | //um exemplo de como é para compilador:
44 | x__1 a = new x__1 { IsValue = true };
45 | ```
46 |
47 | **Uma coisa muito importante, é que o [var] não é um tipo!**
48 |
49 | ### dynamic
50 |
51 | Essa palavra-chave, permite que voce acesse um metodo/prop/campo sem que precise saber o seu tipo.
52 | O termo tecnico disso é dado por [Late Binding](https://en.wikipedia.org/wiki/Late_binding#Late_binding_in_.NET).
53 |
54 | Uma coisa interessante sobre o **dynamic** é que caso durante o acesso do tipo, caso ele não encontre, irá disparar um erro em tempo de execuçao, a famosa, Exception!
55 |
56 | ## Tipos Personalizados
57 |
58 | CSharp, por ser uma linguagem orientada à objeto, permite a criação de classes para serem utilizadas como objetos. Além disso, permitem, enum, structs e interface.
59 |
--------------------------------------------------------------------------------
/docs/3-Básico/03-Entrada-e-saida.md:
--------------------------------------------------------------------------------
1 | # 3.3 Entrada e Saída
2 |
3 | Para você observar alguns resultados em C# ou receber entradas de usuários, precisamos utilizar funções padrões (Console.WriteLine() e Console.ReadLine()).
4 | Lembrando que, é necessário incluir a biblioteca no início do programa `using System` para que estas funções possam ser utilizadas.
5 |
6 | ## Console.WriteLine()
7 |
8 | A função `Console.WriteLine()` exibe um ou mais dados na tela. Dependendo do número de parámetros passados, separados por vírgula.
9 |
10 | Esta função, diferente de algumas linguagens, pode imprimir qualquer tipo, ou até mesmo ser chamada sem parámetro nenhum, imprimindo assim uma linha vazia.
11 |
12 | ### Exemplos:
13 |
14 | ```cs
15 | using System;
16 |
17 | public class Program
18 | {
19 | public static void Main()
20 | {
21 | //Define uma variável string de nome aSerImpresso, com o valor ``vez.``.
22 | string aSerImpresso = "vez.";
23 |
24 | Console.WriteLine("Estou");
25 | Console.WriteLine();
26 | Console.WriteLine("imprimindo");
27 | Console.WriteLine("isso!");
28 | Console.WriteLine(1);
29 | Console.WriteLine(aSerImpresso);
30 | }
31 | }
32 | ```
33 |
34 | Depois de compilado, o resultado será:
35 |
36 | ```
37 | Estou
38 |
39 | Imprimindo
40 | isso!
41 | 1
42 | vez.
43 | ```
44 |
45 | Além disso, é possível formatar valores dentro da string, passando assim multiplos parámetros.
46 |
47 | ```cs
48 | using System;
49 |
50 | public class Program
51 | {
52 | public static void Main()
53 | {
54 | //define uma variável do tipo string de nome multiplicacao e atribui o valor "X".
55 | string multiplicacao = "X";
56 |
57 | //define uma variável do tipo int de nome valor e atribui o valor 4.
58 | int valor = 4;
59 |
60 | Console.WriteLine("{0} {1} {0} = {2}", valor, multiplicacao, valor*valor);
61 | }
62 | }
63 | ```
64 |
65 | Depois de compilado, o resultado será:
66 |
67 | ```
68 | 4 X 4 = 16
69 | ```
70 |
71 | ## Console.ReadLine()
72 |
73 | A função `Console.ReadLine()` para a execução do programa até o usuário escrever um argumento e retorna uma string com o que foi inputado.
74 |
75 | ### Exemplo:
76 |
77 | ```cs
78 | using System;
79 |
80 | public class Program
81 | {
82 | public static void Main()
83 | {
84 | Console.WriteLine("Qual o seu Nome?");
85 |
86 | string aSerImpresso = Console.ReadLine();
87 |
88 | Console.WriteLine("Olá, {0}. Seja bem-vindo ao curso de CSharp.", aSerImpresso);
89 | }
90 | }
91 |
92 | ```
93 |
94 | Depois de compilado, considerando que o usuário entrou o seu nome, o resultado será:
95 |
96 | ```
97 | Qual o seu Nome?
98 | Olá, Bruno. Seja bem-vindo ao curso de CSharp.
99 | ```
100 |
101 | Existem também outros métodos menos utilizados. Não abordaremos neste curso, porém é interessante lerem a respeito:
102 |
103 | | Função | O que faz |
104 | | ----------------- | ---------------------------------------------------------------------------------------------------------------------------- |
105 | | Console.Read() | Lá somente 1 char e retorna um `int` com o valor ASCII deste Char. |
106 | | Console.ReadKey() | Lá a tecla digitada pelo usuário e retorna um `ConsoleKeyInfo` que é um objeto, cujo parámetro `.key`, é o nome desta tecla. |
107 | | Console.Write() | Uma outra forma de executar o WriteLine, porém com algumas peculiaridades. |
108 |
--------------------------------------------------------------------------------
/docs/3-Básico/04-Operadores-aritméticos.md:
--------------------------------------------------------------------------------
1 | # 3.4 Operadores Aritméticos
2 |
3 | Os operadores matemáticos são de importancia fundamental para qualquer tipo de linguagem de programação. Eles são os operadores de adição, subtração, multiplicação, divisão, mod (resto da divisão), incremento e decremento.
4 |
5 | ## Operador de Adição
6 |
7 | Como o nome já diz, é um operador que realiza uma soma, ele pode ser atribuido dentro de variáveis ou realizando soma de duas variáveis, no exemplo abaixo fará mais sentido.
8 |
9 | ```cs
10 | using System;
11 |
12 | public class Program
13 | {
14 | public static void Main()
15 | {
16 | int sum = 10 + 10; //variável inteira de nome "soma" recebe o valor da soma entre 10 e 10;
17 |
18 | /*Aqui foi utilizada uma maneira diferente de formatar strings, utilizando o String.Format, ele funciona independente
19 | se estiver em um WriteLine ou não, veremos exemplos desta utilização mais abaixo. */
20 |
21 | Console.WriteLine(String.Format("O valor da soma 10 + 10 = {0}", sum));
22 | }
23 | }
24 | ```
25 |
26 | Note que, com o conhecimento que possuimos de variáveis, também podemos definir os valores separadamentes em variáveis distintas.
27 |
28 | ## Operador de subtração
29 |
30 | Como o nome já diz, é um operador que realiza uma subtração, ele pode ser atribuido dentro de variáveis ou realizando subtrações de duas variáveis, no exemplo abaixo fará mais sentido.
31 |
32 | ```cs
33 | using System;
34 |
35 | public class Program
36 | {
37 | public static void Main()
38 | {
39 | int firstNumber = 10; //variavel inteira de nome "firstNumber" recebe o valor de 10.
40 |
41 | int secondNumber = 4; //variavel inteira de nome "secondNumber" recebe o valor de 4.
42 |
43 | int sub = firstNumber - secondNumber; //variavel de nome "sub" recebe o valor da subtração entre as variaveis de nome "firstNumber" e "secondNumber".
44 |
45 | string result = "O Resultado da subtração entre {0} e {1} será {2}";
46 |
47 | //Substitui o valor da variável result pela string formatada com os valores de "firstNumber", "secondNumber" e "sub" respectivamente.
48 | result = String.Format(result, firstNumber, secondNumber, sub);
49 |
50 | Console.WriteLine(result);
51 | }
52 | }
53 | ```
54 |
55 | ## Operador de multiplicação
56 |
57 | Como o nome já diz, é um operador que realiza uma multiplicação, ele pode ser atribuido dentro de variáveis ou realizando subtrações de duas variáveis, no exemplo abaixo fará mais sentido.
58 |
59 | ```cs
60 | using System;
61 |
62 | public class Program
63 | {
64 | public static void Main()
65 | {
66 | int number = 5; //variavel inteira de nome "number" recebe o valor de 5.
67 |
68 | int mult = 10 * number; //variável inteira de nome "mul" recebe o valor da multiplicação entre 10 e 5.
69 |
70 | //Note que a maioria dos tipos em c# possui o método ToString() que faz o type cast desta variável para o tipo string
71 | //permitindo o usuário concatenar este resultado com outra string.
72 | Console.WriteLine("O valor da multiplicacao 10 * 5 = " + mult.ToString());
73 | }
74 | }
75 | ```
76 |
77 | ## Operador de divisão
78 |
79 | Como o nome já diz, é um operador que realiza uma divisão, ele pode ser atribuido dentro de variáveis ou realizando subtrações de duas variáveis, no exemplo abaixo fará mais sentido.
80 |
81 | ```cs
82 | using System;
83 |
84 | public class Program
85 | {
86 | public static void Main()
87 | {
88 | int number = 5; //variavel inteira de nome "number" recebe o valor de 5.
89 |
90 | int division = 10 / number; //variável inteira de nome "division" recebe o valor da multiplicação entre 10 e 5;
91 |
92 | Console.WriteLine("O valor da divisão 10 / 5 = {0}", division);
93 |
94 | Console.WriteLine("O valor da divisão {0} / 2 = ", division, division/2);
95 | }
96 | }
97 | ```
98 |
99 | Para este caso específico, vamos observar como ficou o output:
100 |
101 | ```
102 | O valor da divisão 10 / 5 = 2
103 | O valor da divisão 2 / 2 =
104 | ```
105 |
106 | Note que o segundo WriteLine foi escrito errado propositalmente para atentar o leitor a um caso específico, onde há o esquecimento do `{1}`, o C#, particularmente, não apresentará erro de compilação neste caso e irá imprimir o resultado de maneira incompleta.
107 | Portanto, tenha atenção com a forma que você escolhe explicitar a sua saída.
108 |
109 | ## Operador de Mod
110 |
111 | Esse operador retorna o resto de uma divisão. O exemplo abaixo fica mais simples de entender.
112 |
113 | ```cs
114 | using System;
115 |
116 | public class Program
117 | {
118 | public static void Main()
119 | {
120 | int mod = 10 % 5; //variável inteira de nome "mod" recebe o valor do resto da divisão entre 10 e 5.
121 |
122 | int mod2 = num1 % num2; //variavel de nome "mod2" recebe o valor do resto da divisão entre as variaveis de nome "num1" e "num2".
123 |
124 | Console.WriteLine("O resto da divisão 10 / 5 = {0}", mod2);
125 | }
126 | }
127 | ```
128 |
129 | ## Operações resumidas
130 |
131 | Se uma variável for subtrair uma variável com 1, pode-se fazer das seguintes maneiras:
132 |
133 | ```cs
134 | using System;
135 |
136 | public class Program
137 | {
138 | public static void Main()
139 | {
140 | int x = 10;
141 | Console.WriteLine(x);
142 |
143 | x = 10;
144 | x = x - 1; //funciona com qualquer valor, nao somente 1.
145 | Console.WriteLine(x);
146 |
147 | x = 10;
148 | x -= 1; //funciona com qualquer valor nao somente 1.
149 | Console.WriteLine(x);
150 |
151 | x = 10;
152 | x--; //subtrai somente 1 da variavel após essa linha de código.
153 | Console.WriteLine(x);
154 |
155 | x = 10;
156 | Console.WriteLine(x--); //Antes de ver qual o valor impresso, tente pensar um pouco sobre qual será o resultado!
157 | Console.WriteLine(--x);
158 | x = 10;
159 | Console.WriteLine(--x); //Antes de ver qual o valor impresso, tente pensar um pouco sobre qual será o resultado!
160 |
161 |
162 | //Se uma variável for somar uma variável com 1, pode-se fazer das seguintes maneiras:
163 | x = 10;
164 | Console.WriteLine(x);
165 |
166 | x = 10;
167 | x = x + 1; //funciona com qualquer valor, nao somente 1.
168 | Console.WriteLine(x);
169 |
170 | x = 10;
171 | x += 1; //funciona com qualquer valor nao somente 1.
172 | Console.WriteLine(x);
173 |
174 | x = 10;
175 | x++; //soma somente 1 da variavel.
176 | Console.WriteLine(x);
177 |
178 | //O mesmo teste do x-- e --x pode ser feito com x++ e ++x, fica como exercício para o leitor.
179 | }
180 | }
181 | ```
182 |
183 | Para este caso específico, vamos observar a saída do programa ficará da seguinte forma:
184 |
185 | ```
186 | 10
187 | 9
188 | 9
189 | 9
190 | 10
191 | 8
192 | 9
193 | 10
194 | 11
195 | 11
196 | 11
197 | ```
198 |
--------------------------------------------------------------------------------
/docs/3-Básico/05-Operadores-lógicos.md:
--------------------------------------------------------------------------------
1 | # 3.5 Operadores lógicos e de Comparação
2 |
3 | Os operadores lógicos são utilizados quando é necessário usar duas ou mais condições dentro da mesma instrução if para que seja tomada uma única decisão cujo resultado será verdadeiro ou falso.
4 |
5 | | Operadores lógicos | Significado |
6 | | ------------------ | --------------------- |
7 | | && | and condicional |
8 | | ! | not |
9 | | \|\| | or condicional |
10 | | & | and bit a bit |
11 | | \| | or bit a bit |
12 | | ^ | xor bit a bit |
13 | | ~ | complemento bit a bit |
14 | | << | shift para a esquerda |
15 | | >> | shift para a direita |
16 |
17 | A diferença das condições condicionais para as bit a bit são as seguites:
18 |
19 | - Condicional: Só testa o segundo lado se o primeiro lado for verdadeiro (no caso do and) ou falso (no caso do or).
20 | - Bit a bit: Testa ambos os lados todas as vezes.
21 |
22 | | Operadores de Comparação | Significado |
23 | | ------------------------ | --------------------- |
24 | | > | maior que |
25 | | < | menor que |
26 | | >= | maior ou igual |
27 | | <= | menor ou igual |
28 | | == | igual |
29 | | != | não igual (diferente) |
30 |
31 | ## Exemplos:
32 |
33 | ```cs
34 | using System;
35 |
36 | public class Program
37 | {
38 | public static void Main()
39 | {
40 | int dinheiro = Console.ReadLine();
41 |
42 | if(dinheiro >= 100)
43 | {
44 | Console.WriteLine("você acabou de adquirir um fone de ouvido novo");
45 | }
46 | else
47 | {
48 | Console.WriteLine("você ainda não possui dinheiro para comprar este fone de ouvido");
49 | }
50 | }
51 | }
52 | ```
53 |
54 | Note que alguns dos comandos utilizados acima serão vistos posteriormente!
55 |
--------------------------------------------------------------------------------
/docs/3-Básico/06-Instruções-condicionais.md:
--------------------------------------------------------------------------------
1 | # 3.6 Instruções Condicionais
2 |
3 | As instruções condicionais são utilizados quando é trazer lógica de maneira mais simples ao nosso código, como foi visto no capítulo anterior.
4 |
5 | é importante frizar que, em C# existem muitas maneiras de utilizar estas instruções e, abaixo abordaremos algumas delas:
6 |
7 | ## if-else
8 |
9 | Uma instrução if identifica qual instrução executar com base no valor de uma expressão booleana.
10 |
11 | é possível utilizar simplesmente uma função if-else sem mais nem menos.
12 |
13 | ### Exemplo:
14 |
15 | ```cs
16 | using System;
17 |
18 | public class Program
19 | {
20 | public static void Main()
21 | {
22 | bool boolean = false;
23 | if(!boolean)
24 | {
25 | Console.WriteLine("A variável boolean é false");
26 | }
27 | else
28 | {
29 | Console.WriteLine("A variável boolean é true");
30 | }
31 | }
32 | }
33 | ```
34 |
35 | também é possível utilizar if's e else's aninhados.
36 |
37 | ### Exemplo:
38 |
39 | ```cs
40 | using System;
41 |
42 | public class Program
43 | {
44 | public static void Main()
45 | {
46 | int value = 10;
47 | bool boolean = true;
48 | if(!boolean)
49 | {
50 | Console.WriteLine("A variável boolean é false");
51 | if(value-- == 11)
52 | {
53 | Console.WriteLine("value = 11");
54 | }
55 | else if(value == 10)
56 | {
57 | Console.WriteLine("value = 10");
58 | }
59 | else if(value == 9)
60 | {
61 | Console.WriteLine("value = 9");
62 | }
63 | else
64 | {
65 | Console.WriteLine("não sei o valor da variável value");
66 | }
67 | }
68 | else
69 | {
70 | Console.WriteLine("A variável boolean é true");
71 | if(value++ == 11)
72 | {
73 | Console.WriteLine("value = 11");
74 | }
75 | else if(value == 10)
76 | {
77 | Console.WriteLine("value = 10");
78 | }
79 | else if(value == 9)
80 | {
81 | Console.WriteLine("value = 9");
82 | }
83 | else
84 | {
85 | Console.WriteLine("não sei o valor da variável value");
86 | }
87 | }
88 | }
89 | }
90 | ```
91 |
92 | ## Informação nerd extra:
93 |
94 | é possível escrever a instrução if-else em uma linha, utilizando o operador `?:`
95 |
96 | Este operador funciona da seguinte forma:
97 |
98 | ` ? : `
99 |
100 | Se a condição for true, a consequencia ocorrerá. Caso contrário, a alternativa ocorrerá.
101 |
102 | ### Exemplo:
103 |
104 | ```cs
105 | using System;
106 |
107 | public class Program
108 | {
109 | public static void Main()
110 | {
111 | bool boolean = false;
112 |
113 | //Se o boolean for true, imprime true. Caso contrário imprime false.
114 | Console.WriteLine(boolean ? true : false);
115 | }
116 | }
117 | ```
118 |
119 | ## Switch-Case:
120 |
121 | Uma instrução Switch-Case identifica qual instrução executar com base no valor de uma expressão de qualquer tipo.
122 |
123 | No geral o Switch-Case é utilizado como alternativa ao if-else, muitas vezes por organização de código quando há muitos casos aninhados.
124 |
125 | ### Estrutura geral de um switch-case:
126 |
127 | - Switch(valor): A variável valor será responsável por definir qual case será acessado.
128 | - Case 1: caso a variável valor seja igual a 1, entraremos neste case.
129 | - Default: caso não haja nenhum case referente é variável valor, este caso será executado.
130 |
131 | Note também que, ao final de cada case, é necessário haver `return ou break`.
132 |
133 | ### Exemplo:
134 |
135 | ```cs
136 | using System;
137 |
138 | public class Program
139 | {
140 | public static void Main()
141 | {
142 | int valor = 1;
143 |
144 | //Valor, poderia ser de qualquer tipo, não necessariamente um inteiro.
145 | //No geral utilizamos para strings, inteiros e objetos criados pelo próprio usuário
146 | switch (valor)
147 | {
148 | case 1:
149 | Console.WriteLine("Caso 1");
150 | break;
151 | case 2:
152 | Console.WriteLine("Caso 2");
153 | break;
154 | default:
155 | Console.WriteLine("Caso padrão");
156 | return;
157 | }
158 | }
159 | }
160 | ```
161 |
--------------------------------------------------------------------------------
/docs/3-Básico/07-Estruturas-de-repetição.md:
--------------------------------------------------------------------------------
1 | # 3.7 Estruturas de Repetição
2 |
3 | Os comandos de repetição são um recurso que permite que um certo trecho do código de um programa dentro deste loop seja repetido um certo número de vezes.
4 | Facilitando gerar códigos mais organizados e lógicas mais complexas.
5 |
6 | Na liguagem C# existem três comandos de repetição: while, do-while e for.
7 |
8 | ## While
9 |
10 | O `While` é uma estrutura de loop que funciona com um valor condicional instanciado fora do loop.
11 | Esta estrutura irá checar primeiro a condição e, caso a condição seja `true` o código será executado
12 |
13 | ### Exemplo
14 |
15 | ```cs
16 | using System;
17 |
18 | public class Program
19 | {
20 | public static void Main()
21 | {
22 | int controle = 0;
23 |
24 | //Enquanto controle for menor que 5.
25 | while(controle < 5)
26 | {
27 | Console.WriteLine(controle);
28 |
29 | //Soma 1 ao controle.
30 | controle++;
31 | }
32 | }
33 | }
34 | ```
35 |
36 | Depois de compilado, o resultado será:
37 |
38 | ```
39 | 0
40 | 1
41 | 2
42 | 3
43 | 4
44 | ```
45 |
46 | ## Do-While
47 |
48 | O `Do-While` é uma estrutura de loop que funciona com um valor condicional instanciado fora do loop.
49 | Contudo, diferente do `While` regular, esta estrutura irá rodar o código primeiro, e depois verificar a condição.
50 |
51 | ### Exemplo
52 |
53 | ```cs
54 | using System;
55 |
56 | public class Program
57 | {
58 | public static void Main()
59 | {
60 | int controle = 0;
61 |
62 | //Faça.
63 | do
64 | {
65 | Console.WriteLine(controle);
66 |
67 | //Soma 1 ao controle
68 | controle++;
69 |
70 | }while(controle < 5); //Enquanto controle for menor que 5.
71 | }
72 | }
73 | ```
74 |
75 | Depois de compilado, o resultado será:
76 |
77 | ```
78 | 0
79 | 1
80 | 2
81 | 3
82 | 4
83 | ```
84 |
85 | Neste exemplo específico, o resultado para ambos os loops é igual. Contudo é necessário ter cuidado com a lógica utilizada para que não seja obtido algum resultado inesperado.
86 |
87 | ## For
88 |
89 | O `for` é uma estrutura de loop que funciona com um valor condicional instanciado fora do loop.
90 | Esta estrutura irá checar primeiro a condição e, caso a condição seja `true` o código será executado
91 |
92 | ### Exemplo
93 |
94 | ```cs
95 | using System;
96 |
97 | public class Program
98 | {
99 | public static void Main()
100 | {
101 | //Para cada i, enquanto i for menor que 5, soma 1 ao i após o término do primeiro passo.
102 | for(int i = 0; i<5; i++)
103 | {
104 | Console.WriteLine(i);
105 | }
106 | }
107 | }
108 | ```
109 |
110 | Depois de compilado, o resultado será:
111 |
112 | ```
113 | 0
114 | 1
115 | 2
116 | 3
117 | 4
118 | ```
119 |
120 | ## Foreach
121 |
122 | O `foreach` é uma estrutura de loop que funciona um pouco diferente das outras estruturas.
123 | Esta função em específico irá iterar cada objeto que está dentro de outro objeto maior. (será melhor observando o exemplo abaixo)
124 |
125 | ### Exemplo
126 |
127 | ```cs
128 | using System;
129 |
130 | public class Program
131 | {
132 | public static void Main()
133 | {
134 | string valor = "sucesso";
135 |
136 | //Para cada caractere na string valor, imprime esse caractere.
137 | foreach(char caractere in valor)
138 | {
139 | Console.WriteLine(caractere);
140 | }
141 | }
142 | }
143 | ```
144 |
145 | Depois de compilado, o resultado será:
146 |
147 | ```
148 | s
149 | u
150 | c
151 | e
152 | s
153 | s
154 | o
155 | ```
156 |
--------------------------------------------------------------------------------
/docs/3-Básico/08-Funções.md:
--------------------------------------------------------------------------------
1 | # 3.8 Funções
2 |
3 | A criação de uma função é necessária por conta da modularidade do código, ou seja, é possível fazer com que haja nenhuma repetição de código desnecessária, e também é possível fazer com que outras partes do programa utilizem uma mesma função.
4 | Deste modo, tornamos o código mais limpo e mais fácil de ser entendido.
5 |
6 | Para construir uma função, é importante conhecermos a estrutura básica desta, onde podemos olhar abaixo:
7 |
8 | ` `
9 |
10 | As funções, diferentes de outras linguagens C, não precisa ser definida necessariamente antes da função main (porém nada te limita a construir antes).
11 |
12 | ## Exemplo:
13 |
14 | ```cs
15 | using System;
16 |
17 | public class Program
18 | {
19 | private int somador(int a, int b)
20 | {
21 | return a+b;
22 | }
23 |
24 | public void Main()
25 | {
26 | Console.WriteLine(somador(10,20));
27 | }
28 | }
29 | ```
30 |
31 | O resultado impresso neste caso será `30`.
32 |
33 | Note, neste caso, que a Main não está mais com o modificador `static` porém, não teria problema algum de utilizar este modificador, contudo que adicionassemos este modificador a nova função criada, como podemos observar abaixo:
34 |
35 | ```cs
36 | using System;
37 |
38 | public class Program
39 | {
40 | private static int somador(int a, int b) => a + b;
41 |
42 | public static void Main()
43 | {
44 | Console.WriteLine(somador(10,20));
45 | }
46 | }
47 | ```
48 |
49 | O resultado impresso neste caso também será `30`.
50 |
--------------------------------------------------------------------------------
/docs/3-Básico/09-Try-catch.md:
--------------------------------------------------------------------------------
1 | # 3.9 Try-Catch
2 |
3 | A instrução Try-Catch consiste em um bloco `try` seguido de um ou mais blocos `catch` onde tem como objetivo capturar as exceções e, no geral, imprimir uma mensagem para o usuário.
4 |
5 | Toda exceção lançada pelo sistema, procura por um bloco catch. Caso não haja, exibirá uma mensagem de exceção sem tratamento para o usuário e interromperá a execução do programa.
6 |
7 | Esta instrução possui a seguinte estrutura:
8 |
9 | - Try: Tenta fazer a execução de um programa.
10 | - Catch: Caso tenha algum erro na função try, ele entra nesse trecho de código.
11 | - Throw: Caso algum caso seja alcançado, ele dispara uma exceção, que virá a ser tratada pelo Catch.
12 |
13 | ## Exemplos:
14 |
15 | ```cs
16 | using System;
17 |
18 | public class Program
19 | {
20 |
21 | public static void Main()
22 | {
23 | int n = 0;
24 | try
25 | {
26 | //Imprime 0.
27 | Console.WriteLine(n);
28 | }
29 | catch
30 | {
31 | //Neste caso não teremos uma exceção.
32 | Console.WriteLine("Um erro foi detectado");
33 | }
34 | }
35 | }
36 | ```
37 |
38 | ```cs
39 | using System;
40 |
41 | public class Program
42 | {
43 | //Como foi definido na aula de modificadores, uma função sem modificadores private ou public é necessariamente private
44 | static void ProcessaString(string s)
45 | {
46 | if (s == null)
47 | {
48 | //lança uma exceção (Argumento é nulo).
49 | throw new ArgumentNullException();
50 | }
51 | }
52 |
53 | public static void Main()
54 | {
55 | string s = null;
56 | try
57 | {
58 | //Processa uma string null.
59 | ProcessaString(s);
60 | }
61 | catch(Exception ex)
62 | {
63 | //Neste caso vamos imprimir "Um erro foi detectado" pois o valor passado irá disparará uma exceção.
64 | Console.WriteLine("Um erro foi detectado");
65 | }
66 | }
67 | }
68 | ```
69 |
70 | ### Finaly 
71 |
--------------------------------------------------------------------------------
/docs/3-Básico/10-Conversão-de-tipo.md:
--------------------------------------------------------------------------------
1 | # 3.10 Conversão de Tipo (Typecast)
2 |
3 | Como pudemos observar em alguns exemplos anteriores, é possível fazer a conversão de um tipo (int, string, bool) para outro tipo em C#.
4 |
5 | Aquela maneira que vimos não é a única. Veremos abaixo outras maneiras de fazer o `Typecast`
6 |
7 | é importante frizar, que esta linguagem possui duas maneiras genéricas:
8 |
9 | ## [Conversão Implícita](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/conversions#implicit-conversions)
10 |
11 | As conversoes implicitas, como o proprio nome diz, ocorrem quando nao é explicitado (fica evidente) o tipo da conversão.
12 |
13 | Exmplo:
14 |
15 | ```cs
16 | float x = 10.44f
17 |
18 | int y = x; //Conversao implicita, onde o valor de y é a parte inteira de x, ou seja, 10
19 | ```
20 |
21 | ### Boxing
22 |
23 | Esse tipo de conversão ocorre quando o resultado da expressão é atribuido a um tipo `pai`, normalmente, `object`.
24 |
25 | ```cs
26 | // <= C# 8
27 | Pessoa p = new Pessoa();
28 | // >= C# 9
29 | Pessoa p = new();
30 |
31 | object obj = p; //Boxing
32 | ```
33 |
34 | Como o proprio nome já diz, é feito um `empacotamento` do objeto, e como todos os tipos derivam de `object`, logo, eu posso converter implicitamente `Pessoa` para `object`.
35 |
36 | A mesma coisa vale se `Pessoa` fosse uma derivação `Mamifero`, entao:
37 |
38 | ```cs
39 | //declaraçao da classe pessoa
40 | class Pessoas : Mamifero {}
41 |
42 | //..
43 |
44 | Pessoa p = new Pessoa();
45 | Mamifero m = p;
46 | ```
47 |
48 | Mas não se preocupe, que esses detalhes seram abordados nos conceitos de Orientaçao a Objetos.
49 |
50 | Note que não é possível fazer a conversão implícita para todos os tipos. Vamos observar um pouco melhor abaixo:
51 |
52 | ```
53 | //Ordem de containerização:
54 | De sbyte -> short, int, long, float, double, decimal.
55 | De byte -> short, ushort, int, uint, long, ulong, float, double, decimal.
56 | De short -> int, long, float, double, decimal.
57 | De ushort -> int, uint, long, ulong, float, double, decimal.
58 | De int -> long, float, double, decimal.
59 | De uint -> long, ulong, float, double, decimal.
60 | De long -> float, double, decimal.
61 | De ulong -> float, double, decimal.
62 | De char -> ushort, int, uint, long, ulong, float, double, decimal.
63 | De float -> double.
64 | ```
65 |
66 | ### Implicit Operator
67 |
68 | ## [Conversão Explícita](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/conversions#explicit-conversions)
69 |
70 | Sao todas as implícitas, e outras conversoes onde ficam explicitados os tipos da conversão.
71 |
72 | ### Expressao Cast (T)x
73 |
74 | Essa expressao tenta conversão dado objeto em determinado tipo, e caso essa conversão nao seja possível, uma exception será disparada, veja:
75 |
76 | ```cs
77 | using System;
78 |
79 | public class Program
80 | {
81 | public static void Main()
82 | {
83 | var x = "10";
84 |
85 | object y = x;
86 | int i = 0;
87 |
88 | try
89 | {
90 | i = (int)y; //Unboxing
91 | }
92 | catch
93 | {
94 | Console.WriteLine("deu ruim");
95 | }
96 |
97 | Console.WriteLine($"i = {i}");
98 | }
99 | }
100 |
101 | //Saida:
102 | // deu ruim
103 | // i = 0
104 | ```
105 |
106 | Alterando o valor de x para 10, temos:
107 |
108 | ```cs
109 | var x = 10;
110 |
111 | //Saida:
112 | // i = 10
113 | ```
114 |
115 | ### Operador AS
116 |
117 | Este operador faz o mesmo papel da expressão cast, com uma diferença de nunca disparar exception.
118 |
119 | Sintaxe:
120 |
121 | ```cs
122 | var resultado = obj as T
123 | ```
124 |
125 | Sendo `obj` qualquer tipo que permita ser nulo e `T` o tipo do objeto que tentará ser convertido (também deve adimitir ser nulo).
126 |
127 | Caso a conversão nao seja possivel, o valor retornado será nulo, veja o exemplo anterior com o `as`:
128 |
129 | ```cs
130 | using System;
131 |
132 | public class Program
133 | {
134 | public static void Main()
135 | {
136 | var x = "10";
137 |
138 | object y = x;
139 | int? i = null;
140 |
141 | i = y as int?; //Unboxing
142 |
143 | Console.WriteLine($"i = {i}");
144 | }
145 | }
146 |
147 | //Saida:
148 | // i =
149 | ```
150 |
151 | Alterando o valor de x para 10, temos:
152 |
153 | ```cs
154 | var x = 10;
155 |
156 | //Saida:
157 | // i = 10
158 | ```
159 |
160 | ### Explicit Operator
161 |
--------------------------------------------------------------------------------
/docs/3-Básico/11-Enum.md:
--------------------------------------------------------------------------------
1 | # 3.11 Enum
2 |
3 | Uma enumeração é um conjunto de inteiros constantes nomeados. Um tipo `enumerate` é declarado quando utilizamos `enum`
4 |
5 | A estrutura básica de um enum em c# é da seguinte forma:
6 |
7 | ```cs
8 | enum {
9 | Valor_1,
10 | Valor_2,
11 | Valor_3,
12 | ...,
13 | };
14 | ```
15 |
16 | Cada Valor, pode ser visto na verdade como um inteiro, logo, se fizermos: `(int)Valor_1` Obteremos o inteiro 0. Observaremos isso melhor abaixo:
17 |
18 | ```cs
19 | using System;
20 |
21 | public class Program
22 | {
23 | enum Dias {
24 | Dom,
25 | Seg,
26 | Ter,
27 | Qua,
28 | Qui,
29 | Sex,
30 | Sab
31 | };
32 |
33 | public static void Main()
34 | {
35 | int comecoDaSemana = (int)Dias.Dom;
36 | int fimDaSemana = (int)Dias.Sab;
37 |
38 | Console.WriteLine("Domingo: {0}", comecoDaSemana);
39 | Console.WriteLine("Sábado: {0}", fimDaSemana);
40 |
41 | }
42 | }
43 | ```
44 |
45 | A saída deste código será:
46 |
47 | ```
48 | Domingo: 0
49 | Sábado: 6
50 | ```
51 |
52 | Uma observação interessante, é que, para evitar possíveis problemas de ordem do enum, é possível atribuir valores aos enums.
53 |
54 | Podemos observar melhor abaixo:
55 |
56 | ```cs
57 | enum Dias {
58 | Dom = 0,
59 | Seg = 1,
60 | Ter = 2,
61 | Qui = 4,
62 | Qua = 3,
63 | Sex = 5,
64 | Sab = 6
65 | };
66 | ```
67 |
68 | Notem que mesmo invertendo a ordem de Quinta com Quarta, como os valores foram definidos na ordem correta, não teremos problemas na lógica.
69 |
--------------------------------------------------------------------------------
/docs/3-Básico/12-Nullable.md:
--------------------------------------------------------------------------------
1 | # 3.12 Tipos de valores anulaveis
2 |
3 | C# disponiliza para nós um tipo especial de estrutura de dados chamado de `nullable`, onde você pode designar um um limite padrão do seu tipo além de um valor `nulo` adicional
4 | Por exemplo, uma variável `nullable` do tipo `bool`, poderia assumir 3 resultados possíveis: `true`, `false` ou `null`.
5 |
6 | Para utilizar este tipo utilizamos da seguinte estrutura:
7 |
8 | ```
9 | ? = null;
10 | ```
11 |
12 | Porque utilizar esta estrutura ?
13 |
14 | Normalmente, em alguns programas, é possível que a gente obtenha um comportamento indefinido de variáveis.
15 | Por exemplo o tipo booleano. É esperado que o resultado dele seja true ou false. Contudo, em alguns casos, é possível que este valor seja indefinido ou ausente. Por isso optamos pelo nullable.
16 |
17 | ### Exemplo
18 |
19 | ```cs
20 | using System;
21 |
22 | public class Program
23 | {
24 | public static void Main()
25 | {
26 | int? num1 = null;
27 | int? num2 = 45;
28 |
29 | double? num3 = new double?();
30 | double? num4 = 3.14157;
31 |
32 | bool? boolVal = new bool?();
33 |
34 | Console.WriteLine("Resultado das variáveis acima: {0}, {1}, {2}, {3}", num1, num2, num3, num4);
35 | Console.WriteLine("Valor padrão de uma variável nullable: {0}", boolVal);
36 | }
37 | }
38 | ```
39 |
40 | Após compilado a saída será:
41 |
42 | ```
43 | Resultado das variáveis acima: , 45, , 3.14157
44 | Valor padrão de uma variável nullable:
45 |
46 | ```
47 |
48 | ## Operador de coalescência nula
49 |
50 | O operador de coalescência nula `??` retornará o valor do operando esquerdo se não for `null`.Caso contrário, ele avaliará o operando direito e retornará seu resultado.
51 | Este operador não avaliará o operando do lado direito se o operando esquerdo for diferente de `null`.
52 |
53 | ### Exemplo
54 |
55 | ```cs
56 | using System;
57 |
58 | public class Program
59 | {
60 | public static void Main()
61 | {
62 | double? num1 = null;
63 | double? num2 = 3.14157;
64 | double num3;
65 |
66 | num3 = num1 ?? 5.34;
67 | Console.WriteLine("Valor de num3: {0}", num3);
68 |
69 | num3 = num2 ?? 5.34;
70 | Console.WriteLine("Valor de num3: {0}", num3);
71 | }
72 | }
73 | ```
74 |
75 | Após compilado a saída será:
76 |
77 | ```
78 | Valor de num3: 5.34
79 | Valor de num3: 3.14157
80 | ```
81 |
--------------------------------------------------------------------------------
/docs/3-Básico/13-Arrays.md:
--------------------------------------------------------------------------------
1 | # 3.15 Arrays
2 |
3 | Um array, armazena uma coleção de elementos de mesmo tipo, de forma sequencial em um tamanho fixo.
4 |
5 | Esta estrutura de dados é utilizada para armazenar uma coleção de dados, contudo, as vezes é mais comum pensar em um array como uma coleção de variáveis do mesmo tipo, armazenado em um espaço de memória contíguo.
6 |
7 | Em vez de declarar variáveis de maneira individual, `` num0, num1, ...,`numn `` nós declaramos um array de nome `num` e nós podemos acessar os números indexando de `0 até n`, para representar variáveis individuais.
8 |
9 | Todos os arrays consistem em espaços de memória contíguos. O menor endereço corresponde ao primeiro elemento e o maior endereço corresponde ao ultimo elemento.
10 |
11 | Uma estrutura geral de um array é dada da seguinte forma:
12 |
13 | ```
14 | [] ;
15 | ```
16 |
17 | É importante ressaltar que um array, é utilizado para definir matrizes (unidimensionais, multidimensionais e etc).
18 |
19 | Outra ressalva importante é que, ao instanciar um array, o compilador do C# implicitamente inicializa cada elemento do array para um valor `default` dependendo do tipo do array. Como por exemplo o caso de um `int[]` todos os elementos são inicializados em 0.
20 |
21 | Abaixo veremos alguns exemplos de como instanciar um array.
22 |
23 | ### Exemplo
24 |
25 | ```cs
26 | using System;
27 |
28 | public class Program
29 | {
30 | public static void Main()
31 | {
32 | //Define um array1 de tamanho 5. Onde os índices estão definidos de 0 é 4.
33 | int[] array1 = new int[5];
34 |
35 | // Declara um array2 de tamanho 5. Onde os elementos já estão pré inseridos.
36 | int[] array2 = new int[] { 1, 3, 5, 7, 9 };
37 |
38 | // Sintaxe alternativa para definir um array.
39 | int[] array3 = { 1, 2, 3, 4, 5, 6 };
40 |
41 | // Sintaxe alternativa para definir um array.
42 | int[] array4 = new int[5] { 99, 98, 92, 97, 95};
43 |
44 | //Também é possível copiarmos uma variável array em outra variável.
45 | int[] valor = new int[] { 99, 98, 92, 97, 95};
46 | int[] copia = valor;
47 |
48 | //Podemos utilizar de exemplo como acessar o elemento de número 92 deste array definida acima.
49 | int valorNoArray = valor[2];
50 | }
51 | }
52 | ```
53 |
54 | ## Matrizes Multidimensionais
55 |
56 | Uma matriz multidimensional, é na verdade um array multidimensional que pode ser declarado da seguinte forma:
57 |
58 | ```
59 | [,] ; //Array bidimensional.
60 | [,,] ; //Array tridimensional.
61 | ```
62 |
63 | Abaixo veremos alguns exemplos de como instanciar uma matriz multidimensional.
64 |
65 | ### Exemplo
66 |
67 | ```
68 | using System;
69 |
70 | public class Program
71 | {
72 | public static void Main()
73 | {
74 |
75 | //Define uma matriz-2D de tamanho ``4x2``. Onde os índices estão definidos de 0 é 3 e 0 até 1.
76 | int[,] matriz2D = new int[4, 2];
77 |
78 | //Define uma matriz-3D de tamanho ``4x2x3``. Onde os índices estão definidos de 0 é 3, 0 até 1 e 0 até 2.
79 | int[, ,] matriz3D = new int[4, 2, 3];
80 |
81 | //Sintaxe alternativa para definir uma matriz-2D de tamanho ``4x2``.
82 | int[,] matriz2D1 = new int[4, 2] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
83 |
84 | //Sintaxe alternativa para definir uma matriz-2D de tamanho ``4x2``.
85 | //Cada conjunto definido por ``{}`` significa uma linha da matriz. Enquanto cada elemento é definido pelo elemento i,j desta matriz.
86 | int[,] matriz2D2 = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
87 |
88 | //Sintaxe alternativa para definir uma matriz-3D de tamanho ``2x2x3``.
89 | int[, ,] matriz3D2 = new int[,,] { { { 1, 2, 3 }, { 4, 5, 6 } },
90 | { { 7, 8, 9 }, { 10, 11, 12 } } };
91 |
92 | //Sintaxe alternativa para definir uma matriz-3D de tamanho ``2x2x3``.
93 | int[, ,] matriz3D3 = new int[2, 2, 3] { { { 1, 2, 3 }, { 4, 5, 6 } },
94 | { { 7, 8, 9 }, { 10, 11, 12 } } };
95 |
96 | //Podemos utilizar de exemplo como acessar o elemento de número 12 desta matriz3D definida acima.
97 | int valor = matriz3D3[1,1,2];
98 | }
99 | }
100 | ```
101 |
102 | ## Matrizes Denteadas
103 |
104 | Uma matriz denteada é uma matriz cujos elementos são matrizes. Os elementos de uma matriz denteada podem ter diferentes dimensões e tamanhos. às vezes, uma matriz denteada é chamada de matriz de matrizes.
105 |
106 | Tal como os exemplos anteriores, é possível criar uma matriz denteada definida por n matrizes.
107 |
108 | ```
109 | [][] ; //Matriz bidimensional.
110 |
111 | ```
112 |
113 | Diferente dos métodos anteriores, criar uma matriz denteada, não cria o array na memória. Portanto, é necessário fazer o seguinte:
114 |
115 | ```
116 | using System;
117 |
118 | public class Program
119 | {
120 | public static void Main()
121 | {
122 | int[][] valores = new int[5][];
123 |
124 | //valores.Length é o tamanho deste array. Que neste caso é 5.
125 | for (int i = 0; i < valores.Length; i++) {
126 |
127 | //Cada array criado agora é um array de tamanho 4.
128 | valores[i] = new int[4];
129 | }
130 | }
131 | }
132 | ```
133 |
134 | Abaixo veremos alguns exemplos de como instanciar uma matriz denteada.
135 |
136 | ### Exemplo
137 |
138 | ```
139 | using System;
140 |
141 | public class Program
142 | {
143 | public static void Main()
144 | {
145 |
146 | //Define uma matriz de array, onde o primeiro array possui 3 elementos e o segundo array possui 4 elementos.
147 | int[][] valores = new int[2][]{new int[]{92,93,94},new int[]{85,66,87,88}};
148 |
149 | //Define uma matriz de array, que possuem 5 arrays de tamanho 2.
150 | int[][] valores1 = new int[][]{new int[]{0,0}, new int[]{1,2},
151 | new int[]{2,4}, new int[]{ 3, 6 }, new int[]{ 4, 8 } };
152 |
153 | //Podemos utilizar de exemplo como acessar o elemento de número 6 desta matriz3D definida acima.
154 | int resultado = valores1[3][1];
155 | }
156 | }
157 | ```
158 |
--------------------------------------------------------------------------------
/docs/3-Básico/14-Namespace.md:
--------------------------------------------------------------------------------
1 | # 3.16 Namespace
2 |
3 | Os namespaces, em C#, tendem a ser utilizados para organizar suas classes e projetos dentro de uma mesma solução.
4 | Somente para ilustrar ao leitor, a maioria dos aplicativo do C#, começam com uma seção de `using`.
5 | Esta seção lista todos os namespaces que o aplicativo usará com frequência, evitando que o programador repita o nome a cada vez que o método contido for utilizado.
6 |
7 | Podemos observar melhor com o exemplo abaixo:
8 |
9 | ```cs
10 | using System; //Neste caso fazemos uma referência ao namespace System.
11 |
12 | public class Program
13 | {
14 | private int somador(int a, int b)
15 | {
16 | return a+b;
17 | }
18 |
19 | public void Main()
20 | {
21 | Console.WriteLine(somador(10,20));
22 | System.Console.WriteLine(somador(10,20)); //Também é possível executar o código acima, desta forma, fazendo com que não seja necessário adicionar a diretiva using System
23 | }
24 | }
25 |
26 | ```
27 |
28 | No exemplo acima, não criamos nenhum namespace, porém, é possível fazer isso da seguinte forma:
29 |
30 | ```
31 | namespace nome_do_namespace {
32 | // código
33 | }
34 | ```
35 |
36 | Ou seja, é possível encapsular toda a parte de soma em um namespace único e utilizar em outro código de maneira mais organizada. Como podemos observar abaixo:
37 |
38 | ```cs
39 | using System;
40 | using Calculadora;
41 |
42 | namespace Calculadora
43 | {
44 | public class FuncoesBasicas
45 | {
46 | public static int Somador(int a, int b)
47 | {
48 | return a+b;
49 | }
50 | }
51 | }
52 |
53 | public class Program
54 | {
55 | public void Main()
56 | {
57 | Console.WriteLine(FuncoesBasicas.Somador(10,20));
58 | }
59 | }
60 |
61 | ```
62 |
63 | é importante ressaltar também que a criação de namespaces, não se limitam a um só por código ou projeto. Também é possível criar namespaces `aninhados`, onde, neste caso, teremos que acessar o namespace utilizando `ponto(.)`.
64 |
65 | Observe o exemplo abaixo:
66 |
67 | ```cs
68 | using System;
69 | using Projeto.Calculadora; //Acessa o namespace Calculadora que se encontra dentro do projeto.
70 | using Projeto.DiasDaSemana; //Acessa o namespace DiasDaSemana que se encontra dentro do projeto.
71 |
72 | namespace Projeto
73 | {
74 | //Namespace dentro do namespace Projeto.
75 | namespace Calculadora
76 | {
77 | public class FuncoesBasicas
78 | {
79 | public static int Somador(int a, int b)
80 | {
81 | return a+b;
82 | }
83 | }
84 | }
85 | //Namespace dentro do namespace Projeto.
86 | namespace DiasDaSemana
87 | {
88 | public enum Dias {
89 | Dom,
90 | Seg,
91 | Ter,
92 | Qua,
93 | Qui,
94 | Sex,
95 | Sab
96 | };
97 | }
98 | }
99 |
100 | public class Program
101 | {
102 | public void Main()
103 | {
104 | Console.WriteLine(FuncoesBasicas.Somador(10,20));
105 | Console.WriteLine(Dias.Sab);
106 | }
107 | }
108 | ```
109 |
110 | A partir da versão 10 da linguagem C#, é possível também realizar a declaração de namespaces com escopo de arquivo. Ou seja,
111 | podemos utilizar dentro de um arquivo .cs a declaração using dispensando a utilização das chaves `{ }` para a delimitação do escopo do
112 | namespace. Desta forma, estamos indicando que todas as declarações logo abaixo da definição do namespace, pertencem a este namespace:
113 |
114 | ```cs
115 | namespace Projeto;
116 |
117 | public void Main()
118 | {
119 | Console.WriteLine("Hello World!");
120 | }
121 | ```
122 |
123 | Essa nova sintaxe economiza espaço horizontal e vertical para as declarações de namespaces e torna o arquivo de código mais legível.
--------------------------------------------------------------------------------
/docs/4-Intermediario/01-Modificadores-de-acesso.md:
--------------------------------------------------------------------------------
1 | # 4.1 Modificadores de acesso
2 |
3 | São palavras-chave que servem para especificar a acessibilidade de um tipo ou membro.
4 |
5 | No C#, temos quatro tipos de modificadores
6 |
7 | - **public**: o acesso ao membro pode ser de qualquer lugar
8 | - **protected**: somente as classes que derivam dela podem acessar o membro
9 | - **internal**: só pode ser acessado de dentro do assembly em que está declarado
10 | - **private**: não pode ser acessado de fora da própria classe
11 |
12 | É possível também utilizar dois tipos em conjunto, como por exemplo:
13 |
14 | - **protected internal**
15 | - **private protected**
16 |
17 | A omissão do modificador de acesso na declaração de uma classe deixará implícito que o acesso será do tipo **internal**.
18 |
19 | ```cs
20 | // O tipo de acesso será do tipo internal
21 | class Aluno
22 | {
23 | }
24 | ```
25 |
26 | A omissão do modificador de acesso na declaração de um membro deixará implícito que o acesso será do tipo **private**.
27 |
28 | ```cs
29 | public class Aluno
30 | {
31 | // O tipo de acesso deste método será private
32 | void CalcularNota()
33 | {
34 | }
35 | }
36 | ```
37 |
--------------------------------------------------------------------------------
/docs/4-Intermediario/02-Classes.md:
--------------------------------------------------------------------------------
1 | # 4.2 Classes
2 |
3 | As classes em uma linguagem orientada a objetos, no caso o C#, podem ser pensadas como um template para o que um objeto deveria ser.
4 |
5 | Representa um conjunto de propriedades ou métodos que são comuns para o objeto que está sendo pensado.
6 |
7 | Uma classe básica pode ser declarada do seguinte modo:
8 |
9 | ```cs
10 | // [modificador de acesso] - [palavra chave 'class'] - [nome da classe]
11 | public class Pessoa
12 | {
13 | }
14 | ```
15 |
16 | ## Construtor
17 |
18 | É basicamente o método que é chamado ao se instanciar uma classe. Serve para iniciar a classe com os dados básicos necessários para executar sua tarefa.
19 |
20 | Os parâmetros são opcionais, podendo se instanciar a classe sem nenhum dado passado para ela.
21 |
22 | Caso não se declare o construtor, ficará implícito que a classe contem um construtor padrão, sem nenhum parâmetro.
23 |
24 | É possível declarar múltiplos construtores com parâmetros diferente em uma mesma classe.
25 |
26 | ```cs
27 | public class Pessoa
28 | {
29 | // Construtor padrão
30 | public Pessoa()
31 | {
32 | }
33 |
34 | // Construtor com 1 parâmetro
35 | public Pessoa(string nome)
36 | {
37 | }
38 |
39 | // Construtor com 2 parâmetros
40 | public Pessoa(string nome, int idade)
41 | {
42 | }
43 | }
44 | ```
45 |
46 | ## Classes Estáticas
47 |
48 | A inclusão da palavra chave `static` na declaração da classe define que ela não poderá ser instanciada e todos os membros (métodos, propriedades) também deverão ser estáticos. De resto, é basicamente uma classe comum.
49 |
50 | ```cs
51 | // Definição da classe
52 | public static class Pessoa
53 | {
54 | }
55 | ```
56 |
57 | Para chamar uma classe estática, é necessário utilizar seu nome, como no exemplo abaixo:
58 |
59 | ```cs
60 | // [nome da classe].[metodo|propriedade]
61 | Pessoa.MetodoQualquer();
62 | ```
63 |
64 | ## Construtores estáticos
65 |
66 | São utilizados para inicializar dados estáticos na classe, ou para executar alguma ação que precisa ser executada apenas uma vez.
67 |
68 | Os construtores estáticos são chamados antes de qualquer construtor da instância ou membro é acessado.
69 |
70 | Independente da classe ser estática ou não, pode ter somente 1 construtor estático, enquanto uma classe não-estática podem ter quantos construtores de instância forem necessários.
71 |
72 | ```cs
73 | public class Pessoa
74 | {
75 | // campo estático
76 | static readonly int idade;
77 |
78 | // Construtor estático
79 | static Pessoa()
80 | {
81 | idade = 20;
82 | }
83 | }
84 | ```
85 |
86 | ## Classes sealed
87 |
88 | Adicionando a palvra `sealed` em uma classe irá impedir que outras classes possam herdar os atributos e métodos desta classe.
89 |
90 | ```cs
91 | public sealed class Motor
92 | {
93 | }
94 |
95 | public class MotorGasolina : Motor
96 | {
97 | }
98 | ```
99 |
100 | Feito isso caso uma classe deseje extender seus atributos e comportamentos irá ocasionar um erro em tempo de compilação.
101 | O erro que irá aparecer no console será;
102 | `'MotorGasolina': cannot derive from sealed type 'Motor'`
103 |
104 | ## Classes Genéricas
105 |
106 | No C# é possível realizar a criação de classes genéricas, que podem utilizam parâmetros especificados em sua assinatura, exigindo que o parâmetro passado para a classe seja de determinado tipo ou não.
107 | Neste caso abaixo veremos uma especificação genérica que não exige nenhuma herança da classe que for passada por parâmetro.
108 |
109 | ```cs
110 | // Definição de um tipo genérico é dado geralmente entre
111 | public class Motor
112 | {
113 | Ligar(TCombustivel combustivel) { }
114 | }
115 | // Abaixo ele estará passando como parâmetro para a classe `Motor` que espera algum parâmetro que o tipo esperado é a classe Gasolina
116 | public class MotorGasolina : Motor
117 | {
118 | }
119 | ```
120 |
121 | No exemplo abaixo, será exigido que todo o parâmetro passado abaixo deverá conter a herança da classe `Combustivel`. Dentro da classe motor será possível manipular todos os atributos e métodos que forem definidos na classe que for exigida como parametro de entrada que no nosso caso é a `Combustivel`.
122 |
123 | ```cs
124 | // Também é possível exigir que a classe que for passada por parâmetro siga uma pré-definição ou seja, que ela derive de uma herança.
125 | public class Combustivel
126 | {
127 | public string TipoCombustivel { get; set; }
128 | }
129 | // Abaixo a criação de uma classe que exige quem for passado por parâmetro tenha uma herança de Combustivel
130 | public sealed class Motor where TCombustivel : Combustivel
131 | {
132 | Ligar(TCombustivel combustivel)
133 | {
134 | //Aqui poderá manipular os atributos da classe combustivel
135 | Console.WriteLine(combustivel.TipoCombustivel);
136 | }
137 | }
138 | ```
139 |
--------------------------------------------------------------------------------
/docs/4-Intermediario/03-Recods.md:
--------------------------------------------------------------------------------
1 | # 4.3 Records
2 |
3 | Record é um novo tipo de dado introduzido a partir do C# 9. Os records são imutáveis o que significa que uma vez que o objeto é instanciado passandos os dados no seu construtor, esses não podem mais ser alterados. Assim como classes o record possue herança e para podermos criar uma record devemos utilizar a palavra reservada `record` da mesma forma como criamos classes e structs.
4 |
5 | ```cs
6 | public record Pessoa
7 | {
8 | public string Nome {get; init;}
9 | public int Idade {get; init;}
10 |
11 | public Pessoa(string nome, int idade)
12 | {
13 | Nome = nome;
14 | Idade = idade;
15 | }
16 | }
17 | ```
18 | Também podemos abreviar a criação de records da seguinte forma.
19 |
20 | ```cs
21 | public record Pessoa(string Nome, int Idade)
22 | ```
23 |
24 | O código acima é equivalente do primeiro exemplo, dessa forma já declaramos o contrutor automáticamente e por padrão quando criamos um record utilizando essa sintaxe curta, o record é iniciado com a propriedade `init` que iremos falar em seguida.
25 |
26 | ## Propriedade init e expressão with
27 |
28 | Como mencioado no início o record é imutável. Por padrão os records utilizam a propriedade `init` que funciona como instrução única, uma vez passado um valor este valor não pode ser alterado, se tentarmos alterar o valor após instanciar o objeto recebemos a seguinte mensagem de error
29 |
30 | ```cs
31 | public record Pessoa(string Nome, int Idade);
32 |
33 | var pessoa1 = new Pessoa("Larissa", 27);
34 | pessoa1.Idade = 32; // 'Pessoa.Idade' só pode ser atribuído em um inicializador de objeto.
35 | ```
36 |
37 | Certo, mas se record são imutáveis como alteramos o valor?
38 |
39 | Com o C# 9 recebemos a expressão `with`. O with permite criar uma cópia de um objeto e alterar o valor das propriedades do objeto copiado.
40 |
41 | ```cs
42 | public record Pessoa(string Nome, int Idade);
43 |
44 | var pessoa1 = new Pessoa("Larissa", 27);
45 |
46 | // nome Maia e idade 27
47 | var pessoa2 = with pessoa1 { Nome = "Maia" };
48 | ```
49 | No exemplo todas as propriedades de `pessoa1` foram copiadas para `pessoa2` mas o nome alteramos para Maia e `pessoa1` não sofreu nenhuma alteração, preservando a imutabilidade.
50 |
51 | ## Igualdade de referência
52 |
53 | Assim como as classes os records representam um conjunto de propriedades e também possuem um tipo de refência, no caso dos records o tipo de referência é por igualidade. Mas o que isso significa?
54 |
55 | Significa que enquanto as classes possuem seus tipos de referência dos seus dados armazenados na memória, os records possuem seus tipos de referência por valor. Na prática podemos observar com o exemplo abaixo onde temos uma classe `Pessoa1` e um record `Pessoa2`:
56 |
57 | ```cs
58 | public record Pessoa1
59 | {
60 | public string Nome {get; init;}
61 | public int Idade {get; init;}
62 |
63 | public Pessoa(string nome, int idade)
64 | {
65 | Nome = nome;
66 | Idade = idade;
67 | }
68 | }
69 |
70 | public record Pessoa2
71 | {
72 | public string Nome {get; init;}
73 | public int Idade {get; init;}
74 |
75 | public Pessoa(string nome, int idade)
76 | {
77 | Nome = nome;
78 | Idade = idade;
79 | }
80 | }
81 | Pessoa1 pessoa1 = new Pessoa1("Adriano", 24);
82 | Pessoa1 pessoa2 = new Pessoa1("Adriano", 24);
83 |
84 | // resultado ao comparar as classes é false
85 | Console.WriteLine(pessoa1==pessoa2);
86 |
87 | Pessoa2 pessoa3 = new Pessoa2("Adriano", 24);
88 | Pessoa2 pessoa3 = new Pessoa2("Adriano", 24);
89 |
90 | // resultado ao comparar os records é true
91 | Console.WriteLine(pessoa3==pessoa4);
92 | ```
93 |
94 | O que acontece é que pessoa1 e pessoa2 possuem endereços diferentes na memória, então mesmo se tiverem propriedades iguais o resultado será `false` ao comparar. Por outro lado os records por ter seu tipo de referência por igualidade ao comparar duas instanciasa de records se os seus respectivos valores das propriedades forem iguais o resultado é ao realizar a comparação é `true`. Essa comparação por igualidade se dá atráves do metódo `Equals`
95 |
96 | ## Quando usar Record?
97 |
98 | Records é um ótimo caso de uso quando é preciso comparar objetos, quando queremos garantir que os valores das propriedades de um objeto não possam ser alterados durante a execução de outros processos, copiar dados e usar records como DTO(Data Transport Object).
99 |
100 |
--------------------------------------------------------------------------------
/docs/5-Avancado/01-Colecoes.md:
--------------------------------------------------------------------------------
1 | # 5.1 Coleções
2 |
3 | Classes especializadas para manipulação de dados. São um aprimoramento dos _arrays_ e fornecem uma estrutura robusta para trabalhar com dados em diferentes tipos de cenários.
4 |
5 | Existem 3 tipos de coleções:
6 |
7 | - _Standard_ (Padrão)
8 | - _Generic_ (Genérica)
9 | - _Concurrent_ (Concorrente)
10 |
11 | ### **_Standard_**
12 |
13 | São encontradas dentro do _namespace_ `System.Collections`. Não guardam dados tipados, somente objetos do tipo `Object`. São exemplos de coleções padrão: `ArrayList`, `Hashtable`, `Queue` e `Stack` .
14 |
15 | > **Atenção** :warning: Atualmente é recomendado utilizar as coleções genéricas em `System.Collections.Generic` ou `System.Collections.Concurrent` em vez dos tipos legados em `System.Collections`.
16 |
17 | Existe um _namespace_ chamado `System.Collections.Specialized`, que fornece coleções especializadas e tipadas como coleções _string-only_, _linked-list_ e dicionários híbridos.
18 |
19 | ### _Generic_
20 |
21 | São encontradas dentro do _namespace_ `System.Collections.Generic`. São mais flexíveis e preferidas ao se trabalhar com dados. As coleções genéricas propiciam reuso de código, _type safety_ e performance. São exemplos de coleções genéricas: `Dictionary`, `List`, `Queue`, `SortedList` e `Stack`.
22 |
23 | ### _Concurrent_
24 |
25 | São encontradas dentro do _namespace_ `System.Collections.Concurrent`. São exemplos de coleções concorrentes: `BlockingCollection`, `ConcurrentDictionary`, `ConcurrentQueue` e `ConcurrentStack`.
26 |
27 | Devem ser utilizadas quando for necessária a manipulação de coleções por múltiplas _threads_, pois suas implementações corrigem problemas de concorrência de suas classes correspondentes nos _namespaces_ `System.Collections` e `System.Collections.Generic`.
28 |
29 | ## Interfaces
30 |
31 | Todas as coleções implementam algumas _interfaces_ em comum. Essas _interfaces_ definem as funcionalidades básicas em cada coleção.
32 |
33 | As principais _interfaces_ são: `IEnumerable`, `ICollection`, `IDictionary` e `IList`.
34 |
35 |
36 | 
37 |
38 |
39 | `IEnumerable`: é a base para todos os tipos de coleções. Fornece um enumerador que possibilita iteração simples sob uma coleção não-genérica.
40 |
41 | `ICollection`: define o tamanho, enumeradores e métodos de sincronização para todas as coleções não-genéricas.
42 |
43 | `IDicionary`: representa uma coleção não-genérica de pares de chave-valor.
44 |
45 | `IList`: representa uma coleção não genérica de objetos que podem ser acessados individualmente por índices.
46 |
47 | As interfaces não são implementadas por todas as coleções, depende da natureza da coleção. Por exemplo, a interface `IDictionary` só seria implementada por coleções que faram o uso de pares chave-valor, como _Hashtable_ e _SortedList_.
48 |
49 | ## Principais coleções
50 |
51 | ### **ArrayList**
52 |
53 | Essa coleção se encontra somente no namespace `System.Collections`. Sua classe tipada equivalente é a `List`.
54 |
55 | - Elementos podem ser adicionados e removidos da coleção a qualquer momento.
56 | - Não é garantido de ordenação.
57 | - A capacidade é o número de elementos que a lista pode conter.
58 | - Os índices são baseados no zero, ou seja, o primeiro elemento tem o índice 0.
59 | - Os elementos nessa coleção podem ser acessados utilizando um índice inteiro.
60 | - Permite elementos duplicados.
61 | - A utilização de arrays multidimensionais não é suportado.
62 |
63 | É um array dinâmico. Fornece acesso dinâmico ao seus elementos. Um ArrayList automaticamente se expande quando um dado é adicionado. Ao contrário de arrays, podem guardar múltiplos tipos de dados. Os elementos são acessados por um índice inteiro, que são baseados em zero.
64 |
65 | A indexação, inserção e remoção dos elementos no final da lista leva um tempo constante O(1). Mas inserir e remover elementos no meio do array dinâmico é mais custoso, leva um tempo linear O(n).
66 |
67 | ### **Hashtable**
68 |
69 | - Chaves devem ser únicas e diferentes de nulas.
70 | - Permite valores duplicados e nulos.
71 | - Valores podem ser acessados utilizando a sua chave associada.
72 | - Cada par de chave-valor é armazenado como um objeto _`DictionaryEntry`._
73 |
74 | É uma coleção que armazena pares de chave-valor, ou seja, para cada valor adicionado é obrigatório informar uma chave única que irá servir para identificar o valor na lista.
75 |
76 | **Implementação interna**
77 |
78 | É composto de duas partes: um _array_ (geralmente de lista encadeada) e uma função _Hash_. O _array_ é onde os dados são armazenados e a função _Hash_ ajuda a decidir onde os dados devem ser salvos na memória do computador. O modo que isso funciona é que a função gera um _Hash_ a partir da chave e mapeia para um índice e o valor irá ser inserido naquela posição.
79 |
80 | Um ótimo exemplo que é normalmente utilizado para mostrar como funciona é uma estante que pode ter no máximo 10 livros. Como é um exemplo, podemos supor que o algoritmo de mapeamento do _Hash_ funciona contando a quantidade de caracteres do título do livro para dividir pelo tamanho total da estante.
81 |
82 | Pense da seguinte forma para esse exemplo: O livro "Guerra e Paz" tem 12 caracteres, o que significa que realizar o módulo de 12 % 10 retorna o restante que é 2, e o livro irá para a segunda prateleira da estante. Se pegarmos o livro "Cem Anos de Solidão" que tem 19 caracteres, irá para a nona prateleira e assim por diante.
83 |
84 | Mas essa função de _Hash_ tem um problema, se inserirmos outro livro com 12 caracteres no título a posição será a mesma do primeiro livro, ou seja, segunda prateleira. Isso é o que chamamos de Colisão, quando dois ou mais elementos são hasheados ou mapeados para a mesma posição no _array_. A melhor forma de evitar é utilizar uma função que distribui os elementos uniformemente através da _HashTable_.
85 |
86 | A versão genérica da coleção `Hashtable` é a `Dictionary` que utiliza `KeyValuePair`(chave-valor genérica) para enumeração em vez de `DictionaryEntry`.
87 |
88 | ### **Queue (Fila)**
89 |
90 | - Permite elementos duplicados.
91 | - Aceita `null` como um valor válido a ser inserido.
92 |
93 | É uma coleção que representa uma fila, ou seja, o primeiro a entrar é o primeiro a sair. Quando um elemento é adicionado, entra no final da lista. Quando um elemento é removido, será sempre o primeiro da lista. Essa coleção é implementada como uma matriz circular.
94 |
95 | As principais operações que podemos executar em uma fila são as seguintes:
96 |
97 | - Enqueue: adiciona um elemento no final da fila.
98 | - Dequeue: remove o primeiro elemento da fila.
99 | - Peek: retorna o elemento mais antigo da fila, ou seja, o que está na primeira posição. Mas não o remove igual ao comando _Dequeue_.
100 |
101 | ### **Stack (Pilha)**
102 |
103 | - Permite elementos duplicados.
104 | - Aceita `null` como um valor válido a ser inserido.
105 |
106 | É uma coleção que representa uma pilha, ou seja, o ultimo a entrar é o primeiro a sair. Quando um elemento é adicionado, entra no final da lista. Quando um elemento é removido, será também o último da fila.
107 |
108 | As principais operações que podemos executar em uma fila são as seguintes:
109 |
110 | - _Push_: adiciona um elemento no final da fila.
111 | - _Pop_: remove o último elemento da fila.
112 | - _Peek_: retorna o elemento mais novo da fila, ou seja, o que está na última posição. Mas não o remove igual ao comando _Pop_.
113 |
114 | ### **List**
115 |
116 | É uma coleção que pertence ao _namespace `System.Collections.Generic`._ Equivale à classe `ArrayList`, mas fortemente tipada.
117 |
118 | - Os elementos são acessados por índices, que começam em zero.
119 | - Só pode conter elementos do tipo especificado em sua inicialização.
120 | - São mais rápidas do que o `ArrayList` e menos suscetíveis a erros.
121 | - Aceita `null` como um valor válido a ser inserido para tipos de referência.
122 | - Aceita valores duplicados.
123 | - Aumenta a capacidade dinamicamente.
124 |
125 | Fornece múltiplos métodos de ordenação, procura e outros para a manipulação de seus elementos, o que facilita bastante seu uso em cenários diversos.
126 |
127 | A lista não é ordenada ao inserir elementos, mas sim após realizarmos manualmente alguma operação como o método interno _Sort_.
128 |
129 | **Implementação interna**
130 |
131 | Quando acessamos um elemento utilizando índices, por debaixo dos panos estamos acessando a propriedade indexadora da lista que se chama `Item[Int32].` Recuperar e definir um valor utilizando essa propriedade são operações O(1).
132 |
133 | Filas e pilhas são recomendadas para quando você precisa de armazenamento temporário, ou seja, será necessário descartar o valor após lê-lo. Use fila quando precisa ler os valores na mesma ordem em que são adicionados na coleção e pilha quando precisar ler a informação na ordem inversa. Se for necessária a leitura a partir de várias threads simultâneas, utilize a coleção `ConcurrentQueue` ou `ConcurrentStack`.
134 |
135 | **É possível ver as notações Big-O de diferentes estruturas de dados e algoritmos no link a seguir: [https://www.bigocheatsheet.com/](https://www.bigocheatsheet.com/)**
136 |
137 | ## Thread-Safe
138 |
139 | As coleções Standard `ArrayList` e `Hashtable` por exemplo fornecem uma pequena implementação _thread-safe_ através da propriedade `Syncronized`, que retorna um _wrapper thread-safe_ em torno da coleção. O _wrapper_ funciona bloqueando a coleção inteira em cada operação de escrita e remoção. Então, cada _thread_ que tenta acessar a coleção deve aguardar sua vez para pegar obter a permissão de bloqueio. O problema é que isso não é escalável e pode causar problemas de performance se utilizarmos listas com uma enorme quantidade de elementos. Esse design também não é totalmente protegido de _race conditions_ (falha em um sistema ou processo em que o resultado do processo é inesperadamente dependente da sequência ou sincronia doutros eventos).
140 |
141 | Algumas das coleções concorrentes no namespace `System.Collections.Concurrent` utilizam mecanismos leves de sincronia como _SpinLock, SpinWait, SemaphoreSlim e CountdownEvent_ que foram introduzidos no .NET Framework 4. Esses tipos de sincronização utilizam _busy spinning_ por breves períodos antes de colocarem a thread em um estado de _true Wait._ Quando os tempos de espera são esperados serem curtos, _spinning_ é muito menos computacionalmente custoso do que esperar(_waiting_), que envolve uma transição de _kernel_ que geralmente é custosa. Para classes de coleção que utilizam _spinning,_ essa eficácia significa que multiplas _threads_ podem adicionar e remover itens em uma taxa muito alta. As classes `ConcurrentQueue` e `ConcurrentStack` não utilizam _locks._ Em vez disso, elas utilizam operações interligadas (_Interlocked operations_) para alcançar a _thread safety_.
142 |
--------------------------------------------------------------------------------
/docs/5-Avancado/02-Delegates.md:
--------------------------------------------------------------------------------
1 | # 5.2 Delegates
2 |
3 | Um delegate é uma referência a um método com a mesma assinatura, ou seja, podemos chamar métodos através de delegates desde que seu tipo de retorno e seus parâmetros sejam convergentes.
4 |
5 | Declaração de um delegate:
6 |
7 | - _public delegate void MyDelegate();_
8 | Onde _void_ é o tipo de retorno e _MyDelegate_ é o nome do delegate.
9 |
10 | ### Instanciação de um delegate
11 |
12 | Para instanciar um delegate, o método em que o delegate irá referenciar, precisa ser passado como parâmetro, exemplo:
13 |
14 | - _MyDelegate delegate1 = new MyDelegate(método);_
15 |
16 | ### Chamada do delegate
17 |
18 | Para chamar o delegate, apenas digite o nome do objeto instanciado adicionando os parênteses na frente.
19 |
20 | - _delegate1();_
21 |
22 | ## Exemplos
23 |
24 | - _Delegate sem retorno e sem parâmetros_
25 |
26 | ```csharp
27 | using System;
28 |
29 | namespace testes
30 | {
31 | class Program
32 | {
33 | //Delegate
34 | public delegate void MyDelegate();
35 |
36 | //Metodo
37 | static void Print()
38 | {
39 | Console.WriteLine("Olá, mundo!");
40 | }
41 | static void Main(string[] args)
42 | {
43 | //Instanciando um delegate
44 | MyDelegate delegate1 = new MyDelegate(Print);
45 |
46 | //Chamando o delegate
47 | delegate1();
48 | }
49 | }
50 | }
51 | ```
52 |
53 | - _Delegate sem retorno e com parâmetros_
54 |
55 | ```csharp
56 | using System;
57 |
58 | namespace testes
59 | {
60 | class Program
61 | {
62 | //Delegate
63 | public delegate void MyDelegate(string messagem);
64 |
65 | //Metodo
66 | static void Print(string msg)
67 | {
68 | Console.WriteLine(msg);
69 | }
70 | static void Main(string[] args)
71 | {
72 | //Instanciando um delegate
73 | MyDelegate delegate1 = new MyDelegate(Print);
74 |
75 | //Chamando o delegate e atribuindo a uma variavel local
76 | delegate1("Olá, mundo!");
77 | }
78 | }
79 | }
80 | ```
81 |
82 | - _Delegate com retorno e com parâmetros_
83 |
84 | ```
85 | using System;
86 |
87 | namespace testes
88 | {
89 | class Program
90 | {
91 | //Delegate
92 | public delegate int MyDelegate(int numero1, int numero2);
93 |
94 | //Metodo
95 | static int Area(int n1, int n2)
96 | {
97 | return n1 * n2;
98 | }
99 | static void Main(string[] args)
100 | {
101 | int x = 10;
102 | int y = 5;
103 | int resultado = 0;
104 |
105 | //Instanciando um delegate
106 | MyDelegate delegate1 = new MyDelegate(Area);
107 |
108 | //Chamando o delegate e atribuindo a uma variavel local
109 | resultado = delegate1(x, y);
110 |
111 | //Exibindo no console a saída do método apontado pelo delegate
112 | Console.WriteLine(resultado);
113 | }
114 | }
115 | }
116 | ```
--------------------------------------------------------------------------------
/docs/5-Avancado/03-Threads.md:
--------------------------------------------------------------------------------
1 | # 5.3 Threads
2 |
3 | Um thread é um pequeno conjunto de instruções projetadas para serem agendadas e executadas pela CPU independentemente do processo pai.
4 | Por exemplo, um programa pode ter uma thread aberta esperando a ocorrência de um evento específico ou executando uma tarefa separada, permitindo que o programa principal execute outras tarefas.
5 | Um programa é capaz de ter vários threads abertos ao mesmo tempo e os encerra ou suspende depois que a tarefa é concluída ou o programa é fechado.
6 |
7 | ### Instanciação de um Thread
8 |
9 | Exemplo Para instanciar um Thread:
10 |
11 | - _var thread1 = new Thread(NovoMétodoThread);_
12 | _NovoMétodoThread_ é um método que vai ser rodado em outro thread em primeiro ou segundo plano
13 |
14 | ### Chamada do Thread
15 |
16 | Para rodar o Thread, apenas digite o nome do objeto instanciado adicionando .Start os parênteses na frente.
17 |
18 | - _thread1.Start();_
19 |
20 | ### Exemplos de código
21 |
22 | - _Thread trabalhando em algo em segundo plano_
23 |
24 | ```cs
25 | using System;
26 | using System.Threading;
27 |
28 | public class ExamploThread
29 | {
30 | private static void ProcessamentoEmThread()
31 | {
32 | for (int i = 0; i < 10; i++)
33 | {
34 | Console.WriteLine("Thread em segundo plano: {0}", i);
35 | Thread.Sleep(100);
36 | }
37 | }
38 |
39 | public static void Main()
40 | {
41 | Console.WriteLine("Thread Principal: Inicia um segundo Thread.");
42 |
43 | //Passamos o método ProcessamentoEmThread para que seja rodado em um outra linha de processamento
44 | var thread1 = new Thread(ProcessamentoEmThread);
45 |
46 | //Iniciamos o processamento do método
47 | thread1.Start();
48 |
49 | for (var i = 0; i < 4; i++)
50 | {
51 |
52 | Thread.Sleep(1000);
53 | //Se manter em 0 o tempo para a thread principal rodar, vai ver que
54 | //Ambos vão estar trabalhando ao mesmo tempo e em muitas vezes os textos se misturam
55 | //Tanto os da principal e a secundária
56 | Console.WriteLine("Thread Principal: Fazendo Algo.");
57 | }
58 |
59 | Console.WriteLine(
60 | "Thread Principal: Use Join(), Para que o processo principal aguarde o processamento em segundo plano.");
61 | thread1.Join();
62 | Console.WriteLine("Thread Principal: O thread em segundo plano retornou e tudo foi encerrado.");
63 | Console.ReadLine();
64 | }
65 | }
66 | ```
67 | Podemos entender com o seguinte gráfico:
68 | ```mermaid
69 | gantt
70 | dateFormat HH:mm:ss
71 | axisFormat %H:%M:%S
72 | Inicio execução : milestone, 00:00:00, 00:00:00
73 | section Main
74 | Processo : 00:00:00, 00:01:02
75 | FazendoAlgo : 00:00:31, 00:01:01
76 | Aguardando chamar threads :a1, 00:00:00, 00:00:01
77 | Aguardando retorno dos threads : 00:01:01, 00:01:02
78 | section Threads
79 | ThreadSegundoPlano :after a1, 00:00:30
80 | Fim execução : milestone, 00:01:02, 00:01:02
81 | ```
82 |
--------------------------------------------------------------------------------
/docs/5-Avancado/04-Performance.md:
--------------------------------------------------------------------------------
1 | # 5.4 Performance
2 |
3 | Hoje no mundo da programação temos diversos problemas que conseguimos resolver de maneiras variadas. Mas já pensou em qual cenário sua aplicação ganharia desempenho? Será que utilizar função X é melhor que a função Y ? A biblioteca Benchmark.NET, nos dá uma gama de resultados que conseguimos mensurar o desempenho de cada parte do nosso código.
4 |
5 | ## **Cases**
6 |
7 | ### **For x Foreach**
8 |
9 | Tanto **_For_** quanto **_Foreach_** servem para percorrer uma coleção. Primeiro vamos entender cada um.
10 |
11 | - **For**: utilizamos quando queremos ter um controle maior sobre a iteração dos elementos. Com ele conseguimos criar regras mais complexa na iteração, pois temos acesso a posição de cada elemento.
12 |
13 | - **Foreach**: visualmente mais simples de usar, normalmente usamos quando queremos percorrer todos os elementos da coleção sem ter a necessidade de ficar se preocupando com a iteração.
14 |
15 | Quais deles é melhor ?
16 |
17 | - Isso depende da sua necessidade. Em termos de desempenho o **_For_** é melhor do que o **_Foreach_**. Mas por quê?
18 |
19 | - R:. Dentro do **_Foreach_** existe algumas validações e ele usa os métodos GetEnumerator() e Next() para poder verificar se existe mais elementos para percorrer, o que acaba degradando o desempenho. Imagem abaixo mostra testes realizados com **_for_**, **_foreach_** e o **_foreach do linq_**. De momento reparemos apenas na coluna **Mean** que foi o tempo levado para realizar as tarefas.
20 |
21 | 
22 |
23 | - Se ficar em dúvida em qual utilizar utilize o seguinte pensamento:
24 |
25 | - Preciso da maior otimização possível no meu código ?
26 | - Se sim, opte pelo **_for_**.
27 | - Se não, utilize o **_foreach_**.
28 | - Vale lembrar que precisamos pensar na legibilidade do nosso código, se onde você está utilizando essa iteração for um lugar sombrio e difícil de dar manutenção como códigos legados, talvez seja uma boa usar o **_foreach_**.
29 |
30 | -------
31 |
32 | ### **Join x StringBuilder x Concatenação x Concat**
33 |
34 | Dentro do C# temos algumas maneiras de trabalhar com texto, são elas:
35 |
36 | - StringBuilder
37 | - Concatenação
38 | - Concat
39 | - Join
40 |
41 | Certo, e quando devo usar cada uma delas ?
42 |
43 | - **Join** é usado quando normalmente você quer adicionar vários textos separados por um caracter.
44 |
45 | ```csharp
46 | var mensagem = string.Empty;
47 | string[] animais = {"cachorro", "gato", "dinossauro", "marmota", "esquilo"};
48 |
49 | mensagem = string.Join(" ", animais);
50 | ```
51 | Nesse caso estou criando um texto com todos os nomes dos animais separados com um espaço que foi definido no primeiro argumento da função Join.
52 |
53 | - **Concatenação** é usado quando precisamos fazer algo simples com texto como por exemplo, mostrar uma mensagem de erro com alguma informação extra vindo de uma variável.
54 |
55 | ```csharp
56 | var mensagemBase = "Houve um erro ao gravar a informação. ";
57 | var mensagemErro = "A informação X não pode ser nula";
58 |
59 | var mensagemFinal = mensagemBase + mensagemErro;
60 |
61 | ```
62 | ou poderiamos usar a interpolação
63 |
64 | ```csharp
65 | var mensagemBase = "Houve um erro ao gravar a informação. ";
66 | var mensagemErro = "A informação X não pode ser nula";
67 |
68 | var mensagemFinal = $"{mensagemBase} {mensagemErro}";
69 |
70 | ```
71 |
72 | - **Concat** é quando temos um array de string, podendo ser uma lista ou um array mesmo e queremos tornar essa lista em uma string.
73 |
74 | ```csharp
75 | IEnumerable lista = new List() { "Testando ", "a ", " função", " Concat."};
76 | string mensagem = string.Concat(lista);
77 | Console.WriteLine(mensagem);
78 |
79 | /*
80 | Retorno: Testando a função Concat.
81 | */
82 | ```
83 | **E por último, a cereja do bolo**
84 |
85 | - **StringBuilder** é usado para concatenar strings e essa classe vem com algo diferenciado para concatenação, mas primeiro vamos entender a diferença entre usar o StringBuilder e uma concatenação por exemplo:
86 |
87 | Quando fazemos o código abaixo
88 |
89 | ```csharp
90 | var texto = texto + "qualquer mensagem";
91 | ```
92 | estamos realizando algo perigoso dependendo na onde fazemos e se você pensou que o C# substituiu o valor anterior da varíavel pelo texto que adicionamos você acabou esquecendo um conceito importante chamado IMUTABILIDADE. Strings são imutáveis, ou seja, uma vez criada não pode ser alteradas, elas só podem ser alteradas criando um novo objeto na memória e descartando o valor anterior. Então imagina o seguinte cenário onde estamos dentro de um **FOR** percorrendo 100 vezes e nessas 100 vezes estamos fazendo o código acima, quanta memória não alocamos para fazer o processo não é mesmo?
93 |
94 | Peço que olhe com carinho os Method **ConcatenaçãoManual**, **StringBuilder**, **ConcatenacaoManualFor1000Elementos** e **StringBuilderFor1000Elementos**
95 |
96 | Perceba que ConcatenaçãoManual e StringBuilder não há uma diferença grande, o teste realizado foi feito com poucas strings, mas agora repare em ConcatenacaoManualFor1000Elementos e StringBuilderFor1000Elementos que foi utilizado uma repetição de 1000x adicionando texto. Olhe a diferença colossal de memória alocada com a concatenaçãoManual em um **FOR** e usando o StringBuilder.
97 |
98 | Mas ai pode surgir aquela pergunta, o que o StringBuilder tem de diferente da concatenação?
99 | R:. Ele não cria um novo objeto a cada atribuição e sim expande dinamicamente a memória para caber mais strings, ou seja, não fica criando vários objetos que serão descartados rapidamente e sem contar que isso custa também para o Garbage Collection matar esses objetos.
100 |
101 | Quando devo usar o StringBuilder ?
102 | R:. Utilize o StringBuilder quando tiver que trabalhar com muito texto, como por exemplo geração de arquivo ou algo que envolva muito volume. Se for trabalhar com pouco texto utilize uma das funções citadas anteriormente, **MAS LEMBRE-SE, UTILIZE STRINGBUILDER COM GRANDES VOLUMES DE TEXTO**
103 |
104 | 
105 |
106 | -------
107 |
108 | ### **Lista vazia**
109 |
110 | Hoje para podermos validar se uma lista está preenchido temos algumas funções que realizam isso pra gente. Vamos ver quais são eles:
111 |
112 | - Propriedade Count
113 | - Método Count (disponibilizado pelo linq)
114 | - Any (disponibilizado pelo linq)
115 | - FirstOrDefault (disponibilizado pelo linq)
116 |
117 | Abaixo vemos que a propriedade que Count que existe na lista é a campeã, porque a cada remoção e adição de um elemento na lista ela incrementa ou decrementa nessa propriedade.
118 |
119 | 
120 |
121 | Já as demais maneiras como Count(), Any() e FirstOrDefault() há mais validações e chamadas de métodos como GetEnumerator() e MoveNext() o que gera o uso de recursos levando mais tempo. Então se caso precisar validar se a lista está vazia, opte para a propriedade que há na lista.
122 |
123 |
124 |
--------------------------------------------------------------------------------
/docs/6-Referências/01-Referências.md:
--------------------------------------------------------------------------------
1 | # 6.1 Referências
2 |
3 | ## Sites com dicas/informações sobre em C#
4 |
5 | - [Documentação Oficial da Microsoft](https://docs.microsoft.com/pt-br/dotnet/csharp/)
6 |
7 | - [Macoratti](http://www.macoratti.net/pageview.aspx?catid=18)
8 |
9 | - [Tutorialspoint - Em inglês](https://www.tutorialspoint.com/csharp/index.htm)
10 |
11 | ## Dicas de como configurar a interface de programação
12 |
13 | - [Como programar em C# no VSCode](https://code.visualstudio.com/Docs/languages/csharp)
14 |
15 | - [Como programar em C# no Visual Studio](https://docs.microsoft.com/pt-br/visualstudio/get-started/csharp/?view=vs-2019)
16 |
17 | - [Como programar em C# no Linux](https://pt.stackoverflow.com/questions/125949/alternativas-para-desenvolver-em-c-no-linux)
18 |
19 | ## Canais com dicas, cursos e conteúdo sobre c# .NET
20 |
21 | - [Canal oficial do .NET](https://www.youtube.com/c/dotNET)
22 |
23 | - [Nick chapsas](https://www.youtube.com/channel/UCrkPsvLGln62OMZRO6K-llg)
24 |
25 | - [Les Jackson](https://www.youtube.com/c/binarythistle)
26 |
27 | - [Macoratti](https://www.youtube.com/channel/UCoqYHkQy8q5nEMv1gkcZgSw)
28 |
29 | - [Balta.io](https://www.youtube.com/c/baltaio)
30 |
31 | - [PatrickGod](https://www.youtube.com/c/PatrickGod)
32 |
--------------------------------------------------------------------------------
/docs/README.md:
--------------------------------------------------------------------------------
1 | # ROADMAP
2 |
3 | - [1 - Introdução](/docs/1-Introdução)
4 | - [1.1 - Boas-vindas](/docs/1-Introdução/1-Boas-vindas.md)
5 | - [2 - Ambiente](/docs/2-Ambiente)
6 | - [2.1 - Editores](/docs/2-Ambiente/1-Editores.md)
7 | - [2.2 - Sistemas Operacionais](/docs/2-Ambiente/2-Sistemas-Operacionais.md)
8 | - [2.3 - Windows](/docs/2-Ambiente/3-Windows.md)
9 | - [2.4 - Linux](/docs/2-Ambiente/4-Linux.md)
10 | - [2.5 - MacOS](/docs/2-Ambiente/5-MacOS.md)
11 | - [2.6 - Online](/docs/2-Ambiente/6-Online.md)
12 | - [3 - Básico](/docs/3-Básico)
13 | - [3.1 - Declaração de variáveis](/docs/3-Básico/01-Declaração-de-variáveis.md)
14 | - [3.2 - Tipos de variáveis](/docs/3-Básico/02-Tipos-de-variáveis.md)
15 | - [3.3 - Entrada e saida](/docs/3-Básico/03-Entrada-e-saida.md)
16 | - [3.4 - Operadores aritméticos](/docs/3-Básico/04-Operadores-aritméticos.md)
17 | - [3.5 - Operadores lógicos](/docs/3-Básico/05-Operadores-lógicos.md)
18 | - [3.6 - Instruções condicionais](/docs/3-Básico/06-Instruções-condicionais.md)
19 | - [3.7 - Estruturas de repetição](/docs/3-Básico/07-Estruturas-de-repetição.md)
20 | - [3.8 - Funções](/docs/3-Básico/08-Funções.md)
21 | - [3.9 - Tratamento de exceções](/docs/3-Básico/09-Try-catch.md)
22 | - [3.10 - Conversões de tipos](/docs/3-Básico/10-Conversão-de-tipo.md)
23 | - [3.11 - Enum](/docs/3-Básico/11-Enum.md)
24 | - [3.12 - Tipos anuláveis](/docs/3-Básico/12-Nullable.md)
25 | - [3.13 - Arrays](/docs/3-Básico/13-Arrays.md)
26 | - [3.14 - Namespaces](/docs/3-Básico/14-Namespace.md)
27 | - [4 - Intermediário](/docs/4-Intermediario) 
28 | - [4.1 - Modificadores de acesso](/docs/4-Intermediario/01-Modificadores-de-acesso.md)
29 | - [4.2 - Classes](/docs/4-Intermediario/02-Classes.md)
30 | - [4.3 - Records](/docs/4-Intermediario/03-Records.md)
31 | - [5 - Avançado](/docs/5-Avancado)
32 | - [5.1 - Coleções](/docs/5-Avancado/01-Colecoes.md)
33 | - [5.2 - Delegates](/docs/5-Avancado/02-Delegates.md)
34 | - [5.3 - Threads](/docs/5-Avancado/03-Threads.md)
35 | - [5.4 - Performance](/docs/5-Avancado/04-Performance.md )
36 |
37 | - [6 - Referências](/docs/6-Referências)
38 |
--------------------------------------------------------------------------------
