.NET

Common Language Runtime
- Intermediate Language (IL)
- Managed language
- Managed code
- Just-In-Time (JIT)

Frameworks and Base Class Libraries
- The Base Class Libraries (BCL)
- Application framework layers
- .NET Standard

Data Types and Memory Allocation
- Value Types
- Reference Types
- double Versus decimal
- Stack
- Heap

Local method
CLR behind the scene implementations
new versus override
Initialization order
Boxing and unboxing
Struct
Ref Structs
Friend Assemblies
Interface implementations
Enum Type-Safety Issues

Generics
- Constraints
- Covariance
- Contravariance

Events
Delegate
- Parameter compatibility
- Return type compatibility
- Generic delegate type

Lambda Expressions
- Closures
- Captured variables
- Expression tree
- Lambda Expressions Versus Local Methods

try Statements and Exceptions
Enumeration and Iterators
The Array Class
Nullable<T> Struct
Nullable Reference Types
Extension Methods
Anonymous Types
Tuple and ValueTuple

Patterns
- Property Patterns
- Tuple Patterns
- Positional Patterns
- var Patterns
- Constant Patterns

Caller Info Attributes
- CallerMemberName
- CallerFilePath
- CallerLineNumber

Dynamic Binding
Unsafe Code and Pointers

Preprocessor Directives
- Conditional Attributes

Comparing Strings
- Equality comparison
- Order comparison
  - Ordinal versus culture comparison

StringBuilder
Text Encodings and Unicode

Dates and Times
- TimeSpan
- DateTime and DateTimeOffset
- Time Zones
- Alternatives

BigInteger
Complex
Random
The Guid Struct

Standard Equality Protocols
- == and !=
- The virtual object.Equals method
- The static object.Equals method
- The static object.ReferenceEquals method
- The IEquatable interface
- When Equals and == are not equal
- Overriding GetHashCode
- Overriding Equals

Collections
- BitArray
- HashSet and SortedSet
- Dictionaries
- EqualityComparer

LINQ Query
- Deferred Execution
- Subqueries
- Interpreted Queries

Garbage Collection and Memory Consumption
- Finalizers
- How the GC Works
- Managed Memory Leaks

Cross-Platform Diagnostics Tools
- dotnet-counters
- dotnet-trace
- dotnet-dump

Concurrency and Asynchrony and Threading
- Concurrency vs Multi-Threading vs Async vs Parallelism
- Single-core vs multicore or multiprocessor machine
- Related Data-Structures (ex: ConcurrentDictionary, Channels)
- Sleep
- Yield
- Blocking
- Spinning
- Local versus Shared State
- Passing Data to a Thread
- Exception Handling
- Foreground versus Background Threads
- IAsyncStateMachine
- IAsyncEnumerable
- IAsyncDisposable
- Synchronization Contexts
- async void
- The Thread Pool
  - Worker Thread vs I/O Thread
- Tasks
  - Long-running tasks & Task.Run()
  - AggregateException
  - awaiter.GetResult() vs .Result
  - TaskCompletionSource
  - Task.Delay
  - Awaiting
  - Asynchronous call graph execution
  - ValueTask<T>
    - Precautions
  - ConfigureAwait(false)
  - Cancellation
- Synchronization
  - Categories
    - Exclusive locking
      - lock Statement
      - Monitor.Enter and Monitor.Exit
      - Choosing the Synchronization Object
      - Deadlocks
      - Performance
      - Mutex
      - Locking and Thread Safety
    - Nonexclusive locking
      - Semaphore and SemaphoreSlim
      - Reader/Writer Locks
    - Signaling
      - AutoResetEvent
      - ManualResetEvent
      - CountdownEvent
      - Barrier Class
  - Lazy Initialization
  - Thread-Local Storage
  - Timers
  - SpinLock and SpinWait
  - Nonblocking synchronization techniques
    - Interlocked
    - memory barriers
    - volatile
  - Monitor.Wait and Monitor.Pulse

Stream Architecture
- Backing stores
  - FileStream
  - NetworkStream
  - MemoryStream
  - PipeStream
    - Named pipes
    - Anonymous pipes
- Decorators
  - BufferedStream
  - DeflateStream
  - GZipStream
  - CryptoStream
- Adapters
  - TextReader
  - TextWriter
  - StreamReader
  - StreamWriter
  - StringReader
  - StringWriter
- Thread Safety
- File and Directory class vs FileInfo and DirectoryInfo
- Memory-Mapped Files

Network Architecture
- URIs
- WebClient
- HttpClient
- HttpListener
- TCP and UDP
Serialization Engines
- XmlSerializer
- JsonSerializer
- The data contract serializer
- The binary serializer
Assemblies
- The Assembly Manifest
- Resources and Satellite Assemblies
- assembly loading
- Assembly resolution
- Assembly Load Contexts
- AssemblyDependencyResolver
Reflection and Metadata
- GetType Method vs typeof Operator
- Obtaining a Type
  - Array types
  - Nested types
- Type Names
- Instantiating Types
- Member Types
- C# Members versus CLR Members
- Late binding
- Using Delegates for Performance
- Attributes
  - Types
    - Bit-mapped
    - Custom
    - Pseudocustom
  - Properties and constructor parameters constraints

Dynamic Code Generation
- Generating IL with DynamicMethod
- Emitting Assemblies and Types

Dynamic Programming
- Dynamic Language Runtime
- Call Sites
- Dynamic Member Overload Resolution
- Anonymously Calling Members of a Generic Type
- ExpandoObject
Cryptography
- Hash Algorithms
- Hashing Passwords
- Symmetric Encryption
- Public-Key Encryption and Signing

Parallel Programming
- Channel
- Data parallelism and task parallelism
- PLINQ
- The Parallel Class
- Task Parallelism
- Concurrent Collections
- BlockingCollection

Span and Memory
- Spans and Slicing
- Forward-Only Enumerators

Native and COM Interoperability
- Calling into Native DLLs
- The Purpose of COM

Regular Expressions
- Compiled Regular Expressions
- Character Escapes
- Character Sets
- Quantifiers

The Roslyn Compiler
- Roslyn Architecture
  - Parsing code into syntax trees (the syntactic layer)
  - Binding identifiers to symbols (the semantic layer)
  - Emitting Intermediate Language (IL)