Backend line

Core C#

Language fundamentals, LINQ, async/await, records

37 sections

Start: Base Keyword

Foundational 8

  1. Base KeywordIn object-oriented programming (especially in C#), the keyword base is used inside a derived class to refer to its immediate parent (base) class., not read
  2. Chapter 01 Survival Of The SharpestPurpose of this chapter: set context for why modern C# looks the way it does, and which evolutionary themes matter in real codebases., not read
  3. Chapter 08 Super Sleek Properties And Expression Bodied MembersPurpose of this chapter: learn modern property improvements (read-only auto-props, initializers, struct behavior) and when expression-bodied members improve clarity vs when they harm readability., not read
  4. Chapter 09 Stringy FeaturesPurpose of this chapter: get fluent with modern “string-facing” features: interpolated strings (including formatting and culture) and nameof for refactor-safe identifiers., not read
  5. Chapter 10 Smorgasbord Of Features For Concise CodePurpose of this chapter: learn several features that improve day-to-day readability by removing noise: using static, initializer enhancements, the null-conditional operator, and exception filters., not read
  6. Chapter 14 Concise Code In Csharp 7Purpose of this chapter: cover the “small but everywhere” features in C# 7.x that reduce boilerplate while keeping code explicit: local functions, out vars, numeric literal improvements, throw expressions, default literals, named…, not read
  7. FIFO Queues In .NET⚙️ Threading Tip: Prefer Channel<T> or System.Threading.Channels when you need async waiting rather than spin-checking a Queue<T>., not read
  8. Nameof KeywordThe nameof operator returns the simple (unqualified) string name of a variable, type, or member at compile time. It's a small but powerful tool for writing safer, refactor-friendly code., not read

Mid-level 19

  1. In plain words, not read
  2. TL;DR, not read
  3. How it works, not read
  4. See also, not read
  5. Additional notes, not read
  6. Chapter 02 Csharp 2 GenericsPurpose of this chapter: understand the C# 2 features that made “modern C#” possible: generics, Nullable<T>, better delegate syntax (anonymous methods), and iterators (yield)., not read
  7. Chapter 03 Csharp 3 LinqPurpose of this chapter: understand the collection of C# 3 language features that (together) enable LINQ to be expressive and practical: implicit typing, lambdas, extension methods, query syntax, etc., not read
  8. Chapter 04 Csharp 4 Improving InteroperabilityPurpose of this chapter: understand the C# 4 features that make interop and API consumption easier (dynamic, optional/named arguments), and learn generic variance (a key type-system concept used heavily by BCL interfaces)., not read
  9. Chapter 05 Writing Asynchronous CodePurpose of this chapter: build a correct mental model for async/await so you can reason about control flow, exceptions, cancellation, context capture, and performance tradeoffs in production services., not read
  10. Chapter 07 Csharp 5 Bonus FeaturesPurpose of this chapter: cover the “extra” C# 5 features beyond async/await that show up in real code and interviews: foreach closure capture behavior and caller info attributes., not read
  11. Chapter 11 Composition Using TuplesPurpose of this chapter: become fluent with tuples as a lightweight composition tool, understand the difference between System.ValueTuple and System.Tuple, and know when not to use tuples (especially in public APIs)., not read
  12. Chapter 12 Deconstruction And Pattern MatchingPurpose of this chapter: get comfortable with deconstruction (tuples and custom Deconstruct) and pattern matching (type/constant/var patterns, is, and switch) so you can write clearer branching logic and explain compiler behavior in…, not read
  13. Chapter 15 Csharp 8 And BeyondPurpose of this chapter: understand the C# 8 feature set (and nearby future items) that meaningfully change how we write safe, expressive code: nullable reference types, switch expressions and richer patterns, ranges/indexes, and deeper…, not read
  14. Dependency Injection Lifetimes🔐 Tip: Never capture a scoped service inside a singleton—inject IServiceScopeFactory instead and create a scope per operation., not read
  15. Reflection Overview🔍 Interview Angle: Be ready to explain how ActivatorUtilities or JsonSerializer leverage reflection and how source generators reduce reflection cost in .NET 5+., not read
  16. Sorted Collections Interview Notes🧠 Practice Prompt: Explain how you’d pick between SortedList and SortedDictionary for a price ladder updated multiple times per second., not read
  17. Sorting AlgorithmsUse this sheet to describe trade-offs quickly and reference C# examples when whiteboarding or coding live., not read
  18. Struct Vs Class When To Use Which| Feature | struct | class | | -------------------------- |…, not read
  19. TypesChoosing the right kind of type affects memory layout, equality semantics, mutability, and API contracts. Use these rules of thumb when designing models and DTOs:, not read

Senior 10

  1. Async Await Deep DiveUse this sheet to unpack what happens when the compiler rewrites an async method and how to keep code responsive under load., not read
  2. Chapter 06 Async ImplementationPurpose of this chapter: understand what the compiler generates for async/await so you can reason about performance, debugging, and “weird” control-flow issues (especially around try/finally, contexts, and custom awaitables)., not read
  3. Chapter 13 Improving Efficiency With More Pass By ReferencePurpose of this chapter: understand modern by-ref features (ref locals/returns, in parameters, readonly structs, ref-like structs like Span<T>) so you can reason about performance and correctness without introducing unsafe bugs., not read
  4. CLR & Garbage Collector (GC)The CLR's generational GC keeps Gen0/Gen1/Gen2 on the Small Object Heap (compacted) and routes ≥85 KB allocations to the Large Object Heap (not compacted by default), with Server GC the throughput-tuned default for ASP.NET services. The…, not read
  5. CLR & Garbage Collector (GC) Practical ExampleA worked example of allocation-free parsing — a market-data tick stream parsed with ReadOnlySpan<byte> slicing, Utf8Parser for numeric fields, and ArrayPool<byte> for buffer reuse, leaving at most one tiny string allocation per line.…, not read
  6. Forcing Garbage CollectionGC.Collect() and friends force a full, blocking collection across all generations — useful in benchmark setup or memory-snapshot tooling, but almost never in production hot paths, where they spike latency and defeat the GC's own…, not read
  7. IDisposable PatternsIDisposable is the .NET contract for releasing unmanaged resources (sockets, file handles, DB connections, timers) deterministically, paired with using/await using so cleanup runs even on exceptions. The senior-engineer details are…, not read
  8. NET Generational Garbage Collection (GC) Deep Dive, not read
  9. RabbitMQRabbitMQ is an AMQP broker built for command and work queues with rich routing (direct, topic, fanout, headers), per-message acknowledgements, and dead-letter exchanges. Senior engineers reach for it over Kafka when they need flexible…, not read
  10. Server Vs Workstation GCServer GC and Workstation GC are the two .NET garbage collector flavors: Server GC runs one parallel GC thread per core with larger heap segments to maximize throughput on multi-core hosts (the ASP.NET Core default), while Workstation…, not read