Newsletter Archive

Playwright v1.58 brings a token efficient, agent friendly Skills CLI along with UI Mode and Trace Viewer polish, plus a new Speedboard timeline for merged reports that makes .NET E2E testing feel smoother. This post also highlights breaking selector removals and a devtools launch change, and adds an isLocal flag for CDP, helpful for keeping ASP.NET Core pipelines speedy and green.

Rishabh Gupta turns Clean Architecture from buzzword soup into a practical guide for .NET Web APIs. This post shows how the dependency rule and a clean four layer split keep your domain independent of frameworks, with code examples and pitfalls that explain why testing and swaps like EF to Dapper get much easier. He also calls out when this approach is overkill so you use it where it truly pays off.

Jeffrey Palermo sits down with Maddy Montaquila, Senior Product Manager on the .NET Aspire team and former MAUI PM, to unpack the latest .NET update and what it means for building cross platform and cloud native apps. This podcast explores where Aspire and MAUI are headed, lessons from the Xamarin to MAUI journey, and practical guidance that can simplify your tooling and app architecture.

Why Azure Maps returns both a view coordinate and a routing coordinate for the same place, and how that split keeps your pins pretty and your directions accurate. In this post you will learn when to use the view coordinate for display and the routing coordinate for ETAs and turn-by-turn, plus which API fields identify each. If you have ever routed to the middle of a building or the wrong side of a divided road, this will help you fix it.

Karen Payne shows how a custom IDisplayMetadataProvider turns FirstName into First Name across your ASP.NET Core views. This post contrasts it with the Display attribute, walks through simple Program.cs wiring and dynamic model discovery, and shares a sample repo that pairs the provider with FluentValidation to keep your UI clean and consistent.

Chris Ayers gives a practical tour of the Aspire CLI for building and running distributed apps across .NET, Python, and JavaScript. If you want less config glue and an easier path to adding databases and caches, this post offers a clean workflow and the why behind it.

Gregor Suttie shares a practical architecture for deploying AI-enabled apps on Azure Web Apps, treating the app as an orchestrator for Azure OpenAI rather than a model host. This post focuses on managed identities instead of API keys, private endpoints, Key Vault backed configuration, and observability with Application Insights, plus a Bicep example that keeps infra clean and auditable.

William McLean walks through building a minimal MCP server in C# that plugs Gemini CLI into Firestore, then iterates by adding new tools directly from the CLI. This post focuses on why MCP makes .NET a solid fit for AI workflows language independence, a simple stdio transport, and Firestore backed tools that enable a real inventory scenario. It is a friendly blueprint for moving from local validation to cloud ready patterns.

Steven Giesel kicks off the year with a free, open source .NET Toolbox built entirely client side to smooth out everyday dev tasks, especially for newcomers to web work. This post highlights a visual Middleware Designer that teaches common ASP.NET pipelines, flags pitfalls like authorization before authentication, and lets you simulate requests, plus a Package Centralizer that generates Directory.Packages.props from your csproj files to simplify version management.

Michael Maurice lays out eight pragmatic steps for building a maintainable CRUD REST API in .NET 10 using Clean Architecture and DDD. This post walks a tiny Products API through domain, application, infrastructure, and API layers so business rules live in the domain, EF Core stays in infrastructure, and controllers remain calm. If your last API grew into a ball of EF queries and if statements, these patterns show how to keep it testable and ready to grow.

John Reilly shows how to wire up end-to-end static typing between an ASP.NET Core Web API and a React TypeScript client by pairing Microsoft.AspNetCore.OpenApi with openapi-ts. He explains why OpenAPI 3.1 surfaces C# nullability more accurately than older tooling and how a couple of schema transformers tame number|string oddities, delivering a lean client and smaller bundles. If keeping front end and back end in sync without hand-written glue sounds good, this post maps out a pragmatic path with scripts you can drop into your workflow.

Mukesh Murugan shows how to build a minimal .NET API that enables S3 bucket versioning, lists an object's history, restores older versions, and recovers deletes by handling delete markers. You will learn how version IDs and delete markers work under the hood, plus practical guardrails like IAM permissions, lifecycle policies to keep costs in check, and MFA delete for critical data. The patterns for audit trails, rollback to last known good, and scheduled cleanup make it easy to bake resilience into real apps.

Martin digs into five LINQ habits that separate clean code from fast code, showing how deferred execution, allocations, and query shape choices create hidden speed bumps. A friendly tune-up for hot paths that turns readable queries into production-ready performance.

Curious Orbit breaks down the real-world difference between IEnumerable and IQueryable in .NET, showing how LINQ runs in memory vs on the database and why that choice affects scalability. This post demystifies deferred execution and expression trees in EF Core, then highlights pitfalls like calling ToList or switching to AsEnumerable too early. You'll walk away knowing when each interface makes sense so your queries do the heavy lifting in the right place.

Mukesh Murugan shows how to enable AWS Lambda SnapStart for .NET 8 and chop cold starts by 58 to 94 percent using real benchmarks. This post walks through setup, the runtime hooks that warm JIT before snapshot and refresh secrets after restore, plus practical gotchas, costs, and when to pair SnapStart with Native AOT.

Leomaris Reyes explores Telerik's Gauge control for .NET MAUI as a fast, visual way to surface real-time stats in apps, from game-style health and stamina to progress tracking. This post explains when to use radial, vertical, and horizontal gauges and shows practical XAML snippets for indicators, ranges, gradients, and layout tweaks like StartAngle, SweepAngle, and AxisRadiusFactor.

Ajay Narkhedkar breaks down value types and reference types in C#, tying stack vs heap behavior to everyday bugs and performance surprises. This post clarifies how assignment and parameter passing really work, why string behaves differently, and when to pick struct or class for safer, faster code. A tidy mental model here can save your future self from head-scratching shared-state issues.

Henrique Siebert Domareski introduces C# 14 null conditional assignment in .NET 10, showing how you can safely set properties with ?. on the left of an assignment. By skipping writes when the target is null, this post trims boilerplate if checks and makes nested updates far less noisy. Great for working with optional aggregates without risking NullReferenceException.

Mahesh Palanisamy shows how to add cut, copy, and paste to Syncfusion's Blazor Scheduler using built in clipboard support. If you are building scheduling UI in .NET, you will learn practical ways to reduce retyping and create a snappy, flexible workflow.

Raghunath Bhukan charts how modern C# and .NET let teams build nearly anything, from high performance ASP.NET Core APIs to Blazor UIs, MAUI apps, Unity games, and ML.NET powered services, all within one ecosystem. This post highlights the real payoff in consistency and reuse: shared skills, tooling, and patterns that reduce context switching without sacrificing speed. It also calls out where C# is not the best fit so you can make clearer architecture bets.

Swapping input and output path strings is an easy bug the C# compiler will not catch. This post applies the make unrepresentable states unrepresentable idea by introducing marker types plus a generic AppSettingPath wrapper so constructors and methods demand the right path at compile time. The result is a tiny, testable pattern that clarifies intent and prevents costly runtime surprises.

Tejaswini Naresh IT maps how C# error handling evolved into design-first resilience for 2026. This post shows how typed exceptions, Result-style flows, centralized middleware, and structured telemetry turn failures into predictable, observable behavior your team can reason about. Less panic, more predictability for production apps.

Announcing generics support in .NET nanoFramework and pulling back the curtain on the engineering that makes it work on tiny devices, from ECMA-335 friendly TypeSpec and MethodSpec to 16-bit tokens, caching and a new PE v2.0 format. This post focuses on why it matters in real code by adding Span, List and Stack plus stackalloc semantics so allocation-free patterns feel natural on microcontrollers. It also covers the preview firmware and tooling alignment you will need and notes a few debugger rough edges.

Compile & Conquer unpacks why EF Core's default scoped DbContext can trip you up in production, from singleton background services to parallel work and long-running reports. This post explains how the one request one context assumption leads to concurrency errors, stale data, and timeouts, and previews safer patterns like short-lived contexts and IDbContextFactory for better lifetime control. A friendly reality check for anyone building hosted services or parallel pipelines in ASP.NET Core.

Microsoft's Agent Framework drops a new .NET preview that tightens APIs for building C# AI agents with async-only threads, the new AsAIAgent helpers, and consolidated options. This post highlights breaking changes and fresh samples like Durable Agents plus package updates to Microsoft.Extensions.AI 10.2.0 and Google.GenAI 0.11.0 so you can plan a smooth upgrade.

Carl and Richard catch up with Gerald Versluis on where .NET MAUI stands today and what is landing with .NET 10, including quality, performance, and ease of use improvements. If you build cross-platform UIs, this podcast unpacks MAUI's near-term roadmap and how it plays with Uno and Avalonia to make shipping smoother in 2026.

Sasha Ivanova shares what is landing in the ReSharper 2026.1 EAP for C# devs, including smarter code generation that wires up LoggerMessage methods and a cleanup action that consolidates scattered extension members. This post spotlights inspections that catch ImmutableArray pitfalls and short-lived HttpClient patterns along with analysis speedups and a move from DPA to integrated performance monitoring so your code stays safer and your IDE feels snappier.

Nikola Metulev unveils winapp, an open-source Windows App Development CLI that takes the grunt work out of building Windows apps with .NET, C++, Rust or Electron. This post highlights one-command setup for manifests, certs and SDKs, adding package identity for debugging without full packaging, plus simple MSIX packing and easier paths to Windows AI and Windows App SDK features for C# developers.

Jamie Taylor chats with NBomber founder Anton Moldovan about bringing load testing under your C# roof using a simple lambda based approach instead of a custom DSL. This podcast compares end to end user journeys with microservice isolation, shows how to plug results into xUnit and CI, and pairs load testing with chaos engineering to build resilient systems.

Tom Deseyn shows how to containerize a .NET app with the .NET SDK, then run it as a reliable systemd service using Podman quadlets. This post explains why images simplify distribution and upgrades, how Microsoft.Extensions.Hosting.Systemd improves startup and logging, and what rootless containers, volumes, and a dedicated service user mean for safer day 2 operations.

Ajay Narkhedkar walks through modern C# pattern matching, showing how to replace brittle if-else ladders with expressive type, property, relational, logical, and positional patterns. This post leans on relatable scenarios like user roles, order statuses, and grading to show how you get safer casts, clearer intent, and tidier decision logic. Expect takeaways you can apply right away in APIs and business rules without the usual conditional spaghetti.

Rodrigo Bercocano do Amaral unpacks a sneaky perf killer in EF Core: ad-hoc queries that pollute SQL Server's plan cache. In this post he shows how use counts in the plan cache reveals poor plan reuse, why interpolating values into FromSqlRaw causes single-use plans, and how LINQ or FromSqlInterpolated keep queries parameterized. The guidance is especially useful on Azure SQL where instance-level tweaks are limited, helping you keep CPU and memory steady.

FracturedJson tackles the age-old choice between minified and pretty-printed JSON by formatting like a human would: inline when simple, compact multiline for arrays, and table-style alignment for similar objects. In this post, you'll learn the heuristics and options like MaxInlineComplexity and MaxTableRowComplexity that make diffs, logs, and config files easier on the eyes while staying compact, plus how comments can be preserved. It is available as a .NET library along with a browser formatter, VS Code extension, and more.

Ali Hamza Ansari benchmarks minimal APIs in .NET 8 and .NET 10 to show how the new LTS and C# 14 make request pipelines snappier. By combining JIT and GC improvements with practical tweaks like static lambdas and AllowOutOfOrderMetadataProperties, this post demonstrates lower latency and allocations, plus faster endpoint selection in ASP.NET Core. If you want to see which small changes yield big wins in real API scenarios, this post walks through reproducible benchmarks and code.

Nick Randolph shows how to pair Uno Platform with VS Code and Model Context Protocol agents to have AI scaffold and iterate on a real cross platform C# app. This post is a practical look at making agents genuinely useful for .NET UI work, from new project templates to AI guided UI refinements.

Dig into span-based string concatenation and why it can be a tidy performance boost in hot paths. This post compares using ReadOnlySpan with string.Concat overloads to the usual + and StringBuilder, highlighting where allocations disappear and throughput improves. You get practical guardrails on when the span approach pays off and when simpler options are perfectly fine.