C# Hello World: Main, Console.WriteLine and ReadLine

The classic first program prints one line of text. In C# it looks like this:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello, World!");
    }
}

Output:

Hello, World!

Line by line

• using System; lets you write Console instead of the full name System.Console. Console is a class in the System namespace (see namespaces and using).
• class Program declares a class. All C# code lives inside a type; the name Program is a convention, not a requirement.
• static void Main() is the entry point. When the program starts, the runtime looks for a static method named Main and calls it. static means it belongs to the class itself, so no object has to be created first. void means it returns nothing.
• Console.WriteLine("Hello, World!"); calls the WriteLine method with a string argument. Every statement ends with a semicolon.
• The braces { } mark the body of the class and of the method.

C# is case sensitive. console.writeline and main are different names from Console.WriteLine and Main, and neither exists.

Console.WriteLine vs Console.Write

WriteLine adds a newline after the text. Write does not, so the next output continues on the same line. Both accept any type, not only strings: numbers, booleans and objects are converted with their ToString() method.

using System;

class Program
{
    static void Main()
    {
        Console.Write("Loading");
        Console.Write(".");
        Console.Write(".");
        Console.WriteLine(" done");

        Console.WriteLine(42);
        Console.WriteLine(true);
        Console.WriteLine();              // an empty line

        string item = "coffee";
        decimal price = 3.20m;
        Console.WriteLine("Item: " + item);             // concatenation
        Console.WriteLine($"{item} costs {price:F2}");   // interpolation
        Console.WriteLine("{0} costs {1:F2}", item, price); // composite format
    }
}

Output:

Loading.. done
42
True

Item: coffee
coffee costs 3.20
coffee costs 3.20

Notice that true prints as True: that is what bool.ToString() returns. The $"..." form, called string interpolation, is the one you will use most; see string interpolation for the format codes like :F2.

Reading input with Console.ReadLine

Console.ReadLine() waits for the user to type a line and press Enter, then returns that line as a string without the newline. At the end of input (for example when input is redirected from a file that has run out) it returns null.

// stdin: Maya\n27
using System;

class Program
{
    static void Main()
    {
        Console.Write("What is your name? ");
        string name = Console.ReadLine();

        Console.Write("How old are you? ");
        string ageText = Console.ReadLine();

        int age;
        if (int.TryParse(ageText, out age))
        {
            Console.WriteLine();
            Console.WriteLine($"Hi {name}, next year you will be {age + 1}.");
        }
        else
        {
            Console.WriteLine();
            Console.WriteLine($"'{ageText}' is not a number.");
        }
    }
}

Output:

What is your name? How old are you? 
Hi Maya, next year you will be 28.

When you run this in a terminal, the text you type appears after each prompt. The output above has no typed text in it because the input was redirected (piped in) rather than typed, so only what the program itself writes shows up.

ReadLine always returns text. To use the value as a number you have to convert it. int.Parse(text) throws a FormatException when the text is not a number; int.TryParse returns false instead, which is why it is the right choice for user input. The details are in type conversion.

Two related methods: Console.Read() returns the next character as an int code, and Console.ReadKey() reads a single key press without waiting for Enter (it only works in an interactive terminal).

The Main method's other forms

Main can take the command-line arguments and can return an exit code. These are all valid entry points:

static void Main()
static void Main(string[] args)
static int Main()
static int Main(string[] args)
static async Task Main()             // C# 7.1 and later
static async Task<int> Main(string[] args)  // C# 7.1 and later

A returned int becomes the process exit code, which scripts and CI systems read to decide whether the program succeeded (0 means success by convention).

using System;

class Program
{
    static int Main(string[] args)
    {
        Console.WriteLine($"Got {args.Length} argument(s)");
        foreach (string arg in args)
        {
            Console.WriteLine("  " + arg);
        }
        return 0;
    }
}

Output:

Got 0 argument(s)

Run it with dotnet run -- apples pears and args holds "apples" and "pears". The -- separates arguments for your program from arguments for the dotnet tool.

Comments

C# has three kinds of comments. The compiler ignores all of them.

// A single-line comment runs to the end of the line.

/* A block comment
   can span several lines. */

/// <summary>
/// An XML documentation comment. Editors show it as the tooltip for the method.
/// </summary>
static decimal ApplyDiscount(decimal price) => price * 0.9m;

Use // for notes inside code. /// comments go on types and public members; the IDE displays them when you hover over a call, and the compiler can export them to an XML file for documentation tools.

Creating and running a project with dotnet

On your own machine, install the .NET SDK from dotnet.microsoft.com, then:

dotnet new console -o HelloApp
cd HelloApp
dotnet run

Hello, World!

dotnet new console creates two files: HelloApp.csproj (the project file: target framework, settings, package references) and Program.cs. dotnet run compiles the project and runs it. dotnet build compiles without running and writes the output to bin/Debug/net8.0/ (the folder name follows your target framework).

Top-level statements (C# 9 and later)

Open the generated Program.cs and you will find this, and nothing else:

// See https://aka.ms/new-console-template for more information
Console.WriteLine("Hello, World!");

This is a top-level statements program, a C# 9 feature. The compiler generates the Program class and the Main method around your statements. using System; is also missing because .NET 6 and later projects enable implicit usings: common namespaces such as System, System.IO, System.Linq and System.Collections.Generic are imported for the whole project.

Top-level programs can still read args, use await, and return an exit code:

// C# 9 and later: the whole Program.cs
Console.Write("Name: ");
string? name = Console.ReadLine();
Console.WriteLine($"Hello, {name}! You passed {args.Length} arguments.");
return 0;

Only one file per project can contain top-level statements, and types (classes, records) must come after them. The string? annotation is a nullable reference type (C# 8), and it is there because ReadLine can return null. The explicit class Program form used in the examples on this page is equivalent and is what you will see in older code and in most Unity scripts, so it is worth being able to read both. Pass --use-program-main to dotnet new console if you prefer the explicit form in new projects.

Errors you will see first

• CS1002: ; expected. A statement is missing its semicolon. The error is reported at the end of the line that is missing it.
• CS0103: The name 'console' does not exist in the current context. Wrong capitalization, or a missing using System; in a project without implicit usings.
• CS5001: Program does not contain a static 'Main' method suitable for an entry point. Main is misspelled, not static, or has an unsupported signature.
• CS0017: Program has more than one entry point defined. Two classes each have a Main. Keep one, or pick one with the StartupObject setting in the .csproj.
• The window closes immediately. When a console app is started by double-clicking, the window closes when Main returns. Run it from a terminal, or add Console.ReadKey(); at the end while testing.