Newsletter Archive

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.

David Ortinau, Gerald Versluis, Tim Miller, and Javier Suarez walk us through community updates, the origin story of Avalonia, Control Gallery, AlohaKit and several MAUI demos.

The Windows Package Manager team ships 1.12.460 with App Installer moving to WinUI 3, manifest v1.12, and first class font support including a winget-font source plus install and uninstall. This post shows how the update smooths dev box setup and scripting with fixes for portable PATH upgrades and several reliability issues.

Announcing the v8.0.123 release tag for .NET 8.0.23, with guidance on cloning the tag to build .NET from source or using the attached source archives. This post emphasizes PGP-signed tarballs and zipballs with a public key for verification, a practical boost for supply chain hygiene.

Andrew Lock recaps new capabilities in NetEscapades.EnumGenerators 1.0.0-beta19 and why generated enum helpers can be dramatically faster than the built-in Enum APIs. This post introduces EnumParseOptions to turn off number parsing and control comparison behavior, plus SerializationOptions to emit lower or upper invariant names without extra allocations. It also adds ReadOnlySpan<char> APIs via System.Memory so span-based parsing works on netstandard2.0 and .NET Framework targets.

Ian Griffiths unpacks C# 14’s implicit span conversions in .NET 10 and how they make Span and ReadOnlySpan feel first class. You will see why arrays and strings now flow cleanly into span-based APIs, enabling simpler signatures, better type inference, and extension methods that finally behave the way you expect. He also highlights gotchas with older libraries and offers practical design tips to avoid overload ambiguities.

Sudhir Mangla maps the shift from the legacy Application Insights SDK to OpenTelemetry and shows how to get real end-to-end observability for .NET on Azure. This post focuses on why the change matters and gives a practical path with the Azure Monitor OTel distro, the Collector, solid log-trace correlation, and KQL-driven troubleshooting that keeps costs in check.

Ravikumar Makwana explains the real difference between Factory and Strategy in C#, showing how confusing the two leads to brittle code and hidden bugs. Using payment and notification examples, he frames Factory as the choice for what to create and Strategy as the choice for how behavior varies at runtime, then composes them for a clean, testable design. If your code mixes creation and behavior checks, this post offers practical guidelines and sample implementations to simplify things without over-engineering.

A round-up of 10 real-world bugs PVS-Studio caught in 2025 C# projects, surfacing sneaky issues like null coalescing precedence, slippery pattern matching, and LINQ deferred execution with captured variables. This post shows why Equals and GetHashCode drift, why anonymous unsubscription does nothing, and how bit flags can make switch cases unreachable.

Ravikumar Makwana shows how C# records, as data-first types, tame state bugs through value-based equality, immutability, and the with expression for safe updates. This post highlights where records shine in everyday code like DTOs and value objects, while keeping classes for behavior and identity. It closes with a simple rule of thumb to decide between records and classes.

Microsoft ships Windows App SDK 1.8.4, a stability-focused update that trims the Windows ML DLL and adds playful new TextRewriter tones like Rewrite as Shakespeare and Rewrite in Sci‑fi. The release smooths out real world pain points for WinUI 3 apps, fixing Class not registered errors in self-contained deployments and improving StoragePickers, PublishSingleFile, and incremental builds. If you build Windows desktop apps in C#, this post shows what just got easier and why it matters.

Rick and Oscar chat with Anjuli Jhakry, a .NET MAUI developer and MVP building a startup app for people with food intolerances. She shares lessons from moving from Xamarin.Forms to .NET MAUI, why .NET 8 feels production ready, and how she uses ML.NET to learn from user feedback to deliver personalized recommendations. This podcast also hits on keeping architectures simple and how mentorship and community can accelerate developer growth.

Join Daniel Roth, Mike Kistler, and Reuben Bond discuss the future of Orleans in the ASP.NET Community Standup.

Gael Fraiteur announces PostSharp 2026.0 with full support for .NET 10 and C# 14, including the new extension blocks syntax. This post explains how aspects now skip extension block members by default and how to opt in with AllowExtensionBlockMembers, plus a helper to detect compiler-generated metadata. If you maintain AOP in mature codebases, you'll see what changed in the framework baselines and what to review before migrating.

Rahul Bhandari and Tara Overfield share the January 2026 servicing updates for .NET 10.0.2, 9.0.12 and 8.0.23, all non-security patches with links to runtime, ASP.NET Core, SDK, EF Core, WPF and WinForms changelogs. This post helps you gauge update urgency and zero in on fixes that might touch your stack, and it notes that .NET Framework has no new updates this month.

.NET MAUI 10.0.30 SR3 doubles down on quality and developer experience with 100+ fixes across platforms, addressing navigation hangs, SafeArea quirks, and reliability in CollectionView, ScrollView, SearchBar, and Slider. This post also brings Android Material 3 opt in via a build property, sharper XAML binding behavior, refreshed docs and readmes, and sturdier testing so day to day MAUI work feels smoother.

Announcing the Windows App SDK 1.7.7 stable release, a focused maintenance update that steadies WinUI 3 development and fixes an issue that blocked Image Super Resolution on some devices. This post includes links to the release notes, NuGet, and WinUI Gallery for deeper details that may matter to your C# desktop apps.

Melisa Akkuş shows how the Repository Pattern frees your business logic from EF Core, Dapper, and SQL by hiding data access behind a simple interface, so your services stop thinking in LINQ. This post goes interface-first, explains why returning IQueryable breaks the abstraction, and shows that swapping implementations often comes down to a DI registration, yielding easier tests and cleaner services.

Richard Campbell talks with Azure CPO Jeremy Winter about what Azure is rolling out in 2026, from SRE and resiliency agents to Azure Migrate updates, Kubernetes Fleet, and HorizonDB. The focus is on how Copilot and new automation make .NET apps sturdier, migrations less painful, and multi-cluster ops more manageable, along with the impact of new, more efficient global datacenters. This podcast helps you spot the services that could cut on-call noise and shape a practical 2026 cloud roadmap.

J. Tower maps the real tradeoffs in choosing .NET MAUI vs Uno Platform by focusing on what you are optimizing for and the four questions that actually decide the choice: is web a first-class target, how broad your reach needs to be, native feel vs consistent visuals, and how complex your UI is. This post shows where MAUI’s native-control path fits and where Uno’s WebAssembly reach and design-system consistency pay off, plus a simple two-week prototype plan to test the decision on real workflows without months of debate.

Jonathan Tower interviews Sam Basu, Microsoft MVP and Lead Developer Advocate at Uno Platform, about the present and future of cross-platform app development in .NET. This podcast explores how a single codebase can target iOS, Android, WebAssembly, Windows, macOS, and Linux with Uno, why its native and Skia rendering paths matter for performance and design consistency, and how it compares to .NET MAUI, React Native, and Flutter.

Abhishek Yadav walks through the Factory pattern in C#, using a down to earth notification example and a Simple Factory implemented with a switch expression. This post shows how centralizing object creation reduces coupling, supports the Open Closed Principle, and keeps code easier to test, along with guidance on when to use the pattern and common pitfalls.

Dan Roth, Javier Nelson, and Larry Ewing talk about the future of Blazor! In this video, they walk through the themes and ideas they're considering for .NET 11 and open the floor for your questions, suggestions, and experiences to help guide their next steps.

Eriawan Kusumawardhono joins Robert Green on the Visual Studio Toolbox to show us how to use Copilot to modernize existing apps to use the latest technologies.

Ed offers his annual .NET web developer roadmap offering his advice on what technologies to learn and which ones to skip. He also covers other topics like the developer job market and his favorite .NET books and YouTube channels. (Though he left out my favorite. 😉)