What Is C#? The Language, .NET, Versions and a First Program

C# (pronounced "C sharp") is a general-purpose programming language designed at Microsoft by a team led by Anders Hejlsberg, first released in 2002. It is statically typed (every variable has a type the compiler checks before the program runs), object-oriented (code is organized into classes), and managed (a garbage collector frees memory for you). Modern C# also borrows heavily from functional programming: lambdas, LINQ queries, pattern matching and immutable records.

Here is a complete C# program. Press Run:

using System;

class Program
{
    static void Main()
    {
        string name = "Ada";
        int year = 2026;
        Console.WriteLine($"Hello, {name}! It is {year}.");
    }
}

Output:

Hello, Ada! It is 2026.

What C# is used for

C# is a general-purpose language, so it is found in most kinds of software, but a few areas account for most of it:

• Games. Unity, one of the most widely used game engines, is scripted in C#. Godot supports it as well.
• Web backends. ASP.NET Core is the .NET web framework for APIs, websites and real-time apps. It is one of the fastest mainstream web frameworks in public benchmarks.
• Desktop apps. WPF and Windows Forms on Windows, .NET MAUI and Avalonia across platforms.
• Cloud and services. Azure Functions, background workers, microservices in containers.
• Tools and automation. Command-line tools, build scripts, data processing.

It is especially common in enterprise companies that run on Microsoft technology and in game studios. Mobile apps are possible with .NET MAUI (the successor to Xamarin), but that is a smaller niche than Kotlin or Swift.

C# and .NET are not the same thing

C# is the language. .NET is the platform that runs it, and it has three parts:

1. The runtime (CLR). The C# compiler does not produce machine code. It produces Intermediate Language (IL), stored in .dll or .exe files. When the program runs, the Common Language Runtime compiles that IL to native code just in time (JIT), manages memory with a garbage collector, and enforces type safety.
2. The base class library. Collections, file access, networking, text, dates, threading: everything under System.*.
3. The SDK. The dotnet command that creates, builds, tests and runs projects.

Other languages compile to the same IL (F#, Visual Basic), which is why a C# program can use a library written in F#.

There are two generations of the platform. .NET Framework (1.0 in 2002 to 4.8.1) is Windows only and still runs many older applications. .NET (called .NET Core until version 5) is the open source, cross-platform successor that runs on Windows, Linux and macOS. New work targets .NET; even-numbered releases such as .NET 8 and .NET 10 get three years of long-term support.

How a C# program is structured

A C# program is made of types (classes, structs, interfaces, enums, records) that contain members (fields, properties, methods). Execution starts in a static method named Main. Namespaces group related types, and using directives let you refer to them by short names.

using System;
using System.Collections.Generic;

class Order
{
    public string Customer { get; }
    public decimal Total { get; private set; }

    public Order(string customer)
    {
        Customer = customer;
    }

    public void Add(decimal price, int quantity)
    {
        Total += price * quantity;
    }
}

class Program
{
    static void Main()
    {
        var orders = new List<Order>();

        var first = new Order("Maya");
        first.Add(4.50m, 2);
        first.Add(12.00m, 1);
        orders.Add(first);

        var second = new Order("Leo");
        second.Add(3.25m, 4);
        orders.Add(second);

        foreach (var order in orders)
        {
            Console.WriteLine($"{order.Customer}: {order.Total:F2}");
        }
    }
}

Output:

Maya: 21.00
Leo: 13.00

A few things are already visible: Order is a class with two properties (Customer, Total), a constructor, and a method. decimal is the type for money, and the m suffix marks a decimal literal. var lets the compiler infer a local variable's type, and List<Order> is a generic collection that only accepts Order objects. The {order.Total:F2} inside $"..." formats a number with two decimals.

In a real project each class usually lives in its own file, and the files are compiled together into one assembly. See classes and objects for the details.

Static typing, in practice

The compiler knows the type of every expression, so a large class of mistakes never reaches a running program. Assigning a string to an int, calling a method that does not exist, or passing arguments in the wrong order fails at compile time with an error pointing at the line.

using System;

class Program
{
    static void Main()
    {
        int quantity = 3;
        decimal price = 9.99m;

        // quantity = "three";  // error CS0029: Cannot implicitly convert type 'string' to 'int'

        decimal total = quantity * price; // int converts to decimal automatically
        Console.WriteLine(total);

        int parsed = int.Parse("42");      // text to number is explicit
        Console.WriteLine(parsed + quantity);
    }
}

Output:

29.97
45

Types also drive the editor: autocomplete, rename and "find all references" are exact in C# because the tooling reads the same type information the compiler does.

C# versions and what they added

Since C# 9 in 2020, a new version ships every November together with a new .NET release; before that, versions came every two to three years. Each version is designed to keep existing code compiling, and the rare exceptions (such as field becoming a keyword inside property accessors in C# 14) are documented as breaking changes, so a program written for C# 2 almost always compiles unchanged today.

Newer versions mostly remove ceremony. This C# 9 and later program uses top-level statements (no class Program, no Main), a record and a switch expression:

// C# 9 and later, in a .NET 6+ project (implicit usings import System)
var order = new Order("Maya", 21.00m);
Console.WriteLine(Shipping(order));

static string Shipping(Order o) => o.Total switch
{
    >= 50m => "free shipping",
    >= 20m => "standard shipping",
    _ => "shipping fee applies"
};

record Order(string Customer, decimal Total);

The same logic in the older explicit style, which compiles on C# 6 and every later version:

using System;

class Order
{
    public string Customer { get; }
    public decimal Total { get; }
    public Order(string customer, decimal total) { Customer = customer; Total = total; }
}

class Program
{
    static string Shipping(Order o)
    {
        if (o.Total >= 50m) return "free shipping";
        if (o.Total >= 20m) return "standard shipping";
        return "shipping fee applies";
    }

    static void Main()
    {
        var order = new Order("Maya", 21.00m);
        Console.WriteLine(Shipping(order));
    }
}

Output:

standard shipping

Both forms are valid C#. You will meet the older, explicit style in existing code, tutorials and Unity projects, and the shorter style in new .NET projects.

LINQ: querying data in the language

LINQ (Language Integrated Query, C# 3) is one of the features people cite when they explain why they like C#. It lets you filter, sort, group and transform any collection with a chain of methods:

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        var scores = new[] { 72, 95, 58, 88, 64, 91 };

        var passed = scores
            .Where(s => s >= 65)
            .OrderByDescending(s => s)
            .ToList();

        Console.WriteLine(string.Join(", ", passed));
        Console.WriteLine($"Average: {scores.Average():F1}");
        Console.WriteLine($"Best: {scores.Max()}");
    }
}

Output:

95, 91, 88, 72
Average: 78.0
Best: 95

The same syntax works on lists in memory, on database tables through Entity Framework, and on XML. More in LINQ.

Is C# a good first language?

C# asks for more up front than Python: you declare types, end statements with semicolons, and put code inside classes. In exchange, the compiler catches mistakes early, the tooling (Visual Studio, VS Code, Rider) is excellent, and the concepts transfer directly to Java, TypeScript, Kotlin and C++. If you want to build Unity games or work in a .NET shop, it is the obvious choice. If your goal is data analysis or machine learning, Python has the larger ecosystem.

To start, install the .NET SDK and run dotnet new console, or begin with Hello World and run the examples on these pages directly.