CLR & Concurrency
Inspect real runtime metadata, distinguish code from expression data, and verify synchronization ownership, context flow, channel completion, and measurement limits.
- Runtime types and assignability direction
Separate a variable declaration, an object runtime type, and assignability checks.
Types & Metadata · 16 min - Open definitions and constructed generic types
Inspect generic identity and distinguish metadata from creating arbitrary runtime code.
Types & Metadata · 16 min - Explicit member discovery with BindingFlags
Discover only the intended members and avoid relying on reflection enumeration order.
Types & Metadata · 16 min - Attribute data versus attribute execution
Read metadata without invoking the attribute constructor, then instantiate explicitly.
Types & Metadata · 16 min - Reflection invocation and exception boundaries
Distinguish a reflection invocation wrapper from the failure of a directly called delegate.
Types & Metadata · 16 min - Explicit type initialization has a boundary
Observe one static constructor without guessing about beforefieldinit or JIT timing.
Types & Metadata · 16 min - Expression trees are data and delegates execute
Inspect expression nodes and request actual interpretation rather than claiming dynamic code generation.
Expressions & Deployment · 16 min - Captured expression values versus parameters
A captured variable is read later; an explicit input makes the dependency visible.
Expressions & Deployment · 16 min - JIT capability is not a tiering measurement
Keep semantic warmup checks separate from observed runtime diagnostics.
Expressions & Deployment · 16 min - AOT metadata needs an explicit reachability plan
Compare direct registration with annotated reflection without claiming an unpublished native artifact.
Expressions & Deployment · 16 min - Monitor locks are reentrant and thread-owned
Observe same-thread nesting, then test wrong-thread release only in the desktop lab.
Synchronization & Collections · 16 min - Monitor conditions require a predicate loop
Separate durable state from a notification and test a real Wait/Pulse protocol externally.
Synchronization & Collections · 16 min - A global lock order prevents a specific cycle
Order the same resources consistently instead of relying on request direction.
Synchronization & Collections · 16 min - Interlocked covers one operation at a time
Compare atomic operations with a coordinated split read-modify-write experiment.
Synchronization & Collections · 16 min - CAS publication compares reference identity
Publish immutable candidates and keep retryable computation separate from committed effects.
Synchronization & Collections · 16 min - Volatile publication is not a compound transaction
Observe ordered publication while leaving stronger synchronization claims explicit.
Synchronization & Collections · 16 min - ConcurrentDictionary factories may run more than once
Atomic publication does not mean the value factory executes exactly once.
Synchronization & Collections · 16 min - ConcurrentQueue peek does not reserve an item
Treat each concurrent collection operation as its own contract.
Synchronization & Collections · 16 min - Semaphore permits are not monitor ownership
Observe nonreentrancy and a maximum, then test cross-thread release externally.
Synchronization & Collections · 16 min - One lease owns one asynchronous release
Make repeated disposal harmless without confusing a permit with thread affinity.
Synchronization & Collections · 16 min - AsyncLocal flows through logical operations
Observe child context changes without treating ambient values as shared global state.
Context, Channels & Evidence · 16 min - Suppressed flow differs from ConfigureAwait
Control context capture when scheduling work instead of assuming a continuation option erases ambient data.
Context, Channels & Evidence · 16 min - Channels own completion and terminal failure
Drain accepted items and observe the actual terminal task separately from admission.
Context, Channels & Evidence · 16 min - Measure observations without inventing a benchmark
Keep actual timestamp/allocation observations distinct from a portable performance conclusion.
Context, Channels & Evidence · 16 min