Blog
Original articles from production work. Browse by topic when you want a guided path — or filter the feed below.
Featured
C# async/await interview questions, what an identity server is in ASP.NET Core, and the ASP.NET Core config file — strong entry points into the feed.
C# async await interview questions with scenario answers — .Result starvation, async void, Task.WhenAll with EF Core, CancellationToken, and ValueTask.
What is an identity server in ASP.NET Core? When Identity plus JWT is enough, and when OpenIddict or Duende is the SSO answer.
What is appsettings.json in ASP.NET Core — appsettings.{Environment}.json, ASPNETCORE_ENVIRONMENT, user secrets, and why localappsettings.json is not a real framework file.
Browse by topic
.NET interview questions hub — route into async, ASP.NET Core / .NET Core, EF Core, and Angular tracks. The full question bank is the linked .NET interview questions and answers article.
15 articles →
C# async and await language primer — async vs await keywords, TAP examples, then links to ASP.NET Core production articles.
27 articles →
Article map for practical C# design patterns on ASP.NET Core — Factory, Strategy, Repository, and SOLID deep dives.
6 articles →
Topic index for ASP.NET Core DI — links to lifetimes, Unable to resolve service, and IOptions deep dives.
4 articles →
Article map for JWT, Angular interceptors, refresh rotation, BFF/YARP, and CORS — open the linked guide for each failure mode.
16 articles →
Article index for IdentityServer, OpenIddict, ASP.NET Identity, and MapIdentityApi — product choice and migration links.
6 articles →
Article map for EF Core on ASP.NET Core — links to the performance checklist, N+1, cartesian explosion, relationships, and SQL Server plans.
25 articles →
Article index for CQRS-lite — when MediatR helps delivery, license vs Wolverine, and when a mediator is ceremony.
3 articles →
Article map for X12 EDI on ASP.NET Core — parsers, intake pipelines, and PHI-safe logging. Not a compliance certificate.
2 articles →
Article map for ASP.NET Core caching — links to cache-miss, IMemoryCache vs Redis, production Redis, and connection-error guides.
6 articles →
Article map for REST API design on ASP.NET Core — links to definitions, principles checklist, OpenAPI/Swagger, and Angular contracts.
27 articles →
Article map for .NET + Angular architecture — Clean Architecture, modular monolith, middleware order, configuration, and Minimal APIs.
53 articles →
Enterprise Angular guides for .NET developers — Signals, NgRx, SSR, Reactive Forms validation with ProblemDetails, OnPush change detection, and RxJS.
8 articles →
Production Azure architectures for .NET — App Service, Managed Identity, Key Vault, Service Bus, and Azure Functions isolated worker.
8 articles →
Hardening ASP.NET Core APIs and Angular SPAs — OWASP API Security Top 10, BOLA/IDOR prevention, CSP nonces, STRIDE threat modeling, and security headers.
9 articles →
Production deployment pipelines, Docker environments, and GitHub Actions workflows for full-stack .NET and Angular systems.
5 articles →
Real database and service testing for ASP.NET Core — Testcontainers for SQL Server and Redis, and WebApplicationFactory integration tests.
4 articles →
217 articles
7 min read
Implement DDD value objects in .NET as C# records. Map with EF Core using OwnsOne for owned entities and HasConversion for primitive properties.
8 min read
System design interview prep for .NET engineers. Real questions with 30-second answers — URL shorteners, notification systems, distributed systems.
11 min read
A repeatable 4-step framework for system design interviews. Learn how to structure requirements, high-level design, and scaling answers.
11 min read
Implement the Saga pattern in .NET for distributed transactions across microservices. Compare choreography vs orchestration with real C# examples.
6 min read
The three pillars of observability in .NET — when to use structured logs, distributed traces, and metrics. Strategy guide with Serilog and OpenTelemetry.
8 min read
Full system design for a notification system — requirements, architecture, channel routing, reliability, rate limiting, and .NET implementation.
8 min read
Microservices interview prep for .NET developers. Real questions on service communication, data consistency, circuit breakers, and service boundaries.
8 min read
Compare RabbitMQ, Azure Service Bus, and Kafka for .NET. Which message broker fits your workload — from task queues to event streaming at scale.
11 min read
Load balancing algorithms — round-robin, least connections, IP hash, and consistent hashing — with .NET production examples and trade-offs.
11 min read
Horizontal vs vertical scaling for ASP.NET Core APIs — stateless design, load balancing, and when to scale out vs scale up in production.
7 min read
Compare event sourcing and CRUD for .NET. When the audit trail and temporal queries justify event sourcing's complexity, with C# implementation patterns.
7 min read
Build event-driven systems in ASP.NET Core with MassTransit. Events vs commands, async decoupling trade-offs, and when EDA helps vs hurts.
8 min read
EDA interview prep for .NET developers. Domain events, integration events, eventual consistency, and designing idempotent consumers explained.
8 min read
Understand domain services vs application services in .NET DDD. Fix the anemic domain model and know where each type of business logic belongs.
7 min read
Implement domain events in .NET aggregates and dispatch with MediatR. Domain events vs integration events, dispatch timing, and the outbox pattern.
9 min read
Distributed systems interview prep for .NET engineers. CAP theorem, consistency models, partition tolerance, and distributed transactions explained.
7 min read
Cache-aside, write-through, and write-behind patterns in ASP.NET Core with Redis. When each is correct and what breaks when you pick the wrong one.
6 min read
Design idempotent APIs in ASP.NET Core to handle duplicate requests safely. Idempotency keys, database patterns, and safe at-least-once processing.
9 min read
DDD interview prep for .NET engineers — aggregate root, bounded context, domain events vs integration events, and the anemic domain model anti-pattern.
10 min read
Apply DDD in ASP.NET Core with aggregates, value objects, domain services, and application services. Know when it is worth the complexity.
8 min read
Sharding strategies and shard key selection for SQL Server in .NET microservices — range, hash, and directory sharding explained with examples.
10 min read
Database interview prep for .NET developers. How to answer questions on sharding, replication, indexing, ACID, BASE, and SQL vs NoSQL.
7 min read
Combine CQRS and event sourcing in .NET — projections, read models, eventual consistency on the read side, and when to use one without the other.
11 min read
Implement the circuit breaker pattern in ASP.NET Core using Polly. Prevent cascade failures in microservices with open, closed, and half-open states.
11 min read
CAP theorem for .NET engineers — when to choose consistency vs availability in distributed ASP.NET Core systems, with real trade-off examples.
8 min read
Define bounded contexts in .NET with context maps, anti-corruption layers, and the relationship between bounded contexts and microservices.
6 min read
Compare API gateway options for .NET microservices: Azure API Management, YARP, Ocelot, and AWS API Gateway. When to build vs use a managed service.
8 min read
API design interview prep for .NET developers. REST design, idempotency, pagination, versioning, and rate limiting — with 30-second and strong answers.
6 min read
Implement the Anti-Corruption Layer pattern in .NET to translate between bounded contexts and wrap legacy APIs. C# examples for healthcare integrations.
6 min read
Design aggregates in .NET DDD — how to size them, avoid concurrency conflicts, when to split, and implement optimistic concurrency with EF Core.
10 min read
Kafka on .NET for ASP.NET Core: adopt for replay and many consumers, commit the outbox with the row, and commit offsets after the write. Not from the controller.
12 min read
Hot Chocolate authorization in ASP.NET Core for GraphQL fields: policies, the right Authorize attribute, validation versus BeforeResolver, and partial errors.
11 min read
EF Core connection pooling is the SqlClient pool, not AddDbContextPool. Dispose the context to return the session before raising Max Pool Size.
10 min read
EF Core aggregate design for multi-tenant SaaS: one root per save, TenantId stamped by that root, and no second aggregate in the transaction.
12 min read
EF Core AES encryption interceptor using AES-GCM: a key id, an HMAC blind index, and restoring plaintext so the next save does not wrap ciphertext.
11 min read
Decide .NET Aspire vs Docker Compose for local ASP.NET Core and Angular work. One laptop source of truth, not a second tutorial for the team.
15 min read
What to read on the .NET Aspire dashboard in local dev: resources, structured logs, traces, and the few metrics that move during a single session.
9 min read
.NET 9 built-in OpenAPI versus Swashbuckle: who writes the document, who only draws a UI, and where NSwag or Scalar still fits. Do not run two generators.
10 min read
.NET 10 ASP.NET Core new features for APIs: Minimal API validation, OpenAPI 3.1, cookie 401s, and the transformer compile break after you upgrade.
11 min read
A covering index for an EF Core query: which columns are keys versus INCLUDE, how IncludeProperties maps them, and how you prove the key lookup is gone.
11 min read
Capacity planning for ASP.NET Core APIs: write down peak demand, name the pool that saturates first, measure it, and do not scale the wrong tier.
11 min read
Blazor WASM authentication with ASP.NET Core Identity: a same-origin HttpOnly cookie, or OIDC PKCE when the WASM app is hosted on another origin.
12 min read
Blazor vs Angular in front of an ASP.NET Core API: Interactive Server, WebAssembly, or a separate SPA. A team decision, not a framework tutorial.
10 min read
Background report progress with SignalR in ASP.NET Core: store the job, build the file in a worker, and notify only an authorized group. Refresh uses GET.
10 min read
Reach Azure SQL and Key Vault from ASP.NET Core over private endpoints and privatelink DNS, then disable public network access on both services.
11 min read
Azure Monitor workbooks for ASP.NET Core SLOs: weight availability by itemCount, chart latency percentiles, and pass the target in as a parameter.
11 min read
Azure Key Vault access policy vs RBAC: one data-plane model for a .NET app, Secrets User for reads, and how to tell which 403 you actually hit.
10 min read
Azure Functions Service Bus trigger on the .NET isolated worker: bind the queue and settle each message with complete, abandon, or dead-letter.
11 min read
A .NET Azure Functions cold start is host and worker startup, not your method. Which plan settings actually shorten the first call after idle.
10 min read
Azure Event Grid with ASP.NET Core webhooks: the OPTIONS or validationResponse handshake, caller authentication, and a fast ack that stays safe on retry.
10 min read
ASP.NET Core WebSockets vs SignalR: choose SignalR for groups and reconnect, or raw sockets when you must own the frames, auth, and scale-out.
9 min read
Enable ASP.NET Core request decompression so gzip, Brotli, or deflate bodies bind as normal JSON, and cap the inflated size. Not response compression.
10 min read
ASP.NET Core rate limiting vs Polly: return 429 before the action, and limit outbound HttpClient calls in Polly. Most APIs need both, for different budgets.
10 min read
ASP.NET Core output caching in Redis is a shared store, not a backplane. Another instance can serve the cached GET without running the action.
11 min read
ASP.NET Core file download streaming for large CSV exports: async EF rows, an early flush, cancellation, and a one-time ticket instead of a query JWT.
10 min read
Choose ASP.NET Core Data Protection, AES-GCM, or a password hash for the data you have. This page is only that split, not a storage implementation.
13 min read
Architecture decision records (ADR) for ASP.NET Core: one numbered file per choice, the old text left intact, and a new file when it changes.
10 min read
Application Insights for ASP.NET Core and Angular: call UseAzureMonitor, send traceparent from the SPA, and keep tokens and PII out of the portal.
10 min read
An anti-corruption layer in ASP.NET Core translates partner and legacy models at the edge so domain types, errors, and Angular fields stay yours.
11 min read
Angular silent token refresh on startup runs one cookie POST before the first secured call and keeps the access token in memory, not localStorage.
13 min read
Angular OIDC PKCE against ASP.NET Core: a public client, the code exchange, and an API that rejects a wrong audience. No client secret in the bundle.
11 min read
Angular Jest vs Vitest for an ASP.NET Core SPA: CLI default, jsdom, what a Jasmine migration actually changes, and the tests that stay in .NET.
10 min read
Angular i18n routing in ASP.NET Core: allow-listed /en and /ur prefixes, one base href model, and a path culture provider that beats a stale cookie.
12 min read
Angular @defer performance for admin dashboards: which widget waits, which trigger fires, and which ASP.NET Core call is absent on first paint.
9 min read
Angular build budgets fail CI when a production bundle exceeds maximumError. The limit counts raw emitted bytes, not the gzip size on the wire.
10 min read
Download a file with Angular HttpClient as a blob from an ASP.NET Core API, and report upload progress, without parsing that file body as JSON.
12 min read
Angular axe and Playwright accessibility CI: host the SPA in ASP.NET Core, scan real routes, and fail on serious or critical violations. Same host as production.
12 min read
Accessible Angular forms with aria-live: labels, ASP.NET Core field errors, and a live region that already exists when @defer swaps content in.
10 min read
AKS workload identity for an ASP.NET Core pod: federate the service account, remove the client secret, and grant that user-assigned identity.
13 min read
Choose AKS or Azure App Service for a .NET API. Compares operations, deployment slots, and networking, without invented prices or a kubectl guide.
9 min read
ASP.NET Core integration tests with Testcontainers — real SQL or Postgres and Redis beside WebApplicationFactory. Extends WebApplicationFactory; not Angular E2E.
9 min read
STRIDE threat modeling for ASP.NET Core APIs — a 6-step walkthrough with Spoofing, Tampering, and Elevation of Privilege examples.
10 min read
RFC 9457 ProblemDetails in ASP.NET Core — standard error responses, extension fields, Angular error parsing, and client-friendly formats.
9 min read
Prevent BOLA/IDOR in ASP.NET Core with resource-based authorization handlers — the biggest API security vulnerability explained.
9 min read
A practical OWASP API Security Top 10 checklist mapped to ASP.NET Core controls — BOLA, auth, mass assignment, rate limits, CORS, and Angular trust boundaries. Not a JWT or RBAC rewrite.
9 min read
OpenTelemetry in ASP.NET Core — traces, metrics, logs, ActivitySource, OTLP export, W3C traceparent, and sampling strategies.
7 min read
NgRx vs Angular Signals vs SignalStore — when each state management approach is correct for enterprise SPAs backed by ASP.NET Core.
10 min read
Multi-tenancy in ASP.NET Core beyond EF Core query filters — connection-per-tenant, tenant resolution middleware, and resource-based auth.
9 min read
Use Managed Identity in ASP.NET Core on Azure — passwordless SQL, Blob, and Key Vault access using DefaultAzureCredential.
9 min read
Hot Chocolate GraphQL in ASP.NET Core — schema definition, queries, mutations, subscriptions, and auth integration patterns.
8 min read
Hangfire vs Quartz.NET vs Channel workers for ASP.NET Core background jobs — when each is the right choice for scheduling and queuing.
8 min read
gRPC vs REST in ASP.NET Core — when Protobuf streaming beats JSON/HTTP, and when REST is still the right choice for APIs.
9 min read
GitHub Actions CI/CD for ASP.NET Core and Angular — multi-stage build, test gate, Docker publish, and Azure App Service deployment.
9 min read
Getting started with .NET Aspire: the AppHost, service defaults, and adding the ASP.NET Core API and the Angular app. That is the whole scope of this page.
9 min read
Configure Content Security Policy for Angular and ASP.NET Core — nonce-based middleware, inline script handling, and violation reporting.
11 min read
Azure Service Bus with ASP.NET Core — queues, topics, sessions, message processor, and retry/DLQ patterns for production workloads.
8 min read
Load Azure Key Vault secrets into ASP.NET Core configuration — Managed Identity, IConfiguration provider, and secret refresh patterns.
10 min read
Azure Functions isolated worker for .NET — Program.cs DI, HTTP triggers, shared contracts, local Core Tools, and when not to replace App Service.
10 min read
Angular SSR hosted by ASP.NET Core — the production layout that actually works, with build config, proxy setup, and common SSR pitfalls.
10 min read
Angular Reactive Forms validation bound to ASP.NET Core ProblemDetails — map field-level errors from the API envelope to form controls.
4 min read
When an ASP.NET Core API should use vertical slice architecture instead of Clean Architecture, and how to keep one DbContext without four projects per feature.
4 min read
Publish a message only if the EF Core save committed. The transactional outbox writes the event in the same transaction as the order, then a background worker sends it.
5 min read
LINQ interview questions with scenario answers for C# and EF Core: deferred execution, IQueryable SQL, client evaluation, and queries that look fine in memory and fail in production.
5 min read
IEnumerable vs IQueryable vs ICollection in EF Core: which one still builds SQL, which one loads the table, and which one is only a navigation collection.
Updated Published 5 min read
Stop duplicate orders with idempotency keys in ASP.NET Core — store the Idempotency-Key header with the response and replay safely for duplicate requests.
Updated Published 6 min read
Git merge vs git rebase in enterprise teams: 3-way merge commits vs linear history, interactive squashing (git rebase -i), conflict resolution, and the golden rule of rebasing.
Updated Published 5 min read
How to check out a remote Git branch: fetch refs, create local tracking branches with git switch, recover from detached HEAD, and prune branches.
4 min read
How an Angular app and an ASP.NET Core API use Microsoft Entra ID: which token the API accepts, the audience and scope checks that cause 401s, and when a BFF is the better shape.
4 min read
The ASP.NET Core error 'A second operation was started on this context' means one DbContext is running two queries. The usual causes are a missing await, a parallel task, or a context stored in a singleton.
4 min read
How to run EF Core migrations in production without a startup race: generate a SQL script, apply it once in the pipeline, and use expand and contract when the app is already live.
Updated Published 5 min read
Master EF Core connection resiliency in Azure SQL: EnableRetryOnFailure, handling transactions with CreateExecutionStrategy, and idempotency.
4 min read
The difference between .NET Framework, .NET Core, and modern .NET — what each name means and which TargetFramework to use in 2026.
Updated Published 6 min read
Dapper vs EF Core in ASP.NET Core: performance realities, change tracking overhead, sharing transactions in hybrid architectures, and when to use each tool.
3 min read
Offset page numbers skip and duplicate rows when the table changes. Cursor pagination for an ASP.NET Core list API is a key, a stable order, and a next link Angular can follow.
4 min read
C# OOP interview questions with scenario answers: abstract class vs interface, records, virtual and sealed, composition over inheritance, and what to say when the interviewer asks why.
Updated Published 5 min read
Master C# Nullable Reference Types (NRT): compiler static analysis, null attributes ([NotNullWhen]), C# required properties, and EF Core mappings.
Updated Published 6 min read
Master ASP.NET Core integration testing with WebApplicationFactory, Testcontainers SQL Server, synthetic Auth handlers, and Respawn isolation.
Updated Published 5 min read
Configure production HTTP security headers in ASP.NET Core: X-Content-Type-Options, X-Frame-Options, Strict-Transport-Security (HSTS), Content-Security-Policy (CSP), and Permissions-Policy.
Updated Published 5 min read
Master ASP.NET Core Output Caching (.NET 8/9/10): response caching vs in-memory caching, cache eviction with tags, Redis backplane, cache locking, and tenant safety.
Updated Published 5 min read
Configure production health checks in ASP.NET Core: isolate liveness from readiness, write custom IHealthCheck handlers, configure Kubernetes probes, and prevent restart storms.
5 min read
Fix ASP.NET Core redirecting to http, dropping the real client IP, or looping on HTTPS when it sits behind Azure App Service or YARP. The proxy is untrusted until you say so.
Updated Published 5 min read
Implement end-to-end request tracing in ASP.NET Core with custom CorrelationIdMiddleware, ILogger scopes, W3C traceparent headers, and Angular HTTP interceptors.
Updated Published 5 min read
Implement API versioning in ASP.NET Core with Asp.Versioning.Http, URL/Header strategies, OpenAPI Swagger docs, and deprecation sunset headers.
4 min read
Which RxJS map to use when Angular calls an ASP.NET Core API: switchMap for search, exhaustMap for submit, concatMap when order matters. The wrong one drops or doubles the request.
Updated Published 6 min read
Bootstrap Angular apps with standalone components: replace NgModules with provideHttpClient, configure route lazy-loading, and manage DI scopes.
Updated Published 6 min read
Master Angular OnPush change detection: input reference equality, Signals integration, ChangeDetectorRef methods, and immutable update patterns.
Updated Published 21 min read
Swagger is the UI name; OpenAPI is the document. Say both on a README. Package choice lives at /blog/dotnet-9-openapi-vs-swashbuckle, not on this page.
Updated Published 8 min read
Map one-to-one, one-to-many, and many-to-many in EF Core — owned types vs FK, skip-level n-n vs a join entity with payload, delete behavior, and the Angular DTOs I actually return.
4 min read
What is an API — definition, how REST APIs work, request/response flow, and a minimal ASP.NET Core example. Plain English before framework details.
5 min read
What is a cache miss — definition, cache hit vs miss, why misses hurt performance, and how cache misses work with IMemoryCache and Redis on ASP.NET Core APIs.
Updated Published 4 min read
Repository definition and meaning explained — what a repository is in software and in .NET. When to use the pattern with EF Core: see the repository pattern guide.
4 min read
Fix 'error establishing a Redis connection' in ASP.NET Core — connection string, TLS, Azure Cache for Redis, Docker networking, timeout, and fail-open IDistributedCache patterns.
Updated Published 7 min read
.NET interview questions and answers as a topic map. Use this page to pick a track, then open the linked post that actually holds the scenario answers.
Updated Published 5 min read
Deadlock definition and avoidance in OS and C# — lock ordering, async deadlocks, and how that differs from SQL Server reader/writer deadlocks (linked separately).
5 min read
C# multithreading tutorial in one pass — Thread vs ThreadPool vs Task, async is not multithreading, lock and Interlocked, and which primitive article to open next on ASP.NET Core.
4 min read
Callback meaning in async programming — how callbacks differ from promises and async/await, with C# Task and JavaScript Promise examples for ASP.NET Core and Angular teams.
Updated Published 6 min read
Caching layers for .NET — object cache, in-memory vs distributed, IMemoryCache vs Redis on ASP.NET Core. Includes cache-miss definition and layer mapping.
Updated Published 5 min read
Asynchronous meaning and definition explained plainly — what asynchronous means in programming. Side-by-side async vs sync tables: see the comparison guide.
4 min read
How to write an asynchronous class in C# — async methods, constructors, async factory pattern, and IAsyncDisposable for proper cleanup.
Updated Published 5 min read
Async vs sync explained with tables and C# examples — blocking vs non-blocking I/O and when to use each on ASP.NET Core.
4 min read
Promise meaning in async programming — how C# Task, JavaScript Promise, and futures represent work that will complete later, with ASP.NET Core examples and interview answers.
6 min read
Fix IDX10501 JWT kid mismatch in ASP.NET Core — token header kid not in JWKS, signing cert rotation overlap, Authority mismatch, and OpenIddict key refresh.
Updated Published 6 min read
API design principles for production REST APIs — resource naming, versioning, errors, pagination, auth, and idempotency with ASP.NET Core examples.
Updated Published 5 min read
PAGELATCH_UP on database id 2 is TempDB allocation contention. Multiple equal data files fix it. EF does not need a #temp table to cause this.
Updated Published 5 min read
Readers blocking writers deadlock an ASP.NET Core API. READ_COMMITTED_SNAPSHOT (RCSI) uses row versions. It does not fix lost updates on the same row.
4 min read
IdentityServer login loops and redirect_uri mismatch — Duende / OpenIddict client URIs, Angular redirectUrl, post_logout, and PathBase. Not the Identity vs SSO decision.
Updated Published 5 min read
EF Core value conversions for enums and value objects: HasConversion maps EmailAddress or enum to one SQL column — and what LINQ cannot query inside a JSON blob.
5 min read
SQL Server parameter sniffing in EF Core: same LINQ fast for one clinic, 30s timeout for another. How to confirm in Query Store and what to change.
4 min read
EF Core optimistic concurrency with RowVersion: map SQL Server rowversion as a concurrency token, return 409 on conflict, and stop last-write-wins on encounters.
Updated Published 9 min read
EF Core interview questions with production answers — entity relationships, RowVersion concurrency, global query filters, ExecuteUpdate vs SaveChanges, and tenant leaks.
Updated Published 5 min read
EF Core SaveChanges interceptors for audit logs: ISaveChangesInterceptor stamps CreatedBy and ModifiedBy from the JWT. Why ExecuteUpdate bypasses it.
4 min read
EF Core global query filters for soft delete and multi-tenant ClinicId. How HasQueryFilter works — and why IgnoreQueryFilters is how tenant data leaks.
4 min read
EF Core ExecuteUpdateAsync runs one set-based UPDATE without loading entities. When to use it for bulk fee schedules — and why it skips SaveChanges interceptors.
Updated Published 5 min read
AsNoTracking vs identity resolution in EF Core: when no-tracking duplicates Patient objects on every row, and when AsNoTrackingWithIdentityResolution fixes read-only Includes.
6 min read
Thread pool starvation is queued work with no free workers. C# .Result and .Wait on ASP.NET Core cause idle-CPU 504s — diagnose with dotnet-counters, then make the call chain async.
4 min read
TaskCompletionSource in C# — wrapping legacy event APIs, controlling Task completion, and bridging callback patterns with async/await.
4 min read
Task.Yield in C# — when it yields control back to the caller, why it matters on UI threads, and why it is almost never right in ASP.NET Core.
4 min read
Task.WhenAll vs Parallel.ForEach in C# — parallel I/O vs CPU work, WhenAll with EF Core gotchas, and cancellation handling.
7 min read
A Task is a promise that work will finish; a Thread is an OS worker. C# async/await is not multithreading — Task vs Thread vs ThreadPool, Sleep vs Delay, and when ValueTask is worth it.
4 min read
Task.Run queues CPU work on the ThreadPool; await yields the worker during I/O. On ASP.NET Core the request is already on the pool — wrapping ToListAsync makes 504s worse.
4 min read
A semaphore is a handful of tickets. SemaphoreSlim.WaitAsync is the async lock for outbound HttpClient — bulkhead (max in flight), why lock cannot await, versus inbound rate limiting.
4 min read
C# lock vs Monitor vs Mutex — when to use each synchronization primitive, reentrance rules, and cross-process locking patterns.
4 min read
Interlocked.CompareExchange in C# — lock-free atomic operations, CAS patterns, and when to use Interlocked over lock in .NET.
4 min read
IAsyncEnumerable lets you process SQL rows one at a time instead of loading 100,000 entities into RAM. yield return, AsAsyncEnumerable, EnumeratorCancellation, and streaming HTTP.
5 min read
If you only write ASP.NET Core APIs, skip ConfigureAwait(false). It is a library contract for WPF/MAUI SynchronizationContext — not a Core performance trick, and not a .Result amnesty.
4 min read
ConcurrentDictionary is a thread-safe map, not a cache policy. GetOrAdd’s factory can run twice, keys must include tenant id, and a lock is still right when you mutate a value in place.
4 min read
C# Channel producer-consumer pattern — bounded vs unbounded channels, backpressure, cancellation, and production use cases in ASP.NET Core.
5 min read
A CancellationToken is a cooperative please-stop flag. In ASP.NET Core, bind RequestAborted, pass it to EF Core and HttpClient, link timeouts, and do not log client abort as a 500.
5 min read
A BackgroundService is a hosted worker the generic host starts and stops. Use stoppingToken, not RequestAborted. Create a DI scope per message. Task.Run after Ok() is not a worker.
4 min read
AsyncLocal vs ThreadLocal in C# — how async context flows across awaits, when each is appropriate, and common misuse patterns.
5 min read
Fix the ASP.NET Core 'Unable to resolve service' DI error — lifetime mismatches, missing registrations, and captive dependency traps.
Updated Published 5 min read
Fix System.Text.Json object cycle detected in ASP.NET Core — EF navigation graphs, why ReferenceHandler.Preserve breaks Angular, and DTO projection that actually ships.
5 min read
Fix IDX10503 JWT signature validation failed in ASP.NET Core — wrong HMAC secret, disposed RSA keys, opaque Identity tokens, and how it differs from IDX10501 kid mismatch.
Updated Published 5 min read
Fix InvalidOperationException Headers are read-only response has started — IExceptionHandler after WriteAsync, streaming exports, Angular CORS errors, and the HasStarted guard.
Updated Published 5 min read
Fix No XML encryptor found in ASP.NET Core Data Protection — key ring persistence for Docker, App Service scale-out, antiforgery cookies, and the XML encryptor that is not JWT signing.
6 min read
ASP.NET Core 401 Unauthorized vs 403 Forbidden — Challenge vs Forbid, JWT bearer mapping, Angular interceptor rules, and why logging out on 403 is wrong.
Updated Published 4 min read
ASP.NET Core middleware order for production — forwarded headers, exception handler, CORS before auth, rate limiting, and Swagger placement behind Azure and Angular SPAs.
Updated Published 6 min read
Options pattern in C# — when to inject IOptions, IOptionsSnapshot, or IOptionsMonitor, AddOptions vs Configure, named options, and the production bugs I see when teams pick the wrong one.
Updated Published 8 min read
C# expert level interview questions with production answers — IAsyncEnumerable exports, cancellation across MediatR, ConcurrentDictionary caches, Span parsers, and bounded Channels.
Updated Published 7 min read
What is appsettings.json in ASP.NET Core — appsettings.{Environment}.json, ASPNETCORE_ENVIRONMENT, user secrets, and why localappsettings.json is not a real framework file.
6 min read
Serilog PII redaction for healthcare ASP.NET Core APIs — HIPAA-safe logging, destructuring policies, and masking PHI in structured logs.
Updated Published 9 min read
Leaving IdentityServer / IdentityServer4 for OpenIddict on ASP.NET Core — client inventory, keys, Angular OIDC breaks, and a cutover checklist from healthcare and SaaS work.
Updated Published 10 min read
What is an identity server in ASP.NET Core? When Identity plus JWT is enough, and when OpenIddict or Duende is the SSO answer.
7 min read
Duende BFF vs custom YARP BFF for Angular ASP.NET Core — buy vs build, OIDC session, CSRF, licensing tradeoffs, and failure modes at 2 a.m.
Updated Published 12 min read
FluentValidation in ASP.NET Core without the deprecated AspNetCore package — one ProblemDetails envelope, field errors Angular forms can bind, and validation in ASP.NET APIs.
7 min read
HttpOnly cookie refresh tokens for Angular and ASP.NET Core JWT — vs localStorage and BFF, cookie flags, withCredentials, CORS credentials, and CSRF defense.
5 min read
How I use AddKeyedScoped and FromKeyedServices in ASP.NET Core for closed sets of implementations — EDI vs FHIR clients, tenant notifiers — and when a factory is still the honest design.
Updated Published 6 min read
Cartesian explosion in EF Core: two collection Includes multiply SQL rows (lines × events). How to confirm in SSMS and fix with split query or fewer Includes.
Updated Published 7 min read
Fix concurrent 401 refresh stampede in Angular against ASP.NET Core JWT rotation — single-flight RxJS queue, shareReplay pitfalls, skip rules, and POST retry safety.
6 min read
A practical ASP.NET Core decision guide after MediatR’s commercial licensing: when I stay on MediatR, when I migrate to Wolverine, and when CQRS does not need a mediator at all.
6 min read
MapIdentityApi opaque tokens vs JWT in ASP.NET Core — when to use each, cookie vs bearer, and the trade-offs with Angular SPAs.
Updated Published 5 min read
EF Core N+1 problem: extra SQL round-trips when a loop touches navigation properties. How Include, projection, and AsSplitQuery each fix a different bug.
7 min read
Parsing X12 EDI in C# for healthcare APIs — envelope vs transaction sets, 837 pipelines, what libraries do, and how ASP.NET Core should host the work.
7 min read
Backend-for-Frontend BFF pattern with ASP.NET Core, Angular, and YARP — cookie sessions, server-side tokens, CSRF defense, and when to skip SPA-held JWTs.
9 min read
ASP.NET Core JWT refresh token rotation guide — hashed storage, family revocation, reuse detection, concurrency locks, and the Angular single-flight contract.
4 min read
Semantic Kernel and LLMs in ASP.NET Core — prompts, plugins, safety, caching, and how Angular clients call AI features without leaking secrets or tokens.
Updated Published 9 min read
C# async await interview questions with scenario answers — .Result starvation, async void, Task.WhenAll with EF Core, CancellationToken, and ValueTask.
Updated Published 7 min read
Await on the ASP.NET Core request path and pass CancellationToken into SQL and HTTP. Blocking the thread pool is a separate article, not this one.
Updated Published 9 min read
ASP.NET Core and Web API interview questions with scenario answers — DI captive dependencies, JWT with Angular, middleware order, async starvation, EF Core slowness, and production tradeoffs.
Updated Published 8 min read
SOLID principles in C# for ASP.NET Core — detailed SRP, OCP, LSP, ISP, DIP examples with DI, Angular-facing APIs, anti-patterns, and refactor checklists from production systems.
7 min read
Angular interview questions for ASP.NET Core teams — detailed scenario answers on auth guards, JWT interceptors, Signals vs RxJS, CORS myths, RBAC, and SPA performance.
Updated Published 6 min read
ASP.NET Core Minimal APIs guide — MapGet, MapGroup, DI, validation, OpenAPI, JWT auth, and when controllers still win for Angular-backed products.
4 min read
Angular Signals for API-driven apps — load state from ASP.NET Core, computed UI flags, RxJS interop, and when Signals beat BehaviorSubject for SPA state.
Updated Published 7 min read
Microsoft.AspNetCore.RateLimiting in ASP.NET Core — fixed/sliding windows, per-user policies, 429 responses for Angular clients, and multi-instance pitfalls.
Updated Published 6 min read
Set up ASP.NET Core global exception handling with ProblemDetails so Angular forms show consistent errors — middleware vs IExceptionHandler, 400 vs 500, and what not to leak.
6 min read
Use IHttpClientFactory in ASP.NET Core to avoid HttpClient socket exhaustion and stale DNS — named clients, typed clients, Polly retries, and mistakes that still break production APIs.
Updated Published 8 min read
Redis as a distributed cache in ASP.NET Core — IDistributedCache, stampede control, invalidation, and tenant-aware keys. Connection failures: see the Redis connection fix guide.
Updated Published 9 min read
Modular monolith vs microservices for .NET — when to split C# services, module boundaries, data ownership, Angular contract stability, and migration path.
8 min read
Strategy Pattern in C# for ASP.NET Core — swap pricing, validation, or export algorithms without giant if-else blocks, and register strategies with dependency injection.
6 min read
Angular auth guard and CanActivateFn with ASP.NET Core JWT — route protection, role guards, token expiry checks, returnUrl safety, and why guards are UX not API security.
Updated Published 11 min read
C# dependency injection in ASP.NET Core — AddTransient vs AddScoped vs AddSingleton, what a transient dependency is, captive dependencies, and habits that keep .NET APIs testable.
8 min read
How to use the Factory Pattern in C# with ASP.NET Core DI — replace brittle switch statements, use factory delegates and keyed services, and know when a real factory class is worth it.
8 min read
A discovery checklist for freelance ASP.NET Core and Angular engagements — scope, auth, hosting, and handoff criteria that prevent costly surprises.
Updated Published 8 min read
Repository pattern in C# with EF Core — when named queries earn their keep vs generic IRepository ceremony on healthcare and eCommerce ASP.NET Core APIs.
7 min read
Practical ASP.NET Core patterns for uploading files to Azure Blob Storage — validation, private containers, SAS, metadata, and Angular-friendly APIs.
8 min read
ASP.NET Core SignalR for real-time features — hubs, Angular SignalR client, authentication, scale-out with Redis backplane.
Updated Published 9 min read
ASP.NET Core JWT checklist for issuance, validation, and token lifetimes only. Refresh rotation and the Angular interceptor each have their own post.
Updated Published 8 min read
Pragmatic Clean Architecture in C# / ASP.NET Core — Onion vs Clean, domain boundaries, three-project layout, and when to skip ceremony on SaaS and eCommerce APIs.
Updated Published 9 min read
EF Core and SQL Server performance: N+1 queries, projections, AsNoTracking, indexes, and reporting pain that only shows under real data volume.
Updated Published 9 min read
MediatR in C# / ASP.NET Core — when CQRS-lite handlers and pipeline behaviors help a product team ship faster, and when extra folders slow healthcare and SaaS delivery down.
Updated Published 8 min read
Angular and ASP.NET Core integration habits — DTO contracts, error envelopes, pagination metadata, datetime policy, and CORS decisions that stop rework.
8 min read
.NET API, Angular, and SQL Server via Docker Compose — reproducible local environments for marketplace stacks without the 'works on my machine' problem.
Updated Published 8 min read
Go-live checklist for ASP.NET Core on Azure App Service: deployment slots, secrets, health checks, and Data Protection keys. Not a zip-deploy tutorial.
7 min read
ASP.NET Core RBAC with named role policies, and why a failed policy returns 403 rather than 401. Hiding a button in the UI is not enforcement.
7 min read
Angular HTTP interceptors for ASP.NET Core JWT — bearer attach, in-memory access tokens, and single-flight refresh overview. Concurrent 401 queues and 401 vs 403 have dedicated guides.
9 min read
EF Core specification pattern for catalog queries: reusable filters, paging, and counts that stay aligned across API lists and export jobs.
8 min read
Fix CORS between Angular and ASP.NET Core — exact origins, AllowCredentials, OPTIONS preflight, middleware order, Azure App Service, and cookie-based JWT refresh.