Como você declara variáveis e usa var?

Question

Accepted Answer

C# é estaticamente tipado — variáveis têm um tipo conhecido em tempo de compilação. Você pode declarar uma variável com um tipo explícito ou usar **`var`** para inferência de tipo (o compilador deduz o tipo do valor), mas de qualquer forma o tipo é fixo. ## Declarando variáveis ```csharp int count = 42; // explicit type string name = "Ann"; double price = 9.99; bool active = true; var age = 30; // inferred as int (var = let the compiler figure it out) var message = "Hello"; // inferred as string var items = new List(); // inferred as List ``` `var` infere o tipo do inicializador — `var age = 30` é exatamente `int age = 30`. Crucialmente, **`var` ainda é estaticamente tipado**: o tipo é fixo em tempo de compilação (você não pode depois atribuir uma string a `age`); é apenas inferido, não dinâmico. ## var requer um inicializador e mantém o tipo fixo ```csharp var x = 5; x = "hi"; // ❌ compile error — x is an int, can't become a string var y; // ❌ error — var needs an initializer to infer from ``` ## Quando usar var (estilo) ```csharp var user = new UserService(); // ✅ type is obvious from the right side — var is clean var count = users.Count; int total = CalculateComplexValue(); // explicit when the type isn't obvious aids readability ``` Use `var` quando o tipo é óbvio do lado direito (reduz redundância, especialmente com tipos genéricos longos); use tipos explícitos quando ajuda na clareza. ## Constantes e outras declarações ```csharp const double Pi = 3.14159; // compile-time constant (can't change) readonly int id; // set once (in constructor), then immutable int a = 1, b = 2; // multiple of the same type nint nativeInt; // platform-sized integer ``` ## Tipos built-in comuns ```text int, long, short, byte integers float, double, decimal floating point (decimal for money — exact) bool, char, string boolean, character, text object the base of all types ``` ## Por que isso importa Compreender declaração de variáveis e `var` é conhecimento fundamental do C# do dia a dia. O ponto conceitual chave é que **`var` é inferência de tipo, não digitação dinâmica** — um equívoco comum. Com `var`, o compilador deduz o tipo do inicializador, mas o tipo ainda é fixo em tempo de compilação (você obtém todos os benefícios da tipagem estática — verificação de tipo, IntelliSense, desempenho), apenas sem escrever o nome do tipo explicitamente. Isso torna `var` uma conveniência para legibilidade (especialmente com tipos genéricos verbosos como `Dictionary>`) em vez de um afrouxamento do sistema de tipos. Saber quando usar `var` (quando o tipo é óbvio do lado direito, reduzindo redundância) versus tipos explícitos (quando ajuda na clareza), junto com os tipos built-in (notavelmente **`decimal` para dinheiro** — aritmética decimal exata, diferentemente de `double`), constantes (`const`, `readonly`), é conhecimento do dia a dia para escrever C#. Compreender que C# é estaticamente tipado em toda parte (quer você escreva o tipo ou use `var`), e os idiomas em torno da declaração de variáveis, é fundamental para ler e escrever código C# limpo e correto, e o ponto var-não-é-dinâmico é uma clarificação frequente que reflete compreensão apropriada da linguagem.