C# Introduction: Understand Your First Program

What you will understand

• Distinguish the C# language from the .NET platform and SDK.
• Follow source code through compilation and execution.
• Read a small console program and predict its output.
• Separate text, numbers, calculations, and input assumptions.
• Repair a valid program that produces the wrong answer.

What is C#?

C# is a programming language, pronounced C sharp. A programming language gives you a precise way to describe information, calculations, and decisions. Instead of manually subtracting a workshop's bookings from its capacity, you can write the rule once and ask a program to apply it to different values.

C# is commonly used with .NET to build web applications, APIs, desktop software, services, and other kinds of applications. Different application types need different tools and libraries. Learning the language gives you foundations; it does not mean you already know every web or mobile framework.

We begin with console applications: programs that write text to a terminal. A console gives us a small, visible result without first building buttons, screens, or a database. The same habits—name your information, describe the rule, check the result—remain useful in larger applications.

C#, C++, and Java are different languages. They share some familiar-looking punctuation, but their tools, standard libraries, and program rules are not interchangeable. A Java example cannot become C# simply by changing the filename.

C#, .NET, and the SDK have different jobs

C# is the language you write. .NET is the platform that provides a runtime and libraries for applications. The SDK, or software development kit, adds the tools used to create, build, and run projects. Installing only a runtime is not the same as installing the SDK needed to compile your own program.

A source file such as Program.cs contains the instructions you edit. A project file such as Lesson.csproj describes how the application should be built. Our browser runner supplies the framework references and compiler settings for you; the editor contains only your C# source.

During a typical .NET build, the C# compiler checks the source and produces an assembly containing intermediate instructions and metadata. The .NET runtime loads the application and, in the normal execution model used here, translates methods into machine code as needed. There are other publishing models, including ahead-of-time compilation; you do not need them for this lesson.

Keep the practical distinction simple: the editor changes source, the compiler checks and builds it, and the runtime executes the built application. Output is what the running program produces. A source file is not its own output.

1. WriteEdit Program.cs
2. BuildThe compiler checks and builds an assembly
3. Run.NET executes it and produces output

Read your first program before changing it

Read the two messages below and predict their order. Then select Run code. The service compiles the current editor contents and runs the compiled program in an isolated .NET container. The expected output is a separate reference, not a simulated execution result.

The using System directive lets this file refer to the Console type by its short name rather than writing System.Console. The dot in Console.WriteLine selects a method on Console. Parentheses contain the argument supplied to the method, and the semicolon ends the statement.

These are top-level statements. Modern C# allows the compiler to supply the entry-point structure around them. You can focus on the work the program performs before learning how to design classes and methods. Keep the using line intact and change only a message on your first attempt.

using System;

Console.WriteLine("Welcome to C# practice.");
Console.WriteLine("Read, predict, run, and explain.");

Select Run code to compile and execute this program.

Welcome to C# practice.
Read, predict, run, and explain.

Text that looks like arithmetic is still text

A string is text. Quotation marks tell the compiler where that text begins and ends. The program prints the content rather than treating every word or symbol inside it as an instruction. That is why printing a sentence containing a plus sign does not perform an addition.

Compare all three statements before running them. In the interpolated message, the number is calculated rather than typed directly into the label. If you change an operand, predict both calculated results again. Editing an expected-output reference would not change the executable program.

using System;

Console.WriteLine("12 + 3");
Console.WriteLine(12 + 3);
Console.WriteLine($"Total: {12 + 3}");

Select Run code to compile and execute this program.

12 + 3
15
Total: 15

Follow information through a useful calculation

A workshop has 30 seats and 18 bookings. Independently calculate the answer: 30 minus 18 leaves 12. This small manual prediction gives you something meaningful to compare with the program. A successful run alone does not prove that the rule is correct.

The keyword int declares a whole-number value. The equals sign assigns the value on its right to the name on its left; here it is not an instruction to compare two values. The availableSeats statement uses the values already assigned to totalSeats and bookedSeats.

Change bookedSeats to 20. The new answer should be 10. The names describe the values' roles, not an automatic connection to a live booking service. Both inputs are written into the source, and no person supplies input while this program runs.

This first version assumes that bookings are between zero and the total capacity. With 32 bookings, it prints -2. That tells you the input is outside the assumed domain; the example does not yet reject overbooking. Validation and decisions are later topics, so do not mistake an assumption for an implemented check.

using System;

int totalSeats = 30;
int bookedSeats = 18;
int availableSeats = totalSeats - bookedSeats;

Console.WriteLine("Workshop places");
Console.WriteLine($"Available seats: {availableSeats}");

Select Run code to compile and execute this program.

Workshop places
Available seats: 12

Why some examples contain class Program and Main

You will also encounter the explicit entry-point form below. It performs the same two print operations as the first program. Main is where this version starts; the class groups the method. For now, recognize the wrapper without trying to design your own use of every keyword.

Use either the top-level form or the explicit Main form for one example. Do not paste both complete programs into the same editor and expect both entry points to run. In a project, top-level statements belong to a single source file.

Replace the editor contents when trying a different complete example. This also prevents duplicate local names from unrelated examples from becoming confusing compilation errors. The filename Program.cs is a helpful project convention; it is not a rule requiring every C# class to have that exact name.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Welcome to C# practice.");
        Console.WriteLine("Read, predict, run, and explain.");
    }
}

Select Run code to compile and execute this program.

Welcome to C# practice.
Read, predict, run, and explain.

Optional: run the same programs locally

Install the .NET 10 SDK if you want to practise locally. Create a new project in a new practice folder with the commands above. Replace the generated Program.cs contents with one complete example, save it, then run dotnet run from the folder containing CSharpFirstSteps.csproj. The command builds first when needed, then executes the application. Setup and build messages are separate from the program output shown in this lesson. You do not need a local SDK to use the page's configured browser runner.

dotnet --version
dotnet new console --name CSharpFirstSteps
cd CSharpFirstSteps

Now replace Program.cs with one complete example and save it. Inside the project folder, run:

dotnet run

Change one message and run again. Seeing that change helps confirm you are editing and running the same project.

Predict and repair a believable mistake

The workshop has 30 seats and 18 bookings, but this program says 48 seats are available. Predict the current result, find the incorrect rule, and repair only the calculation. Explain why compilation succeeds even though the answer is wrong.

using System;

int totalSeats = 30;
int bookedSeats = 18;
int availableSeats = totalSeats + bookedSeats;

Console.WriteLine($"Available seats: {availableSeats}");

Select Run code to compile and execute this program.

Available seats: 48

using System;

int totalSeats = 30;
int bookedSeats = 18;
int availableSeats = totalSeats - bookedSeats;

Console.WriteLine($"Available seats: {availableSeats}");

Select Run code to compile and execute this program.

Available seats: 12

Independent lab: a reading tracker

Build a small console reading tracker. A book named The Quiet Library has 120 pages, of which 45 have been read. Calculate the remaining pages and print a labelled three-line summary. Work from the starter before opening the reference solution.

Acceptance checklist

• Store the book title as text and both page counts as whole numbers.
• Calculate pagesLeft from totalPages and pagesRead; do not hard-code 75.
• Print the book title, pages read, and pages left on separate labelled lines.
• Keep the example limited to reporting: no keyboard input, files, or database are required.
• State the assumption that pagesRead is between zero and totalPages.

using System;

string bookTitle = "Choose a title";
int totalPages = 120;
int pagesRead = 0;
int pagesLeft = 0; // Replace with a calculation.

Console.WriteLine($"Book: {bookTitle}");
Console.WriteLine($"Pages read: {pagesRead}");
Console.WriteLine($"Pages left: {pagesLeft}");

Select Run code to compile and execute this program.

Book: Choose a title
Pages read: 0
Pages left: 0

using System;

string bookTitle = "The Quiet Library";
int totalPages = 120;
int pagesRead = 45;
int pagesLeft = totalPages - pagesRead;

Console.WriteLine($"Book: {bookTitle}");
Console.WriteLine($"Pages read: {pagesRead}");
Console.WriteLine($"Pages left: {pagesLeft}");

Select Run code to compile and execute this program.

Book: The Quiet Library
Pages read: 45
Pages left: 75

Test changes, not just the starter values

• pagesRead = 0 should leave 120 pages.
• pagesRead = 45 should leave 75 pages.
• pagesRead = 120 should leave zero pages.
• pagesRead = 130 produces -10: explain why this version does not validate progress.
• Change totalPages to 200 and pagesRead to 80; expect 120 remaining pages.

Common errors and how to investigate them

Questions beginners ask

Recap and next step

C# describes your program; the SDK builds it, and the .NET runtime runs it. A compiler checks language rules, while your predictions and test cases check the intended behavior. You have read complete programs, changed their inputs, and repaired a calculation without pretending that a console report is a full application.

Continue to SDK and editor setup using Next lesson below. You will install the tools, create a project, and verify your own save-build-run workflow.

References and further reading

These are original SovranCode explanations, scenarios, exercises, and quiz questions. Technical details were checked against Microsoft’s documentation.

• Microsoft Learn: A tour of C#
• Microsoft Learn: Create a console application
• Download the .NET SDK

Last updated: 25 October 2026