Syntax Basics

This chapter covers the everyday building blocks of C#: variables, methods, control flow, string interpolation, and the namespaces that organize your code. If you have written C, Java, or JavaScript, most of the syntax will feel familiar right away.

Variables and Constants

C# is statically typed, so every variable's type is fixed at compile time. You can spell the type out, or use var and let the compiler infer it from the right-hand side. Either way the type is locked in; var is not a dynamic type.

int count = 10;
double price = 19.99;
string title = "Learning C#";
bool isActive = true;

var total = count * price;      // inferred as double
var names = new List<string>(); // inferred as List<string>

const int MaxRetries = 3;       // compile-time constant
count += 5;                     // variables can be reassigned
// MaxRetries = 4;              // error: constants cannot change

By convention, locals and parameters use camelCase, while methods, properties, types, and constants use PascalCase. Statements end with a semicolon.

Methods

A method declaration lists a return type, a name, and parameters; use void when nothing is returned. When the body is a single expression, the => arrow form keeps it short.

static int Add(int a, int b)
{
    return a + b;
}

static int Square(int x) => x * x;

// optional parameter with a default value
static string Greet(string name, string greeting = "Hello")
    => $"{greeting}, {name}!";

Console.WriteLine(Add(2, 3));                         // 5
Console.WriteLine(Square(4));                         // 16
Console.WriteLine(Greet("Sam"));                      // Hello, Sam!
Console.WriteLine(Greet(greeting: "Hi", name: "Jo")); // named arguments

Methods declared in a top-level statements file become local functions inside the generated entry point. Inside a class, a static method belongs to the type itself, while a method without static belongs to each instance. Methods can also hand back extra values through out parameters; int.TryParse is the classic example.

Control Flow

Conditionals and loops look just like other curly-brace languages. On top of that, C# offers switch expressions and pattern matching for compact branching.

int score = 87;

if (score >= 90)
    Console.WriteLine("A");
else if (score >= 80)
    Console.WriteLine("B");
else
    Console.WriteLine("C or below");

string grade = score switch
{
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    _ => "F",
};

for (int i = 0; i < 3; i++)
    Console.WriteLine($"for: {i}");

foreach (var fruit in new[] { "apple", "pear", "plum" })
    Console.WriteLine($"foreach: {fruit}");

int n = 0;
while (n < 3)
{
    n++;
    if (n == 2) continue; // skip to the next iteration
    Console.WriteLine($"while: {n}");
}