What You Can Do With C#

Let's get the joke out of the way, because you're going to hear it within four minutes of telling anyone you're learning C#:

"Oh, C#? Isn't that just Microsoft Java?"

Yes. Kind of. A little. Here's the actual story. Back around 2000, Microsoft wanted a modern, garbage-collected, object-oriented language for their shiny new .NET platform. Java existed and was extremely popular. Microsoft had previously shipped their own version of Java, Sun sued them into the sea, and the whole thing ended in tears and lawyers. So Microsoft did the very sensible, very corporate thing: they hired Anders Hejlsberg, the man who built Turbo Pascal and Delphi, and said: "make us a Java, but ours, and don't get us sued."

He did. And then he kept improving it for twenty-five years while Java spent a decade arguing about whether it should add lambdas. So calling C# "Microsoft Java" today is like calling a smartphone "a Microsoft telegraph." Technically, you can trace the lineage. It is also extremely funny to the person being insulted, which is the only thing that matters.

So, what can you actually do with this thing? More than you'd think. Let's take the tour.

First, the obligatory Hello World

Every language tour is legally required to start here. C#'s has changed a lot, which tells you something about the language's whole vibe.

The old way, circa 2005, was a ceremony:

using System;

namespace MyFirstApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, world!");
        }
    }
}

Eleven lines to say hello. You needed a namespace, a class, a Main method with a specific signature, and the kind of static void incantation that makes beginners quietly close the tab and go learn Python instead.

The modern way (C# 9 and later) is this:

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

That's the whole program. The compiler quietly puts all the ceremony back for you behind the scenes. This is C# in a nutshell: it grew up in a buttoned-up enterprise suit, and over twenty years it has slowly been allowed to loosen its tie.

Thing one: it builds the boring software that runs the world

Here is the unglamorous truth. The single biggest thing C# does is business software — the web APIs, the internal tools, the systems that process your insurance claim and your payroll and your tax return. This is done with ASP.NET Core, and it is genuinely excellent at it.

A whole working web API in modern C# looks like this:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/users/{id}", (int id) => new { Id = id, Name = "Mom" });

app.Run();

Run that and you have a real web server answering real HTTP requests. (And yes — /users/{id} with a sequential integer is the German Tank Problem waiting to happen, but that's a different article, and you've already read it.)

"Boring" is doing a lot of heavy lifting here as a compliment. Boring means it pays the bills. Boring means there are jobs. Nobody puts "enterprise C# developer" on a hoodie, but they do put it on a mortgage application, and the bank, also running C#, approves it.

Thing two: it secretly makes most of your video games

This is the fun one, and it's the reason a lot of people learn C# without even meaning to.

Unity, the engine behind a frankly absurd chunk of the games you've played, especially indie hits and basically everything on mobile, is scripted in C#. Hollow Knight, Cuphead, Among Us, Pokémon GO, and Cities: Skylines. All C#.

When you write game logic in Unity, you're writing things like:

void Update()
{
    if (Input.GetKeyDown(KeyCode.Space))
    {
        rigidbody.AddForce(Vector3.up * jumpHeight);
    }
}

That's "every frame, if the player hits space, launch them upward." That's a jump. You just made a character jump. Congratulations, you are now technically a game developer and contractually obligated to start and never finish three different projects.

There's a beautiful bait-and-switch here: thousands of people who would never sit down to "learn enterprise programming" learned C# because they wanted to make a little platformer where a cube collects coins. The language that runs the world's payroll also runs the world's coin-collecting cubes. Range.

Thing three: desktop apps, phone apps, and everything with a window

C# can build apps with actual graphical interfaces, the windows, buttons, and menus kind:

• WinForms / WPF — classic Windows desktop apps. Old, reliable, the COBOL-survivor energy of the GUI world.
• .NET MAUI — one codebase that builds apps for Windows, macOS, iOS and Android. Write once, deploy to the phone, the tablet, and the laptop, in theory, when the build gods are merciful.

So the same language does the back-end API and the app talking to it. There's a real, underrated joy in not having to context-switch your entire brain between the front and the back of your own project.

The actual reason C# is nice to learn: it has good taste now

Beyond the "what can it build" list, here's what makes C# pleasant to write in 2026. A few greatest hits.

LINQ lets you query collections like they're a database, in plain, readable lines:

var bigSpenders = customers
    .Where(c => c.TotalSpent > 1000)
    .OrderByDescending(c => c.TotalSpent)
    .Select(c => c.Name);

Read that out loud. "Where the total spent is over 1000, ordered by spent descending, select the name." It reads like English, describing what you want, not a for loop describing how to suffer through getting it. Once LINQ clicks, going back to manual loops feels like being handed a typewriter.

async/await makes "do slow things without freezing everything" almost embarrassingly simple:

async Task<string> GetDataAsync()
{
    var response = await httpClient.GetStringAsync("https://api.example.com");
    return response;
}

The await keyword means "go do this slow network thing, and let the rest of the program keep breathing while we wait." Whole books exist on how hard this used to be. Now it's one word.

Strong typing that doesn't nag you to death. C# knows the types, so your editor autocompletes everything, catches your typos before you run, and tells you you're an idiot at compile time instead of letting you find out from a furious user at 2 am. But thanks to var, you rarely have to type the types out yourself. You get the safety without the paperwork.

Okay, here's where I have to be the annoying friend

Because no language is free, and I refuse to write the post that pretends C# is.

It carries some Microsoft baggage. It's enormously more cross-platform than it used to be. .NET runs beautifully on Linux and macOS now; this is no longer 2010, but the cultural centre of gravity is still Windows and Visual Studio, and some tutorials still assume you have a Windows machine and the patience of a saint.

The ecosystem has a lot of old. Search a problem, and you'll get four answers: the 2009 way, the 2014 way, the 2019 way, and the actually-current way, and they will not be labelled. You'll waste an afternoon implementing a pattern that was quietly replaced by one line of syntax three versions ago. (See: the eleven-line Hello World you'd still find in some "beginner" posts today.)

It is a big language. Twenty-five years of "ooh let's add that feature" means there are usually five ways to do anything, and a beginner can drown trying to figure out which one is current. The flip side of a language that never stopped improving is a language with a lot of sediment.

None of these are reasons not to learn it. There are reasons to learn the 2026 version of it, and to be suspicious of any tutorial that opens with a namespace and a sad static void Main.

So what do you actually do tomorrow

You can't learn a whole language in a weekend, but you fully control where you start, so start somewhere real:

1. Install the .NET SDK (free, cross-platform) and run dotnet new console, then dotnet run. You'll have a running C# program in about ninety seconds, on whatever OS you own.
2. Pick the lane that excites you, not the "correct" one. Want to build a web thing? ASP.NET Core minimal APIs. Want to make a game? Install Unity and make the cube jump. Motivation beats virtue every time — the person building a silly game finishes more C# than the person dutifully grinding "fundamentals."
3. Learn LINQ and async/await early. They're the two features that make the language feel modern instead of like Java's stricter cousin, and they're where the "oh, that's why people like this" moment lives.

C# is the language that runs the bank and makes the cube jump. It spent two decades being the responsible one and then quietly got fun when nobody was looking.

Now go make the cube jump, preferably before you make the bank.

And the next time someone calls it "just Microsoft Java", you get to be the insufferable person in the room who explains, at length, exactly why that's both true and completely irrelevant. Anders would be proud.