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

Show the remaining 30 units