C# for Beginners: Core Concepts

You have .NET installed. You know what the platform is. Now you need to write actual code.

This post covers the core concepts of C# — the parts that every program uses, explained without unnecessary theory. By the end, you will have built something that works and understand why it works.

Why C#

Before you invest time learning any language, you should know what you are getting into.

Readable — C# reads close to English. It is explicit about what it does. When you come back to your code six months later, you will understand it. That is not a trivial advantage.

Strongly typed — The compiler catches mistakes before your code ever runs. You misspell a variable name, use the wrong type, or forget a return value — the compiler tells you immediately. This is not a limitation. It is a safety net that saves hours of debugging.

Huge ecosystem — NuGet has over 400,000 packages. Whatever you need to build, someone has probably solved part of the problem already.

Great tooling — Visual Studio, Rider, and VS Code with the C# Dev Kit all provide autocompletion, refactoring, and debugging that actually works. The tooling makes learning faster because it shows you your options as you type.

Jobs everywhere — C# consistently ranks in the top 5 most in-demand programming languages. Enterprise software, game development with Unity, cloud services, APIs — the job market is broad and pays well.

Setup in 2 Minutes

Open a terminal and run:

dotnet new console -n MyFirstApp
cd MyFirstApp
dotnet run

That is it. Three commands.

dotnet new console -n MyFirstApp creates a new project folder with a Program.cs file and a project file (MyFirstApp.csproj). The -n flag sets the name. The console template gives you a command-line application — the simplest starting point.

dotnet run compiles and executes your code. You should see Hello, World! in the terminal.

Open Program.cs in your editor. You will see a single line:

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

Modern C# uses top-level statements, which means you do not need a class or Main method to start writing code. The ceremony is gone. You write logic, it runs.

Variables and Types

Variables store data. C# requires you to declare what type of data a variable holds.

int age = 30;
string name = "Ada";
bool isActive = true;
double price = 19.99;

int is a whole number. string is text. bool is true or false. double is a decimal number. There are more types, but these four cover most beginner scenarios.

You can also use var and let the compiler figure out the type:

var count = 10;       // compiler knows this is int
var message = "done"; // compiler knows this is string

var is not dynamic typing. The type is still fixed at compile time — you just did not write it explicitly. The compiler infers it from the value you assign. If you try to assign a string to count later, it will not compile. The safety net stays in place.

When to use var vs explicit types: Use var when the type is obvious from the right side of the assignment. Use explicit types when clarity matters or when someone reading the code cannot immediately tell what the type is.

Control Flow

Programs need to make decisions and repeat actions. C# handles both with familiar syntax.

If/Else — Making decisions:

int temperature = 35;

if (temperature > 30)
{
    Console.WriteLine("It is hot.");
}
else if (temperature > 15)
{
    Console.WriteLine("It is comfortable.");
}
else
{
    Console.WriteLine("It is cold.");
}

The condition in parentheses evaluates to true or false. The code inside the matching block runs. Nothing surprising here.

For — Repeating a known number of times:

for (int i = 0; i < 5; i++)
{
    Console.WriteLine($"Iteration {i}");
}

The $ before the string is string interpolation. It lets you embed variables directly in text with curly braces. You will use this constantly.

Foreach — Iterating over a collection:

string[] languages = { "C#", "F#", "Python", "Rust" };

foreach (string lang in languages)
{
    Console.WriteLine(lang);
}

foreach is how you loop through arrays, lists, and any other collection. It is cleaner than a for loop when you do not need the index.

While — Repeating until a condition changes:

int countdown = 5;

while (countdown > 0)
{
    Console.WriteLine(countdown);
    countdown--;
}

Use while when you do not know in advance how many iterations you need. Be careful to update the condition variable inside the loop, or you get an infinite loop.

Methods

Methods are named blocks of code that do one thing. They take inputs, do work, and optionally return a result.

int Add(int a, int b)
{
    return a + b;
}

void PrintGreeting(string name)
{
    Console.WriteLine($"Hello, {name}!");
}

int result = Add(3, 7);
PrintGreeting("Ada");

int Add(int a, int b) declares a method named Add that takes two integers and returns an integer. void means the method does not return anything — it just performs an action.

Methods are how you stop repeating yourself. If you write the same logic in three places, put it in a method and call it three times instead. When you need to fix a bug, you fix it once.

Classes

A class groups related data and behavior together. This is the basic unit of organization in C#.

class Task
{
    public string Title { get; set; }
    public bool IsComplete { get; set; }

    public void MarkComplete()
    {
        IsComplete = true;
        Console.WriteLine($"'{Title}' marked complete.");
    }
}

You create an instance of a class with new:

Task myTask = new Task();
myTask.Title = "Learn C#";
myTask.IsComplete = false;
myTask.MarkComplete();

public means other code can access that member. { get; set; } creates a property — a variable that belongs to the class with built-in getter and setter methods.

That is enough to understand classes for now. You do not need to learn inheritance, interfaces, abstract classes, or polymorphism today. Those concepts matter, but they matter after you are comfortable creating objects and calling methods on them. Learn the basics first. Layer complexity when you actually need it.

Your First Useful Program

Here is a complete command-line calculator. It takes two numbers and an operator from the user, performs the calculation, and prints the result. Replace the contents of Program.cs with this:

Console.WriteLine("=== Simple Calculator ===");
Console.Write("Enter first number: ");
double num1 = Convert.ToDouble(Console.ReadLine());

Console.Write("Enter operator (+, -, *, /): ");
string op = Console.ReadLine()!;

Console.Write("Enter second number: ");
double num2 = Convert.ToDouble(Console.ReadLine());

string result = Calculate(num1, num2, op);
Console.WriteLine(result);

string Calculate(double a, double b, string operation)
{
    double answer = operation switch
    {
        "+" => a + b,
        "-" => a - b,
        "*" => a * b,
        "/" when b != 0 => a / b,
        "/" => double.NaN,
        _ => double.NaN
    };

    if (double.IsNaN(answer))
    {
        return operation == "/" ? "Error: Cannot divide by zero." : $"Error: Unknown operator '{operation}'.";
    }

    return $"{a} {operation} {b} = {answer}";
}

Run it with dotnet run and try some calculations.

This program uses most of what you learned: variables, types, control flow (the switch expression), methods, string interpolation, and user input. It is not production code — there is no real input validation — but it works, and it demonstrates that you can build something functional with basic concepts.

Notice the switch expression. It is pattern matching — a feature that makes C# more expressive than many people expect. The when b != 0 is a guard clause that adds a condition to the pattern. The _ is the default case, matching anything not explicitly handled.

What to Learn Next

You now have the foundation. Here is what builds on it:

Collections — List<T>, Dictionary<TKey, TValue>, arrays. You will use these in every non-trivial program. Lists grow dynamically, dictionaries map keys to values, and both support LINQ.

LINQ — Language Integrated Query. Filter, transform, and aggregate data with concise, readable syntax. Once you learn LINQ, you will wonder how you wrote code without it. It is one of C#'s genuine competitive advantages.

Async/Await — Asynchronous programming. Any time your code waits for something — a database query, an API call, a file read — async/await lets it do useful work instead of blocking. Modern C# applications use this everywhere.

Error Handling — Try/catch blocks and how to handle failures gracefully. Real programs encounter bad input, missing files, and network failures. Handling errors well is the difference between software that crashes and software that recovers.

Each of these topics deserves its own post, and they are coming.

The Takeaway

C# gives you readable syntax, a compiler that catches your mistakes early, and an ecosystem that scales from a 20-line console app to a distributed system handling millions of requests. The core concepts — variables, types, control flow, methods, and classes — are the same patterns you will use whether you are building a calculator or an enterprise API. They do not change. They just compose into larger structures.

The barrier to writing C# is not the language. It is getting past the assumption that you need to understand everything before you can build something. You do not. You need the concepts in this post and a willingness to look things up when you get stuck.

Next in the learning path: The next post in the Getting Started with .NET series covers collections, LINQ, and how to work with groups of data — the concepts that turn simple programs into useful ones.