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

Controle de versão de código distribuído na prática

Dando continuidade ao Post anterior, vamos praticar um pouquinho do assunto utilizando o GIT.

O Git é um versionador do tipo distribuído. De modo dar total praticidade ao assunto, vamos nos ater aos comandos do GIT. (detalhes de instalação deverão ser pesquisados na Internet, ok?

Vamos pensar no seguinte cenário: dois desenvolvedores resolvem trabalhar num projeto de um site. 

Como falamos no post anterior, cada desenvolvedor terá uma área de trabalho e um repositório local. 

Além desses repositórios ficou acertado entre os desenvolvedores que deveria existir um repositório central hospedado no github.

Bom, os desenvolvedores deverão ter instalados o Git em suas respectivas máquinas e cada ter uma conta no GitHub.

O primeiro passo é criar um diretório para colocar os arquivos desse projeto. Vamos chamar esse diretório de projetoSite (no meu caso criei o diretório em C:\Users\Hugo Neto\projetoSite). 

Feito isso, é necessário dizer ao Git que você quer transformar este diretório em um repositório, ou seja, que os arquivos ali inseridos deverão ter suas alterações controladas e versionadas pelo Git. Como fazer isso? Abra o terminal de seu computador, navegue até o diretório criado e em seguida utilize o comando “git init”. O git retornará a mensagem  abaixo:

Em seguida vamos nos imaginar como um dos programadores e criar a página inicial do site objeto do projeto com as características da figura abaixo. Vamos chamar essa página de index.html e vamos salva-la no diretório criado para o projeto.

A princípio, podemos imaginar que o arquivo jogado no diretório criado já está sendo controlado pelo Git. Entretanto não é assim que a coisa funciona. Para verificar quais arquivos estão sendo controlados/trackeados pelo Git devemos executar o comando git ls-files.

Repare que ao executar esse comando, o Git não retornou o arquivo que nós salvamos no diretório. Para que isto aconteça, é necessário executar o comando git status.

Ao executar este comando, o git lista o arquivo que salvamos no diretório e informa que este arquivo está untracked, ou seja, que ele ainda não está sendo controlado pelo Git. Para que o Git comece a trackear o arquivo, é necessário executar o comando Git add

Feito isso, ao executarmos o comando git status novamente, o Git listará o arquivo index.html como tracked. Nessa situação, podemos dizer que o arquivo encontra-se na área de trabalho do desenvolvedor. Após as alterações realizadas no arquivo, o desenvolvedor deve commitar essas alterações através do comando Git commit. Ao fazer isso, o desenvolvedor grava a revisão do arquivo no repositório local.

Repare que incluímos ao comando git commit a opção -m(mensagem) para descrever a alteração realizada. Note também que o git exibiu uma mensagem solicitando a identificação de quem está realizando o commit. Para informamos isso usamos os comandos git config as opções user.email “email@email.com.br”  e user.name=”seu nome”

Ao executar o comando novamente, o git comitará o arquivo para o repositório local. Ao executar o comando git status novamente, o git informará que não existem alterações a serem comitadas para o repositório.

Vamos fazer mais algumas alterações no arquivo. Verificamos que a palavra “incial” presente no título da página está incorreto. Vamos corrigir a palavra e verificar o status do nossa área de trabalho.