Implicitly Typed Variable

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

var variableName = initializationExpression;

​

Core Mechanics

• Static Typing: The var keyword does not create a dynamically typed variable (unlike the dynamic keyword). Once the compiler infers the type during initialization, that type is immutable for the lifetime of the variable. Attempting to assign a value of an incompatible type later in the code will result in a compiler error.
• Compile-Time Resolution: The Common Intermediate Language (CIL) generated by the compiler for an implicitly typed variable is identical to the CIL generated for an explicitly typed variable. There is zero runtime performance overhead associated with using var.

​

Structural Variations and Mandatory Usage

• Anonymous Types: The var keyword is strictly mandatory when declaring a variable initialized with an anonymous type. Because the compiler generates a distinct, unspeakable (non-denotable) name for the anonymous type at compile time, it is impossible to explicitly write the type in the source code.
• Inline out Variable Declarations: The var keyword can be used to implicitly type an out variable directly within a method call’s argument list. Instead of requiring a right-hand assignment, the compiler infers the variable’s type directly from the method’s parameter signature.

​

Syntactic Rules and Constraints

1. Mandatory Initialization: A standard implicitly typed variable must be initialized in the exact same statement as its declaration.
2. Non-Null Initialization: The initialization expression cannot be exactly null, as null does not possess a distinct type. It can, however, be assigned a typed null value via casting.
3. Local Scope Restriction: The var keyword can only be used for local variables declared within method bodies, constructors, or block scopes (like for, foreach, or using statements). It cannot be used for class-level fields, method parameters, or return types.
4. Single Declarator: Multiple implicitly typed variables cannot be declared in a single comma-separated statement.
5. Lambda and Method Group Constraints: A lambda expression or method group can only be assigned to an implicitly typed variable if the compiler can infer a “natural type” (a feature introduced in C# 10). For example, a lambda must have explicitly typed parameters for the compiler to successfully deduce its delegate type (e.g., Func<int, int>). If the parameters are untyped, type inference fails.

​

Code Examples

var integerValue = 10;                  // Inferred as System.Int32
var stringValue = "Hello";              // Inferred as System.String
var objectInstance = new HttpClient();  // Inferred as System.Net.Http.HttpClient
var typedNull = (string)null;           // Inferred as System.String
var lambda = (int x) => x + 1;          // Inferred as System.Func<System.Int32, System.Int32> (C# 10+)

// Mandatory usage with an anonymous type
var anonymousObj = new { Name = "Alice", Age = 30 }; 

// Inline 'out' variable declaration
if (int.TryParse("123", out var parsedNumber)) 
{
    // parsedNumber is inferred as System.Int32
}

var uninitialized;                      // Error: Implicitly-typed variables must be initialized
var nullValue = null;                   // Error: Cannot assign <null> to an implicitly-typed variable
var x = 1, y = 2;                       // Error: Implicitly-typed variables cannot have multiple declarators
var untypedLambda = x => x + 1;         // Error: Cannot assign lambda expression to an implicitly-typed variable

// Error: Cannot implicitly convert type 'string' to 'int'
var number = 42; 
number = "Forty-Two";