Newsletter Archive

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.

Michael Hawker opens up XAML Studio under the .NET Foundation, turning the WinUI prototyping workhorse into a community-driven project. This post explains how years of building XAML Studio spawned reusable Windows Community Toolkit controls like SwitchPresenter, the Sizer suite, and experimental Adorners, and what V2 adds for faster XAML iteration with live editing and debugging.

Viktor Ponamarev recaps a zero overhead year for .NET, where Adaptive Server GC in .NET 9 and sharper JIT work in .NET 10 delivered real memory and throughput gains with almost no tuning. This post shows how params Span in C# 13 and the preview of C# 14 killed hidden array allocations while Garnet, MemoryPack, Sep, and Frozen collections turned common workloads into lean, fast paths. Expect practical insights on getting faster apps by upgrading the runtime and choosing specialized libraries instead of rewriting logic.

Mike James demystifies the Windows console for .NET by showing how to open and attach a console from non-console apps using a few Win32 calls. Ideal when you want quick logging or interactive I/O without building a custom UI.

Ajay Narkhedkar demystifies C# delegates showing how to pass behavior without tight coupling. This post walks through single-cast and multicast delegates, passing delegates as parameters, and the built-in Func, Action, and Predicate, then connects the dots to events and LINQ. Expect practical patterns to make your code more flexible, testable, and calm under change.

Raghunath walks through C# 14’s upgraded lambdas that accept ref, in, and out parameters, trimming boilerplate and enabling in-place updates and copy-free reads. This post highlights when these modifiers shine and closes with a handy decision guide to balance speed and readability.

Walk through creating custom validation in ASP.NET Core MVC, from a simple MinimumAge attribute to a cross property date check with IValidatableObject. This post shows how validation fires in API controllers, how errors surface via ModelState, and how to exercise the rules in Postman without any Razor or JavaScript. Perfect when built in attributes are close but not quite enough and you want clean, reusable domain rules.

Spencer Thomason argues that .NET 10 is winning teams back through refinement, not reinvention, with runtime and memory improvements that actually matter under load and less ceremony like running a single C# file. If you are weighing stacks, you will find a practical view of how modern C# now fits the realities of enterprise delivery.

Patrik Duch untangles the knots between concurrency, parallelism, and async/await in .NET, clarifying that async is about nonblocking work rather than extra CPU. With a clear mental model and a practical CI test example, this post shows when to embrace concurrency and when true parallelism actually makes things faster. Expect fewer threading myths and more confident performance choices.

Laurent Kempé explores C# 14's new field keyword and how it bridges the gap between auto-properties and full property logic. This post shows practical patterns like validation, transformations, lazy initialization, and MVVM-friendly change notifications without manual backing fields, along with nuances such as contextual usage and property initializers. The result is cleaner properties, simpler migrations, and fewer refactoring pitfalls in .NET 10 projects.

Jerrie Pelser shows how to wire Tailwind 4 into an ASP.NET Core 10 MVC or Razor Pages app without a heavy front-end pipeline. Using the Tailwind CLI, the new @import and @source directives, and a small MSBuild target, this post generates site.css in wwwroot on every build while keeping client files neatly isolated. Ideal if you want utility-first styling that is predictable in local dev and CI.

Mashrul Haque introduces Microsoft Agent Framework, the preview successor to AutoGen and Semantic Kernel, and shows how to build practical AI agents in C# without duct tape. This post covers getting started with Microsoft.Extensions.AI, adding memory with threads, wiring up C# tools, and orchestrating multiple agents, plus hard won notes on token costs, errors, and shifting APIs. A clear look at what you gain by consolidating on the new model and how to try it safely.

Microsoft rebrands Trusted Signing to Artifact Signing and makes it generally available for Windows app developers. This post shows how the fully managed service handles short-lived certificates, verified publisher identity, RBAC, and full audit trails while plugging into GitHub Actions, Azure DevOps, Visual Studio, MSBuild, and signtool.

C# 14 widens the "partial" bridge by letting you split instance constructors and events into defining and implementing declarations. The post unpacks the strict one-and-one pairing, why partial events are deliberately not field-like (custom add/remove only), and the real win for source generators clean separation of API surface from generated plumbing for weak events, interop, and bindings plus gotchas around lookup/metadata, signature matching, attributes, and docs.

Azure Cosmos DB's Linux-based vNext emulator gets a serious tune-up: a more capable query engine (nested/cross JOINs, string/array operators, cleaner subdocument handling) and first-class OpenTelemetry so you can trace, log, and grab metrics locally like production. The post shows practical queries, Docker Compose wiring for Jaeger/Prometheus, and health probes that pair nicely with Testcontainers handy for .NET devs validating complex data access patterns and CI pipelines without touching the cloud.

Chris Woodruff demystifies the Identity Map for ASP.NET Core Minimal APIs with the rule of thumb: one database row, one in-memory object. He shows how EF Core's DbContext already provides this behavior, why multiple DbContexts and AsNoTracking can cause subtle lost-update bugs, and walks through a before/after refactor that aligns Identity Map with a Unit of Work. For non-tracking data access, he includes a lightweight C# identity map and a Dapper-friendly unit of work to keep your customer from turning into three people during a single request.

This practical series makes backend dev feel less like framework wizardry and more like solid C#: it starts by contrasting .NET Framework vs .NET Core, then digs into production-grade fundamentals OOP in the real world, delegates/events/lambdas, extension methods, generics, and LINQ. Part 1 lays out the roadmap with bite-size explainers and tees up performance-minded topics next (EF Core + LINQ, async/await, GC) so your services behave predictably when traffic and data grow.

This guide demystifies Redis for .NET devs covering its in-memory speed, data structures, persistence, pub/sub, TTLs, and clustering with practical StackExchange.Redis snippets. The real value is architectural: wire Redis into Clean Architecture by putting it in Infrastructure behind an ICacheService and keeping controllers blissfully unaware. Round it out with production-minded tips like TTLs, payload limits, a singleton ConnectionMultiplexer, and Azure Redis to shave load off your database and keep things snappy.

By replacing string.Split with ReadOnlySpan slicing and a small ref struct, this log parser goes 3x faster while allocating just 470 bytes on 100k lines GC basically takes a coffee break. It's a practical tour of zero-allocation string processing in .NET, showing how spans and stack-friendly types tame memory churn in real-world workloads.

A tour of ASP.NET Core in .NET 10 that focuses on production-ready refinements: passwordless Identity with passkeys, richer built-in OpenTelemetry metrics, smarter memory behavior for long-running services, and thoughtful polish across Minimal APIs, OpenAPI, and Blazor. With concrete snippets (passkey setup, SSE streaming, YAML OpenAPI, reusable validation), it leans into "simple by default, extensible when needed" ergonomics while tightening security and observability. If your APIs hum 24/7 or your Blazor app has grown up, this is less yak‑shaving and more shipping.

Time zones look easy until your nightly job runs an hour early and users see "future" timestamps. This .NET explainer shows why offsets, DST, and historical rule changes make date-time tricky, and lays down the golden rule: store and transmit UTC, convert to local time only at the edges (like the UI). A practical primer to keep data consistent across systems and your users' clocks sane.

Recep Serit breaks down why mixing SQL Server and NoSQL in a single TransactionScope doesn't fly in .NET NoSQL drivers skip MSDTC/2PC, turning dual-writes into a consistency trap. He demonstrates the Transactional Outbox pattern with EF Core: commit your change and an Outbox row atomically, then let a background worker forward to NoSQL or a broker for at-least-once, eventual consistency. A practical, beard-friendly blueprint for polyglot persistence without distributed transaction drama.

Empty collections sneaking into your business logic? This explainer introduces NonEmptyList for .NET 6/8 a type-safe collection that guarantees at least one element then walks through head/tail deconstruction, Map/FlatMap, seedless Reduce, async/parallel helpers, an immutable variant, and serialization/EF Core integration. A realistic order-processing pipeline shows how moving "non-empty" into your types shifts failures to the compiler and keeps your LINQ honest.

Ajay Kumar shows how TDD makes refactoring in .NET feel safe, turning 300-line if-fests into small, testable pieces. Through clear C# examples extracting a DiscountCalculator, introducing shipping strategies, and writing characterization tests he leans on Red-Green-Refactor, practical patterns, and tools like Stryker.NET to prevent regressions. A friendly, test-first playbook for trimming duplication and fixing bugs once across your codebase.

EF Core 10 adds LeftJoin and RightJoin LINQ operators, letting you express joins with far less ceremony than the old GroupJoin + DefaultIfEmpty + SelectMany pattern. The post shows the before-and-after code along with the SQL EF generates, making the readability and correctness gains crystal clear. A tidy quality-of-life upgrade for anyone tired of re-remembering left-join gymnastics in LINQ.