kostyl.dev
System Programming Windows

Системне Програмування C# (Windows) — 07.system-programming-windows

Нова папка 07.system-programming-windows. Модуль 06 ігнорується (буде видалений). 20 файлів, 5 блоків. Фокус: багатопоточність та асинхронність від А до Я.

Системне Програмування C# (Windows) — 07.system-programming-windows

Нова папка 07.system-programming-windows. Модуль 06 ігнорується (буде видалений). 20 файлів, 5 блоків. Фокус: багатопоточність та асинхронність від А до Я.

Блок A: Фундамент ОС (01–03)

📄 01.how-os-works.md — Як Працює Операційна Система

  1. Що таке ОС?
    • Ядро (kernel), user mode vs kernel mode
    • Аналогія: ОС — менеджер ресторану (розподіляє столики, офіціантів, кухню)
  2. Що таке Процес?
    • Визначення на рівні Windows
    • Ізоляція: власний адресний простір, handles, security context
    • PID, Virtual Address Space, Handle Table, PEB
    • Working Set, Private Bytes, Virtual Size
    • Аналогія: процес — "квартира" (ізольоване середовище)
  3. Що таке Потік (Thread)?
    • Одиниця виконання всередині процесу
    • Власний стек (~1MB), регістри, instruction pointer
    • Спільний address space з іншими потоками процесу
    • Main Thread — entry point процесу
    • Аналогія: потоки — "мешканці квартири" (спільна кухня/ванна)
  4. Scheduling: Як ОС Розподіляє CPU
    • Preemptive multitasking: time slicing
    • Context switch: що зберігається/відновлюється, ціна (~1-10μs)
    • Quantum (time slice) у Windows: ~15ms
    • Priority-based scheduling, round-robin для однакових пріоритетів
  5. CPU Cores vs Threads
    • Фізичний паралелізм (multi-core) vs конкурентність (time-slicing)
    • Hyper-Threading / SMT
    • Concurrency vs Parallelism — ключова різниця з діаграмами
    • Закон Амдала (з формулою та прикладами)
  6. Process vs Thread vs Task: Зведена Таблиця
    • Ресурси, ізоляція, вартість створення, use cases
    • Mermaid діаграма: Process → Threads → Shared Resources

📄 02.processes-in-dotnet.md — Процеси в .NET

  1. System.Diagnostics.Process: Повний API
    • Process.GetCurrentProcess() — поточний процес
    • Process.GetProcesses(), GetProcessesByName(), GetProcessById()
    • Властивості: Id, ProcessName, StartTime, WorkingSet64, Threads, Modules
    • ⚡ Практика: утиліта "мій Task Manager" в консолі
  2. Task Manager та Performance Monitor
    • Як читати CPU %, Memory, Handles, Threads columns
    • Моніторинг власного .NET додатку
  3. Запуск Зовнішніх Процесів
    • Process.Start(), ProcessStartInfo
    • FileName, Arguments, WorkingDirectory
    • UseShellExecute vs direct execution
    • Verb (RunAs для адміністратора)
    • Приклад: відкрити блокнот, браузер, консольну програму
  4. Дочірні Процеси та Комунікація
    • RedirectStandardInput/Output/Error
    • Синхронне та асинхронне читання stdout
    • OutputDataReceived event
    • WaitForExit(), ExitCode
    • ⚡ Практика: Запуск ping і парсинг результатів
    • ⚡ Практика: Запуск dotnet build з відображенням прогресу
  5. Завершення Процесів
    • Kill(), CloseMainWindow() — graceful vs forceful
    • HasExited, EnableRaisingEvents, Exited event
  6. Міжпроцесна Комунікація (IPC)
    • Named Pipes: NamedPipeServerStream, NamedPipeClientStream
    • Memory-Mapped Files: MemoryMappedFile
    • ⚡ Практика: два .NET процеси обмінюються даними через Named Pipe
  7. Практичні Завдання
    • Рівень 1: Console Process Explorer
    • Рівень 2: Batch Launcher з моніторингом
    • Рівень 3: IPC Chat між двома процесами

📄 03.appdomains-assemblies.md — Application Domains та Збірки

  1. AppDomain: Історія та Сучасність
    • .NET Framework: логічна ізоляція, плагіни, sandbox
    • .NET Core/.NET 5+: один AppDomain на процес
  2. AssemblyLoadContext (Сучасна Альтернатива)
    • AssemblyLoadContext.Default
    • Власний AssemblyLoadContext, collectible contexts
    • Завантаження/вивантаження збірок у runtime
    • ⚡ Практика: плагін-система — завантаження DLL у runtime
  3. Збірки (Assemblies)
    • Strong naming, версіонування, Assembly metadata
    • Deps file, runtime config
  4. Практичні Завдання
    • Рівень 1: Assembly Inspector
    • Рівень 2: Hot-Reload Plugin System

Блок B: Багатопоточність — ВСЕ від А до Я (04–11)

📄 04.thread-fundamentals.md — Потоки: Основи

  1. Проблема: Чому Потрібна Багатопотоковість?
    • Frozen UI — класичний приклад
    • Benchmark: послідовна vs паралельна обробка
    • Еволюція: від single-core до multi-core (timeline діаграма)
  2. Клас Thread: Фундаментальний API
    • ThreadStart — делегат без параметрів
    • ParameterizedThreadStart — передача object?
    • Lambda expressions (рекомендовано) + closure pitfall (int i в циклі!)
    • thread.Start(), new Thread() — створення vs запуск
  3. Отримання Результатів з Потоку
    • Shared variable (з Join)
    • Object instance container
    • Task<T> (preview: буде детально в темі 11)
  4. Background vs Foreground Threads
    • Вплив на завершення процесу (таблиця + sequence diagram)
    • IsBackground = true
    • Коли що використовувати
  5. Життєвий Цикл Потоку
    • ThreadState flags enum: Unstarted → Running → WaitSleepJoin → Stopped
    • Діаграма переходів (stateDiagram-v2)
    • Deprecated: Suspend, Resume, Abort → чому CancellationToken
  6. Thread Priorities
    • ThreadPriority enum: Lowest → Highest
    • Preemptive scheduling, round-robin
    • Priority Inversion (Mars Pathfinder 1997!)
    • Best practices: залишайте Normal для 99% випадків
  7. Ключові Методи
    • Thread.Sleep(ms) — призупинення; Sleep(0) vs Yield()
    • Thread.Join() — очікування з timeout
    • Thread.CurrentThread — поточний потік
    • Naming threads: thread.Name — для debugging
  8. Практичні Завдання
    • Рівень 1: Parallel Countdown
    • Рівень 2: Multi-threaded File Downloader
    • Рівень 3: Thread Pool (ручна реалізація)

📄 05.shared-state-problems.md — Проблеми Спільного Стану ⚠️

КЛЮЧОВА ТЕМА. Без розуміння проблем — синхронізація не має сенсу.

  1. Race Condition
    • Визначення: результат залежить від порядку виконання потоків
    • Приклад: банківський рахунок — два потоки знімають одночасно
    • Check-then-act pattern — чому він небезпечний
    • ⚡ Демонстрація з кодом + Mermaid sequence diagram
  2. Data Race
    • Визначення: одночасний доступ до пам'яті, де хоча б один — запис
    • Різниця з Race Condition (можна мати одне без іншого)
    • i++ — НЕ атомарна операція! (Read → Modify → Write)
    • ⚡ Демонстрація: 10 потоків інкрементують лічильник → результат < очікуваного
  3. Visibility Problem (Проблема Видимості)
    • CPU cache hierarchy: L1/L2/L3 cache, store buffers
    • Потік A записує значення, потік B його НЕ бачить
    • Memory reordering: компілятор та CPU переставляють інструкції
    • ⚡ Демонстрація: boolean flag не видно іншому потоку
  4. Torn Reads
    • Часткове зчитування 64-bit значень на 32-bit системах
    • long/double — не atomic на x86-32
  5. Lost Update
    • Read-Modify-Write без захисту
    • Відмінність від Race Condition
  6. Memory Model .NET
    • Happens-before relationship (концепція)
    • Acquire/Release semantics (що це означає)
    • Чому "просто volatile" — не завжди достатньо
  7. Таксономія Проблем: Зведена Таблиця
    • Проблема → Причина → Наслідок → Рішення (посилання на теми 06–08)
  8. Висновок: Навіщо Синхронізація
    • Кожна проблема має рішення → наступні три теми

📄 06.synchronization-fundamentals.md — Синхронізація: Основи

  1. Critical Section — Концепція
    • Mutual exclusion: тільки один потік одночасно
    • Аналогія: одномісна вбиральня з замком
  2. lock Statement
    • Синтаксис, правила вибору lock object (таблиця: ✅ vs ❌)
    • private readonly object _lock = new() — золотий стандарт
    • ❌ lock(this), ❌ lock("string"), ❌ lock(typeof(...))
  3. Під Капотом: lock → Monitor
    • Компілятор генерує Monitor.Enter/Exit + try/finally
    • Чому try/finally — гарантія звільнення при exceptions
  4. Monitor Class: Повний Контроль
    • Monitor.TryEnter(timeout) — неблокуюча спроба
    • Monitor.Wait() / Monitor.Pulse() / Monitor.PulseAll() — signaling
    • ⚡ Практика: BlockingQueue через Wait/Pulse (з sequence diagram)
    • Правило: while замість if перед Wait() (spurious wakeup)
  5. System.Threading.Lock (C# 13/.NET 9)
    • Новий тип, оптимізований для сучасних CPU
    • Lock.EnterScope() — ref struct з using
    • Порівняння з old object lock (таблиця)
  6. Deadlock: Взаємне Блокування
    • 4 умови Coffman: mutual exclusion, hold-and-wait, no preemption, circular wait
    • ⚡ Приклад: два потоки, два locks, circular wait
    • Запобігання: Lock ordering, timeout (Monitor.TryEnter), lock hierarchy
    • Dining Philosophers Problem
    • Deadlock detection в production
  7. Livelock та Starvation
    • Livelock: потоки активні, але не прогресують (аналогія: двоє в коридорі)
    • Starvation: потік ніколи не отримує lock
  8. Практичні Завдання
    • Рівень 1: Thread-safe counter + bank account
    • Рівень 2: Producer-Consumer з Monitor.Wait/Pulse
    • Рівень 3: Deadlock simulator + resolver

📄 07.synchronization-advanced.md — Синхронізація: Kernel-Level та Advanced

  1. Mutex: Cross-Process Synchronization
    • Local Mutex (in-process) vs Named Mutex (system-wide)
    • WaitOne(), ReleaseMutex(), AbandonedMutexException
    • ⚡ Практика: Single-instance application
    • Порівняння з lock/Monitor (таблиця: scope, performance, ownership)
  2. Semaphore та SemaphoreSlim
    • Обмежена кількість одночасних потоків (аналогія: парковка)
    • SemaphoreSlim(initialCount, maxCount)
    • WaitAsync() — async support (preview: деталі в темі 16)
    • ⚡ Практика: Connection Pool, Rate Limiter
  3. AutoResetEvent та ManualResetEvent(Slim)
    • Signaling між потоками
    • Auto: турнікет (один пройшов — закрився)
    • Manual: ворота (відкрились — всі проходять)
    • Set(), Reset(), WaitOne() / Wait()
    • ⚡ Практика: Producer-Consumer з signaling
  4. CountdownEvent
    • Координація завершення N операцій
    • Signal(), Wait(), AddCount()
    • ⚡ Практика: Parallel initialization (чекаємо 5 сервісів)
  5. Barrier
    • Синхронізація фаз паралельних потоків
    • SignalAndWait(), post-phase callback
    • ⚡ Практика: Multi-phase data pipeline
  6. ReaderWriterLockSlim
    • Read/Write access pattern: множинні readers АБО один writer
    • EnterReadLock(), EnterWriteLock(), EnterUpgradeableReadLock()
    • LockRecursionPolicy
    • ⚡ Практика: Thread-safe cache
  7. Зведена Таблиця: Коли Що Використовувати
    • Примітив → Scope → Async Support → Use Case
  8. Практичні Завдання
    • Рівень 1: Thread-safe LRU Cache з ReaderWriterLockSlim
    • Рівень 2: Parallel Pipeline з Barrier
    • Рівень 3: Worker coordination з CountdownEvent + Semaphore

📄 08.interlocked-volatile-lockfree.md — Atomic Operations та Lock-Free

  1. Interlocked Class: Атомарні Операції
    • Increment, Decrement, Add
    • Exchange — atomic swap
    • CompareExchange — CAS (Compare-And-Swap): фундамент lock-free
    • Read — atomic read для 64-bit на 32-bit
  2. CAS (Compare-And-Swap) Pattern
    • Як працює CAS під капотом (CPU instruction CMPXCHG)
    • CAS loop: retry pattern
    • ⚡ Практика: Lock-free counter через CAS
  3. volatile Keyword
    • Що гарантує: заборона кешування та reordering для цієї змінної
    • Чого НЕ гарантує: не дає atomicity для i++
    • Коли використовувати: boolean flags, simple read/write
    • ❌ Поширена помилка: volatile int counter; counter++ — це НЕ thread-safe!
  4. Thread.MemoryBarrier()
    • Full fence: запобігає reordering з обох сторін
    • Коли потрібен (рідко в прикладному коді)
  5. SpinLock та SpinWait
    • User-mode spinning vs kernel transition
    • SpinLock.Enter(), SpinLock.Exit() — для дуже коротких critical sections
    • SpinWait.SpinOnce(), SpinWait.SpinUntil() — adaptive spinning
    • Коли spinning краще за lock, коли гірше
  6. Lock-Free Data Structures
    • ⚡ Практика: Lock-free Stack через CAS + Interlocked.CompareExchange
    • ABA Problem — що це, як вирішувати
  7. Практичні Завдання
    • Рівень 1: Atomic counter benchmarks
    • Рівень 2: Lock-free queue (single-producer, single-consumer)
    • Рівень 3: Compare: lock vs Interlocked vs SpinLock benchmarks

📄 09.thread-pool.md — ThreadPool

  1. Чому Створювати Thread — Дорого?
    • Overhead: ~1MB стеку, kernel object, context switch cost
    • Benchmark: new Thread() vs ThreadPool.QueueUserWorkItem()
    • Аналогія: таксі (Thread) vs автобус (ThreadPool)
  2. Архітектура ThreadPool
    • Worker threads та I/O completion port (IOCP) threads
    • Hill Climbing Algorithm: динамічне додавання/видалення потоків
    • ThreadPool.SetMinThreads(), SetMaxThreads()
    • ThreadPool.ThreadCount, PendingWorkItemCount
  3. Використання ThreadPool
    • ThreadPool.QueueUserWorkItem(callback) — без стану
    • ThreadPool.QueueUserWorkItem(callback, state, preferLocal) — зі станом
    • ThreadPool.UnsafeQueueUserWorkItem — без ExecutionContext flow
    • ⚡ Практика: паралельна обробка колекції
  4. RegisteredWaitHandle
    • ThreadPool.RegisterWaitForSingleObject() — ефективне очікування
  5. ExecutionContext та SynchronizationContext
    • Що передається між потоками, навіщо
    • SynchronizationContext — введення (деталі → тема 13)
  6. Проблеми ThreadPool
    • Thread starvation: коли всі потоки зайняті блокуючими операціями
    • Антипатерн: Thread.Sleep() в ThreadPool
    • Long-running tasks — коли ThreadPool не підходить
    • Діагностика: ETW, PendingWorkItemCount
  7. Практичні Завдання
    • Рівень 1: Parallel File Scanner
    • Рівень 2: Connection Pool
    • Рівень 3: Thread starvation detector

📄 10.concurrent-collections.md — Concurrent та Immutable Collections

  1. Чому Звичайні Колекції Не Thread-Safe?
    • List<T> + два потоки = corruption
    • Dictionary<K,V> + конкурентний доступ = exception
  2. ConcurrentDictionary<TKey, TValue>
    • GetOrAdd, AddOrUpdate, TryAdd, TryRemove, TryUpdate
    • Під капотом: striped locking (не один lock на всю колекцію)
    • ⚡ Практика: Thread-safe word counter
  3. ConcurrentQueue, ConcurrentStack, ConcurrentBag
    • Lock-free implementations
    • TryDequeue, TryPop, TryTake
    • ConcurrentBag: thread-local storage optimization
  4. BlockingCollection
    • Bounded producer/consumer
    • Add() (blocks if full), Take() (blocks if empty)
    • CompleteAdding(), GetConsumingEnumerable()
    • ⚡ Практика: Multi-producer, multi-consumer pipeline
  5. Immutable Collections
    • ImmutableList<T>, ImmutableDictionary<K,V>, ImmutableStack<T>
    • Builder pattern: ImmutableList.CreateBuilder<T>()
    • Thread safety через immutability (ніхто не змінює → не потрібен lock)
    • Коли Immutable краще за Concurrent (таблиця)
  6. Практичні Завдання
    • Рівень 1: Thread-safe URL cache
    • Рівень 2: Log aggregator з BlockingCollection
    • Рівень 3: Concurrent web crawler з ConcurrentDictionary (visited URLs)

📄 11.tpl-parallel-plinq.md — TPL, Parallel та PLINQ

  1. Від Thread до Task: Еволюція
    • Task як абстракція "одиниці роботи"
    • Task vs Thread (таблиця: результат, exceptions, cancellation, pooling)
  2. Task та Task
    • Task.Run() (рекомендовано), Task.Factory.StartNew() (LongRunning, DenyChildAttach)
    • Cold vs Hot tasks, new Task() + Start() — чому не рекомендується
    • TaskStatus enum, lifecycle діаграма
    • .Result, .GetAwaiter().GetResult() — блокуюче очікування
  3. Composing Tasks
    • Task.WhenAll(), Task.WhenAny(), Task.WhenEach() (.NET 9)
    • Task.Delay(), Task.FromResult(), Task.CompletedTask
    • ContinueWith (legacy) — проблеми з SynchronizationContext
  4. CancellationToken
    • CancellationTokenSource, CancellationToken
    • ThrowIfCancellationRequested(), IsCancellationRequested
    • token.Register(callback), linked tokens, timeout
    • ⚡ Практика: Download з progress + cancellation
  5. Exception Handling
    • AggregateException, Flatten(), Handle()
    • Unobserved: TaskScheduler.UnobservedTaskException
    • ⚡ Практика: error handling з WhenAll
  6. Parallel Class: Data Parallelism
    • Parallel.For(), Parallel.ForEach(), Parallel.Invoke()
    • ParallelOptions: MaxDegreeOfParallelism, CancellationToken
    • Thread-local state, Break() vs Stop()
    • Parallel.ForEachAsync() (.NET 6+)
    • ⚡ Практика: Parallel image processing
  7. PLINQ
    • AsParallel(), AsOrdered(), WithDegreeOfParallelism(N)
    • WithCancellation(), WithExecutionMode(), WithMergeOptions()
    • ForAll(), Aggregate(), partitioning strategies
    • Коли НЕ використовувати (Amdahl's Law, overhead)
  8. Практичні Завдання
    • Рівень 1: Parallel File Processor + CancellationToken
    • Рівень 2: Monte Carlo π calculation з Parallel + PLINQ
    • Рівень 3: MapReduce з WhenAll

Блок C: Асинхронність — ВСЕ від А до Я (12–16)

📄 12.async-fundamentals.md — Async/Await: Фундамент

  1. Проблема: Чому Async?
    • I/O-bound vs CPU-bound (аналогія: офіціант vs кухар)
    • Blocking I/O: потік чекає відповідь мережі → thread starvation
    • Non-blocking I/O: потік вільний поки чекаємо
    • C10K problem, масштабування
  2. Історія: APM → EAP → TAP
    • BeginRead/EndRead (legacy), BackgroundWorker (legacy)
    • TAP — сучасний стандарт, чому переміг
  3. async та await: Синтаксис
    • async — що робить (і чого НЕ: не робить метод паралельним!)
    • await — точка "призупинення" та повернення потоку
    • Return types: Task, Task<T>, ValueTask, ValueTask<T>, void
    • Naming convention: Async суфікс
    • ⚡ Приклад: async file read, async HTTP GET
  4. State Machine Під Капотом
    • Що компілятор генерує з async/await
    • IAsyncStateMachine interface
    • Кожен await — точка зупинки (стан автомата)
    • Розбір згенерованого коду (SharpLab/ILSpy)
    • ⚡ Практика: порівняння sync vs async в SharpLab
  5. Exception Handling в Async
    • await автоматично unwrap AggregateException
    • Exceptions у Task.WhenAll — перший + .Exception
    • ❌ async void — exceptions "втрачаються"!!
  6. Практичні Завдання
    • Рівень 1: Async File Copier з progress reporting
    • Рівень 2: Concurrent API Caller (WhenAll + WhenAny)
    • Рівень 3: Async pipeline з error recovery

📄 13.async-context-configureawait.md — SynchronizationContext та ConfigureAwait

  1. SynchronizationContext
    • Що це: абстракція для контексту виконання (UI thread, ASP.NET)
    • UI SynchronizationContext: WPF, WinForms
    • SynchronizationContext.Current, Post(), Send()
  2. ConfigureAwait(false)
    • Default: continuation повертається на captured context
    • ConfigureAwait(false): продовжити на будь-якому потоці
    • Правило: завжди ConfigureAwait(false) в бібліотечному коді
    • ConfigureAwait(true) у UI-коді
  3. Deadlock Scenario ⚠️
    • UI thread + .Result → deadlock (повний розбір із діаграмою)
    • ASP.NET (old) + .Result → deadlock
    • Як уникнути: ніколи .Result/.Wait() в sync context
  4. ExecutionContext
    • Що передається: SecurityContext, логічний call context
    • AsyncLocal<T> — "thread-local" для async (передається через await)
    • ⚡ Практика: Correlation ID через AsyncLocal
  5. Практичні Завдання
    • Рівень 1: Deadlock demo + fix
    • Рівень 2: AsyncLocal-based RequestContext
    • Рівень 3: Custom SynchronizationContext

📄 14.async-advanced.md — Async: Просунуті Паттерни

  1. TaskCompletionSource
    • Перетворення callback-based API на async
    • Перетворення event-based API на async
    • ⚡ Практика: wrap FileSystemWatcher → Task
  2. IAsyncEnumerable: Async Streams
    • yield return в async контексті
    • await foreach + WithCancellation()
    • [EnumeratorCancellation] attribute
    • ⚡ Практика: streaming data з paginated API
  3. IAsyncDisposable та await using
    • Коли потрібен async Dispose (DB connections, streams)
  4. ValueTask та ValueTask
    • Struct-based, no heap allocation для sync completion
    • Коли використовувати vs Task
    • ⚠️ Обмеження: не await двічі, не .Result до completion
  5. Best Practices (Повний Список)
    • ❌ async void — тільки для event handlers
    • ❌ .Result/.Wait() — deadlock
    • ❌ Task.Run() в ASP.NET (fake async)
    • ✅ ConfigureAwait(false) в бібліотеках
    • ✅ CancellationToken скрізь
    • ✅ Prefer ValueTask для hot paths
  6. Common Pitfalls
    • Sync-over-async (.Result / .GetAwaiter().GetResult())
    • Fire-and-forget правильно: _ = DoWorkAsync()
    • Lazy<Task<T>> — lazy async init
    • Retry pattern з async
  7. Custom Awaitables (Для Допитливих)
    • GetAwaiter() pattern, ICriticalNotifyCompletion
  8. Практичні Завдання
    • Рівень 1: TaskCompletionSource wrapper для timer
    • Рівень 2: Async Producer-Consumer з IAsyncEnumerable
    • Рівень 3: Custom AsyncLock

📄 15.channels.md — System.Threading.Channels

  1. Producer-Consumer: Мотивація
    • Чому BlockingCollection не підходить для async (блокує потоки)
    • Channels = async-native producer/consumer
  2. Channel API
    • Channel.CreateBounded<T>(capacity), CreateUnbounded<T>()
    • ChannelWriter<T>: WriteAsync, TryWrite, Complete
    • ChannelReader<T>: ReadAsync, ReadAllAsync, WaitToReadAsync
    • ⚡ Практика: Log processing pipeline
  3. BoundedChannelOptions
    • BoundedChannelFullMode: Wait, DropNewest, DropOldest, DropWrite
    • SingleReader, SingleWriter — performance optimizations
  4. Multi-stage Pipelines
    • Побудова pipeline: Channel₁ → Transform → Channel₂ → Load
    • ⚡ Практика: ETL Pipeline (Extract → Transform → Load)
  5. BackgroundService + Channel
    • Queue-based async processing
    • ⚡ Практика: Email sending queue
  6. Benchmarks: Channel vs BlockingCollection vs ConcurrentQueue + SemaphoreSlim
  7. Практичні Завдання
    • Рівень 1: Chat Server
    • Рівень 2: Image Processing Pipeline
    • Рівень 3: Rate-limited API Client

📄 16.async-synchronization.md — Асинхронна Синхронізація

  1. Чому lock Не Можна з await
    • Compiler error: cannot await inside lock
    • Причина: lock = thread-affine, async = thread-agnostic
  2. SemaphoreSlim.WaitAsync() — Async Lock
    • new SemaphoreSlim(1, 1) = async-compatible mutex
    • Pattern: await semaphore.WaitAsync() + try/finally { Release() }
    • ⚡ Практика: Async-safe resource access
  3. Throttling та Rate Limiting
    • SemaphoreSlim(N) для обмеження concurrent async operations
    • ⚡ Практика: Max 5 concurrent HTTP requests
  4. Timeout + Cancellation Patterns
    • Task.WhenAny(task, Task.Delay(timeout)) — manual timeout
    • CancellationTokenSource.CancelAfter() — auto timeout
    • Linked cancellation tokens для ієрархії
  5. Nito.AsyncEx (Бібліотека)
    • AsyncLock, AsyncAutoResetEvent, AsyncManualResetEvent
    • AsyncCollection<T>, AsyncLazy<T>
  6. Практичні Завдання
    • Рівень 1: Async Mutex для file access
    • Рівень 2: Throttled web scraper
    • Рівень 3: Resilient service з timeout, retry, circuit breaker

Блок D: Unsafe Code (17)

📄 17.unsafe-code.md — Unsafe Code та Вказівники

  • unsafe контекст, AllowUnsafeBlocks
  • Вказівники: int*, byte*, void*, операції &, *, ->
  • Pointer arithmetic, fixed statement (pinning)
  • stackalloc + Span<T>, sizeof, Marshal.SizeOf
  • Function pointers (delegate*, C# 9+)
  • Практика: Fast Array Copy, Image Pixel Manipulation

Блок E: Windows API (18–20)

📄 18.pinvoke-winapi.md — P/Invoke та Windows API

  • Win32 API: kernel32, user32, advapi32; Handles, HWND
  • [DllImport] vs [LibraryImport] (.NET 7+)
  • Marshalling: strings, structs, callbacks, SafeHandle, Marshal class
  • Практика: MessageBox, GetSystemInfo, EnumWindows, Window automation

📄 19.windows-registry.md — Реєстр Windows

  • Архітектура: Hives, Keys, Values; regedit
  • Microsoft.Win32.Registry API: read/write/delete/monitor
  • Автозапуск, файлові асоціації, WOW64, P/Invoke RegNotifyChangeKeyValue

📄 20.windows-hooks-services.md — Hooks, Hotkeys та Services

  • Hooks: SetWindowsHookEx, WH_KEYBOARD_LL, WH_MOUSE_LL
  • Hotkeys: RegisterHotKey/UnregisterHotKey, message loop
  • Windows Services: BackgroundService, sc.exe, Event Log
  • Tray Apps: NotifyIcon, context menu

Підсумок: 20 Файлів

#ФайлБлокЗалежить від
01How OS WorksA—
02Processes in .NETA01
03AppDomains & AssembliesA02
04Thread FundamentalsB01
05Shared State Problems ⚠️B04
06Synchronization FundamentalsB05
07Synchronization AdvancedB06
08Interlocked, Volatile, Lock-FreeB05
09ThreadPoolB04, 06
10Concurrent CollectionsB06, 08
11TPL, Parallel, PLINQB09
12Async FundamentalsC11
13SyncContext & ConfigureAwaitC12
14Async Advanced PatternsC12
15ChannelsC12, 14
16Async SynchronizationC07, 12
17Unsafe CodeD01
18P/Invoke & WinAPIE17
19Windows RegistryE18
20Windows Hooks & ServicesE18, 12

Windows Hooks, Hotkeys та Services — Глибока Інтеграція з ОС

Повний розбір Windows Hooks для перехоплення подій, глобальних Hotkeys, створення Windows Services та Tray застосунків. Від теорії до практичних прикладів з детальним кодом.

8.1.1. Основи роботи з файловою системою

Copyright © 2026