Bits of .NET

It allocates a delegate and blocks break/continue. ✅ Prefer foreach (var item in list) { }

C# — DateTimeKind.Unspecified Breaks Serialization

Unspecified kind leads to wrong conversions. ✅ Rule Always specify: DateTime.SpecifyKind(date, DateTimeKind.Utc)

C# — record Types Can Accidentally Leak Data

record auto-generates ToString(). public record User(string Email, string Password); ❌ Risk Sensitive data may appear in logs. ✅ Fix Override ToString() or avoid records for secrets.

Asp.Net Core / C#

Background Tasks the Right Way

The Problem: You are firing off Task.Run() in a controller and hoping it finishes, but the server kills it. The Fix: Implement BackgroundService. It’s the reliable, built-in way to run long-running processes. public class Worker : BackgroundService { protected override async Task ExecuteAsync(CancellationToken stoppingToken) { while (!stoppingToken.IsCancellationRequested) { // Your logic here await Task.Delay(1000, stoppingToken); […]

Asp.Net Core / C#

Hot Reload Configuration with IOptionsSnapshot

The Problem: You changed a value in appsettings.json, but the app keeps using the old value until you restart the server. The Fix: Inject IOptionsSnapshot<T> instead of IOptions<T>. It reads the config file every time the request is made. public class MyService { private readonly MySettings _settings; // Updates immediately when json changes! public MyService(IOptionsSnapshot<MySettings> […]

Splitting Lists with .Chunk()

The Problem: You need to process a list of 10,000 items in batches of 100, but writing the for loop math is tedious and error-prone. The Fix: Since .NET 6, you can simply use LINQ’s .Chunk(). var heavyItems = GetHugeList(); // Instantly splits into arrays of 100 items foreach (var batch in heavyItems.Chunk(100)) { ProcessBatch(batch); […]

Stop Allocating Memory with Span

The Problem: You need to parse a large string (like a substring), but String.Substring() creates a new string object in memory every time, hurting performance. The Fix: Use Span<T>. It provides a type-safe, memory-safe representation of a contiguous region of arbitrary memory without allocation. string text = “2023-10-25”; // Instead of text.Substring(0, 4) which allocates… […]

The Null Coalescing Assignment Operator (??=)

- 29.12.25 | 29.12.25 - ErcanOPAK comment

The Problem: You are writing verbose if (variable == null) checks just to assign a default value. The Fix: Use ??= to assign a variable only if it is currently null. It makes your initialization logic incredibly clean. // Old way if (myList == null) { myList = new List<string>(); } // Life-saver way myList […]

C# — using Blocks Can Hide IO Bottlenecks

using var stream = File.OpenRead(path); 🧠 Problem Dispose can block while flushing buffers. ✅ Rule Avoid heavy IO inside tight loops.

C# — string.Concat Is Faster Than string.Format

Formatting is expensive. ✅ Faster var s = string.Concat(a, “-“, b); ❌ Slower string.Format(“{0}-{1}”, a, b); Impact: hot paths, logging, serialization.

C# — readonly Fields Don’t Make Objects Immutable

Many devs assume readonly = immutable. ❌ Reality readonly protects the reference, not the object. readonly List<int> items = new(); items.Add(1); // allowed ✅ Fix Use immutable collections when needed.

Observability — Logs Without Correlation IDs Are Noise

Distributed tracing without IDs is guesswork. ✅ Fix Propagate correlation IDs across services.

JSON — Schema Validation Prevents Silent API Breakage

Clients change. APIs break quietly. ✅ Fix Validate JSON against schema before processing.

Cancellation — Passing Token Is Not Enough

You passed CancellationToken…but didn’t observe it. ✅ Rule Check ThrowIfCancellationRequested() in loops.

Async Streams — IAsyncEnumerable Saves Memory

Instead of loading everything: await foreach (var item in stream) Benefits Lower memory usage Faster first response Ideal for large datasets

C# / Entity Framework

EF Core — Change Tracking Is a Hidden Performance Tax

Tracking thousands of entities slows everything. ✅ Fix context.ChangeTracker.QueryTrackingBehavior = NoTracking; Or per query: .AsNoTracking()

Unicode — String Length Is Not What You Think

“👨‍👩‍👧‍👦”.Length // NOT 1 Why UTF-16 code units Grapheme clusters ✅ Fix Use text element enumeration for user-visible length.

Time Zones — DateTime.Now Is a Data Corruption Bug

DateTime.Now depends on server locale. ❌ What breaks Distributed systems Daylight Saving Time Audits & reporting ✅ Rule Store UTC, display local. DateTime.UtcNow

Asp.Net Core / C#

.NET Core — Request Aborted Token Is Ignored Too Often

Client disconnects — server keeps working. ✅ Fix Use: HttpContext.RequestAborted Cancel long-running operations immediately.

Asp.Net Core / C#

.NET Core — Async Controllers Can Still Block Threads

Async does NOT guarantee non-blocking. ❌ Hidden blocker Task.Result Task.Wait() ✅ Rule Async all the way — no sync-over-async.

C# — Exceptions Are Extremely Expensive

Exceptions are not control flow. ❌ Bad try { Parse(); } catch { } ✅ Better Use TryParse patterns. Impact Exceptions allocate Capture stack traces Kill throughput under load

C# — foreach Copies Structs Silently

Iterating structs can create hidden copies. foreach (var item in largeStructList) { item.Modify(); // modifies a copy } ✅ Fix Use ref foreach: foreach (ref var item in CollectionsMarshal.AsSpan(list))

C# — Memory Works with Async, Span Does Not