Learning .NET with Nick Chapsas on YouTube: A Student's Guide

What this guide is about

Nick Chapsas runs one of the most popular YouTube channels for learning C# and .NET. He is a Microsoft MVP, which is a title Microsoft gives to people who help the community a lot. His channel has hundreds of thousands of subscribers. New videos come out often.

But here is the problem. There are hundreds of videos. If you are new, it is easy to feel lost. Where do you even start? Which videos are for beginners? Which ones are only useful once you have some experience?

This guide fixes that. It explains what kinds of videos he makes, gives you a clear viewing plan by skill level, and shows you how to mix watching with real practice. Let's go.

A real-life analogy first

Think about learning to cook.

You do not start by watching a chef make a fancy five-course dinner. You would be lost. First you learn to boil an egg. Then you learn to fry one. Then you make a simple meal. Only later do you watch the fancy stuff, and by then it makes sense.

Nick's channel is like a huge cooking show with thousands of episodes. Some are "boil an egg" easy. Some are "Michelin-star chef" hard. The trick is to watch them in the right order for your skill. Watch an "egg" video first. Save the "fancy dinner" videos for later.

This guide is your menu. It tells you which episodes to watch, and when.

The kinds of videos he makes

Once you know the main types of videos, the whole channel feels less scary. Most of his videos fall into one of these groups.

Let's look at each one in plain words.

New features. When a new version of .NET or C# comes out, Nick makes videos about the new toys. For example, .NET 10 shipped in November 2025 as an LTS release. LTS means "Long-Term Support", so Microsoft supports it for three years. It came with C# 14. Looking even further ahead, C# 15 is in preview and brings union types in the .NET 11 previews. Nick's "new features" videos show you these in action.

Performance. These videos are about speed. He measures how fast code runs and how much memory it uses. He often uses a tool called BenchmarkDotNet, which times your code in a fair way. These videos are fun, but save them for when you are comfortable with the basics.

Clean code. These teach you to write code that humans can read. Good names. Small methods. Less mess. This matters as much as making code work.

Library reviews. The .NET world has thousands of free add-on packages. Nick reviews them so you know which ones are worth using. One important note here. Some once-free libraries like MediatR, MassTransit, and AutoMapper now need a paid commercial licence in many cases. Nick has covered this change, so his videos help you decide what to use today.

"Stop doing this" videos. These are some of his most famous. He shows a common mistake, then a cleaner way. They are great for breaking bad habits early.

A viewing plan by skill level

You should not watch random videos. Watch the right ones for where you are now. Here is a simple plan.

Level 1: Total beginner

If you have never written C#, do not start on the channel alone. First do a free beginner tutorial, like the official Microsoft Learn path. Get to the point where you can write a tiny program.

Here is the kind of code you should be able to read first:

// A tiny program. It prints a greeting.
string name = "Sam";
Console.WriteLine($"Hello, {name}!");

Once that makes sense, watch his beginner-friendly videos. Look for titles with words like "for beginners", "explained", or "from scratch". Skip anything about performance or memory for now.

Level 2: Early intermediate

Now you can write small programs. Time to learn good habits. Watch his clean code and "stop doing this" videos. These teach you to write code other people enjoy reading.

For example, you might learn to replace a long if chain with a cleaner pattern:

// Harder to read
if (status == 1) return "Active";
else if (status == 2) return "Paused";
else return "Unknown";
 
// Cleaner with a switch expression
return status switch
{
    1 => "Active",
    2 => "Paused",
    _ => "Unknown"
};

Level 3: Intermediate

You are comfortable building things now. Start watching the "new features" videos. Learn what C# 14 added, like field-backed properties and extension members. These help you write less boilerplate.

Here is a small taste of a C# 14 field-backed property:

public class Product
{
    // The 'field' keyword refers to the hidden backing field.
    public string Name
    {
        get => field;
        set => field = value?.Trim() ?? "";
    }
}

Level 4: Advanced

Now dig into performance. Watch how he benchmarks code. Learn about memory, spans, and allocations. This is where the deep dives live. Here is the flavour of a benchmark:

[Benchmark]
public int SumWithLoop()
{
    int total = 0;
    for (int i = 0; i < _numbers.Length; i++)
        total += _numbers[i];
    return total;
}

Level 5: Pro

You design systems now. Watch his architecture, design pattern, and library review videos. Use his opinions to question your own choices. You will not always agree, and that is healthy.

Key themes and "playlists" to look for

The channel does not always have neat numbered playlists, but the same themes come up again and again. Search the channel for these words to find a cluster of related videos.

• C# tips. Short videos with one clever trick each. Great for snacking.
• What's new in .NET. Updates for each new version.
• Performance and benchmarking. Speed, memory, and BenchmarkDotNet.
• Clean code and SOLID. Writing code that scales with your team.
• Testing. How to write unit tests that do not break for silly reasons.
• Libraries and tools. Honest reviews of popular packages.

A good habit: when one video mentions a topic you do not know, search the channel for that word. You will usually find a video that explains it.

How to combine watching with practising

This is the most important part. Watching alone does not make you a developer. You learn by doing. Here is a simple loop to follow for every video.

Let's break that down.

1. Watch the whole video once. Just listen. Do not pause to code yet. Get the big picture.

2. Watch again and type along. This time, open your editor. Type the code yourself. Do not copy and paste. Typing it slowly builds memory in your hands and brain.

3. Break it on purpose. Change a number. Delete a line. Rename a thing. See what error you get. Errors are not scary. They are tiny lessons. The faster you read errors, the faster you grow.

4. Rebuild it from memory. Close the video. Try to write the same idea from scratch. If you get stuck, peek, then close it again. This is the real test.

5. Use it in a tiny project. Take the new trick and use it somewhere real. Even a console app counts. A trick you actually use is a trick you keep.

Here is a tiny challenge to make a video stick. Say you watched a video about the switch expression. Try writing your own:

// Your turn: write a method that turns a day number into a name.
static string DayName(int day) => day switch
{
    1 => "Monday",
    2 => "Tuesday",
    3 => "Wednesday",
    _ => "Some other day"
};
 
Console.WriteLine(DayName(2)); // Tuesday

If you can write that without peeking, the lesson stuck. If not, watch once more. No shame in that. Repetition is how everyone learns.

A simple weekly routine

You do not need hours every day. A small, steady plan beats a giant burst once a month. Here is a routine a student could follow.

Stick to this for a month and you will be shocked at your progress. Slow and steady wins.

A few honest warnings

The channel is great, but keep these in mind so you stay on track.

Do not chase every new feature. New is fun, but you do not need every shiny tool. Master the basics first. A strong base beats a pile of half-learned tricks.

Opinions are opinions. Nick shares strong views, and that is good for thinking. But not every team agrees with every take. Learn the reasons behind a view, not just the view itself.

Free channel, paid courses. The YouTube videos are free. He also runs a paid course site called Dometrain. You never need to pay to learn from the channel. The courses are an option, not a requirement.

Watching is not doing. This is the big one. It is easy to watch ten videos and feel smart, then write zero code. Always practise. The loop above is your friend.

Quick recap

• Nick Chapsas runs a top free YouTube channel for learning C# and .NET.
• His videos fall into types: new features, performance, clean code, library reviews, and "stop doing this".
• Watch in the right order for your level. Basics first, performance and architecture later.
• .NET 10 is the current LTS with C# 14. C# 15 union types are coming in the .NET 11 previews.
• Some old libraries like MediatR and AutoMapper now need paid licences, and he covers that.
• Always pair watching with practice: watch, type along, break it, rebuild it, use it.
• A small steady weekly routine beats rare giant study sessions.

References and further reading

• Nick Chapsas on YouTube — the channel itself.
• What's new in .NET 10 (Microsoft Learn) — official feature list.
• Announcing .NET 10 (.NET Blog) — the LTS launch post.
• Dometrain courses by Nick Chapsas — his paid course platform, optional.
• Microsoft Learn C# training — a free beginner path to start with.