ROLE PARA O FINAL DA PAGINA

cod1

using System;
namespace MyApp // Note: actual namespace depends on the project name.
{
internal class Program //modificador internal: acessa qualquer código no mesmo assembly, mas não
de outro
assembly.
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
}
}

cod2

Expressões com operadores relacionais.

using System;

namespace Projeto_1_Cap_7 // Note: actual namespace depends on the project name.

{
internal class Program //modificador internal: acessa qualquer código no mesmo assembly, mas não
de
outro assembly.
{
static void Main(string[] args)
{
int peso = 80;
char genero = 'M';
Console.WriteLine(peso == 80);
Console.WriteLine(peso >= 80);
Console.WriteLine(genero == 'F');
Console.WriteLine(genero > 'F');
Console.WriteLine((2 * 3 > 4) != (5 < 2));
}
}
}

cod3
Expressões com operadores relacionais e lógicos.

using System;
namespace Projeto_2_Cap_7 // Note: actual namespace depends on the project name.
{
internal class Program //modificador internal: acessa qualquer código no mesmo assembly, mas não
de
outro assembly.
{
static void Main(string[] args)
{
Console.WriteLine();
Console.WriteLine("Primeira expessão é {0}: ",4 > 5);
Console.WriteLine("Segunda expessão é {0}: ", 4 < 5 && 6 > 10);
Console.WriteLine("Terceira expessão é {0}: ", 40 < 50 || 60 > 90);
Console.WriteLine("Quarta expessão é {0}: ", !(40 < 50 || 60 > 90));
Console.WriteLine();
}
}
}

cod4

If (<condição>){
<bolo_instruções>
}
using System;
namespace Projeto_3_Cap_7 // Note: actual namespace depends on the project name.
{
internal class Program //modificador internal: acessa qualquer código no mesmo assembly, mas não
de
outro assembly.
{
static void Main(string[] args)
{
int num1, num2;
string var1 = "maior", var2 = "menor", var3 = "iguais";

Console.WriteLine();
Console.Write("Insira o primeiro número: ");
num1 = int.Parse(Console.ReadLine());
Console.WriteLine();

Console.Write("Insira o segundo número: ");

num2 = int.Parse(Console.ReadLine());
Console.WriteLine();
 if(num1 > num2){
Console.WriteLine("O primeiro número é {0} que o segundo número.", var1);
}else{
if(num1 < num2){
Console.WriteLine("O primeiro número é {0} que o segundo número.", var2);
}else{
Console.WriteLine("Os números são {0}.", var3);
}
}
Console.WriteLine();
}
}
}

cod5
Instrução if ... else simples e encadeada.

using System;
namespace Projeto_4_Cap_7 // Note: actual namespace depends on the project name.
{
internal class Program //modificador internal: acessa qualquer código no mesmo assembly, mas não
de
outro assembly.
{
static void Main(string[] args)
{
Console.WriteLine();
Console.Write("Insira um valor para o dia da semana: ");
int dia = int.Parse(Console.ReadLine());
if(dia == 1) {Console.WriteLine("Domingo");}
else if(dia == 2) {Console.WriteLine("Segunda");}
else if(dia == 3) {Console.WriteLine("Terça");}
else if(dia == 4) {Console.WriteLine("Quarta");}
else if(dia == 5) {Console.WriteLine("Quinta");}
else if(dia == 6) {Console.WriteLine("Sexta");}
else if(dia == 7) {Console.WriteLine("Sábado");}
else{Console.WriteLine("DIA INVÁLIDO");}
Console.WriteLine();
}
}
}

cod6

Decisão múltipla com instrução if ... else.

using System;
namespace Projeto_5_Cap_7 // Note: actual namespace depends on the project name.
{
internal class Program //modificador internal: acessa qualquer código no mesmo assembly, mas não
de
outro assembly.
{
static void Main(string[] args)
{
Console.WriteLine();
Console.Write("Insira um valor para o dia da semana: ");
int dia = int.Parse(Console.ReadLine());

switch (dia){
case 1:
Console.WriteLine("Domingo");
break;

case 2:
Console.WriteLine("Segunda");
break;

case 3:
Console.WriteLine("Terça");
break;

case 4:
Console.WriteLine("Quarta");
break;

case 5:
Console.WriteLine("Quinta");
break;

case 6:
Console.WriteLine("Sexta");
break;

case 7:
Console.WriteLine("Sábado");
break;

default:
Console.WriteLine("DIA INVÁLIDO");
break;
}
 }
}
}

cod7

Leitura e escrita de dados

using System;

namespace Projeto_1_Cap_6 // Note: actual namespace depends on the project name.

{
internal class Program //modificador internal: acessa qualquer código no mesmo assembly, mas não
de outro
assembly.
{
static void Main(string[] args)
{
Console.Write("Bom ");
Console.WriteLine("dia!");
Console.WriteLine("Ricardo. ");
Console.WriteLine();

//Podemos utilizar o caracter \n

Console.WriteLine("Bom dia!\nRicardo\n");
}
}
}

exemplo 2

using System;
namespace Projeto_2_Cap_6 // Note: actual namespace depends on the project name.
{
internal class Program //modificador internal: acessa qualquer código no mesmo assembly, mas não
de outro
assembly.
{
static void Main(string[] args)
{
// Ler um inteiro
Console.Write("Insira um número inteiro: ");
int numeroInt = int.Parse(Console.ReadLine());
Console.WriteLine("{0:D1}", numeroInt); // digitar 5
Console.WriteLine("{0:D2}", numeroInt); // digitar 5
Console.WriteLine("{0:D3}", numeroInt); // digitar 5
 Console.WriteLine("{0:D4}", numeroInt); // digitar 5
Console.WriteLine();

// Ler um real (float)

Console.Write("iInsira um número real (float): ");
float numeroFloat = float.Parse(Console.ReadLine());
Console.WriteLine("{0:f1}", numeroFloat); // digitar 5,2
Console.WriteLine("{0:f2}", numeroFloat); // digitar 5,2
Console.WriteLine("{0:f3}", numeroFloat); // digitar 5,2
Console.WriteLine();

// Ler um real (double)

Console.Write("iInsira um número real (double): ");
double numeroDouble = double.Parse(Console.ReadLine());
Console.WriteLine("{0:f1}", numeroDouble); // digitar 5,2
Console.WriteLine("{0:f2}", numeroDouble); // digitar 5,2
Console.WriteLine("{0:f3}", numeroDouble); // digitar 5,2
Console.WriteLine();
}
}
}

COD8

Entrada de dados

Em C#, entrada de dados são tipo string (sequências de caracteres alfanuméricos (letras,
números e/ou símbolos) portanto caso os dados sejam int, doble, float.... devem ser
convertidos de string para o tipo de dado desejado.

using System;
namespace MyApp //
{
internal class Projeto_1_Cap_5
{
static void Main(string[] args)
{
Console.WriteLine("Digite seu primeiro nome:");
string nome_1 = Console.ReadLine();
Console.WriteLine();

Console.WriteLine("Digite seu segundo nome:");

string nome_2 = Console.ReadLine();
Console.WriteLine();
 Console.WriteLine("Digite seu terceiro nome:");
string nome_3 = Console.ReadLine();
Console.WriteLine();

Console.WriteLine(nome_1);
Console.WriteLine(nome_2);
Console.WriteLine(nome_3);
Console.WriteLine();
}
}
}

Durante a execução do código, se houver indicações em vermelho sublinhando uma parte do código, isso
significa que não precisa da utilizar a conversão de dados, pois a entrada é string e a variável de
armazenamento do dado é string.

Exemplo 2

Neste exemplo estamos usando “Parse” e “Console.Write()”

using System;
namespace Projeto_2_Cap_5
{
internal class Program
{
static void Main(string[] args)
{
Console.WriteLine();
Console.Write("Entre com seu nome completo: ");
string nome = Console.ReadLine();
Console.WriteLine();

Console.Write("Sexo: M ou F: "); //digitar apenas um caracter

char sexo = char.Parse(Console.ReadLine());
Console.WriteLine();

Console.Write("Qual sua idade: ");

int idade = int.Parse(Console.ReadLine()); //digitar idade, exemplo: 22
Console.WriteLine();

Console.Write("Digita a temperada: ");

double temperatura = double.Parse(Console.ReadLine()); //digitar 28,5

Console.WriteLine();
Console.WriteLine("Você digitou:");
Console.WriteLine(nome);
Console.WriteLine(sexo);
 Console.WriteLine(idade);
Console.WriteLine(temperatura);
}
}
}

Exemplo 3:
ESSE PODE CAIR NA PROVA

Divisão por inteiros/reais.

O exemplo mostra os resultados que se obtém quando se
faz uma divisão por inteiros ou por reais.

using System;

namespace Projeto_3_Cap_5
{
internal class Program //modificador internal: acessado por qualquer código no mesmo assembly,
mas não de
outro assembly.
{
static void Main(string[] args)
{
int a = 2, b = 5;
float c = 2, d = 5;
Console.WriteLine("Divisao por inteiros: {0}/{1} = {2}", b, a, b/a);
Console.WriteLine("Divisão por reais: {0}/{1} = {2}", d, c, d/c);
Console.WriteLine("Divisão por reais utilizando o operaor de casting: {0}/{1} = {2}", b, a, (float)
b/a);
}
}
}

Exemplo 4, o codigo tem o mesmo objetivo do exemplo 3, a diferença e que esse codigo permite digitar
o valor diretamente no teclado .

using System;

namespace Projeto_4_Cap_5 // Note: actual namespace depends on the project name.

{
internal class Program
{
static void Main(string[] args)
{
Console.Write("Inserir valor da variável a do tipo int: ");
int a = int.Parse(Console.ReadLine()); // a = 2
 Console.Write("Inserir valor da variável b do tipo int: ");
int b = int.Parse(Console.ReadLine()); // b = 5
Console.Write("Inserir valor da variável c do tipo float: ");
float c = float.Parse(Console.ReadLine()); // c = 2 ou 2,5, qualquer número
Console.Write("Inserir valor da variável d do tipo float: ");
float d = float.Parse(Console.ReadLine()); // d = 5 ou 5,5, qualquer número
Console.WriteLine();
Console.WriteLine("Divisao por inteiros: {0}/{1} = {2}", b, a, b/a);
Console.WriteLine();
Console.WriteLine("Divisão por reais: {0}/{1} = {2}", d, c, d/c);
Console.WriteLine();
Console.WriteLine("Divisão por reais utilizando o operador de casting: {0}/{1} = {2}", b, a, (float)
b/a);
Console.WriteLine();
}
}
}

COD9
Utilização do operador ++:

Sufixo - o valor da variável é primeiro utilizado e depois é que o seu valor é alterado.

Prefixo - primeiro altera-se o valor da variável e depois é que se utiliza a variável.

using System;
namespace Projeto_5_Cap_5
{
internal class Program //modificador internal: acessado por qualquer código no mesmo assembly,
mas não de
outro assembly.
{
static void Main(string[] args)
{
int a = 10, b;
Console.WriteLine("Sufixo de a: {0}", a++); //primeiro utiliza depois atualiza
Console.WriteLine();
a = 10;
Console.WriteLine("Prefixo de a: {0}", ++a); // atualiza e utiliza
Console.WriteLine();
Console.WriteLine("Utilização do Sufixo");
a = 10;
b = a++;
Console.WriteLine("Antes {0} e depois {1}", b, a);
Console.WriteLine();
 Console.WriteLine("Utilização do Prefixo");
a = 10;
b = ++a;
Console.WriteLine("Antes {0} e depois {1}", b, a);
}
}
}

exemplo 2
O exemplo apresenta a utilização do operador de atribuição sozinho ou
combinado com outros operadores aritméticos.

using System;

namespace Projeto_6_Cap_5
{
internal class Program //modificador internal: acessado por qualquer código no mesmo assembly,
mas não de
outro assembly.
{
static void Main(string[] args)
{
int a = 10;
Console.WriteLine("Atribuição {0}", a = 5);
Console.WriteLine("Adição {0}", a += 3);
Console.WriteLine("Subtração {0}", a -= 2);
Console.WriteLine("Multiplicação {0}", a *= 5);
Console.WriteLine("Divisão {0}", a /= 2);
Console.WriteLine("Resto da Divisão {0}", a %= 4);
}
}
}

ESSE CODIGO TEM TODAS AS CARACTERISTICAS QUE DOS CODIGOS ACIMA

using System;

namespace Exemplo
{
class Program
{
static void Main(string[] args)
{
// Solicita ao usuário que insira dois números inteiros
Console.Write("Insira o primeiro número inteiro: ");
int num1 = int.Parse(Console.ReadLine());
Console.Write("Insira o segundo número inteiro: ");
int num2 = int.Parse(Console.ReadLine());

// Realiza algumas operações matemáticas com os números fornecidos

int soma = num1 + num2;
int diferenca = num1 - num2;
int produto = num1 * num2;
int quociente = num1 / num2;
int resto = num1 % num2;

// Exibe os resultados das operações

Console.WriteLine("\nResultados das operações:");
Console.WriteLine("Soma: {0}", soma);
Console.WriteLine("Diferença: {0}", diferenca);
Console.WriteLine("Produto: {0}", produto);
Console.WriteLine("Quociente: {0}", quociente);
Console.WriteLine("Resto da divisão: {0}\n", resto);

// Realiza algumas operações adicionais para praticar

Console.WriteLine("Operações adicionais:");
Console.WriteLine("Incremento de num1: {0}", ++num1);
Console.WriteLine("Decremento de num2: {0}", --num2);
Console.WriteLine("Atribuição composta: {0}", soma += 10);

// Exemplo de expressão lógica com if-else

if (soma > produto)
{
Console.WriteLine("A soma é maior que o produto.");
}
else
{
Console.WriteLine("O produto é maior que a soma.");
}

// Exemplo de expressão lógica com switch

Console.WriteLine("\nExemplo de switch:");
switch (quociente)
{
case 0:
Console.WriteLine("O quociente é zero.");
 break;
case 1:
Console.WriteLine("O quociente é um.");
break;
default:
Console.WriteLine("O quociente não é zero nem um.");
break;
}
}
}
}