C♯, também escrito como C Sharp, é uma linguagem de programação orientada a objetos, fortemente tipada, desenvolvida pela Microsoft como parte da plataforma .NET. A sua sintaxe orientada a objetos foi baseada no C++ mas inclui muitas influências de outras linguagens de programação, como Object Pascal e Java. Fonte (http://pt.wikipedia.org/wiki/C_Sharp).
É recomendável que se faça a leitura do material http://pt.wikipedia.org/wiki/C_Sharp.
Algumas ferramentas, como por exemplo, Unity 3D utiliza a linguagem C# como sintaxe de programação, por ser uma linguagem completamente estruturada.
Utilizando a ferramenta Visual Studio da Microsoft para programação em CSharp, podemos criar uma aplicação em ASP.NET e utilizar o mesmo algoritmo para Windows Forms, Console e até compilação para DLL.
O foco desta matéria não é ensinar a utilização do Visual Studio, e sim apresentar a linguagem, normas além de toda programação, aqui você vai conhecer cada sintaxe no CSharp e entende-la completamente. Será utilizado o Console Application, já que não será necessário ter um Form para apresentação.
Criando o Projeto e entendo o projeto
Crie um novo projeto do Tipo ConsoleApplication, para isto vá até File->New->Project.
Escolha .Net Framework 4,ConsoleApplication, atribua um nome e clique em OK.
Assim que o projeto e criado, no editor de código já é pré-carregado uma série de algoritmos, nele contém:
using – Importa uma biblioteca, sempre por padrão são carregado bibliotecas básicas para funcionamento, nunca importe uma biblioteca se não for utiliza-la;
namespace: Como se fosse um pacote, todas as class que estiverem dentro do mesmo namespace, poderá ser facilmente manipulado.
class: Dentro da class contém um conjunto de métodos e atributos, isto está relacionado a Orientação a Objetos, que não veremos aqui.
Por padrão um método do tipo staticvoid é criado, com o nome Main, este método é o principal do projeto, ele é executado assim que o projeto é executado.
Um método do tipo estático não precisa ser instanciado (new objeto()).
Assim como em todas as linguagens de programação, existem algumas regras quando for atribuir algum nome para variáveis, class dentre outros, estas regras são:
- Não use espaço nem acentuação;
- Não repita um nome no mesmo projeto, como por exemplo uma class chamada produtos e uma outra variável com o mesmo nome;
- Não utilize palavras reservadas.
- Csharp é uma linguagem CaseSensitive, ou seja, ele diferencia caracteres maiúsculas de minúsculas, como por exemplo A e a, preste muita atenção em nomes de métodos.
Palavras reservadas são nomes nativos da linguagem como por exemplo class, using e assim vai, o compilador vai retornar uma sequência de erros. Confira no link abaixo todas as palavras reservadas.
https://msdn.microsoft.com/pt-br/library/x53a06bb.aspx
Sintaxes de entrada e saída
O fluxo de processamento de um algoritmo é: Entrada, Processamento e Saída.
Entrada: Pode ser apresentado por Teclado ou Mouse, por exemplo.
Processamento: Faz a leitura dos dados fornecidos pela Entrada, executa alguma operação.
Saída: Exibe o resultado da operação executada pelo processamento, esta saída pode ser na tela, impressão, E-mail, SMS dentre outros.
Para efetuar a impressão na tela podemos usar dois métodos da classe console, que são:
Console.WriteLine(): Quebra uma linha para imprimir algo na tela, como o nome diz, escreva na linha.
Console.Write(): Imprime algo na tela sem quebrar uma linha.
Para ler um valor digitado pelo usuário, é utilizado o método ReadLine().
Console.ReadLine(): Faz a leitura de uma informação enviada pelo usuário, por padrão retorna uma string (veremos posteriormente).
Por padrão, o modo console faz toda a leitura do fluxo e fecha a operação, se quisermos exibir algo na tela, após imprimir ele fechará o Console, pois provavelmente não haverá nenhuma parada, visando este problema, usamos o método ReadKey(), ele fica esperando pelo pressionamento de qualquer tecla para prosseguir com a operação.
Console.ReadKey(): Espera pelo pressionamento de qualquer tecla para continuar o fluxo do processamento.
Note que estes métodos são escritos com alguns caracteres em maiúscula, este caracteres devem ser respeitados, já que se escrever tudo na minúscula ocorrerá erros.
Comentários
É possível deixar blocos de comentários espalhados pelo algoritmo, estes comentários não aparecerá para o usuário.
Caso queria comentar apenas uma única linha use //, mas caso queria comentar um bloco com mais de uma linha, use /* no início e */ no final.
Logo a frente vamos ver alguns exemplos, pois vamos usar os comentários para deixar algumas explicações.
Variáveis, impressão e leitura
Variáveis são como gavetas, elas servem para armazenar valores, que podem variar seus tipos, assim como temos vários tipos de gavetas reservadas para, colheres, pratos, panos e por ai vai. Na programação variáveis funciona exatamente desta forma, podemos declarar algumas variáveis que vão armazenar seus próprios valores.
Existem vários tipos de variáveis, cada tipo tem sua exclusiva responsabilidade, sendo que podemos fazer a conversão, os principais tipos são:
string: Armazena uma sequência de palavras, como por exemplo “Olá mundo”, obrigatoriamente o valor atribuído deve ficar dentro de aspas.
char: Armazena um único caracteres, como por exemplo ‘v’, obrigatoriamente o valor atribuído deve ficar dentro de apostrofo.
int: Armazena um número inteiro, como por exemplo 1002, 98875.
double: Armazena números quebrados assim como o tipo float (não veremos), como por exemplo 100.2 ou 9874.3.
bool: Armazena apenas dois tipos de valores, que são true ou false (verdadeiro ou falso).
Quando criamos uma variável, dizemos que ela foi declarada, é recomendável que não use o termo criado e sim declarado, e quando definirmos ou associar um valor a uma variável, dizemos que foi atribuído um valor, estas são apenas duas dicas para uma melhor prática.
Vamos ao nosso primeiro exemplo de variáveis, vamos declarar variáveis dos tipos explicados acima e atribuir seus respectivos valores.
Código 01:
string nome = "Gunner Correa";
int ra = 33913;
char sexo = 'F';
double mensalidade = 450.00;
bool aprovado = true;Podemos notar em nosso algoritmo, que a atribuição é feira através do sinal de = (igual) em seguida o valor correspondente ao tipo da variável, como por exemplo, o valor do double tem um . (ponto), podemos também gravar um inteiro no double, mas não o contrário.
Se uma variável for declarada dentro de um bloco de código, ela será visível apenas dentro daquele bloco de código, ou seja, se for declarado uma variável dentro do método Main, nenhum outro método poderá visualizar aquela variável, não se preocupe, veremos isto posteriormente mais detalhado.
Vamos agora, imprimir na tela o valor de nossas variáveis, para isto vamos fazer em duas partes que é exibir um texto e juntar com uma variável, esta junção de texto e variável, chamamos de concatenação, vamos ver nos dois exemplos abaixo.
Código 02:
string nome = "Gunner Correa";
int ra = 33913;
char sexo = 'F';
double mensalidade = 450.00;
bool aprovado = true;
Console.WriteLine("Aluno: \t" + nome);
Console.WriteLine("RA: \t" + ra);
Console.WriteLine("Sexo: \t" + sexo);
Console.WriteLine("Valor: \t" + mensalidade);
Console.WriteLine("Aprov: \t " + aprovado);
Console.ReadKey();Vamos analisar o algoritmo, Console.WriteLine("Aluno: \t" + nome);.
O método WriteLine(), imprime uma string, e assim como vimos sobre as variáveis, valores de string devem ficar dentro de aspas, neste método acontece o mesmo. \t é um caractere Literal, ele adiciona a string uma tabulação, neste caso foi usado para melhor apresentar os valores na tela, ele simula o pressionamento da tecla TAB. O sinal de + (mais) é o que chamamos de concatenação, quando juntamos dois valores, como no exemplo, juntamos “Aluno \t” com a variável nome.
Confira um material sobre caracteres literais em: https://msdn.microsoft.com/en-us/library/aa691087%28v=vs.71%29.aspx
Até agora tudo funcionou normalmente, mas se criamos uma segunda variável chamada de resultado e tentarmos concatenar o RA com o Valor da mensalidade, não será possível, já que a variável resultado está esperando por um valor do tipo string, para isto existem as conversões, vamos usar conversões o tempo todo, em nossos exemplos para ler o que o usuário digita.
Se você leu atentamente a explicação do método ReadLine(), vai se lembrar que ele retorna uma string, então logo já sabemos que será necessário converter o que o usuário digitou para atribuir a um valor a variável do tipo int ou duble...
Para nosso segundo exemplo, vamos imprimir apenas o valor de nossas variáveis.
Código 03:
string nome = "Gunner Correa";
int ra = 33913;
char sexo = 'F';
double mensalidade = 450.00;
bool aprovado = true;
Console.WriteLine(nome);
Console.WriteLine(ra);
Console.WriteLine(sexo);
Console.WriteLine(mensalidade);
Console.WriteLine(aprovado);
Console.ReadKey();
Agora vamos fazer a leitura de informações digitadas pelos usuários, note atentamente o algoritmo abaixo, pois ele contém um erro.
Código 04:
string nome;
int ra;
char sexo;
double mensalidade;
bool aprovado = true;
Console.WriteLine("Insira seu nome: ");
nome = Console.ReadLine();
Console.WriteLine("Insira seu RA: ");
ra = Console.ReadLine();
Console.WriteLine("Insira seu sexo: ");
sexo = Console.ReadLine();
Console.WriteLine("Insira o valor da sua mensalidade: ");
mensalidade = Console.ReadLine();Temos variáveis do tipo double, char e int recebendo valores string, o compilador nem a linguagem permite este tipo de operação, então no próprio editor já é notório erros, sublinhando o local do erro de vermelho ou verde além de exibir um alerta informando que erros durante a compilação.
Neste caso será necessário efetuar a conversão dos dados para que possamos conseguir fazer a atribuição dos valores.
Para efetuar a conversão usamos Convert.To..(), obrigatoriamente devemos informar para que tipo queremos converter, os tipos são:
Convet.ToInt16(), Toint32() ou ToInt64(): Converte um valor para Inteiro;
Convert.ToChar(): Converte um valor para Char;
Convert.ToDouble(): Converte um valor para Double.
Convert.ToString(): Converte um valor para string, podemos também usar, variael.ToString().
Veja o exemplo no código abaixo.
Código 05:
string nome;
int ra;
char sexo;
double mensalidade;
bool aprovado = true;
Console.WriteLine("Insira seu nome: ");
nome = Console.ReadLine();
Console.WriteLine("Insira seu RA: ");
ra = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Insira seu sexo: ");
sexo = Convert.ToChar(Console.ReadLine());
Console.WriteLine("Insira o valor da sua mensalidade: ");
mensalidade = Convert.ToDouble(Console.ReadLine());
Console.WriteLine(nome);
Console.WriteLine(ra);
Console.WriteLine(sexo);
Console.WriteLine(mensalidade);
Console.WriteLine(aprovado);
Console.ReadKey();
No exemplo acima, digitamos corretamente as informações de acordo com o valor de nossa variável, mas como já sabemos, não podemos confiar no usuário, pois ele pode ao invés de digitar M no sexo, digitar Masculino, e isto dispara um erro, interrompe a operação e por ai vai.
Podemos usar o método TryParse() para forçar a conversão, ou seja, mesmo que se o usuário digitar algo errado, ele garante um retorno válido para que não possa ocorrer um erro, se o valor de retorno for um valor válido, então sabemos que tudo ocorreu corretamente.
Veja um exemplo abaixo do mesmo algoritmo acima, porém utilizando TryParse(), tente digitar algum valor inválido para ver o resultado, note que foi utilizado o Caractere Literal \n\n, apenas um \n quebra uma linha, então dois \n quebra duas linhas.
Código 06:
string nome;
int ra;
char sexo;
double mensalidade;
bool aprovado = true;
Console.WriteLine("Insira seu nome: ");
nome = Console.ReadLine();
Console.WriteLine("Insira seu RA: ");
int.TryParse(Console.ReadLine(), out ra);
Console.WriteLine("Insira seu sexo: ");
char.TryParse(Console.ReadLine(), out sexo);
Console.WriteLine("Insira o valor da sua mensalidade: ");
double.TryParse(Console.ReadLine(), out mensalidade);
Console.WriteLine("\n\n");
Console.WriteLine(nome);
Console.WriteLine(ra);
Console.WriteLine(sexo);
Console.WriteLine(mensalidade);
Console.WriteLine(aprovado);
Console.ReadKey();
Até este ponto já sabemos o que é uma variável, para que serve, como utiliza-las, também aprendemos como imprimir valores, ler dados digitados pelo usuário, efetuar conversões e até tratar erros além de alguns outros assuntos.
Apenas por curiosidade, veja como é possível mudar a cor do texto exibido no modo Console.
Código 07:
string nome;
int ra;
char sexo;
double mensalidade;
bool aprovado = true;
Console.ForegroundColor = ConsoleColor.Blue; //Altera a cor para Azul.
Console.Write("Insira seu nome: ");
Console.ForegroundColor = ConsoleColor.Yellow; //Altera a cor para Amarelo
nome = Console.ReadLine();
Console.ForegroundColor = ConsoleColor.Blue; //Altera a cor para Azul.
Console.Write("Insira seu RA: ");
Console.ForegroundColor = ConsoleColor.Yellow; //Altera a cor para Amarelo
int.TryParse(Console.ReadLine(), out ra);
Console.ForegroundColor = ConsoleColor.Blue; //Altera a cor para Azul.
Console.Write("Insira seu sexo: ");
Console.ForegroundColor = ConsoleColor.Yellow; //Altera a cor para Amarelo
char.TryParse(Console.ReadLine(), out sexo);
Console.ForegroundColor = ConsoleColor.Blue; //Altera a cor para Azul.
Console.Write("Insira o valor da sua mensalidade: ");
Console.ForegroundColor = ConsoleColor.Yellow; //Altera a cor para Amarelo
double.TryParse(Console.ReadLine(), out mensalidade);
Console.WriteLine("\n\n");
Console.ResetColor(); //Volta a cor padrão.
Console.WriteLine(nome);
Console.WriteLine(ra);
Console.WriteLine(sexo);
Console.WriteLine(mensalidade);
Console.WriteLine(aprovado);
Console.ReadKey();
Note que o foi digitado o valor 600.00, porém na impressão foi exibido 60000, isto é um grave problema, imagine que foi digitado um boleto no valor de 600.00 e impresso 6000, isto não é tolerável.
Para resolver o problema, basta usarmos, mensalidade.ToString(“n2”);, o N2 respeita as casas decimais.
Código 08:
string nome;
int ra;
char sexo;
double mensalidade;
bool aprovado = true;
Console.ForegroundColor = ConsoleColor.Blue; //Altera a cor para Azul.
Console.Write("Insira seu nome: ");
Console.ForegroundColor = ConsoleColor.Yellow; //Altera a cor para Amarelo
nome = Console.ReadLine();
Console.ForegroundColor = ConsoleColor.Blue; //Altera a cor para Azul.
Console.Write("Insira seu RA: ");
Console.ForegroundColor = ConsoleColor.Yellow; //Altera a cor para Amarelo
int.TryParse(Console.ReadLine(), out ra);
Console.ForegroundColor = ConsoleColor.Blue; //Altera a cor para Azul.
Console.Write("Insira seu sexo: ");
Console.ForegroundColor = ConsoleColor.Yellow; //Altera a cor para Amarelo
char.TryParse(Console.ReadLine(), out sexo);
Console.ForegroundColor = ConsoleColor.Blue; //Altera a cor para Azul.
Console.Write("Insira o valor da sua mensalidade: ");
Console.ForegroundColor = ConsoleColor.Yellow; //Altera a cor para Amarelo
double.TryParse(Console.ReadLine(), out mensalidade);
Console.WriteLine("\n\n");
Console.ResetColor(); //Volta a cor padrão.
Console.WriteLine(nome);
Console.WriteLine(ra);
Console.WriteLine(sexo);
Console.WriteLine(mensalidade.ToString("n2"));
Console.WriteLine(aprovado);
Console.ReadKey();Note que em Sexo foi escrito om M maiúsculo, mas nada impede que o usuário digite com M minúsculo, para isto podemos converter tudo para maiúscula ou minúscula.
Podemos usar o método ToLower() para converter para minúscula e ToUpper() para maiúscula, veja um exemplo abaixo, onde a própria variável recebe um valor alterado para ela mesma, isto não só é permitido mas como o recomendável, já que não precisamos declarar outras.
Código 09:
string nome;
string sobrenome;
Console.Write("Insira seu nome: ");
nome = Console.ReadLine();
Console.Write("Insira seu Sobrenome: ");
sobrenome = Console.ReadLine();
nome = nome.ToUpper();
sobrenome = sobrenome.ToLower();
Console.WriteLine("\n\n");
Console.WriteLine(nome);
Console.WriteLine(sobrenome);
Console.ReadKey();If e else
If e else são estruturas de condição, onde podemos verificar várias ocorrências e o valor de retorno é verdadeiro ou falso, este tipo de estrutura você vai utilizar para o resto de sua vida, caso você não desista de programação.
Sua sintaxe é:
Código 10:
if(condição){
//se a condição for satisfeita...
}else{
//se a condição não for satisfeita...
}As condições suportadas no If são:
== - Se um valor é igual a outro.
!= - Se um valor for diferente de outro.
> - Se um valor for maior que outro.
>= - Se um valor for maior ou igual a outro.
< - Se um valor for menor que outro.
<= - Se um valor for menor ou igual a outro.
Dentro do if executa algo se a condição for verdadeira e o else se a condição for falsa.
Podemos utilizar esta estrutura para infinitas ocorrências, como validar um CPF, verificar se um número é maior que o outro e por ai vai.
Dentro do If, podemos ter várias condições, que são || e &&, onde:
|| - Se uma condição for satisfeita ou outra.
&& - Obrigatoriamente duas condições deverão ser satisfeitas.
Código 11:
int idade = 18;
char sexo = 'M';
if(idade >= 18){
Console.WriteLine("Entrada permitida.");
}else{
Console.WriteLine("Entrada negada.");
}
Console.WriteLine("\n");
if (sexo > 'M')
{
Console.WriteLine("Masculino.");
}
else
{
Console.WriteLine("Feminino.");
}No exemplo acima, foi realizado duas verificação, a primeira se o usuário tem idade para entrar em algum lugar, onde é exigido ser maior ou ter 18 anos, a segunda exibe o sexo do usuário.
Usando a mesma regra acima, vamos verificar agora se o usuário tem 18 anos ou mais e se ele é do sexo masculino.
Código 12:
int idade = 18;
char sexo = 'M';
if (idade >= 18 && sexo > 'M')
{
Console.WriteLine("Entrada permitida.");
}else{
Console.WriteLine("Entrada negada.");
}
Console.WriteLine("\n");
Console.ReadKey();Note que foi usado o && para separar duas condições, podemos também usar || onde uma das duas condições podem ser verdadeiras, se o usuário tiver 18 anos ou for do sexo masculino, então tem acesso.
Veja um exemplo, agora estamos solicitando que o usuário digite sua idade e seu sexo.
Código 13:
int idade;
char sexo;
Console.Write("Qual sua idade? ");
int.TryParse(Console.ReadLine(), out idade);
Console.Write("Qual seu sexo? (m ou f)? ");
char.TryParse(Console.ReadLine(), out sexo);
Console.WriteLine("\n\n");
if (idade >= 18 && sexo > 'M')
{
Console.WriteLine("Entrada permitida.");
}else{
Console.WriteLine("Entrada negada.");
}
Console.WriteLine("\n");
Console.ReadKey();
Switch
Além do If e Else, existe o Switch, que é uma estrutura de decisão, porém ele apenas testa valor iguais, ele tem um proposito diferente do If, então é totalmente errado dizer que o Switch é mais rápido que o If ou o contrário.
A sintaxe do Switch esta apresentada abaixo.
Código 14:
switch(variavel){
case valor1:
//executa
break;
case valor2:
//executa
break;
case valor3:
//executa
break;
default:
//executa
break;
}Dentro de switch() fica a variável que será testada, independentemente de sua tipagem, no case, em valor logo à frente o case, fica o valor a ser testado. O Default é executado quando nenhuma operação é satisfeita.
Vamos solicitar ao usuário o número do curso, que são:
1 – Medicina
2 – Farmácia
3 – Bioquímica
4 – Biomedicina
5 – Veterinária
6 – Biologia
7 – Nutrição
Estes são os cursos válidos, caso o usuário inserir qualquer outro código que não seja estes, exibirá na tela que o curso selecionado está indisponível.
Veja o algoritmo abaixo.
Código 15:
int curso;
Console.WriteLine("##################################");
Console.WriteLine("##############Cursos##############");
Console.ForegroundColor = ConsoleColor.DarkRed;
Console.WriteLine("1 – Medicina-#####################");
Console.WriteLine("2 – Farmácia-#####################");
Console.WriteLine("3 – Bioquímica-###################");
Console.WriteLine("4 – Biomedicina-##################");
Console.WriteLine("5 – Veterinária-##################");
Console.WriteLine("6 – Biologia-#####################");
Console.WriteLine("7 – Nutrição-#####################");
Console.ResetColor();
Console.WriteLine("##################################");
Console.Write("\n\nInsira o código do curso: ");
int.TryParse(Console.ReadLine(), out curso);
Console.Write("\n");
switch (curso)
{
case 1:
Console.WriteLine("Curso: Medicina.");
Console.WriteLine("Duração: 6 anos.");
break;
case 2:
Console.WriteLine("Curso: Farmácia.");
Console.WriteLine("Duração: 4 anos.");
break;
case 3:
Console.WriteLine("Curso: Bioquímica.");
Console.WriteLine("Duração: 4 anos.");
break;
case 4:
Console.WriteLine("Curso: Biomedicina.");
Console.WriteLine("Duração: 4 anos e meio.");
break;
case 5:
Console.WriteLine("Curso: Veterinária.");
Console.WriteLine("Duração: 5 anos.");
break;
case 6:
Console.WriteLine("Curso: Biologia.");
Console.WriteLine("Duração: 3 anos e meio.");
break;
case 7:
Console.WriteLine("Curso: Nutrição.");
Console.WriteLine("Duração: 5 anos.");
break;
default:
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Curso indisponível.");
break;
}
Console.WriteLine("\n");
Console.ReadKey();
While() e For
Imagine que necessitamos imprimir uma sequência numérica na tela, ou repetir um fluxo de código até que o usuário indique terminado, fazer manualmente é impossível, para isto existem dois laços de repetição além de um terceiro que não será visto aqui (foreach).
Muitos erram em dizer que o for veio para substituir o while, enquanto cada um tem diferentes responsabilidades, apesar de fazer a mesma coisa, as responsabilidades são:
While - Não sabemos quando o lago vai terminar, como por exemplo, pode esperar por um comando do usuário;
For: Sabemos quando começa e quando termina, como por exemplo, imprimir do ano 2000 até 2020.
Tanto o while quanto o for necessitam de uma condição de saída, caso contrário vai entrar no que chamamos de loop infinito, o fluxo vai ser executado enquanto a aplicação estiver aberta.
As condições de saídas, são as mesmas utilizadas no if, abaixo veremos um exemplo.
Código 16:
int anoAtual = DateTime.Now.Year;
int ano = 1992;
while (ano < anoAtual)
{
Console.WriteLine(ano.ToString());
ano++;
}
Console.ReadKey();
Utilizamos o while nesta ocorrência, pois não sabemos quando a condição vai acabar, já que começa de 1992 e vai até o ano corrente.
DateTime.Now.Year, retorna o ano atual, e dentro do while incrementamos a variável ano, se removermos ano++, será impresso 1992 até que a aplicação seja fechada.
O bloco do while vai se repetir até a variável ano seja menor que o ano corrente, no caso, 2014.
Vamos ver o mesmo exemplo, usando o for, porém o ano inicial será de 1980 e o ano final 2020.
Código 17:
for (int ano = 1980; ano <= 2020; ano++)
{
Console.WriteLine(ano.ToString());
}
Console.ReadKey();
Dentro do for, iniciamos nossa variável ano, estabelecemos a condição de saída e incrementamos nossa variável.
No exemplo abaixo, é cadastrado um cliente fictício até que o usuário indique terminado, podemos comparar com um carrinho de comprar, será inserido itens até que o usuário clique em finalizar compra.
Código 18:
bool cadastrar = true;
char result;
while(cadastrar){
Console.WriteLine("\n\nCliente Cadastrado. \n\n");
Console.Write("Deseja cadastrar outro cliente? (s ou n)");
char.TryParse(Console.ReadLine(), out result);
if (result != 's')
{
cadastrar = false;
}
}
Console.ReadKey();
Com o conteúdo desta matéria, você está apto prosseguir seus estudos de forma mais fácil, já que aqui você adquiriu conhecimentos sobre o que é ou não permitido, conheceu algumas sintaxes e muitos outros assuntos.
Nas próxima matérias será explicado o que é um Vetor, Matriz, laço foreach além de cálculos aritméticos.
Espero que tenha tirado muitas dúvidas, mas caso tenha ficado algum, não hesite em deixar nos comentários.
Obs. Não tenha preguiça de reler o material, além de conferir os links deixados na matéria.
Confira: https://msdn.microsoft.com/pt-br/library/26etazsy%28v=vs.110%29.aspx
Até a próxima!
