Skip to content
New this month 24 fresh C++, C#, F#, JavaScript, TypeScript and Lua courses just landed. Browse new releases Use code WELCOME10 for 10% off your first order · 14-day refund
WisdomCharms — home
Cart 0 items in cart
Programming Languages Intermediate

C# Intermediate: LINQ, async/await and Dependency Injection

The three C# skills that separate a junior developer from a confident team member.

Rated 5.0 out of 5 from 1 review 20 students

YT Created by Yuki Tanaka

  • Last updated August 2026
  • English
  • 10h 24m of material
  • 78 lessons

What you will learn

8 concrete outcomes

Every bullet below is something you will have built, shipped or be able to explain by the time you finish the last lesson.

  • Distinguish IEnumerable from IQueryable and control exactly when a query executes
  • Read the SQL that EF Core generates and reshape a LINQ query to fix it
  • Explain what await compiles into and why blocking on a task can deadlock
  • Use cancellation tokens, WhenAll, and IAsyncEnumerable in production code paths
  • Choose transient, scoped and singleton lifetimes and detect captive dependencies
  • Bind and validate configuration with the options pattern
  • Write unit and integration tests for asynchronous services without flakiness
  • Profile allocations and async overhead, then remove the ones that matter

Course curriculum

6 modules · 78 lessons · 10h 24m of material

14 lessons running 1h 50m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

12 lessons running 1h 36m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

15 lessons running 2h 00m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

13 lessons running 1h 42m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

13 lessons running 1h 44m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

11 lessons running 1h 32m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

6 modules · 78 lessons

10h 24m total length

Requirements

Short list, and deliberately so. If you meet these you can start today.

  • Comfortable writing C# classes, interfaces and basic LINQ queries
  • The .NET 8 or .NET 9 SDK installed and a recent editor
  • Some exposure to ASP.NET Core or any application that performs real I/O

About this course

Most C# developers reach a plateau in the same place. LINQ works until a query silently enumerates a database table three times. Async works until a deadlock appears only in production. Dependency injection works until nobody can explain why a scoped service was captured by a singleton. This course is about crossing that plateau on purpose.

The LINQ section separates IEnumerable from IQueryable, shows deferred execution with a debugger and a SQL profiler, and covers grouping, joins, projections and the expression-tree translation that Entity Framework Core performs on your behalf. You will learn to read generated SQL and predict it before you look.

The async section rebuilds your model of the task system: what await actually compiles to, synchronisation contexts, ConfigureAwait, cancellation tokens, IAsyncEnumerable, parallel composition with WhenAll, and the classic deadlock recreated then fixed. The dependency injection section covers service lifetimes, options binding, factory patterns, and how to design constructors that stay testable. Everything is demonstrated inside a realistic ASP.NET Core service with tests.

Topics covered

Frequently asked questions

Still unsure about something? Write to misteryjj100@gmail.com and a human answers, usually the same working day.

Yes. The LINQ and async material is framework independent, and the dependency injection module uses the generic host, which works in console apps and worker services too.

It covers the parts where LINQ and EF Core meet: query translation, tracking and enumeration pitfalls. Migrations and schema design are outside the scope.

All examples are verified on .NET 9 and run unchanged on .NET 8. Version-specific behaviour is called out where it exists.

Checkout is handled on our provider's secure payment page. The moment your payment clears we email your personal access link and access code to the address you used at checkout, and the same link appears in your account library. There is nothing to install and nothing to wait for.

Email misteryjj100@gmail.com within 14 days of your purchase, quote your order number, and we refund the full amount to your original payment method. No form to fill in and no questions about how much of the course you watched.

What students say

Reviews are written by people who bought this course. We publish the critical ones too.

5.0

Rated 5.0 out of 5

Course rating · 1 review

Rating distribution

  • 5 stars 100%
  • 4 stars 0%
  • 3 stars 0%
  • 2 stars 0%
  • 1 star 0%
  • BP

    Bethan Price

    Software engineer

    Dec 2025
    Rated 5.0 out of 5

    IQueryable and the SQL it really generates

    Watching an expression tree become an actual query, and then watching one innocent change quietly drag the whole table into memory, is a lesson that will stay with me. The service lifetime section also explained a captive dependency bug we had been living with for months.

Your instructor

YT

Yuki Tanaka

Game developer and C# instructor

  • 120 students taught
  • 5 courses published
  • 4.3 instructor rating
  • C#
  • .NET
  • Unity
  • Gameplay programming

Yuki has shipped six commercial titles, four of them solo, across PC and mobile. She teaches C# and .NET the way small studios actually use them — inside Unity, under a deadline — so the language lessons and the engine lessons arrive together. Students finish a playable game in every course, complete with menus, save files and a distributable build. She mentors at game jams most weekends and has judged three of them.

See every course by Yuki Tanaka
$74 USD

One-time payment · lifetime access

The WisdomCharms dispatch

One useful email a week. No fluff, no spam.

New course releases, discount codes before anyone else, and a short, practical breakdown of one technique — a prompt pattern, a C++ idiom, a TypeScript trick — that you can use the same day.

  • Subscriber-only launch pricing
  • Unsubscribe in one click
  • We never sell your address

By subscribing you agree to our Privacy Policy. Questions? Write to misteryjj100@gmail.com.