Learn C# - Basic Syntax & Program Structure

#Introduction

In episode 2 you understood the architecture behind C#. Now it's time to write real code. Episode 3 is the most important foundation because almost all other syntax is built on top of the variables, data types, operators, and control flow we learn here.

C# is an expressive language: there are many ways to write the same thing. In this episode we use the recommended modern style — var for local variables, top-level statements for simple programs, and string interpolation for composing text.

Episode 3 covers the console program structure, variable and constant declarations, basic data types, operators and control flow, and how to run it all with the dotnet CLI.

#Console Program Structure

#Top-level Statements

A new console project from the template uses top-level statements: you write statements directly without a class and Main method. The compiler wraps them automatically. This keeps small programs concise:

Console.WriteLine("Belajar C#");
Console.WriteLine($"Bulan sekarang: {DateTime.Now:MMMM}");

For larger programs, you can still write the Main method explicitly:

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine($"Jumlah argumen: {args.Length}");
    }
}

The second pattern is common in legacy projects or when you need full control over the entry point. For this series, we use top-level statements unless stated otherwise.

#Variable and Constant Declarations

#The var Keyword

var is a shorthand for variable declarations: the type is determined by the compiler from its initial value. This isn't a dynamic variable — the type stays strict, only the writing is shorter:

var nama = "Arman";
var umur = 30;
var gaji = 7.5m;
Console.WriteLine($"{nama} berusia {umur} tahun");

Notice that var gaji = 7.5m is inferred as decimal because of the m suffix. The compiler enforces this type — if you force an incorrect value, the build fails immediately.

#The const and readonly Keywords

Use const for values that are truly fixed and known at compile time. For values determined at runtime but that must not change afterwards, use readonly:

const double Pajak = 0.11;
var namaAplikasi = "Toko";
 
readonly string Region = "id";
Console.WriteLine($"Pajak {Pajak:P0}, region {Region}");

Note: const only applies to primitive types and strings. For complex immutable values, readonly is the right choice.

#Basic Data Types

#Numbers, Text, and Boolean

C# basic data types fit their respective domains:

• int: 32-bit integer, enough for most calculations.
• long: 64-bit integer for large values.
• double: 64-bit floating point, the default for scientific calculations.
• decimal: high-precision decimal for money, free from rounding errors.
• bool: a true or false value.
• string: immutable Unicode text.

int jumlahBarang = 5;
long totalPengunjung = 1_000_000L;
double rataRata = 3.14;
decimal harga = 199_999.99m;
bool stokTersedia = true;
string pesan = "Halo dunia";
 
Console.WriteLine($"{jumlahBarang} | {totalPengunjung} | {harga:C}");

The _ notation as a digit separator has been available since C# 7.0 and makes large numbers easy to read. The L suffix for long and m for decimal assert the literal type.

#Operators and Control Flow

#Comparison and Logical Operators

C# provides comparison operators (<, >, ==, !=) and logical operators (&&, ||, !). Logical evaluation is short-circuit: the expression stops as soon as the result is already determined.

var nilai = 78;
var naikKelas = nilai >= 75;
var beasiswa = naikKelas && nilai > 90;
 
if (beasiswa)
{
    Console.WriteLine("Kalian mendapat beasiswa penuh.");
}
else if (naikKelas)
{
    Console.WriteLine("Kalian naik kelas.");
}
else
{
    Console.WriteLine("Kalian harus mengulang.");
}

#The for and foreach Loops

For looping, for is used when you know the number of iterations, while foreach is safest when processing collections:

for (var i = 1; i <= 5; i++)
{
    Console.WriteLine($"Iterasi ke-{i}");
}
 
var daftar = new[] { "satu", "dua", "tiga" };
foreach (var item in daftar)
{
    Console.WriteLine(item);
}

The foreach var item in daftar loop will never go past the bounds of a collection, making it safer than accessing an index manually.

#Running the Program

#Build and Run

Save all the code above in Program.cs, then run:

dotnet run

If there's a type error, the compiler stops and shows a complete message with the line number. Get into the habit of reading compiler error messages — they'll be your best friend while learning C#.

#Closing

Key takeaways:

• Top-level statements keep small programs concise without a class and Main method.
• var infers the type at compile time, not a dynamic variable.
• const for values fixed at compile time; readonly for values fixed at runtime.
• decimal is required for money; double for scientific calculations.
• Logical operators are short-circuit; foreach is safer than manual indexing.

In the next episode 4 we enter the heart of the C# paradigm: classes, objects, and OOP — class and constructors, encapsulation with properties, inheritance, polymorphism, abstract classes and interfaces, and record types for immutable data.