Skip to content
L-SYSTEM

recommendedintermediate

C# 14 and .NET 10: From Surface Knowledge to Working Knowledge (Extended)

For developers who "know C#" but stall at code review and in interviews when asked why something is built the way it is. The language is taught not as a list of constructs but as a set of decisions with a price: value and reference types, memory and the garbage collector, equality, null, pattern matching, strings and Span, generics, collections, LINQ, exceptions, async and concurrency, data at the process boundary, reflection and source generators. Five units then take SOLID one principle at a time, each as the answer to a concrete pain rather than a slogan. Design patterns follow — creational, structural, behavioural and the applied .NET ones — always including the case where the pattern hurts. The course closes on testability, talking through an architecture decision out loud, and what is new in C# 13 and 14. An optional branch, "C# in an application", takes the language into a working service: the host and DI, Minimal APIs, HttpClient and background jobs, EF Core, tests, and deployment to Azure. Every example lives in one system, the ENGAGE backend of the fictional firm Aldervane. Targets C# 14 / .NET 10 LTS. Written in Russian.

Your lesson is in your language: your assistant leads it.

  • Material: Russian
  • Exam: Russian — taken on the site, not translated
How it works

Your assistant takes the course material from our server and leads the lesson in your language.

The exam is taken on the site, without an assistant. Exam questions are not translated: this is decided for every course.

How to connect an assistant

Path through the course

· 38 units

the order is free · the steps below are the order the author suggests, not a conditionView: map · steps

  1. Stage 1

    ~2 h

  2. Stage 2

    ~2 h

  3. Stage 3

    ~5.5 h

    by the author’s design, after “Value and reference types: the stack, the heap and boxing”

  4. Stage 4

    ~7.5 h

  5. Stage 5

    ~8 h

  6. Stage 6

    ~4 h

  7. Stage 7

    ~8 h

  8. Stage 8

    ~6 h

  9. Stage 9

    ~4 h

  10. Stage 10

    ~1.5 h

  11. Stage 11

    ~2.5 h

  12. Stage 12

    ~8 h

  13. Stage 13

    ~8 h

  14. Stage 14

    ~4.5 h

  15. Stage 15

    ~4 h

  16. Exam

    closed · enrol on the course

    • final · in the browser, without the assistant

      Exam

The path in words
  • Stage 1 · What really happens when you press F5 — ~2 h
  • Stage 2 · Value and reference types: the stack, the heap and boxing — by the author’s design, after “What really happens when you press F5”; ~2 h
  • Stage 3 · Memory and lifetime: the garbage collector, IDisposable, using — by the author’s design, after “Value and reference types: the stack, the heap and boxing”; ~2 h
  • Stage 3 · class, struct, record: what to declare data with — by the author’s design, after “Value and reference types: the stack, the heap and boxing”; ~2 h
  • Stage 3 · Strings: immutability, interning, StringBuilder, Span — by the author’s design, after “Value and reference types: the stack, the heap and boxing”; ~1.5 h
  • Stage 4 · Equality, hashing and comparison: a contract that is easy to break — by the author’s design, after “class, struct, record: what to declare data with”; ~2 h
  • Stage 4 · null: nullable types, nullable reference annotations and what to do about them — by the author’s design, after “class, struct, record: what to declare data with”; ~1.5 h
  • Stage 4 · Span, Memory, ref struct and how to measure — by the author’s design, after any one of these: “Value and reference types: the stack, the heap and boxing”, “Strings: immutability, interning, StringBuilder, Span”; ~2 h
  • Stage 4 · Encapsulation and construction: an object that cannot be assembled wrongly — by the author’s design, after “class, struct, record: what to declare data with”; ~2 h
  • Stage 5 · Pattern matching, tuples, deconstruction — by the author’s design, after any one of these: “class, struct, record: what to declare data with”, “null: nullable types, nullable reference annotations and what to do about them”; ~2 h
  • Stage 5 · Inheritance and polymorphism: virtual, override, new, sealed — by the author’s design, after “Encapsulation and construction: an object that cannot be assembled wrongly”; ~2 h
  • Stage 5 · Delegates, lambdas, closures, events — by the author’s design, after “Encapsulation and construction: an object that cannot be assembled wrongly”; ~2 h
  • Stage 5 · Exceptions: what they are and what they are not — by the author’s design, after “Encapsulation and construction: an object that cannot be assembled wrongly”; ~2 h
  • Stage 6 · Interfaces: the contract, explicit implementation, DIM — by the author’s design, after “Inheritance and polymorphism: virtual, override, new, sealed”; ~1.5 h
  • Stage 6 · async/await: what it is and what it is not — by the author’s design, after “Delegates, lambdas, closures, events”; ~2.5 h
  • Stage 7 · Generics: constraints, reification, variance — by the author’s design, after “Interfaces: the contract, explicit implementation, DIM”; ~2 h
  • Stage 7 · Data at the boundary: JSON, files and streams, dates and times — by the author’s design, after any one of these: “Exceptions: what they are and what they are not”, “async/await: what it is and what it is not”; ~2 h
  • Stage 7 · Concurrency: lock, Lock, Interlocked, SemaphoreSlim, Channel, Parallel — by the author’s design, after “async/await: what it is and what it is not”; ~2 h
  • Stage 7 · SRP: one reason to change — by the author’s design, after “Interfaces: the contract, explicit implementation, DIM”; ~2 h
  • Stage 8 · Metadata: reflection, attributes, source generators — by the author’s design, after any one of these: “What really happens when you press F5”, “Generics: constraints, reification, variance”; ~2 h
  • Stage 8 · Collections: choosing a data structure and its cost — by the author’s design, after “Generics: constraints, reification, variance”; ~2 h
  • Stage 8 · OCP: open for extension, closed for modification — by the author’s design, after “SRP: one reason to change”; ~2 h
  • Stage 9 · LINQ: deferred execution, yield, IQueryable — by the author’s design, after “Collections: choosing a data structure and its cost”; ~2 h
  • Stage 9 · LSP: a subtype must be substitutable — by the author’s design, after “OCP: open for extension, closed for modification”; ~2 h
  • Stage 10 · ISP: clients are not forced to depend on what they don't need — by the author’s design, after “LSP: a subtype must be substitutable”; ~1.5 h
  • Stage 11 · DIP and dependency injection — by the author’s design, after “ISP: clients are not forced to depend on what they don't need”; ~2.5 h
  • Stage 12 · Creational patterns: who creates objects and how — by the author’s design, after “DIP and dependency injection”; ~2 h
  • Stage 12 · Structural patterns: how to assemble objects into a whole — by the author’s design, after “DIP and dependency injection”; ~2 h
  • Stage 12 · Behavioral patterns: who calls whom and when — by the author’s design, after “DIP and dependency injection”, “Delegates, lambdas, closures, events”; ~2 h
  • Stage 12 · The host, DI in practice, configuration, logging — by the author’s design, after “DIP and dependency injection”; optional; ~2 h
  • Stage 13 · Applied .NET patterns: Repository, Options, CQRS, Result — by the author’s design, after 2 of these: “Creational patterns: who creates objects and how”, “Structural patterns: how to assemble objects into a whole”, “Behavioral patterns: who calls whom and when”; ~2 h
  • Stage 13 · Minimal API: the pipeline, binding, validation, errors — by the author’s design, after “The host, DI in practice, configuration, logging”; optional; ~2 h
  • Stage 13 · HttpClient, resilience and background jobs — by the author’s design, after “The host, DI in practice, configuration, logging”, “async/await: what it is and what it is not”; optional; ~2 h
  • Stage 13 · EF Core without illusions — by the author’s design, after “The host, DI in practice, configuration, logging”, “LINQ: deferred execution, yield, IQueryable”; optional; ~2 h
  • Stage 14 · Finale: testability and talking about architecture out loud — by the author’s design, after “Applied .NET patterns: Repository, Options, CQRS, Result”, “async/await: what it is and what it is not”; ~2.5 h
  • Stage 14 · Shipping to Azure: App Service, secrets, managed identity — by the author’s design, after “Minimal API: the pipeline, binding, validation, errors”; optional; ~2 h
  • Stage 15 · What's new in C# 13 and 14 and how interviewers ask about it — by the author’s design, after “Finale: testability and talking about architecture out loud”; ~2 h
  • Stage 15 · Testing a service: from the unit to HTTP — by the author’s design, after “The host, DI in practice, configuration, logging”, “Finale: testability and talking about architecture out loud”; optional; ~2 h

Programme · 38 units

1What really happens when you press F5

Describe the path from source code to machine code: Roslyn → IL and metadata → JIT (tier0 → tier1) → machine code, and what Debug and Release change

~2 h
2Value and reference types: the stack, the heap and boxing

Predict how code behaves on assignment and when passing to a method for value and reference types, including structs in collections and tuples

~2 h
3Memory and lifetime: the garbage collector, IDisposable, using

Explain generational collection and why its cost is determined by surviving objects, not dead ones

~2 h
4class, struct, record: what to declare data with

Choose between class, struct, record class, record struct and readonly record struct by the question "value or entity", not out of habit

~2 h
5Equality, hashing and comparison: a contract that is easy to break

Predict what == compares and what Equals compares, by the static and the actual type

~2 h
6null: nullable types, nullable reference annotations and what to do about them

Distinguish Nullable<T> from nullable reference types: what the compiler does, what the runtime does (special boxing) and what nobody does

~1.5 h
7Pattern matching, tuples, deconstruction

Rewrite if/else chains with is and casts into a switch expression and explain why the order of arms is part of the meaning

~2 h
8Span, Memory, ref struct and how to measure

Explain what Span<T> and ReadOnlySpan<T> are, and predict where a slice gives a window and where it gives a copy

~2 h
9Strings: immutability, interning, StringBuilder, Span

Explain what string immutability gives (safe passing, thread-safe reading, a reliable key, interning) and what it does not give (hash caching, the ability to erase a secret)

~1.5 h
10Encapsulation and construction: an object that cannot be assembled wrongly

Explain encapsulation through invariants and design a type in which an invalid state cannot be expressed

~2 h
11Inheritance and polymorphism: virtual, override, new, sealed

Predict precisely which implementation is called with virtual/override, new and new virtual, through a base and a derived reference

~2 h
12Interfaces: the contract, explicit implementation, DIM

Design an interface from the consumer's side and place it next to the consumer to invert the dependency

~1.5 h
13Delegates, lambdas, closures, events

Explain how a delegate is built (Target, Method, invocation list) and predict the result of a multicast invocation, including one with an exception

~2 h
14Generics: constraints, reification, variance

Explain the reification of generics: separate machine code for value-type T, shared code for reference types, the real type at run time

~2 h
15Metadata: reflection, attributes, source generators

Explain what assembly metadata is and what reflection does (Type, GetProperties, PropertyInfo.GetValue), and name its cost: member lookup, late binding, boxing, unguaranteed order

~2 h
16Collections: choosing a data structure and its cost

Choose a collection by the hot operation, mutability, the required order and the number of writers, not out of habit

~2 h
17LINQ: deferred execution, yield, IQueryable

Explain deferred execution as pulling elements one at a time from the end of the chain and predict its effects: repeated work, changes to the source, captured variables

~2 h
18Exceptions: what they are and what they are not

Decide from the method's contract what is an exception and what is an expected result

~2 h
19Data at the boundary: JSON, files and streams, dates and times

Configure System.Text.Json for an external contract: a single JsonSerializerOptions instance, a naming policy, strictness (required, RespectNullableAnnotations, RespectRequiredConstructorParameters from .NET 9), polymorphism

~2 h
20async/await: what it is and what it is not

Explain why async frees the thread for the duration of the wait rather than creating a new one, and how scalability differs from speed

~2.5 h
21Concurrency: lock, Lock, Interlocked, SemaphoreSlim, Channel, Parallel

Explain the read-modify-write race and predict what will happen to a shared field that several threads modify

~2 h
22SRP: one reason to change

State SRP through the reason to change: one actor who comes with requirements

~2 h
23OCP: open for extension, closed for modification

Explain OCP through pressure: one change in requirements means edits in several working modules

~2 h
24LSP: a subtype must be substitutable

State LSP through the expectations of the calling code and the base contract: preconditions, postconditions, invariants, history and exceptions

~2 h
25ISP: clients are not forced to depend on what they don't need

Explain ISP through the mechanics of dependency: a change to a fat interface rebuilds and breaks clients that don't need the changed member

~1.5 h
26DIP and dependency injection

State both parts of DIP and show why the second one (a contract in the consumer's language, owned by the consumer) matters more

~2.5 h
27Creational patterns: who creates objects and how

Name the pressure each creational pattern relieves, and the cases where new is enough

~2 h
28Structural patterns: how to assemble objects into a whole

Distinguish Adapter, Decorator, Facade and Proxy by intent and by whether the interface changes

~2 h
29Behavioral patterns: who calls whom and when

Recognize, in ENGAGE code, the pressure that gives rise to Strategy, Template Method, Observer, Command, State and Chain of Responsibility

~2 h
30Applied .NET patterns: Repository, Options, CQRS, Result

Decide with arguments whether you need your own repository on top of EF Core, and name what a generic IRepository<T> takes away

~2 h
31What's new in C# 13 and 14 and how interviewers ask about it

Assign a feature to a language version: before C# 13, C# 13 (.NET 9) or C# 14 (.NET 10) — and not pass off the old as new

~2 h
32Finale: testability and talking about architecture out loud

Link testing difficulties to specific design defects: new inside a method, statics, DateTime.Now, new HttpClient(), the file system

~2.5 h
33The host, DI in practice, configuration, logging

Explain what Host.CreateApplicationBuilder and WebApplication.CreateBuilder register, and assemble Program.cs as a composition root with scopes for Scoped services

~2 h
34Minimal API: the pipeline, binding, validation, errors

Predict the source of each handler parameter (route, query string, body, DI, [AsParameters]) and the response to a binding error

~2 h
35HttpClient, resilience and background jobs

Explain why new HttpClient() per request exhausts ports while an eternal static client doesn't see DNS changes, and choose between IHttpClientFactory and a long-lived client with PooledConnectionLifetime

~2 h
36EF Core without illusions

Determine which part of a LINQ query goes to SQL and which runs in memory: Expression versus Func, ToList in the middle of the chain, untranslatable method calls

~2 h
37Testing a service: from the unit to HTTP

Explain which class of defects each level of service tests catches, and choose between the pyramid and the diamond by where the bugs live

~2 h
38Shipping to Azure: App Service, secrets, managed identity

Publish the ENGAGE service (dotnet publish) and choose a mode: framework-dependent, self-contained or ReadyToRun — with the cost of each

~2 h