Program Structure and Compilation

Vaibhav • September 11, 2025

In the previous article, we wrote and ran our first C# program using the Main method and Console.WriteLine. Now it’s time to zoom out and understand how a C# program is structured at a higher level. What are namespaces? Why do we need classes? What exactly happens when we compile our code? This article answers those questions and introduces you to the anatomy of a C# project and how it transforms from source code into something the computer can actually run.

Understanding the Building Blocks

Every C# program is made up of a few essential building blocks: namespaces, classes, and methods. You’ve already seen the Main method in action. Let’s now look at how it fits into the bigger picture.

using System;

namespace HelloWorld
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello from structured C#!");
        }
    }
}

This is a complete, minimal C# program. Let’s walk through it from top to bottom.

The using System; line tells the compiler that we want to use the System namespace, which contains the Console class. Without this line, we’d have to write System.Console.WriteLine every time.

The namespace HelloWorld block wraps our code in a logical container. Namespaces help organize code and prevent naming conflicts. For example, two different libraries might both have a class called Logger, but if they’re in different namespaces, they won’t clash.

Inside the namespace, we define a class called Program. In C#, all executable code must live inside a class. This is part of the object-oriented nature of the language.

Finally, we have the Main method. This is the entry point of the program-the first method that runs when the application starts. It must be static because it’s called by the runtime before any objects are created.

What Happens When You Compile?

When you write C# code, you’re writing source code. This is the human-readable text that lives in files like Program.cs. But computers don’t run source code directly-they need it in a form they can understand.

Here’s what happens when you compile your code:

dotnet build

This command triggers the C# compiler, which performs several steps:

• Step 1: The compiler checks your code for syntax errors.
• Step 2: If everything is valid, it translates your source code into Intermediate Language (IL).
• Step 3: The IL is packaged into a .dll or .exe file, depending on the project type.

This IL is not yet machine code. It’s a platform-independent representation of your program. When you run the program, the .NET runtime (CLR) takes over and compiles the IL into native machine code using a Just-In-Time (JIT) compiler.

Where Does the Output Go?

After running dotnet build, your compiled files are placed in the bin/Debug/netX.X/ folder (where X.X is your .NET version).

You’ll typically see:

• HelloWorld.dll - the compiled IL code
• HelloWorld.pdb - debugging symbols (used by debuggers)
• ref/ and obj/ folders - intermediate build artifacts

You can run the compiled program directly using:

dotnet bin/Debug/net8.0/HelloWorld.dll

This is equivalent to dotnet run, but it separates the build and execution steps.

Why This Structure Matters

Understanding the structure of a C# program helps you write better code. It also prepares you for more advanced topics like multiple classes, custom namespaces, and modular design.

For now, just remember:

• Every program starts in Main
• All code lives inside a class
• Classes are grouped into namespaces
• Compilation turns your code into IL, which the CLR executes

Summary

In this article, you learned how C# programs are structured and compiled. You now understand:

• How namespaces, classes, and the Main method work together
• The difference between source code, IL, and executable output
• How to compile your code using dotnet build
• Where the compiled files are stored and how to run them

These concepts form the foundation of every C# application. In the next article, we’ll explore how to write comments and documentation that make your code easier to understand and maintain.