English for C# Developers

C# code reviews are full of precise, often compiler-enforced terminology, and getting the English right matters because these terms describe compile-time guarantees, not just style preferences. This vocabulary set covers five concepts that come up in almost every .NET team discussion.

Key Vocabulary

Nullable reference type — a C# 8+ feature where reference types are annotated as either nullable (string?) or non-nullable (string), letting the compiler warn you when a possibly-null value is used without a check. “The compiler flagged this as a warning because user is a nullable reference type and we’re accessing .Name without checking for null first.”

LINQ query — Language Integrated Query syntax that lets you filter, project, and aggregate collections using SQL-like or method-chain expressions directly in C#. “Instead of a nested foreach loop, we rewrote that as a single LINQ query using Where and Select.”

Async/await — the pair of keywords that let a method run asynchronously, freeing the calling thread while an I/O-bound or long-running operation completes, without blocking. “Make sure that database call uses async/await properly, or you’re going to block the thread pool under load.”

Dependency injection — a design pattern where a class receives its dependencies (like services or repositories) from an external container rather than constructing them itself, typically wired up in Startup.cs or Program.cs. “We register the repository interface with dependency injection so the controller doesn’t need to know which concrete implementation it’s getting.”

Garbage collection — the .NET runtime’s automatic memory management process that reclaims memory used by objects no longer referenced, organized into generations for efficiency. “That latency spike lines up with a garbage collection pause — we should check if we’re allocating too many short-lived objects in that hot path.”

Common Phrases

• “Is this parameter a nullable reference type, or did we just forget the annotation?”
• “Can we simplify this loop into a single LINQ query?”
• “Did you await that call, or is this fire-and-forget by accident?”
• “Is this service registered with dependency injection, or are we newing it up directly?”
• “Could this slowdown be a garbage collection pause rather than an actual bottleneck in our code?”

Example Sentences

Reviewing a pull request: “You’re dereferencing this without a null check — since it’s a nullable reference type, the compiler warning here isn’t something we should suppress.”

Explaining an architecture decision: “We use dependency injection everywhere so we can swap the real payment service for a mock one in tests without changing the controller code.”

Debugging a performance issue: “The profiler shows repeated garbage collection cycles, so let’s look at whether we’re allocating new objects inside that loop instead of reusing them.”

Professional Tips

• Call out a nullable reference type warning by name in code review instead of just saying “this might crash” — it points the author straight to the compiler’s own diagnostic.
• Suggest converting verbose loops into a LINQ query when it genuinely improves readability, but don’t force it where a loop is clearer — mention both options explicitly in review comments.
• When discussing performance under load, ask whether async/await is used correctly end-to-end, since a single blocking call in the chain can defeat the whole benefit.
• Frame testability arguments around dependency injection — it’s the standard justification .NET teams expect when explaining why a class takes interfaces instead of concrete types.

Practice Exercise

1. Explain to a junior developer why a nullable reference type warning shouldn’t just be suppressed with !.
2. Describe, in one or two sentences, what problem async/await solves that synchronous code doesn’t.
3. Write a sentence you’d say in a design review defending the use of dependency injection over direct instantiation.