C# Program Structure

Anatomy of a Full Program

While top-level statements are great for small scripts, real C# programs use an explicit structure with namespaces, classes, and a Main method. Understanding this structure now will make later OOP lessons — where you'll define many classes across many files — much easier to reason about.

using System;

namespace MyApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello from a fully structured program!");
        }
    }
}

Reading from the outside in: using System brings in a library; namespace MyApp groups everything below it under that name; class Program defines a container for code; and Main is the specific method the runtime looks for and calls first.

Namespaces

A namespace groups related classes together and prevents naming collisions between libraries — it works like a folder for your code, except purely at the language level rather than the file system. Two different classes named Logger can coexist peacefully in the same project as long as they live in different namespaces (e.g., MyApp.Logging.Logger and ThirdParty.Diagnostics.Logger).

namespace MyApp.Services
{
    class EmailService { }
}

namespace MyApp.Models
{
    class User { }
}

File-Scoped Namespaces (C# 10+)

Since C# 10 (2021), a file-scoped namespace declaration removes one whole level of curly-brace nesting and indentation, when every class in a file belongs to the same namespace (the overwhelmingly common case).

namespace MyApp
{
    class Program
    {
        static void Main()
        {
            // ...
        }
    }
}

namespace MyApp;

class Program
{
    static void Main()
    {
        // ...
    }
}

using Directives & Global Usings

A using directive at the top of a file imports a namespace, so you can reference its types without fully spelling out their path every time.

using System;              // brings in Console, DateTime, etc.
using System.Collections.Generic; // brings in List<T>, Dictionary<K,V>, etc.

Console.WriteLine("No need to write System.Console.WriteLine every time.");

Modern .NET projects with ImplicitUsings enabled (the default, as seen in the .csproj file from the previous lesson) automatically add a handful of the most common using directives — like System — to every file for you, which is why the very first "Hello, World!" program in this course needed no using statement at all.

For a using directive you want applied across your entire project rather than repeated in every file, a global using declares it once.

global using System;
global using System.Collections.Generic;

Classes

Every executable statement in C# lives inside a class (or, since C# 9, is generated implicitly for you by top-level statements). Classes are the fundamental building block of C#'s object-oriented design — a topic this course dedicates an entire section to later, starting with the "Classes & Objects" lesson.

The Main Method

Main() is the entry point of a traditionally structured C# application — the first code that runs when your program starts, found and invoked automatically by the .NET runtime. It can optionally accept command-line arguments through the `string[] args` parameter, and can optionally return an integer exit code instead of nothing.

Reading Command-Line Arguments

The args parameter is simply an array of strings, one per argument passed when the program was launched.

static void Main(string[] args)
{
    if (args.Length == 0)
    {
        Console.WriteLine("No arguments provided.");
        return;
    }

    Console.WriteLine($"You passed {args.Length} argument(s):");
    foreach (string arg in args)
    {
        Console.WriteLine($"- {arg}");
    }
}

dotnet run -- Alice 28 Engineer

In top-level statements form, the same args array is available implicitly, without needing to declare a Main method at all.

foreach (string arg in args)
{
    Console.WriteLine(arg);
}

Comments

// This is a single-line comment

/* This is a
   multi-line comment */

/// <summary>
/// XML documentation comment — shown in IntelliSense
/// </summary>
/// <param name="name">The user's display name.</param>
static void Greet(string name)
{
    Console.WriteLine($"Hello, {name}!");
}

The triple-slash /// form is not just a fancier comment — it generates structured XML documentation that IntelliSense reads and displays as a tooltip anywhere the method is called, and can even be compiled into a separate .xml file for generating full API documentation websites.

Common Beginner Mistakes

FAQs

Key Takeaways

Summary

You now understand the full anatomy of a C# program — namespaces, classes, Main, and comments — which prepares you for the deeper object-oriented programming lessons later in this course. Next, you'll start working with variables, the basic containers every program uses to store data.