C# is statically typed — variables have a type known at compile time. You can declare a variable with an explicit type or use var for type inference (the compiler deduces the type from the value), but either way the type is fixed.
count = ;
name = ;
price = ;
active = ;
age = ;
message = ;
items = List<>();
var infers the type from the initializer — var age = 30 is exactly int age = 30. Crucially, var is still statically typed: the type is fixed at compile time (you can't later assign a string to age); it's just inferred, not dynamic.
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
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 when the type is obvious from the right-hand side (reduces redundancy, especially with long generic types); use explicit types when it aids clarity.
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
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
Understanding variable declaration and var is fundamental everyday C# knowledge.
The key conceptual point is that var is type inference, not dynamic typing — a common misconception.
With var, the compiler deduces the type from the initializer, but the type is still fixed at compile time (you get all the benefits of static typing — type checking, IntelliSense, performance), just without writing the type name explicitly.
This makes var a convenience for readability (especially with verbose generic types like Dictionary<string, List<int>>) rather than a loosening of the type system.
Knowing when to use var (when the type is obvious from the right side, reducing redundancy) versus explicit types (when it aids clarity), along with the built-in types (notably decimal for money — exact decimal arithmetic, unlike double), constants (const, readonly), is everyday knowledge for writing C#.
Understanding that C# is statically typed throughout (whether you write the type or use var), and the idioms around variable declaration, is foundational for reading and writing clean, correct C# code, and the var-is-not-dynamic point is a frequent clarification that reflects proper understanding of the language.