C# Typing Speed Test
C# blends Java-style verbosity with functional density: LINQ chains, `=>` lambdas, and `$"{interpolated}"` strings. These drills cover the modern C# you actually write — expression-bodied members, switch expressions, and async pipelines.
LINQ Chains and Lambda Density
LINQ turns C# into a chain of lambdas: `.Where(o => o.Total > 100m)` repeats the pattern parenthesis-identifier-space-arrow across every query, making `=>` as central to C# as it is to JavaScript — but here it also defines expression-bodied members (`public int Wpm => _wpm;`). String interpolation prefixes quotes with `$` and embeds braces, stacking three symbol types in `$"Hello {name}"`.
Modern C# adds pattern matching with property patterns (`Circle { Radius: > 10 }`), null-coalescing (`??`) and null-conditional (`?.`) operators, and the decimal suffix (`100m`). PascalCase applies to methods as well as types — unlike Java — so Shift presses come even more frequently. Real LINQ and async code gives all these patterns the repetitions they need.
Key Drills for C#:
- Arrow everywhere: `=>` serves lambdas, members, and switch arms. It should be your fastest two-symbol combination.
- Dollar-quote interpolation: Drill `$"` as a pair — interpolated strings are the default in modern C#.
- Question-mark operators: `?.`, `??`, and `??=` chain null handling. Practice them as distinct chunks, not individual keys.
Sample Drill: LINQ Query & Projection
Filtering and projecting collections with LINQ methods.
var topOrders = orders
.Where(o => o.Total > 100m && o.Status == OrderStatus.Paid)
.OrderByDescending(o => o.Total)
.Select(o => new { o.Id, o.Customer.Email })
.Take(10)
.ToList();The Symbols That Slow You Down
The keystrokes below are where C# typing speed is won or lost. Key positions shown for QWERTY — the pattern transfers to any layout, just on different physical keys.
| Symbol | Used For | Keys | How to Drill It |
|---|---|---|---|
| => | Expression-bodied / lambda | = unshifted, then > as Shift+Period | Lambdas, properties, and switch arms — the workhorse of modern C#. It should be your fastest two-symbol combo. |
| $"…" | Interpolated string | $ as Shift+4, then quotes as Shift+Apostrophe | The dollar-quote opener is two shifted reaches in sequence — drill it as a single pair. |
| {} | Interpolation braces | Shift+[ and Shift+] | Inside every interpolated string: `$"Hello {name}"`. Braces nest inside quotes constantly. |
| ?. | Null-conditional | ? as Shift+Slash, then . unshifted | Safe navigation chains: `user?.Address?.City`. The shift-release-shift rhythm is worth automating. |
| ?? | Null-coalescing | Shift+Slash twice | `??` and `??=` — doubled question marks. Two even Shift-slash strikes. |
| ; | Statement end | Unshifted semicolon | C# lines end in semicolons as reliably as Java's. The right pinky closes every statement. |
Common C# Typing Mistakes
- ✗Forgetting the `$` before interpolated strings — the braces then type as literal junk. Drill the dollar-quote opener.
- ✗Confusing `?.` with `??` — one is Shift-slash-period, the other Shift-slash twice. Train them separately.
- ✗Slowing on PascalCase method names (`GetOrCreateAsync`) — mid-word Shift presses at every boundary.
What's a Good C# Typing Speed?
C# mixes verbosity with functional density: 30–45 WPM is solid working speed, and 50+ WPM at 96%+ accuracy is excellent. LINQ chains are the perfect self-test — they repeat `=>` and `.` in tight rhythm.