C#

É uma linguagem de alto nível, compilada e fortemente tipada (eu preciso informar o tipo da
variável).

 int => 32-bit

 float => 32 bit
 double => 64 bit
 decimal => 128 bit

Foi criada por Anders Hejsberg em meados de 2001. Ele também criou o Delphi e o Typescript
(superset do JavaScript). Antes ele trabalhava na Borland. Nessa época a principal linguagem
da Microsoft era o Visual Basic. Atualmente a principal linguagem da Microsoft é o C#.

Característica do C#

 Linguagem completa (aplicações Web, aplicações Desktop, aplicações mobile, Machine

Learning, Data Science, games (Unity). Faz parte de um ecossistema
 Maturidade. Nasceu em 2001. Base de dados sobre erros.
 Mercado. Em expansão. Mercado Enterprise (empresas grandes).
 Comunidade. Muito grande, no mundo todo.
 Aplicabilidade. Muito vasta (web, Windows, mobile)
 Apoio da Microsoft.
 Orientação à Objetos.

É uma linguagem de código gerenciado. Sua execução depende de um gerenciador, também

conhecido como Runtime. No caso de C# o runtime se chama CLR ou CLR Runtime. CRL é a
sigla para Common Language Runtime. Gerencia memória, segurança entre outros recursos
básicos. Permite interagirmos menos ou quase não interagir com recursos de máquina (alocar
memória, liberar memória).

A Microsoft possui outras linguagens além do C#, como o VB.NET, F# e até Cobol.NET. A
Microsoft criou um ecossistema pensando nisso, em podermos utilizar várias linguagens.
Assim ela tem um único gerenciador que é utilizado para várias linguagens. Cada linguagem
tem o seu próprio compilador que faz uma compilação inicial, que não gera o código binário,
ele gera um código intermediário e depois é feita a compilação final que irá gerar um arquivo
binário. A compilação inicial gera um código intermediário (Intermediate language – IL).

Embora as compilações sejam diferentes, o gerenciamento é igual (alocação de memória,

execução de instruções no processador).

O CLR recebe um código (C#) e compila para IL. O resultado da compilação do IL é sempre o
mesmo.

Código C# => IL => código binário.

JIT – Just in Time (conversão de IL para binário)

Framework é uma estrutura, um alicerce, um conjunto de bibliotecas (ou programas) que

utilizamos como base para construir aplicações. Assim não precisamos começar do zero. A
Microsoft tem o framework dotNET (.Net).
A ideia de um framework é trazer recursos comuns já prontos para serem utilizados (escrita de
arquivos em disco, acesso a um banco de dados, criar um site, aplicação desktop, desenho de
um botão), que já tenham sidos validados e testados, assim pouparemos tempo no
desenvolvimento do nosso software. O .NET nasceu junto com o C# em 2001 portanto temos
muita coisa já pronta. Nos poupa tempo e também reduz o risco, pois tudo já foi testado.

.NET Framework nasceu em 2001. Versões 1.0, 1.1, 2.0, 3.0, 3.5, 4.x (atualmente). Pode ser
instalada side-by-side (uma versão do lado da outra). Só é compatível com o Windows. É
considerado legado (antigo).

.NET Core nasceu em 2015. É uma versão moderno do .NET Framework. Ele veio para suportar
outros sistemas operacionais como Linux e Mac. Suas primeiras versões tinha apenas o básico.
Ele foi totalmente reescrito. Atualmente já tem quase tudo que tinha no .NET Framework. A
versão 3.1 está bem estável. Versões 1.0, 1.1, 2.0, 2.1, 3.0, 3.1. Instalação side-by-side.

.NET Standard. O .NET Framerwork e .NET Core podem coexistir na mesma máquina. Como
garantir que o código que estamos escrevendo será suportado pelos 2 Frameworks? Isso é
feito pelo .NET Standard que garante que tudo que está sendo escrito irá funcionar no .NET
Core e .NET Framework. O .NET Standard não é um framework, é apenas um contrato, uma
definição. Também é chamado de Surface API. O .NET Standard é um conjunto básico de APIs
comuns a todas as implementações do .NET.

Xamarin/Mono é uma implementação .NET para executar aplicativos em todos os principais

sistemas operacionais móveis.
.NET 5 é a unificação dos Frameworks (.NET Core e .NET Framework). O .NET Core chegou no
nível do .NET Framework, não é somente o CORE, portanto não faz mais sentido chama-lo
de .NET Core.

Releases

No .NET Framework não havia uma definição de quando seria lançado uma nova
versão.

No .NET Core, as releases são semestrais. São mais frequentes e a mudanças são
menores.

No .NET 5 as versões serão anuais.

LTS (Long Term Support). Deve-se usar este release pois garante o suporte por mais
tempo. No .NET Core as versões terminadas em 1 serão LTS, por exemplo versão 3.1.

No .NET 5 as versões maiores serão LTS, por exemplo a versão 5.0 será LTS, as versões
5.x não serão LTS.

Versionamento

Versão semântica que é dividida em fases (Alpha, Beta, Release Candidate, Final).
Alpha é muito no início, é um esboço. Beta é uma versão de testes, já está funcionando.
Release Candidate é de fato a candidata para ser a versão final (correção de bugs).

Dividida em três partes (Major, Minor, Patch)

 15.8.2
 0.0.1
 1.0.2-rc1 (release candidate 1)

Major. Pode conter incompatibilidade com versões anteriores. São chamados de Breaking
Changes

Minor. Possui mudanças, mas é totalmente compatível com versões anteriores. Backward
Compatibility

Patch. Correções de bugs e outros itens simples

Alpha. Não se tem certeza de como será o produto, e muito pode mudar. (0.0.1-a1)

Beta. Já tem a ideia da estrutura, mas ainda podem ocorrer alterações (0.0.2-b1)

Release Candidate. Candidato à versão final. (1.0.0-rc1)

Final. Versão final. (1.0.0)

Runtime e SDK

Runtime é necessário para executar as aplicações C# que já foram compiladas. Verificar a

compatibilidade da versão do runtime com a versão do C# que você utilizou para desenvolver
o seu software.
SDK (Software Development Kit). Possui tudo que precisamos para criar aplicações (inclusive o
compilador). Já vem com o Runtime instalado. Não deve ser utilizado em produção (somente
usar o runtime em produção).

Para rodar o .NET Core:

Resumo:
Visual Studio Code é um editor de código como Atom, Sublime, Brackets.

Visual Studio Community (gratuita) que é uma IDE que possui muitos mais recursos que um
editor de código e precisa de um computador com bastante memória.

http://code.visualstudio.com (Mac OS, Windows, Linux)

extensões do VS Code (CTRL-SHIFT-X)

CTRL, => settings

Abrir settings em formato JSON

CTRL SHIFT P => comandos do VS Code

Pesquisar: Theme

Criando um projeto

.Net é um Framework para criar aplicações (web, API, machine learning). Cada aplicação que
iremos criar precisamos identificar o tipo de projeto que terá um resultado final diferente.

 Class Libray
o O resultado final é uma DLL
o Não possui interface
 Console Application
o O resultado é uma aplicação que roda no terminal
o Pode receber dados, esperar input do usuário
 Projeto Web
 Projeto Testes
Isso criar uma estrutura inicial para o programa.

Se você executar o comando dotnet new, ele irá gerar na pasta atual.

No power shell, criar um diretório projetos e dentro dele um diretório teste.

Convenção é sempre criar uma aplicação com a primeira letra em maiúscula (Teste).

D:\projetos\Teste

> dotnet new console

Dir ou ls

Comandos principais do dotNET

O dotnet executa alguns comandos que são baixados do github e executa um comando
chamado dotnet restore.

Verificar no diretório onde você criou a aplicação e verificar se existe um arquivo com a
extensão csproj. Significa que é um projeto C#, o cs significa c sharp.

Se você executar um dotnet restore, ele irá buscar todos os pacotes que a sua aplicação
precisa para ser executada e fazer a instalação. Por isso que na primeira vez que você cria uma
aplicação, o dotnet restore demora um pouco mais. Por exemplo, para escrever em disco
usaremos o System.IO Namespace, para consultar um banco de dados System.Data.SqlClient
Namespace. São pacotes que o dotnet possui.

A primeira coisa que você faz quando pega uma apliacação dotnet é executar um dotnet
restore.

Se você executar o dotnet restore em um diretório que não tenha um arquivo csproj, ocorrerá
um erro.

Para compilar uma aplicação usamos o comando dotnet build.

Outro comando é o dotnet clean que irá limpar todos os arquivos de cache da nossa aplicação.
Uma dica é antes de executar um dotnet build executar um dotnet clean.

E também temos o dotnet run que é para executar a nossa aplicação. Para testar, toda vez que
você cria uma aplicação com dotnet new, já é criada uma aplicação do tipo console de teste
que mostar Hello World!. Basta executar dotnet run.
Variáveis de ambiente.

Estrutura do App
Ir no diretório da aplicação e digitar [code . ] e o VS Code será aberto com essa aplicação. Ou
você pode abrir o VS Code => File => Open Folder.

Os itens necessários para fazer o debug não foram encontrados. Clicar em Yes.

Será gerada uma pasta .vscode.

A pasta bin só apareceu porque executamos o comando dotnet build.

MeuApp.csproj é um arquivo XML.

OutputType de console => Exe.

TargetFramework => netcoreapp3.1 (.net Standard)

Program.cs
Toda aplicação .net sem ser um class library, procura um arquivo Program.cs para ser
executado (dotnet run). Não alterar o nome program.cs.

A pasta obj é utilizada para fazer debug da aplicação.

Debug (depuração)
[CTRL crase] Abre um terminal

Ou usar Terminal => New Terminal

Podemos executar a aplicação em 2 modos: Release

Maximizar o terminal

Executando a aplicação no terminal (dotnet run) automaticamente irá executar o build.

dotnet run executa a aplicação em modo Release (executa a aplicação).

exit fecha o terminal. CTRL C, para a execução do terminal.

O x esconde o terminal.

A lixeira fecha o termnal

Podemos debugar um arquivo .cs

Passando o mouse vemos uma bolinha vermelha do lado esquerdo do código. É o break point
(ponto de pausa). Na execução do seu programa quando chegar nesse ponto ele irá parar a
execução para você verificar alguma coisa (valor das variáveis, por exemplo).

CTRL , para ir no settings e ativar o format on save, que salvará o arquivo com endentação.
Criamos um breakpoint.
Para que o breakpoint funcione temos que executar a aplicação em modo Debug.
Ele parou a execução da aplicação no breakpoint.

Várias opções para continuar a execução da aplicação.

Se você colocar o mouse em cima de uma variável, verá o valor dela.

Do lado esquerdo do Vs Code também conseguimos ver os valores das variáveis.

Continuando a execução da app.

O valor da variável texto mudou de nulo para Testando.

Vai exibir o resultado na tela.

Lembrar que precisamos ter a pasta .vscode para poder fazer o debug.

Se você não tiver esta pasta =>

Clicar em create a launch.json file que isso fará com que a pasta seja criada.

Pode fechar um arquivo json que ele irá abrir.

C# é case sensitive e não Code Sensitive !

Escopo de um programa é tudo o que ele precisa para ser executado.

Importação de um módulo para escrita de arquivos em disco. As importações ficam no começo

do arquivo do nosso programa.

Namespaces são separações lógicas dentro da aplicação. A divisão física fica nos arquivos.
Procura o Program.cs, depois a classe Program, e executa o método Main.

Namespaces

Eu posso ter 2 arquivos com o mesmo nome desde que estejam em pastas diferentes e eles
devem ter namespaces diferentes também. O namespace normalmente tem o mesmo nome
da pasta. Se você tem uma pasta chamada teste, você tem um namespace chamado teste.

Se eu criar uma nova pasta e dentro dela um novo arquivo com o mesmo nome de um arquivo
que está em outra pasta, por exemplo, vou criar uma pasta chamada Teste e dentro dela um
arquivo chamado Program.cs (já existente em outra pasta) e tentar criar um namespace com o
mesmo nome (MeuApp) e criar um classe dentro desse namespace com o mesmo nome de
uma já existente, vou receber um erro.

Pasta Teste

Arquivo Program.cs dentro da pasta Teste

Criei um namespace chamada MeuApp e tentei criar uma classe Program. Vou receber um
erro!

Para resolver isso, alterar o nome do namespace colocando o nome da pasta (sugestão). O
nome do namespace ficará MeuApp.Teste.
O ideal é ter um namespace e uma classe por arquivo, mas o mesmo namespace pode existir
em vários arquivos. Tomar cuidado para não tentar criar classe com o mesmo nome.

Criei um arquivo Teste.cs e dentro dele um namespace MeuApp.Teste.

Toda vez que vamos usar a classe Teste em outro arquivo temos que chamar o namespace.
Para usar a classe Teste no arquivo Program.cs eu coloquei no início do arquivo “using
MeuApp.Teste;”

Using
Para importar um namespace usamos a palavra using. Tudo o que queremos usar no nosso
programa temos que importar (using) sempre no começo do arquivo (recomendado).

Variáveis

Instanciar um objeto ou variável significa cria-lo.

Sempre define o tipo antes do nome da variável.

Se você utiliza var sempre precisa passar um valor inicial. Var é uma forma de evitar de
descrever o tipo da variável.

Não criar variável com nomes que não dizem nada como x, y, z.
Constantes

Não é possível usar constante (const) com var. Utilizar sempre com maiúsculas (convenção).

Palavras reservadas.
Comentários
CTRL K C comenta a linha

CTRL K U descomenta

Tipos de dados primitivos (built-in types)

System

Existe um namespace de nome System.

Byte
8 bits = 1 byte

Sbyte (signed byte)

Números inteiros

U => unsigned
Números reais
O var foi interpretado como inteiro.

Nesse caso o var foi interpretado como double.

Boolean
Boolean true e false sempre em minúsculas.
O var automaticamente reconhece a variável como boolean.

Char

Armazena somente um (1) caracter no formato Unicode (universal). Usar aspas simples!

Não podemos user aspas duplas! Dá erro! Aspas duplas é para cadeira de caracteres.
Com aspas simples fica correto.

O var também reconhece corretamente se a variável é char.

String
Usamos aspas duplas.

No exemplo acima primeiraLetra é uma lista de caracteres com somente um (1) caracter.

Se tentarmos definir uma string e usar aspas simples, ocorrerá um erro.

O sublinhado em vermelho significa erro, em amarelo significa que a variável foi definida,
porém nunca foi utilizada.
Sempre colocar ponto e virgula no final (;).

Sempre que o valor da variável estiver entre aspas duplas, será string, independentemente de
termos informado um número.

Var

Se a variável definida por var, na primeira vez for reconhecida por um tipo, deverá permanecer
com este tipo, não podemos mudar o tipo depois.
A variável idade já foi reconhecida como inteiro (int), portanto não poderá receber uma string,
pois já foi reconhecida e definida como int anteriormente.

Apenas um exemplo que quando seria melhor usar var em vez de indicar o tipo.

A primeira definição é igual a segunda, onde foi utilizado o var. Não é para entender agora,
isso é somente para mostrar que existe utilidade para utilizarmos o var.

A variável aluno, do tipo var, foi identificada como IEnumerable<MeuTipoComplexo>.

Você escreve menos código utilizando var.

Object
O object não possui intellisense (ajuda do VS Code auxiliando na codificação e verificação de
erros).

No var é obrigado a informar um valor na definição da variável.

var idade = 12;

var idade; // ERRO !!!

No caso do object eu posso definir uma variável sem passar um valor inicial;

O object permite mudar de int para float. Object pode ser qualquer coisa.
Cuidado ao usar o object, pois você não tem controle sobre qual informação ele contém.

Nullable types

Void significa vazio, não tem retorno.

Null não tem valor, é vazio.

int? idade = null; // precisa colocar ? depois do tipo)

Dessa forma recebemos mensagem de erro, pois int é non-nullable. Precisamos colocar ?
depois do tipo.
Agora a atribuição foi aceita.

Para conseguir atribuir um valor nulo, eu tenho que definir a variável usando (?).

Alias
Valores Padrão

Conversão Implícita
Atribui um inteiro a um número real.

Tabela que mostra a conversão automática.

Conversão Explícita

Em tempo de compilação o erro não será mostrado, pois não sabemos qual é o valor da
variável (sem tem valores negativos ou não). Podemos ter erro na execução do programa se
for passado um valor negativo para uma variável unsigned.

Parse

O parse sempre espera receber uma string.

Convert
O convert é diferente do parse, pois o parse é uma extensão do tipo. O convert é uma classe.

O convert permite converter vários tipos e não somente o string. É uma vantagem sobre o
parse. O convert pode converter um double, float, boolean ...para tentar converter de um tipo
para outro. Assim como a conversão explícita e o parse, ele vai tentar converter, se ele não
conseguir irá retornar um erro. Esse erro não acontece em tempo de debug, somente será
pego na execução do programa.Fora a conversão implícita, que já vimos antes, todas as outras
conversões trazem um risco para a execução do programa, pois não sabemos se o valor será
convertido ou se receberemos um erro. Tenha muito cuidado na utilização das conversões.

Convertendo tipos no dotnet

Se eu não definir um valor para uma variável int, ela terá por default um valor igual a zero.
Se eu tentar fazer uma variável do tipo int receber uma variável do tipo real(float), vou receber
um erro.

Não consegue fazer uma conversão implícita de float para int.

Fazer o contrário funciona sem problemas (converter um int para float).

Foi feita a conversão implícita, neste caso o valor de real passou a ser 100.0f.

Dessa forma eu forço a conversão de um número real para um número inteiro. É uma
conversão explícita.
Observe uma lâmpada amarela indicando um warning avisando que na execução poderá
ocorrer algum problema nesta conversão.

Mostrando o número inteiro convertido de um real que antes fora convertido implicitamente
de um inteiro.
Agora mostrando um inteiro que foi convertido de um real (25.8f). Ele simplesmente eliminou
o decimal do número e mostrou 25 (não fez arredondamento).

Agora usando o comando Parse que espera receber uma string. Observe que ocorreu um erro,
pois não foi passado uma string e sim um float.
Também existe uma outra forma de fazer a conversão que é o .ToString.Todo objeto tem um
método chamado .ToString que fará a conversão para uma string.

Convertemos um real para strings e em seguida utilizamos o .Parse para converter para int.
fizemos isso pois o .Parse precisa receber um string.

Ou podemos criar uma variável valorReal com o valor de real já convertido para uma string e
depois usar esta variável valorReal como parâmetro do int.Parse. É a mesma coisa do exemplo
anterior, apenas fizemos em duas partes.

Porem aconteceu um erro!

Vamos investigar o que ocorreu.

A variável valorReal está com conteúdo 25.8 e o .Parse não conseguiu converter para int. Este
foi o motivo do erro anterior. Então vamos ter que usar a conversão explícita => (int) real.

Uma outra forma de conversão é o convert.

Escolher a opção desejada (ToInt16, ToInt32..., ToDecimal...). Normalmente se escolhe o
ToInt32.

Para converter para booleano, 0 significa false, qualquer outro valor significa true.

O Convert arredondou para cima, de 25.8 para 26.

Convert.ToBoolean(1) retornou true, pois é diferente de zero.

Apenas para mostra o .Parse funcionando (passamos o valor 255).

Operações Aritméticas
Operadores de Atribuição

Também existe o x++ e o x--. Soma 1 e subtrai 1.

Operadores de comparação.
Utilizando operadores
Operadores Lógicos

Operações condicionais. Retorna true ou false.

Operador condicional IF
Utilizando o IF
Estrutura condicional
Muito if encadeado não é muito bom. É melhor usar o Switch. Não esquecer de usar o break.

Poder ser inteiro, string ...

Se você esquecer de colocar o break, será avisado que você não conseguirá sair do loop.

É comum se chamar uma função na chamada do case.

Exemplo com valor booleano.

bool? => nullable type. Poderá ser true, false ou nulo.

Laços de repetição FOR

Inicialização, condição, incremento

Se tiver somente uma linha depois do for não precisa usar chaves ({}).
Laços de repetição While
O incremento está antes do Console.WriteLine.
Laço de repetição DO

O while checa a condição ANTES de executar e DO primeiro executa e DEPOIS checa a

condição.

O comando do-while deve ser usado sempre que:

 que não soubermos exatamente quantas vezes o laço deve

ser repetido;
 o teste deva ser feito depois da execução de um bloco de
comandos;
 o bloco de comandos deve ser executado pelo menos 1 vez;
Métodos e funções

Um método pode ou não ter um retorno.

A composição do que o método retorna, nome do método e os parâmetros que ele recebe é
chamado de assinatura do método. Podemos ter métodos com o mesmo nome, porém com
assinaturas diferentes (retorno diferente, parâmetros diferentes ...).

Conversão é ter o nome do método sempre começando com a primeira letra da palavra em
maiúscula.
Usar o void pois não retorna nada.

Métodos e funções prática

Não pode ter método dentro de método no C#.

O C# não irá aceitar isso.

Mudamos o MeuMetodo para fora do método main.

Chamando (executando) o MeuMetodo.

Para chamar o MeuMetodo dentro do main, tenho que acrescentar static que significa que não
precisa ser instanciada.
Se eu informar que o método retorna algo, no caso retorna uma string, ele deve ter um
retorno em todas as situações da sua função. No exemplo acima o VS infoma que há um erro,
pois se o código somente tem um return se a condição if for verdadeira, se ela for falsa não
temos um return. Nem todo o cenário do seu código retorna um valor.

Sempre colocar nomes que signifiquem algo.

Ele trouxe os nome e sobrenome grudados.

Coloquei um espaço em branco entre nome e sobrenome.

Se eu quiser que um parâmetro seja opcional, eu devo informar um valor inicial para ele.

Eu não precisei passar a idade, e mesmo assim funcionou.

Mas eu também posso informar a idade.

Saída sem passar a idade e passando a idade=48.

Os parâmetros opcionais sempre tem que ter um valor especificado e devem ser os ÚLTIMOS
parâmetros a serem informados no método. Posso ter vários parâmetros opcionais, mas eles
devem estar por último.

Value types e reference types

Built-in, structs, enums são sempre do tipo Valor.

Garbage collector acessa a memória Heap.

Value types e reference types – Prática

Notamos que os valores de x e y mudaram (32 e 25), pois são variáveis diferentes, y é uma
cópia de x.
Agora usando arrays. Criamos um array como sendo string de duas posições e depois fizemos
arr2 = arr.
Apesar de alterarmos somente o arr, o arr2 também foi modificado pois ele é apenas uma
referência para o arr, não é uma cópia.

Structs.

É um value type, fica no Stack memory. Classes são referenced types.

Estrutura os dados. Sempre em maiúsculas.

É um conjunto de tipos primitivos.

Método não retorna nada e não precisa colocar void e tem o mesmo nome do struct. Não
retorna nada. É executado sempre que o struct é criado (new). É o local ideal para você
inicializar algo.

É preciso passar os valores na criação do struct.

Struct é um tipo de dado.

Structs – Prática

O Struct não é função, então não pode ficar dentro do Main

O structs tem que estar em um escopo fora da classe, pois eles competem com a classe.
Também não pode ficar dentro do Main e nem dentro de uma classe. Ele tem que ficar em um
escopo fora da classe, pois eles competem com a classe. O Struct é do tipo value type e a
classe é do tipo reference. O struct é composto de propriedades e métodos.

Notar que as conversões de nomes são muito importantes. Quando começa com maiúscula,
Price, é uma propriedade. Com p minúsculo (dolar) é um parâmetro. As convenções nos
ajudam a entender/identificar o que se passa no código.

O método construtor é um método que tem o mesmo nome do struct ou classe, só que não
retorna nada. Também não preciso colocar o void na frente do construtor

. Sempre que se cria um método construtor, eu preciso explicitar os parâmetros que ele irá
receber.
Notar que id, name e price na chamada do método construtor Product, estão escritos em
letras minúsculas. As propriedades tem o mesmo nome dos parâmetros (Id e id), mas a gente
sabe que o nome que começa com maiúscula é propriedade e o nome que começa com
minúscula é parâmetro. No caso Id = id, a propriedade Id recebe o parâmetro id.

Para instanciar um struct, utilizamos o var ou o nome do tipo, no caso Product,( Product
mouse = new Product;() ). Sempre temos duas opções: parameterless (não passa nenhum
parâmetro) ou a opção com parâmetros (que criamos no método construtor). Se não
passarmos nenhum parâmetro quando instanciamos o struct, o programa não vai passar
pelo método construtor e os valores Id, Name, Price não receberão nenhum valor. O Id virá
como zero (int), o Price também virá como zero (double) e o Name virá com vazio (string).

Posso usar as propriedades do mouse (mouse.ID, mouse.Name, mouse.Id) como em

Console.WriteLine(mouse.Id);

Se você informar os valores

Você verá os valores impressos na tela.

Eu também posso iniciar sem passar os parâmetros e depois atribuirmos valor a eles.

Agora mostramos o valor 55 do Id do mouse em vez de 1;

Tanto faz colocar o nome to tipo ou colocar var.
using System;

namespace MeuApp2

class Program

static void Main(string[] args)

Product mouse = new Product(1,"Mac",1000.99);

Console.WriteLine(mouse.Id);

Console.WriteLine("."+mouse.Name+".");

Console.WriteLine(mouse.Price);

struct Product

public Product(int id, string name, double price)

Id = id;

Name = name;

Price = price;

public int Id;

public string Name;

public double Price;

public double PriceInDolar(double dolar)

return Price * dolar;

}
VSCODE => /d/Veigar/Git Testes/demo-repo

dotnet new console => para criar uma aplicação do tipo console

dotnet run => para executar o projeto que está aberto no VSCode

Enums – Enumeradores
Eu não preciso consultar uma tabela para saber que Casado é igual a 2. Usamos enum para
facilitar, pois fica mais fácil trabalhar com números do que com strings (Casado, casado,
CASADO...).

O enum também não pode ser criado dentro de uma classe.

using System;
namespace MeuApp2
{
class Program
{
static void Main(string[] args)
{
 Product mouse = new Product(1,"Mac",1000.99, EProductType.Service);
var manutencaoEletrica = new Product(2,"Manutenção Elétrica residencial", 500,
EProductType.Service );

Console.WriteLine(mouse.Id);
Console.WriteLine("."+ mouse.Name+".");
Console.WriteLine(mouse.Price);
Console.WriteLine(mouse.Type);
Console.WriteLine((int) mouse.Type);
}
}
struct Product
{
public Product(int id, string name, double price, EProductType type)
{
Id = id;
Name = name;
Price = price;
Type = type;
}
public int Id;
public string Name;
public double Price;
public EProductType Type;

public double PriceInDolar(double dolar)

{
return Price * dolar;
}
}
enum EProductType
{
Product = 1,
Service =2
}
}
Revisão
If e switch

06 Mão na massa. Criando uma calculadora

Em /d/Veigar/Git Testes

dotnet new console -o Calculator

foi criado um diretório D:\Veigar\Git Testes\Calculator

no VSCode => Open folder =>

serão gerados os arquivos

Clicar em yes

Será gerado a pasta .vscode.

O ”$” antes de um string permite que eu coloque uma variável dentro do texto entre chaves. É
chamado de interpolação de string.

Tenho que colocar v1 +v2 entre parênteses para o C# entender que é uma operação.

“texto “+ (v1 + v2)

Se não colocar o parênteses ele simplesmente mostra os valores de v1 e v2 concatenados.

“texto “+ v1 + v2

// See https://aka.ms/new-console-template for more information

// Console.WriteLine("Hello, World!");

using System;

namespace Calculator
{
class Program
{
static void Main(string[] args)

{
Soma();
Subtracao();
Divisao();
Multiplicacao();
}

static void Soma()

{
Console.Clear();
Console.WriteLine("== Soma ==");

Console.WriteLine("Primeiro Valor:");
float v1 = float.Parse(Console.ReadLine());
Console.WriteLine("Segundo Valor: ");
float v2 = float.Parse(Console.ReadLine());

Console.WriteLine("Valor de v1 + v2: " + (v1 + v2) );

Console.WriteLine($"Resultado da soma é: {v1 + v2}");
Console.ReadKey();
 }
static void Subtracao (){
Console.Clear();
Console.WriteLine("== Subtração ==");
Console.WriteLine("Valor de v1: ");
float v1 = float.Parse(Console.ReadLine());

Console.WriteLine("Valor de v2: ");

float v2 = float.Parse(Console.ReadLine());

Console.WriteLine($"Resultado da Substracao de {v1} e {v2} é {v1 - v2}");

Console.ReadKey();

}
static void Divisao (){
Console.Clear();
Console.WriteLine("== Divisão ==");
Console.WriteLine("Digite o primeiro valor: ");
var v1 = float.Parse(Console.ReadLine());
Console.WriteLine("Digite o segundo valor: ");
var v2 = float.Parse(Console.ReadLine());
var resultado = v1 / v2 ;
Console.WriteLine($"O valor da divisão de {v1} por {v2} é {resultado}");
Console.ReadKey();
}

static void Multiplicacao (){

Console.Clear();
Console.WriteLine("== Multiplicacao");
Console.WriteLine("Digite o primeiro valor: ");
var v1 = float.Parse(Console.ReadLine());
Console.WriteLine("Digite o segundo valor: ");
var v2 = float.Parse(Console.ReadLine());
var resultado = v1 * v2;
Console.WriteLine($"O valor da multiplicação de {v1} por {v2} é {resultado}");

}
}

Menu da aplicação

Mão na massa: Cronômetro.

Dotnet new console -o Stopwatch

/d/Veigar/Git Testes/Calculator
D:\Veigar\Git Testes
Dotnet new console -o Stopwatch

String