Booleanos em C #

Muitas vezes, na programação, você precisará de um tipo de dados que possa ter apenas um dos dois valores, como:

SIM NÃO
LIGADO DESLIGADO
VERDADEIRO FALSO

Para isso, o C # possui um tipo de dados bool, que pode levar os valores verdadeiro ou falso.

Valores booleanos
Um tipo booleano é declarado com a palavra-chave bool e só pode levar os valores true ou false:

Exemplo
bool isCSharpFun = true;
bool isFishTasty = false;
Console.WriteLine (isCSharpFun); // Saída True
Console.WriteLine (isFishTasty); // Saídas falsas

No entanto, é mais comum retornar valores booleanos de expressões booleanas, para testes condicionais (veja abaixo).

Expressão booleana
Uma expressão booleana é uma expressão em C # que retorna um valor booleano: True ou False.

Você pode usar um operador de comparação, como o operador maior que (>), para descobrir se uma expressão (ou variável) é verdadeira:

Exemplo
int x = 10;
int y = 9;
Console.WriteLine (x> y); // retorna True, porque 10 é maior que 9

Ou ainda mais fácil:

Exemplo
Console.WriteLine (10> 9); // retorna True, porque 10 é maior que 9

Nos exemplos abaixo, usamos o operador igual a (==) para avaliar uma expressão:

Exemplo
int x = 10;
Console.WriteLine (x == 10); // retorna True, porque o valor de x é igual a 10

Exemplo
Console.WriteLine (10 == 15); // retorna False, porque 10 não é igual a 15

O valor booleano de uma expressão é a base para todas as comparações e condições de C #.

C # Strings

As strings são usadas para armazenar texto.

Uma variável de cadeia contém uma coleção de caracteres entre aspas duplas:

Exemplo
Crie uma variável do tipo string e atribua um valor a ela:

string cumprimento = "Olá";

Comprimento da string

Uma string em C # é na verdade um objeto, que contém propriedades e métodos que podem executar determinadas operações nas strings. Por exemplo, o comprimento de uma sequência pode ser encontrado com a propriedade Length:

Exemplo
string txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
Console.WriteLine ("O comprimento da cadeia de caracteres txt é:" + txt.Length);

Outros métodos
Existem muitos métodos de sequência disponíveis, por exemplo, ToUpper () e ToLower (), que retornam uma cópia da sequência convertida em maiúsculas ou minúsculas:

Exemplo
string txt = "Olá, mundo";
Console.WriteLine (txt.ToUpper ()); // Saídas "HELLO WORLD"
Console.WriteLine (txt.ToLower ()); // Saídas "olá mundo"

Concatenação de String
O operador + pode ser usado entre cadeias para combiná-las. Isso é chamado de concatenação:

Exemplo
string firstName = "John";
string lastName = "Doe";
nome da string = nome + sobrenome;
Console.WriteLine (nome);

Observe que adicionamos um espaço após "John" para criar um espaço entre firstName e lastName na impressão.

Você também pode usar o método string.Concat () para concatenar duas seqüências:

Exemplo
string firstName = "John";
string lastName = "Doe";
nome da string = string.Concat (nome, sobrenome);
Console.WriteLine (nome);


Interpolação de String
Outra opção da concatenação de strings é a interpolação de strings, que substitui valores de variáveis ​​em espaços reservados em uma string. Observe que você não precisa se preocupar com espaços, como na concatenação:

Exemplo
string firstName = "John";
string lastName = "Doe";
string name = $ "Meu nome completo é: {firstName} {lastName}";
Console.WriteLine (nome);

C # Math

A classe C # Math possui muitos métodos que permitem executar tarefas matemáticas em números.

Math.Max ​​(x, y)
O método Math.Max ​​(x, y) pode ser usado para encontrar o valor mais alto de x e y:

Exemplo
Math.Max ​​(5, 10);

Math.Min (x, y)
O método Math.Min (x, y) pode ser usado para encontrar o valor mais baixo de x e y:

Exemplo
Math.Min (5, 10);

Math.Sqrt (x)
O método Math.Sqrt (x) retorna a raiz quadrada de x:

Exemplo
Math.Sqrt (64);

Math.Abs ​​(x)
O método Math.Abs ​​(x) retorna o valor absoluto (positivo) de x:

Exemplo
Math.Abs ​​(-4,7);

Math.Round ()
Math.Round () arredonda um número para o número inteiro mais próximo:

Exemplo
Math.Round (9,99);

Operadores C #

Operadores são usados ​​para executar operações em variáveis ​​e valores.

No exemplo abaixo, usamos o operador + para adicionar dois valores:

Exemplo

int x = 100 + 50;

Embora o operador + seja frequentemente usado para adicionar dois valores, como no exemplo acima, ele também pode ser usado para adicionar uma variável e um valor, ou uma variável e outra variável:

Exemplo

int sum1 = 100 + 50; // 150 (100 + 50)

int soma2 = soma1 + 250; // 400 (150 + 250)

int soma3 = soma2 + soma2; // 800 (400 + 400)

Operadores aritméticos

Operadores aritméticos são usados ​​para executar operações matemáticas comuns:

+ Adição Adiciona dois valores x + y

- Subtração Subtrai um valor de outro x - y

* Multiplicação Multiplica dois valores x * y

/ Division Divide um valor de outro x / y

% Módulo Retorna o restante da divisão x% y

Incremento ++ Aumenta o valor de uma variável em 1 x ++

- Decremento Diminui o valor de uma variável em 1 x--

Operadores de atribuição C #

Operadores de atribuição são usados ​​para atribuir valores a variáveis.

No exemplo abaixo, usamos o operador de atribuição (=) para atribuir o valor 10 a uma variável chamada x:

Exemplo

int x = 10;

O operador de atribuição de adição (+ =) adiciona um valor a uma variável:

Exemplo

int x = 10;

x + = 5;

Uma lista de todos os operadores de atribuição:

= x = 5 x = 5

+ = x + = 3 x = x + 3

- = x - = 3 x = x - 3

* = x * = 3 x = x * 3

/ = x / = 3 x = x / 3

% = x% = 3 x = x% 3

x = x & 3 = x & 3

| = x | = 3 x = x | 3

^ = x ^ = 3 x = x ^ 3

>> = x >> = 3 x = x >> 3

<< = x << = 3 x = x << 3

Operadores de comparação de c #

Operadores de comparação são usados ​​para comparar dois valores:

Exemplo do nome do operador Experimente

== Igual a x == y

! = Diferente x! = Y

> Maior que x> y

> = Maior ou igual a x> = y

<= Menor ou igual a x <= y

Operadores lógicos em C #

Operadores lógicos são usados ​​para determinar a lógica entre variáveis ​​ou valores:

&& Logical and Returns true se ambas as afirmações forem verdadeiras x <5 amp="" div="" x="">

|| Lógico ou Retorna verdadeiro se uma das instruções for verdadeira x <5 div="" x="">

! Lógico não Inverte o resultado, retorna falso se o resultado for verdadeiro! (X <5 amp="" div="" x="">

Conversão de tipos (Type Casting)

A conversão de tipo ocorre quando você atribui um valor de um tipo de dados a outro tipo.

No C #, existem dois tipos de conversão:

• Transmissão implícita (automaticamente) - convertendo um tipo menor para um tamanho maior char -> int -> long -> float -> duplo
• Transmissão explícita (manualmente) - convertendo um tipo maior para um tipo de tamanho menor double -> float -> long -> int -> char

Conversão implícita

A conversão implícita é feita automaticamente ao passar um tipo de tamanho menor para um tipo de tamanho maior:

Exemplo
int myInt = 9;
double myDouble = myInt; // Conversão automática: int para dobrar

Console.WriteLine (myInt); // Saídas 9
Console.WriteLine (myDouble); // Saídas 9

Conversão explícita

A conversão explícita deve ser feita manualmente, colocando o tipo entre parênteses à frente do valor:

Exemplo
double myDouble = 9,78;
int myInt = (int) myDouble; // Transmissão manual: double to int

Console.WriteLine (myDouble); // Saídas 9.78
Console.WriteLine (myInt); // Saídas 9

Métodos de conversão de tipo

Também é possível converter tipos de dados explicitamente usando métodos internos, como Convert.ToBoolean, Convert.ToDouble, Convert.ToString, Convert.ToInt32 (int) e Convert.ToInt64 (long):

Exemplo
int myInt = 10;
double myDouble = 5,25;
bool myBool = true;

Console.WriteLine (Convert.ToString (myInt)); // converte int para string
Console.WriteLine (Convert.ToDouble (myInt)); // converte int para o dobro
Console.WriteLine (Convert.ToInt32 (myDouble)); // converte double para int
Console.WriteLine (Convert.ToString (myBool)); // converte bool para string

Por que conversão?
Muitas vezes, não há necessidade de conversão de tipo. Mas às vezes você precisa ao trabalhar com a entradas do usuário, para ver um exemplo disso.

Tipos de dados C #

Conforme explicado no post sobre variáveis, uma variável em C # deve ter um tipo de dados especificado:

Exemplo:
int myNum = 5; // Inteiro (número inteiro)
double myDoubleNum = 5.99D; // Número do ponto flutuante
char myLetter = 'D'; // Personagem
bool myBool = true; // Boleano
string myText = "Olá"; // Corda

Um tipo de dados especifica o tamanho e o tipo de valores variáveis. É importante usar o tipo de dados correto para a variável correspondente; para evitar erros, economizar tempo e memória, mas também tornará seu código mais sustentável e legível. Os tipos de dados mais comuns são:

Tipo de dados

• int 4 bytes Armazena números inteiros de -2.147.483.648 a 2.147.483.647
• 8 bytes longos Armazena números inteiros de -9.223.372.036.854.775.808 a 9.223.372.036.854.775,807
• float 4 bytes Armazena números fracionários. Suficiente para armazenar 6 a 7 dígitos decimais
• double 8 bytes Armazena números fracionários. Suficiente para armazenar 15 dígitos decimais
• bool 1 bit Armazena valores verdadeiros ou falsos
• char 2 bytes Armazena um único caractere / letra, entre aspas simples
• string 2 bytes por caractere Armazena uma sequência de caracteres, entre aspas duplas

Números

Os tipos de número são divididos em dois grupos:

• Tipos inteiros armazenam números inteiros, positivos ou negativos (como 123 ou -456), sem decimais. Tipos válidos são int e long. O tipo que você deve usar depende do valor numérico.
• Os tipos de ponto flutuante representam números com uma parte fracionária, contendo uma ou mais casas decimais. Tipos válidos são float e double.

Embora existam muitos tipos numéricos em C #, os mais usados ​​para números são int (para números inteiros) e duplos (para números de ponto flutuante). No entanto, descreveremos todos eles enquanto você continua a ler.

Tipos de número inteiro
Int
O tipo de dados int pode armazenar números inteiros de -2147483648 a 2147483647. Em geral, e em nosso tutorial, o tipo de dados int é o tipo de dados preferido quando criamos variáveis ​​com um valor numérico.

Exemplo
int myNum = 100000;
Console.WriteLine (myNum);

Grandes
O tipo de dados longo pode armazenar números inteiros de -9223372036854775808 a 9223372036854775807. Isso é usado quando int não é grande o suficiente para armazenar o valor. Observe que você deve finalizar o valor com um "L":

Exemplo
myNum longo = 15000000000L;
Console.WriteLine (myNum);

Tipos de ponto flutuante
Você deve usar um tipo de ponto flutuante sempre que precisar de um número decimal, como 9.99 ou 3.14515.

Flutuador
O tipo de dados flutuante pode armazenar números fracionários de 3.4e-038 a 3.4e + 038. Observe que você deve finalizar o valor com um "F":

Exemplo
float myNum = 5,75F;
Console.WriteLine (myNum);

Números científicos
Um número de ponto flutuante também pode ser um número científico com um "e" para indicar a potência de 10:

Exemplo
flutuador f1 = 35e3F;
d1 duplo = 12E4D;
Console.WriteLine (f1);
Console.WriteLine (d1);


Booleanos
Um tipo de dados booleano é declarado com a palavra-chave bool e só pode levar os valores true ou false:

Exemplo
bool isCSharpFun = true;
bool isFishTasty = false;
Console.WriteLine (isCSharpFun); // Saída True
Console.WriteLine (isFishTasty); // Saídas falsas

Os valores booleanos são usados ​​principalmente para testes condicionais, sobre os quais você aprenderá mais em um capítulo posterior.

Char
O tipo de dados char é usado para armazenar um único caractere. O caractere deve estar entre aspas simples, como 'A' ou 'c':

Exemplo
char myGrade = 'B';
Console.WriteLine (myGrade);

strings
O tipo de dados da sequência é usado para armazenar uma sequência de caracteres (texto). Os valores da string devem estar entre aspas duplas:

Exemplo
string greeting = "Olá, mundo";
Console.WriteLine (saudação);

Variáveis ​​C #

Variáveis ​​são contêineres para armazenar valores de dados.

No C #, existem diferentes tipos de variáveis ​​(definidas com palavras-chave diferentes), por exemplo:

int - armazena números inteiros (números inteiros), sem decimais, como 123 ou -123
double - armazena números de ponto flutuante, com decimais, como 19,99 ou -19,99
char - armazena caracteres únicos, como 'a' ou 'B'. Os valores de caracteres são cercados por aspas simples
string - armazena texto, como "Hello World". Os valores das cadeias são cercados por aspas duplas
bool - armazena valores com dois estados: verdadeiro ou falso

Declarando (Criando) Variáveis
Para criar uma variável, você deve especificar o tipo e atribuir um valor a ela:

Sintaxe
tipo nomeVariavel = value;

Onde type é um tipo de C # (como int ou string) e variableName é o nome da variável (como x ou nome). O sinal de igual é usado para atribuir valores à variável.

Para criar uma variável que deve armazenar texto, observe o seguinte exemplo:

Exemplo
Crie uma variável chamada nome do tipo string e atribua a ela o valor "John":

string nome  = "John";
Console.WriteLine (nome);

Para criar uma variável que deve armazenar um número, observe o seguinte exemplo:

Exemplo
Crie uma variável chamada myNum do tipo int e atribua a ela o valor 15:

int myNum = 15;
Console.WriteLine (myNum);

Você também pode declarar uma variável sem atribuir o valor e atribuir o valor posteriormente:

Exemplo
int myNum;
myNum = 15;
Console.WriteLine (myNum);

Observe que se você atribuir um novo valor a uma variável existente, ele substituirá o valor anterior:

Exemplo
Altere o valor de myNum para 20:

int myNum = 15;
myNum = 20; // myNum agora tem 20 anos
Console.WriteLine (myNum);

Constantes
No entanto, você pode adicionar a palavra-chave const se não desejar que outras pessoas (ou você mesmo) substituam os valores existentes (isso declarará a variável como "constante", o que significa inalterável e somente leitura):

Exemplo
const int myNum = 15;
myNum = 20; // erro

A palavra-chave const é útil quando você deseja que uma variável armazene sempre o mesmo valor, para que outras pessoas (ou você) não atrapalhem o seu código. Um exemplo que é frequentemente referido como uma constante é PI (3.14159 ...).

Nota: Você não pode declarar uma variável constante sem atribuir o valor. Caso contrário, ocorrerá um erro: Um campo const exige que um valor seja fornecido.

Comentários C #

Os comentários podem ser usados ​​para explicar o código C # e torná-lo mais legível. Também pode ser usado para impedir a execução ao testar código alternativo.

Os comentários de linha única começam com duas barras (//).

Qualquer texto entre // e o final da linha é ignorado por C # (não será executado).

Este exemplo usa um comentário de linha única antes de uma linha de código:

Exemplo
// Este é um comentário
Console.WriteLine ("Olá Mundo!");

Este exemplo usa um comentário de linha única no final de uma linha de código:

Exemplo
Console.WriteLine ("Olá Mundo!"); // Este é um comentário

Comentários de várias linhas em C #
Os comentários de várias linhas começam com / * e terminam com * /.

Qualquer texto entre / * e * / será ignorado pelo C #.

Este exemplo usa um comentário de várias linhas (um bloco de comentários) para explicar o código:

Exemplo
/ * O código abaixo imprimirá as palavras Hello World
na tela e é incrível * /
Console.WriteLine ("Olá Mundo!");

Sintaxe do C#

Programinha básico

using System;

namespace HelloWorld
{
  class Program
  {
    static void Main(string[] args)
    {
      Console.WriteLine("Hello World!");    
    }
  }
}

Exemplo explicado
Linha 1: usar System significa que podemos usar classes no namespace System.

Linha 2: uma linha em branco. C # ignora o espaço em branco. No entanto, várias linhas tornam o código mais legível.

Linha 3: Namespace é usado para organizar seu código e é um contêiner para classes e outros espaços para nome.

Linha 4: os chavetas {} marcam o início e o fim de um bloco de código.

Linha 5: class é um contêiner para dados e métodos, que traz funcionalidade ao seu programa. Toda linha de código executada em C # deve estar dentro de uma classe. Em nosso exemplo, nomeamos a classe Program.

Não se preocupe se você não entender como funciona o System, namespace e classe. Pense nisso como algo que (quase) sempre aparece em seu programa e você aprenderá mais sobre eles em um capítulo posterior.

Linha 7: Outra coisa que sempre aparece em um programa C #, é o método Main. Qualquer código dentro de seus colchetes {} será executado. Você não precisa entender as palavras-chave antes e depois de Principal. Você os conhecerá pouco a pouco enquanto lê este tutorial.

Linha 9: Console é uma classe do espaço para nome System, que possui um método WriteLine () usado para gerar / imprimir texto. No nosso exemplo, ele exibirá "Hello World!".

Se você omitir a linha System, seria necessário escrever System.Console.WriteLine () para imprimir / imprimir texto.

Nota: Toda instrução C # termina com um ponto-e-vírgula;

Nota: C # diferencia maiúsculas de minúsculas: "MyClass" e "myclass" têm um significado diferente.

Nota: Ao contrário do Java, o nome do arquivo C # não precisa corresponder ao nome da classe, mas costumam corresponder (para melhor organização). Ao salvar o arquivo, salve-o usando um nome próprio e adicione ".cs" ao final do nome do arquivo. Para executar o exemplo acima no seu computador, verifique se o C # está instalado corretamente.

WriteLine ou Write

O método mais comum para gerar algo em C # é WriteLine (), mas você também pode usar Write ().

A diferença é que WriteLine () imprime a saída em uma nova linha de cada vez, enquanto Write () imprime na mesma linha (observe que você deve se lembrar de adicionar espaços quando necessário, para melhor legibilidade):

Exemplo
Console.WriteLine ("Olá Mundo!");
Console.WriteLine ("Imprimirei em uma nova linha.");

Console.Write ("Olá, mundo!");
Console.Write ("Imprimirei na mesma linha.");

C#

O C# é uma das linguagens entendidas pelo compilador presente no .NET framework. Trata-se de uma liguagem orientada à objetos, pois através desta é possível implementar todos os princípios presentes no paradigma da Orientação a objetos.

Não vou aqui promover um curso de C#. O propósito deste post é fazer um resumo que possibilite a programas experientes se familiarizar com a sintaxe da linguagem.

O que é C #?

C # é pronunciado "C-Sharp".

É uma linguagem de programação orientada a objetos criada pela Microsoft que é executada no .NET Framework.

O C # tem raízes da família C e a linguagem está próxima de outras linguagens populares como C ++ e Java.

A primeira versão foi lançada no ano de 2002. A versão mais recente, C # 8, foi lançada em setembro de 2019.

C # é usado para:

• Aplicações Móveis
• Aplicativos de desktop
• Aplicativos da web
• serviços web
• Web sites
• Jogos
• VR
• Aplicativos de banco de dados
• E muito, muito mais!

Por que usar c #?

• É uma das linguagens de programação mais populares do mundo
• É fácil de aprender e simples de usar
• Tem um enorme apoio da comunidade
• C # é uma linguagem orientada a objetos que fornece uma estrutura clara aos programas e permite que o código seja reutilizado, reduzindo os custos de desenvolvimento.
• Como o C # está próximo de C, C ++ e Java, facilita para os programadores mudar para C # ou vice-versa