Newsletter Archive

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. 😉)

Mike James reports C# has been named TIOBE Programming Language of the Year 2025 after the biggest year-over-year gain, even as Python cools from its mid-2025 peak. This post explains what the index does and does not measure, ties the momentum back to Anders Hejlsberg's component-oriented vision for C#, and explores what rising share could mean for hiring and the .NET ecosystem. The takeaway is steady momentum that may push C# past Java soon, with practical implications for teams choosing languages and tooling.

Prasad Raveendran walks through native validation for Minimal APIs in .NET 10, bringing them much closer to MVC controllers. This post shows how data annotations plus AddValidation enable a source generated validator that short circuits bad requests with consistent ProblemDetails, trimming boilerplate and keeping handlers focused on business logic. A small addition with a big impact on production readiness.

El Bruno ran into 100-second HttpClient timeouts while using OllamaSharp for long-running local model work and traced it to the library's fixed client timeout. In this post he packages the fix as a small extension so you can set timeouts directly on the OllamaSharp client, with quick, standard, and long presets. If you are doing video analysis or lengthy generations, this keeps your runs alive and your code tidy.

Baibhav Kumar unpacks Redis caching patterns that shape real production behavior, focusing on who owns the source of truth, who handles failures, and where latency lands. This post contrasts cache-aside, read-through, write-through and write-behind with practical tradeoffs, and includes a C# cache-aside example for .NET apps. A clear guide to choosing the safer default vs when to accept risk for consistency or speed.

Mohamed Baioumy from Microsoft explains how Azure SQL Database bakes high availability into the platform across General Purpose, Business Critical, and Hyperscale, and what actually happens during failover. This post walks through gateway routing, replica and storage models, and typical recovery times, then ties it back to app design with zone redundancy choices and why your .NET clients still need transient retries. Handy context for matching SLAs to the right tier while keeping ops overhead low.

Yoshifumi Kawai unveils ToonEncoder, a C# library that encodes a JSON-compatible TOON format to shrink LLM prompts by packing primitive object arrays into a compact, CSV-like layout. This post shows where TOON pays off in real apps, how to plug it into Microsoft.Extensions.AI with source generated converters using attributes like GenerateToonTabularArrayConverter and GenerateToonSimpleObjectConverter, and why encode only is often all you need for function calls. Expect practical guidance on selectively applying TOON so you save tokens while keeping JSON where it still fits best.

Yohan Malshika compares direct DbContext usage and the repository pattern in ASP.NET Core with EF Core, showing where each shines. This post lays out definitions, pros and cons, and a small code sample, then frames the decision around project size, domain complexity, and testing needs. You come away knowing when to keep it simple with DbContext and when an extra abstraction can save you pain later.

Gulam Ali H. unpacks List beyond the dynamic array mental model, showing how capacity growth, resizing, and iteration rules shape performance and correctness. This post walks through what happens under the hood, why operations like Insert and Remove can surprise you at scale, and when EnsureCapacity, TrimExcess, or alternative collections are the better fit.

Round The Code gives a quick tour of ASP.NET Core route constraints for Minimal APIs, showing how to push validation to the edge with int, bool, Guid, date and string rules, plus regex and file path checks. If your endpoints need to be picky about inputs, this post shows how to make the URL do the heavy lifting.

Jordan Rowles untangles why string.Empty and the empty string literal are usually the same object but can diverge when empty strings are created at runtime. This post demystifies string interning, how it impacts ReferenceEquals checks, memory usage, and debugging, and where String.Intern helps or hurts. Expect clear, practical guidance like preferring string.IsNullOrEmpty for checks and using string.Empty for intent.

Atakan Serbes unpacks the Mixed Mode Operations anti-pattern in ORMs, where bulk SQL updates bypass the change tracker and leave EF Core out of sync with the database. A concise guide for speeding up large updates without breaking the mental model of your Unit of Work.

Melisa demystifies how EF Core builds the IModel on first use, what DbContext actually does, and when OnModelCreating kicks in. This post explains why the model is cached and shared across DbContext instances, using a helpful blueprint vs worker analogy to make performance implications clear. Expect practical guidance on shaping the model with Fluent API and global filters without wasting cycles rebuilding metadata.

Carl Franklin and Richard Campbell sit down with Jerome Laban and Sam Basu to unpack what .NET 10 means for the Uno Platform. This podcast connects the dots between Uno, MAUI, and WebAssembly, and digs into how AI with MCP can speed delivery and smooth legacy migrations.

Mohammad Rabie announces WebForms Core on NuGet, bringing a server driven UI runtime that integrates with ASP.NET Core, Razor Pages, and MVC. This post walks through the Commander and Executor model that sends intent based commands to the browser for deterministic updates, tiny payloads, and a stateless server, with a simple C# example that removes a DOM element without writing JavaScript. If you want SPA like interactivity without a front end framework, this offers a clean C# first path.

Peter Ritchie introduces DotNetPsCmds, a PowerShell module that reimagines dotnet CLI tasks with object outputs, pipelining, and sensible defaults that make scaffolding .NET solutions and projects faster. This post shows how to compose solution and project creation, add package and project references, and reuse objects in pipelines, while trimming boilerplate files and avoiding noisy solution folders. You will see practical examples plus a short roadmap for templated solutions and solution level configuration.

Anthony Giretti explores the new .NET 10 WebSocket stream API that makes sockets feel like regular Stream I/O. This post shows how treating a WebSocket as a Stream trims custom framing and loops in real world scenarios like large file transfers and real time feeds, with a client example that reads like copying between file streams. If Stream is second nature, this will slide right into your existing patterns.

Jordan Rowles digs into building production-ready plugin systems in .NET that can actually unload and hot reload without file locks or memory leaks. This post nails the AssemblyLoadContext mental model, plus patterns like shadow copying and reflection-free discovery with System.Reflection.Metadata to avoid type identity chaos and static cache leaks. A practical blueprint for safe contracts, realistic unload testing, and knowing when to move out of process.

Pete shares a practical guide to getting .NET 10 running on a Raspberry Pi and writing your first C# IoT apps. This post includes a one-line install script, a Hello World console, and hands-on GPIO samples to blink an LED and read a button, plus notes on board compatibility, library deprecations, and a 3A+ workaround. Great for going from fresh Pi to real pins without tripping over missing libs or numbering schemes.

Jordan Rowles combines the Memento pattern, the Command pattern, and domain events in .NET to deliver reliable undo, redo, and a complete audit trail without exposing internals. This post walks through a practical Order aggregate with commands, snapshots, and event replay, showing how the pieces fit for real apps where state changes matter.

Ali Hamza Ansari breaks down how .NET 10 and C# 14 make EF Core 10 queries faster in production, with benchmarks showing 25 to 50 percent gains. In this post he explains the why behind the speedups including JIT inlining, expression tree caching, and leaner row materialization, and shows small code changes like static lambdas and relaxed JSON metadata ordering that reduce allocations. You will come away knowing which improvements matter and how to apply them to real APIs.

Azure's .NET Translator SDK hits 2.0.0-beta.1 with support for the Azure AI Translator 2025-10-01-preview API, bringing LLM translations, adaptive custom translation, tone variants, and gender-aware output. This post highlights important breaking changes like renamed properties and removed options, helping you plan a smooth migration for multilingual apps.

Darshan Adakane makes dependency injection in ASP.NET Core feel simple, moving from tightly coupled code to interface-first design that is easy to test and evolve. In this post you will compare constructor and parameter injection, register services in Program.cs, and see how Transient, Scoped, and Singleton lifetimes shape behavior. A friendly guide that helps your services play nicely together without turning your code into a tangle.

Dan Roth shares the ASP.NET Core roadmap for .NET 11, an early look at priorities rather than a feature list. The focus spans fundamentals like performance and reliability, doubling down on Minimal APIs, Blazor, SignalR and gRPC, plus easier distributed apps with Aspire. It also explores agentic web apps via the Microsoft Agent Framework and Copilot assisted development through MCP servers and custom agents.

Laurent tours C# 14 extension members, which go beyond methods to let you add properties, operators, and static members to types you don't control. This post shows how extension blocks can make APIs feel native and more readable, with examples like operator math on Point and IEnumerable factories, plus guidance on ref receivers, resolution rules, and migrating from classic extensions.