Variáveis C# e tipos de dados (primitivos)

Neste tutorial, aprenderemos sobre variáveis, como criar variáveis em C# e diferentes tipos de dados que a linguagem de programação C# suporta.

Uma variável é um nome simbólico dado a um local de memória. Variáveis são usadas para armazenar dados em um programa de computador.

Como declarar variáveis em C#?

Aqui está um exemplo para declarar uma variável em C#.

int age;

Neste exemplo, uma variável idade do tipo int (integer) é declarado e só pode armazenar valores inteiros.

Podemos atribuir um valor à variável posteriormente em nosso programa como:

int age;
... ... ...
age = 24;

No entanto, a variável também pode ser inicializada com algum valor durante a declaração. Por exemplo,

int age = 24;

Aqui, uma variável idade do tipo int é declarado e inicializado para 24 ao mesmo tempo.

Como é uma variável, também podemos alterar o valor das variáveis. Por exemplo,

int age = 24;
age = 35;

Aqui, o valor de idade é alterado para 35 de 24.

Variáveis em C# devem ser declaradas antes de serem usadas. Isso significa que o nome e o tipo da variável devem ser conhecidos antes que eles possam receber um valor. É por isso que C# é chamado de linguagem de tipagem estática.

Uma vez declarado, o tipo de dados de uma variável não pode ser alterado dentro de um escopo. Um escopo pode ser pensado como um bloco de código onde a variável está visível ou disponível para uso. Se você não entender a declaração anterior, não se preocupe, aprenderemos sobre escopos nos capítulos posteriores.

Por enquanto, lembre-se, não podemos fazer o seguinte em C#:

int age;
age = 24;
... ... ...
float age;

Variáveis de tipo implícito

Alternativamente, em C#, podemos declarar uma variável sem saber seu tipo usando var palavra-chave. Essas variáveis são chamadas de variáveis locais implicitamente tipadas .

Variáveis declaradas usando var palavra-chave deve ser inicializada no momento da declaração.

var value = 5;

O compilador determina o tipo de variável a partir do valor atribuído à variável. No exemplo acima, valor é do tipo int . Isso é equivalente a:

int value;
value = 5;

Você pode aprender mais sobre variáveis locais tipadas implicitamente.

Regras para nomear variáveis em C#

Existem certas regras que precisamos seguir ao nomear uma variável. As regras para nomear uma variável em C# são:

O nome da variável pode conter apenas letras (maiúsculas e minúsculas), sublinhado( _ ) e dígitos.

O nome da variável deve começar com uma letra, sublinhado ou símbolo @. Por exemplo,

Regras para nomear variáveis em C#
Nomes de variáveis	Observações
`nome`	Válido
`assunto101`	Válido
`_idade`	Válido (prática recomendada para nomear variáveis de membro privado)
`@break`	Válido (Usado se o nome for uma palavra-chave reservada)
`101assunto`	Inválido (começa com dígito)
`seu_nome`	Válido
`seu nome`	Inválido (contém espaços em branco)

C# diferencia maiúsculas de minúsculas. Significa idade e Idade refere-se a 2 variáveis diferentes.
Um nome de variável não deve ser uma palavra-chave C#. Por exemplo, if , for , using não pode ser um nome de variável. Discutiremos mais sobre palavras-chave C# no próximo tutorial.

Práticas recomendadas para nomear uma variável

Escolha um nome de variável que faça sentido. Por exemplo, nome , idade , assunto faz mais sentido do que n , a e s .
Usar camelCase notação (começa com letra minúscula) para nomear variáveis locais. Por exemplo, numberOfStudents , idade , etc.
Usar PascalCase ou CamelCase (começa com letra maiúscula) para nomear variáveis de membro público. Por exemplo, Nome , Preço , etc.
Use um sublinhado inicial (_) seguido por camelCase notação para nomear variáveis de membro privado. Por exemplo, _bankBalance , _emailAddress , etc.

Você pode aprender mais sobre convenções de nomenclatura em C# aqui.

Não se preocupe com variáveis de membros públicas e privadas. Aprenderemos sobre eles em capítulos posteriores.

Tipos de dados primitivos C#

As variáveis em C# são amplamente classificadas em dois tipos:Tipos de valor e Tipos de referência . Neste tutorial, discutiremos sobre tipos de dados primitivos (simples) que são uma subclasse de tipos de valor.

Os tipos de referência serão abordados em tutoriais posteriores. No entanto, se você quiser saber mais sobre tipos de variáveis, visite C# Types and variables (documentos oficiais de C#).

Boolean (bool)

O tipo de dados booleano tem dois valores possíveis:true ou false
Valor padrão :false
Variáveis booleanas são geralmente usadas para verificar condições como em instruções if , laços , etc.

Por exemplo:

using System;
namespace DataType
{
    class BooleanExample
    {
        public static void Main(string[] args)
        {
            bool isValid = true;
            Console.WriteLine(isValid);
        }
    }
}

Ao executarmos o programa, a saída será:

True

Integral assinado

Esses tipos de dados contêm valores inteiros (positivos e negativos). Do total de bits disponíveis, um bit é usado para sinal.

1. sbyte

Tamanho :8 bits
Intervalo :-128 a 127.
Valor padrão :0

Por exemplo:

using System;
namespace DataType
{
    class SByteExample
    {
        public static void Main(string[] args)
        {
            sbyte level = 23;
            Console.WriteLine(level);
        }
    }
}

Ao executarmos o programa, a saída será:

Tente atribuir valores fora do intervalo, ou seja, menores que -128 ou maiores que 127 e veja o que acontece.

2. curto

Tamanho :16 bits
Intervalo :-32.768 a 32.767
Valor padrão :0

Por exemplo:

using System;
namespace DataType
{
    class ShortExample
    {
        public static void Main(string[] args)
        {
            short value = -1109;
            Console.WriteLine(value);
        }
    }
}

Ao executarmos o programa, a saída será:

-1109

3. int

Tamanho :32 bits
Intervalo :-231 a 231-1
Valor padrão :0

Por exemplo:

using System;
namespace DataType
{
    class IntExample
    {
        public static void Main(string[] args)
        {
            int score = 51092;
            Console.WriteLine(score);
        }
    }
}

Ao executarmos o programa, a saída será:

4. longo

Tamanho :64 bits
Intervalo :-263 a 263-1
Valor padrão :0L [L no final representa que o valor é do tipo longo]

Por exemplo:

using System;
namespace DataType
{
    class LongExample
    {
        public static void Main(string[] args)
        {
            long range = -7091821871L;
            Console.WriteLine(range);
        }
    }
}

Ao executarmos o programa, a saída será:

-7091821871

Integral não assinado

Esses tipos de dados mantêm apenas valores iguais ou maiores que 0. Geralmente usamos esses tipos de dados para armazenar valores quando temos certeza de que não teremos valores negativos.

1. byte

Tamanho :8 bits
Intervalo :0 a 255.
Valor padrão :0

Por exemplo:

using System;
namespace DataType
{
    class ByteExample
    {
        public static void Main(string[] args)
        {
            byte age = 62;
            Console.WriteLine(level);
        }
    }
}

Ao executarmos o programa, a saída será:

2. ushor

Tamanho :16 bits
Intervalo :0 a 65.535
Valor padrão :0

Por exemplo:

using System;
namespace DataType
{
    class UShortExample
    {
        public static void Main(string[] args)
        {
            ushort value = 42019;
            Console.WriteLine(value);
        }
    }
}

Ao executarmos o programa, a saída será:

3. uint

Tamanho :32 bits
Intervalo :0 a 232-1
Valor padrão :0

Por exemplo:

using System;
namespace DataType
{
    class UIntExample
    {
        public static void Main(string[] args)
        {
            uint totalScore = 1151092;
            Console.WriteLine(totalScore);
        }
    }
}

Ao executarmos o programa, a saída será:

4. longo

Tamanho :64 bits
Intervalo :0 a 264-1
Valor padrão :0

Por exemplo:

using System;
namespace DataType
{
    class ULongExample
    {
        public static void Main(string[] args)
        {
            ulong range = 17091821871L;
            Console.WriteLine(range);
        }
    }
}

Ao executarmos o programa, a saída será:

17091821871

Ponto flutuante

Esses tipos de dados contêm valores de ponto flutuante, ou seja, números contendo valores decimais. Por exemplo, 12,36, -92,17, etc.

1. flutuar

Tipo de ponto flutuante de precisão simples
Tamanho :32 bits
Intervalo :1,5 × 10−45 a 3,4 × 1038
Valor padrão :0.0F [F no final representa que o valor é do tipo float]

Por exemplo:

using System;
namespace DataType
{
    class FloatExample
    {
        public static void Main(string[] args)
        {
            float number = 43.27F;
            Console.WriteLine(number);
        }
    }
}

Ao executarmos o programa, a saída será:

43.27

2. duplo

Tipo de ponto flutuante de precisão dupla. Qual é a diferença entre ponto flutuante de precisão simples e dupla?
Tamanho :64 bits
Intervalo :5,0 × 10−324 a 1,7 × 10308
Valor padrão :0.0D [D no final representa o valor é do tipo double]

Por exemplo:

using System;
namespace DataType
{
    class DoubleExample
    {
        public static void Main(string[] args)
        {
            double value = -11092.53D;
            Console.WriteLine(value);
        }
    }
}

Ao executarmos o programa, a saída será:

-11092.53

Personagem (caractere)

Ele representa um caractere unicode de 16 bits.
Tamanho :16 bits
Valor padrão :'\0'
Intervalo :U+0000 ('\u0000') a U+FFFF ('\uffff')

Por exemplo:

using System;
namespace DataType
{
    class CharExample
    {
        public static void Main(string[] args)
        {
            char ch1 ='\u0042';
            char ch2 = 'x';
            Console.WriteLine(ch1);
            Console.WriteLine(ch2);
        }
    }
}

Ao executarmos o programa, a saída será:

B
x

O valor unicode de 'B' é '\u0042' , portanto imprimindo ch1 imprimirá 'B' .

Decimal

O tipo decimal tem mais precisão e um intervalo menor em comparação com os tipos de ponto flutuante (double e float). Portanto, é apropriado para cálculos monetários.
Tamanho :128 bits
Valor padrão :0,0M [M no final representa que o valor é do tipo decimal]
Intervalo :(-7,9 x 1028 a 7,9 x 1028) / (100 a 28)

Por exemplo:

using System;
namespace DataType
{
    class DecimalExample
    {
        public static void Main(string[] args)
        {
         decimal bankBalance = 53005.25M;
            Console.WriteLine(bankBalance);
        }
    }
}

Ao executarmos o programa, a saída será:

53005.25

O sufixo M ou m deve ser adicionado no final, caso contrário o valor será tratado como um double e um erro será gerado.

C# Literais

Vejamos a seguinte afirmação:

int number = 41;

Aqui,

int é um tipo de dados
número é uma variável e
41 é um literal

Literais são valores fixos que aparecem no programa. Eles não requerem nenhum cálculo. Por exemplo, 5 , false , 'w' são literais que aparecem em um programa diretamente sem qualquer computação.

Literais Booleanos

true e false são os literais booleanos disponíveis.
Eles são usados para inicializar variáveis booleanas.

Por exemplo:

bool isValid = true;
bool isPresent = false;

Literais inteiros

Os literais inteiros são usados para inicializar variáveis de tipos de dados inteiros, ou seja, sbyte , short , int , long , byte , ushort , uint e ulong .
Se um literal inteiro terminar com L ou l , é do tipo long. Para práticas recomendadas, use L (não l ).
```
long value1 = 4200910L;
long value2 = -10928190L;
```
Se um literal inteiro começar com um 0x , representa o valor hexadecimal. Número sem prefixos são tratados como valor decimal. A representação octal e binária não são permitidas em C#.
```
int decimalValue = 25;
int hexValue = 0x11c;// decimal value 284
```

Literais de ponto flutuante

Os literais de ponto flutuante são usados para inicializar variáveis de tipos de dados float e double.
Se um literal de ponto flutuante terminar com um sufixo f ou F , é do tipo float. Da mesma forma, se terminar com d ou D , é do tipo double. Se nenhum dos sufixos estiver presente, é do tipo double por padrão .

Esses literais contêm e ou E quando expressos em notação científica.

double number = 24.67;// double by default
float value = -12.29F;
double scientificNotation = 6.21e2;// equivalent to 6.21 x 102 i.e. 621

Caractere e literais de string

Os literais de caractere são usados para inicializar variáveis de tipos de dados char.
Os literais de caracteres são colocados entre aspas simples. Por exemplo, 'x' , 'p' , etc.
Eles podem ser representados como caractere, sequência de escape hexadecimal, representação unicode ou valores integrais convertidos em char.
```
char ch1 = 'R';// character
char ch2 = '\x0072';// hexadecimal
char ch3 = '\u0059';// unicode
char ch4 = (char)107;// casted from integer
```
Os literais de string são a coleção de literais de caracteres.
Eles estão entre aspas duplas. Por exemplo, "Olá" , "Programação fácil" , etc.
```
string firstName = "Richard";
string lastName = " Feynman";
```
C# também suporta caracteres de sequência de escape, como:

Personagem Significado

\' Aspas simples

\" Aspas duplas

\\ Barra invertida

\n Nova linha

\r Devolução de carro

\t Guia horizontal

\a Alerta

\b Retrocesso