1
What really happens when you press F5
~2 h
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.
Path through the course
· 38 unitsthe order is free · the steps below are the order the author suggests, not a conditionView: map · steps
2
Value and reference types: the stack, the heap and boxing
~2 h
by the author’s design, after “What really happens when you press F5”
3
Memory and lifetime: the garbage collector, IDisposable, using
~2 h
by the author’s design, after “Value and reference types: the stack, the heap and boxing”
4
class, struct, record: what to declare data with
~2 h
by the author’s design, after “Value and reference types: the stack, the heap and boxing”
5
Equality, hashing and comparison: a contract that is easy to break
~2 h
by the author’s design, after “class, struct, record: what to declare data with”
6
null: nullable types, nullable reference annotations and what to do about them
~1.5 h
by the author’s design, after “class, struct, record: what to declare data with”
27
Pattern matching, tuples, deconstruction
~2 h
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”
28
Span, Memory, ref struct and how to measure
~2 h
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”
7
Strings: immutability, interning, StringBuilder, Span
~1.5 h
by the author’s design, after “Value and reference types: the stack, the heap and boxing”
8
Encapsulation and construction: an object that cannot be assembled wrongly
~2 h
by the author’s design, after “class, struct, record: what to declare data with”
9
Inheritance and polymorphism: virtual, override, new, sealed
~2 h
by the author’s design, after “Encapsulation and construction: an object that cannot be assembled wrongly”
10
Interfaces: the contract, explicit implementation, DIM
~1.5 h
by the author’s design, after “Inheritance and polymorphism: virtual, override, new, sealed”
11
Delegates, lambdas, closures, events
~2 h
by the author’s design, after “Encapsulation and construction: an object that cannot be assembled wrongly”
12
Generics: constraints, reification, variance
~2 h
by the author’s design, after “Interfaces: the contract, explicit implementation, DIM”
31
Metadata: reflection, attributes, source generators
~2 h
by the author’s design, after any one of these: “What really happens when you press F5”, “Generics: constraints, reification, variance”
13
Collections: choosing a data structure and its cost
~2 h
by the author’s design, after “Generics: constraints, reification, variance”
14
LINQ: deferred execution, yield, IQueryable
~2 h
by the author’s design, after “Collections: choosing a data structure and its cost”
15
Exceptions: what they are and what they are not
~2 h
by the author’s design, after “Encapsulation and construction: an object that cannot be assembled wrongly”
30
Data at the boundary: JSON, files and streams, dates and times
~2 h
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”
16
async/await: what it is and what it is not
~2.5 h
by the author’s design, after “Delegates, lambdas, closures, events”
29
Concurrency: lock, Lock, Interlocked, SemaphoreSlim, Channel, Parallel
~2 h
by the author’s design, after “async/await: what it is and what it is not”
17
~2 h
by the author’s design, after “Interfaces: the contract, explicit implementation, DIM”
18
OCP: open for extension, closed for modification
~2 h
by the author’s design, after “SRP: one reason to change”
19
LSP: a subtype must be substitutable
~2 h
by the author’s design, after “OCP: open for extension, closed for modification”
20
ISP: clients are not forced to depend on what they don't need
~1.5 h
by the author’s design, after “LSP: a subtype must be substitutable”
21
~2.5 h
by the author’s design, after “ISP: clients are not forced to depend on what they don't need”
22
Creational patterns: who creates objects and how
~2 h
by the author’s design, after “DIP and dependency injection”
23
Structural patterns: how to assemble objects into a whole
~2 h
by the author’s design, after “DIP and dependency injection”
24
Behavioral patterns: who calls whom and when
~2 h
by the author’s design, after “DIP and dependency injection”, “Delegates, lambdas, closures, events”
25
Applied .NET patterns: Repository, Options, CQRS, Result
~2 h
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”
32
What's new in C# 13 and 14 and how interviewers ask about it
~2 h
by the author’s design, after “Finale: testability and talking about architecture out loud”
26
Finale: testability and talking about architecture out loud
~2.5 h
by the author’s design, after “Applied .NET patterns: Repository, Options, CQRS, Result”, “async/await: what it is and what it is not”
33 · C# в приложении
The host, DI in practice, configuration, logging
~2 h
by the author’s design, after “DIP and dependency injection”
34 · C# в приложении
Minimal API: the pipeline, binding, validation, errors
~2 h
by the author’s design, after “The host, DI in practice, configuration, logging”
35 · C# в приложении
HttpClient, resilience and background jobs
~2 h
by the author’s design, after “The host, DI in practice, configuration, logging”, “async/await: what it is and what it is not”
36 · C# в приложении
~2 h
by the author’s design, after “The host, DI in practice, configuration, logging”, “LINQ: deferred execution, yield, IQueryable”
37 · C# в приложении
Testing a service: from the unit to HTTP
~2 h
by the author’s design, after “The host, DI in practice, configuration, logging”, “Finale: testability and talking about architecture out loud”
38 · C# в приложении
Shipping to Azure: App Service, secrets, managed identity
~2 h
by the author’s design, after “Minimal API: the pipeline, binding, validation, errors”
final · in the browser, without the assistant
Exam
closed · enrol on the course
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
| 1 | What 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 |
| 2 | Value 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 |
| 3 | Memory and lifetime: the garbage collector, IDisposable, using Explain generational collection and why its cost is determined by surviving objects, not dead ones | ~2 h |
| 4 | class, 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 |
| 5 | Equality, 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 |
| 6 | null: 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 |
| 7 | Pattern 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 |
| 8 | Span, 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 |
| 9 | Strings: 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 |
| 10 | Encapsulation 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 |
| 11 | Inheritance 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 |
| 12 | Interfaces: 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 |
| 13 | Delegates, 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 |
| 14 | Generics: 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 |
| 15 | Metadata: 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 |
| 16 | Collections: 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 |
| 17 | LINQ: 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 |
| 18 | Exceptions: 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 |
| 19 | Data 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 |
| 20 | async/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 |
| 21 | Concurrency: 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 |
| 22 | SRP: one reason to change State SRP through the reason to change: one actor who comes with requirements | ~2 h |
| 23 | OCP: open for extension, closed for modification Explain OCP through pressure: one change in requirements means edits in several working modules | ~2 h |
| 24 | LSP: 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 |
| 25 | ISP: 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 |
| 26 | DIP 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 |
| 27 | Creational patterns: who creates objects and how Name the pressure each creational pattern relieves, and the cases where new is enough | ~2 h |
| 28 | Structural patterns: how to assemble objects into a whole Distinguish Adapter, Decorator, Facade and Proxy by intent and by whether the interface changes | ~2 h |
| 29 | Behavioral 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 |
| 30 | Applied .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 |
| 31 | What'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 |
| 32 | Finale: 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 |
| 33 | The 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 |
| 34 | Minimal 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 |
| 35 | HttpClient, 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 |
| 36 | EF 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 |
| 37 | Testing 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 |
| 38 | Shipping 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 |