Your First C# Program: Create, Build and Run It Step by Step

Write, compile, and run your very first C# program — and understand every step along the way.

You've learned what C# and .NET are. Now it's time to build something real.

In this lesson, you'll create a working C# application from scratch. You'll write code, compile it, and run it. You'll see the entire lifecycle of a C# program — from a blank file to a running application.

Think of this as the "Hello, World!" moment every developer remembers. It's small, but it's the foundation for everything that follows.

What Is a C# Application?

The Simple Explanation

A C# application is a program you write in the C# language that runs on the .NET platform. It's a set of instructions that tells the computer what to do — from printing text to handling complex business logic.

The Technical Definition

A C# application consists of one or more source code files (with a .cs extension) that are compiled into an assembly (a .dll or .exe file) which the .NET runtime executes. The simplest C# application is a console application — a program that runs in a terminal window.

Why Does It Exist?

The Problem

Before you can build anything useful, you need to know how to create any program at all. Many beginners get stuck at the very first step — writing code and seeing it run.

• How do I set up my environment?
• Where do I write the code?
• How do I run it?
• What happens when I run it?

The Solution

Creating a "first application" solves all of these problems. It gives you a working template you can understand, modify, and extend. It's the starting point for every program you'll ever write.

Big Picture

Here's the journey your code takes — from your keyboard to a running application:

How It Works — Step by Step

Let's walk through the entire process of creating and running your first C# application. We'll use the .NET CLI (Command Line Interface) — the tool every .NET developer uses.

Step 1 — Install .NET SDK

First, you need the .NET SDK (Software Development Kit). This includes:

• The C# compiler (csc)
• The .NET runtime (CLR)
• The Base Class Library (BCL)
• The dotnet command-line tool

Download it from dotnet.microsoft.com/download and install it. After installation, open a terminal and verify:

Step 2 — Create a New Project

In your terminal, navigate to where you want to store your projects. Then run:

This command creates a new console application named MyFirstApp. Let's look at what it created:

Step 3 — Open and Understand the Code

Open Program.cs in any text editor or IDE. You'll see this code:

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

That's it. Just one line of code. Let's break it down:

• Console — A built-in .NET class that represents the terminal window
• WriteLine — A method that prints text and moves to a new line
• "Hello, World!" — The text to display

This single line tells .NET: "Write this text to the console."

Step 4 — Run the Application

In the terminal, make sure you're inside the MyFirstApp/ folder. Then run:

Congratulations! You've just written and run your first C# application.

Under the Hood

Let's trace exactly what happens when you run dotnet run. This is the execution flow:

Console.WriteLine("Hello, World!");

                IL_0000: ldstr "Hello, World!"
                IL_0005: call void [System.Console]System.Console::WriteLine(string)
                IL_000A: ret
            

Hello, World!

What's in the .csproj File?

The MyFirstApp.csproj file tells .NET how to build your project. With .NET 10, it's very simple:

        <Project Sdk="Microsoft.NET.Sdk">
          <PropertyGroup>
            <OutputType>Exe</OutputType>
            <TargetFramework>net10.0</TargetFramework>
            <ImplicitUsings>enable</ImplicitUsings>
            <Nullable>enable</Nullable>
          </PropertyGroup>
        </Project>
    

• OutputType — Exe means this is an executable application
• TargetFramework — net10.0 means we target .NET 10
• ImplicitUsings — automatically includes common namespaces (like System)
• Nullable — enables modern null‑safety features

Simple Example — Make It Yours

Now let's change the code. Update Program.cs to say something more personal:

        Console.WriteLine("Hello, C# learner!");
        Console.WriteLine("Welcome to .NET 10.");
    

Run it again:

You've just made your first change! This is how all C# development works:

• Write code
• Run it with dotnet run
• See the result
• Iterate

Real‑World Example

You might think: "But real applications don't just print text."

You're right. But the pattern is exactly the same. Here's how the "Hello, World" pattern scales:

Console.WriteLine("Hello!");

var balance = _accountService.GetBalance(userId);
Console.WriteLine($"Balance: {balance:C}");

The structure is the same: get data → display output. Your first app is the foundation for every app you'll build.

Analogy

Common Confusion

dotnet run vs dotnet build

dotnet run does both — it builds and runs. It's your go‑to for development.

Common Mistakes

Mistake 1 — Not running from the right folder

Wrong: Running dotnet run from the wrong folder
Correct: Navigate to the folder containing .csproj first

Mistake 2 — Forgetting to save the file

Wrong: Edit code, don't save, run → old output
Correct: Save (Ctrl+S) before running

Mistake 3 — Confusing WriteLine with Write

Console.Write("Hello");
Console.Write("World");

Console.WriteLine("Hello");
Console.WriteLine("World");

When Should I Use This?

Use this pattern whenever you:

• Start a new project — Every new app begins the same way
• Test a new idea — Create a console app to experiment with code
• Learn a new concept — Use a console app to practice without complexity
• Build a CLI tool — Many developer tools are console applications

When you might use something different:

• Web application — Use dotnet new web for ASP.NET Core
• Class library — Use dotnet new classlib for reusable components
• Mobile app — Use MAUI templates for cross‑platform mobile

The console app is your foundation — you'll always come back to it.

Mental Model

Key Takeaway

Check Your Understanding

You've created your first C# application, seen the full compilation and execution pipeline, and learned the essential .NET CLI commands. Now let's make sure you can apply this knowledge.

Console.WriteLine("Hello");
Console.Write("World");

HelloWorld

You've written your first C# application and understand the entire development lifecycle!