Newsletter Archive

Sudhir Mangla maps out an architecture-first blueprint for building global .NET apps that behave consistently across platforms by adopting ICU, resolving culture correctly, and keeping formatting in the presentation layer. This post helps you avoid costly i18n pitfalls with concrete patterns for NodaTime, money as structured data, ICU MessageFormat and Fluent, RTL friendly CSS, culture-aware storage and search, plus production-grade caching, testing, and trimming.

Mike Irving shows how to target .NET 10 from Visual Studio 2022 without jumping to the new IDE by installing the .NET SDK and verifying with dotnet --version, so you can keep your project moving. In this post he also shares when an upgrade to Visual Studio 2026 makes sense and mentions alternatives like VS Code with C# Dev Kit or Rider.

Round The Code busts five Minimal API myths with practical patterns for moving logic out of Program.cs, organizing route groups, unit testing handlers, and wiring up authorization, validation, and OpenAPI in .NET 10. If you are coming from controllers, this post shows how to keep Minimal APIs clean, scalable, and well documented so they fit real world apps, not just toy projects.

Rolf Bjarne lays out the dotnet/macios plan for Xcode 26.3 support, from branching and version bumps to API bindings and the xtro and introspection test gauntlet. This post gives a behind the scenes look at how .NET for iOS and macOS track new Xcode releases, and what that means for MAUI dependencies, NuGet packages, and your builds staying green.

Peter Ritchie introduces Pri.ProductivityExtensions.Source, a source-only NuGet that adds internal polyfills for newer BCL types so modern C# features work in .NET Standard libraries without extra assemblies. This post lays out why features like ranges, indices, and CallerArgumentExpression trip up .NET Standard projects and how the package unblocks analyzers and PowerShell modules while keeping wide compatibility.

Ali Hamza Ansari breaks down how .NET 10 and C# 14 turbocharge API model validation by swapping reflection for precomputed metadata, cutting allocations, and streamlining hot paths for steadier p95 and p99 latency. In this post you get a minimal BenchmarkDotNet setup comparing .NET 8 and .NET 10 plus practical context on why these changes can deliver around 3x faster validation in real traffic.

Steven Giesel rolls out a February refresh of his browser-based .NET Toolbox, adding an Options Generator that turns JSON config into C# options classes, a typed DI helper for HttpClient and SignalR, and an SRP analyzer to spot single responsibility drift. This post shows how these open source, client-side tools cut boilerplate and encourage cleaner design, with Roslyn-powered ideas possibly on the horizon.

Anthony Giretti gives a clear, no-drama tour of .NET 10's new post-quantum crypto, covering ML-DSA, SLH-DSA, and ML-KEM with patterns that feel like everyday System.Security.Cryptography. In this post you will learn when each algorithm shines and how to future-proof signatures and key exchange in real apps without rewriting everything.

The Visual Studio team rolls out 2026 updates that weave AI into everyday C# work with Copilot powered test generation, call stack analysis, and NuGet security help from both an MCP server and new audit sources. ASP.NET and Blazor devs get faster Razor Hot Reload with auto restart, a snappier Razor editor with Tag Helper go to definition and better IntelliSense, plus practical IDE polish like speedy scrolling, colorized completions, and cleaner Solution Explorer views.

Mori recounts a production incident where orders vanished after a clean deploy, tracing it to EF Core defaults hiding behind a perfectly normal DbSet. This post shows how to take back control with explicit, centralized configuration for entities, clarifying relationships and delete behavior to keep data safe when version or model changes roll through.

Daniel Hindrikes walks us through the new C# expressions feature for .NET MAUI. C# Expressions is so much more than replacing converters; you can finally write inline, strongly-typed logic directly in XAML, making your UI code cleaner and faster to write. Not to mention its performance boost!

This month's .NET AI Community Standup brought Bruno Capuano, Jeff Fritz, and Maanav Dalal together to explore Foundry Local and how C# developers can use it to run AI models directly on their machines, without cloud dependencies. Watch them discuss architecture, local-first AI scenarios, and how Foundry Local fits into modern .NET and AI workflows.

Adam shares nine practical ways to tame .NET 10 app configuration with the Options pattern so your settings stay typed, validated, and reloadable. If your config feels like a junk drawer, this post shows how to model settings as config objects, ditch magic strings, and set sensible defaults your future self will appreciate.

Per Sonberg introduces Zeta, a schema-first async validation library for .NET inspired by Zod that treats schemas as composable values and returns result types with path-aware errors. Along the way, this post contrasts it with FluentValidation pain points around async, DI and composition, shows simple ASP.NET Core integration, and shares early benchmarks with lower allocations and faster failure handling.

The dotnet/dotnet repo has tagged v10.0.3, marking the next point release on the .NET 10 line. This post is handy for version pinning in CI or dependency manifests, though assets and notes were not visible here due to a loading hiccup.

If you’ve ever had to share a single “dev” Service Bus namespace with your team (and deal with broken queues, leftover subscriptions, or random test messages), this setup is the fix: a clean, repeatable local environment that’s perfect for development and integration testing. Milan Jovanović show you how in this video.

El Bruno shows how to use GitHub Copilot CLI to spin up a .NET console app that joins 65 MP3s into one 3.6GB file, turning a scrappy idea into a reliable utility. In this post you pick up practical patterns like streaming to disk to dodge memory limits, adding Spectre.Console polish, and knowing when to step outside Copilot to keep real-time output.

Alvin Ashcraft’s WinDev Helper extension turns VS Code into a tidy WinUI 3 workbench with F5 debugging, x86 x64 ARM64 builds, MSIX signing, and C# Dev Kit features like Solution Explorer. This post shows how winapp CLI integration and ready made templates reduce the friction of scaffolding, packaging, and shipping Windows App SDK apps while XAML IntelliSense and Hot Reload remain on the roadmap.

Ashok Reddy explores the .NET 10 preview feature for single file C# apps that lets you bypass project files and spin up native executables fast. In this post he builds a one file password generator that checks Have I Been Pwned, showing how this lightweight workflow can speed up prototypes, scripts, and everyday utilities.

Carl Franklin and Richard Campbell talk with Ben Dechrai about how AI tooling is changing secure software practices for .NET teams, from code exposure risks and model choices to the realities of running models locally. This podcast offers practical ways to set guardrails for AI-assisted coding and to understand the emerging AI-driven attack and defense landscape so your C# apps ship safer.

Benedict Odoh peeks under the hood of LINQ in EF Core, showing how your lambda expressions become expression trees that EF translates to SQL and why that mental model matters for performance. This post contrasts query and method syntax, clarifies deferred vs immediate execution and terminal operations, and demystifies loading related data with Include, lazy loading, and explicit loading to help you shape cleaner, faster data access.

The .NET team tagged the .NET 8 servicing release with runtime 8.0.24 and SDK 8.0.124 on GitHub, including clear steps to build from the release tag or attached source archives. This post also highlights PGP signatures and the 2023 public key so you can verify artifacts and keep your pipeline squeaky clean.

Aspire 13.1.1 lands with targeted fixes that smooth local HTTPS setup, clean up Vite config path handling, and resolve Azure publishing hiccups, plus an update to Azure.Identity 1.17.1. In this post, you get the highlights on what was patched and why it makes day to day development less cranky, from templates that build reliably to dev certs that behave.

James Montemagno shares .NET 11 Preview 1 with release notes across C#, ASP.NET Core, MAUI, runtime and the SDK. This post points you to what is changing across the stack and how to try the preview with the .NET 11 SDK in Visual Studio 2026 Insiders or VS Code with the C# Dev Kit.

PureWeen ships .NET MAUI 10.0.31 SR3.1, a small service release that bumps the patch version and reverts a recent Android SafeAreaEdges Container fix. This post flags a change that may impact label placement under the Android status bar, useful for anyone polishing cross platform layouts.

Edin Kapić recaps Microsoft's OData .NET 9.0.0 Preview 3 with safer defaults, cleaned up APIs, and tighter spec compliance that mean fewer surprises around nullable actions and untyped JSON. This post spotlights the migration gotchas from 8.x, why some legacy bits were trimmed, and how the client stack is marching toward .NET 8 to 10 alongside ASP.NET Core OData.

Compile & Conquer closes out a Clean Architecture in .NET series with this post on pragmatic production readiness. You get a sensible testing plan per layer, from pure domain unit tests with no mocks to application tests with mocked ports and integration tests against a real database. It also flags common traps like anemic models, EF leaking into your domain, and returning entities from handlers so your core stays maintainable.

Raghunath explores the null-conditional assignment operator ?.= for C# 14, a small tweak that trims repetitive null checks when updating optional dependencies. With concrete examples across logging, UI, caching, middleware, and plugins, this post shows how to apply it safely, where to avoid it in core domain updates, and what it compiles down to. Expect a practical decision guide and patterns you can drop into everyday code.

Raghunath explores C# 14's new field keyword and how it gives you direct access to an auto property's backing field inside getters and setters without extra boilerplate. Through clear examples for validation, change tracking, and lazy initialization, this post focuses on where field improves readability and maintainability and when simpler models still win. It wraps with best practices and performance notes that show the feature adds control with no runtime cost.

David Ortinau and Gerald Versluis host the .NET MAUI Community Standup live from MAUI Day London where they discuss various topics, including control customization, build times, and the platform's future. Plus, learn about upcoming features and explore strategies for creating data-driven apps.

Jody Donetti shares the story and design of FusionCache, showing how hybrid caching in .NET avoids cache stampedes, improves resilience, and lets you start in memory then flip on a distributed layer like Redis without rewriting code. Framed around Microsoft's HybridCache and the IHybridCache abstraction, this podcast spotlights real multi-level caching patterns that speed up APIs, scale across pods, and keep data fresh without drama.

Microsoft's Agent Framework for .NET ships a new preview that tightens how agents manage sessions and context, boosts declarative workflow fidelity when mapping ChatMessage, and starts moving from reflection to source generation. In this post you will spot a few intentional breaking changes along with new Anthropic samples and reorganized durable agent examples that make building real-world C# agents smoother.

Carl Franklin and Richard Campbell chat with Jason Bock about when .NET source generators shine, from compile-time regex to safer P/Invoke, and where they can backfire. This podcast offers practical heuristics for deciding if generators will pay off in your codebase, balancing performance wins with complexity, diagnostics, and build-time costs.

Catharsis packages a practical tour of authentication and authorization in ASP.NET Core, showing how JWT-backed sign-in, Identity, and minimal API/controller hooks fit together. It also covers token hardening tips like short expirations, strong signing keys, and refresh flows.

Explore .NET 10's Microsoft Agent Framework and how agent-based apps bring the JARVIS spirit to everyday C# work. If you write C#, you will see how your skills map to defining agents and their tool access with Azure OpenAI or local models.

Mohan Veer Singh explains how interfaces shape clean, testable C# code and why C# 8 added default interface implementations alongside abstract classes. Through DI-friendly examples and an IPaymentService evolution scenario, this post shows how to grow shared contracts in NuGet and microservices without breaking consumers. You will learn where interfaces, abstract classes, and default methods fit in real projects and how they keep enterprise codebases stable.