Newsletter Archive

Getting a string length sounds trivial, but this post digs into what the JIT actually does, benchmarking string.Length, AsSpan and other patterns alongside the guidance behind CA1820 and CA1829. Expect practical takeaways on when Span helps, which checks are fastest in hot paths, and how to silence analyzers without sacrificing readability.

Alice Yang walks through practical patterns for extracting pages from Word documents in C# using Spire.Doc, from grabbing a single page or range to splitting a file into one document per page. The examples and gotchas around zero-based indexing, page vs section, and safe cloning help you automate approvals and conversions without layout surprises.

Gérald Barré shows how to have your NuGet packages include a Software Bill of Materials by wiring up Microsoft.Sbom.Targets and letting dotnet pack embed an SPDX manifest for you. This post frames SBOMs as practical supply chain hygiene that helps with license visibility and audits while keeping your release flow simple.

Mike James digs into multicast delegates and how they power C# events, untangling Delegate vs MulticastDelegate and showing how invocation lists actually behave in real code. Expect practical takeaways like why the last handler returns the value, how += and -= build or trim pipelines, and the gotcha that an exception stops the chain, all backed by clear examples and lambdas.

Matteo Pagani shows how to build a secure MCP server in ASP.NET Core that uses Microsoft Entra for identity, fronted by Azure API Management so agents like GitHub Copilot can call your tools safely over Streamable HTTP. In this post, you wire up C# tools with the MCP .NET SDK, generate OpenAPI, publish to App Service, add OAuth code flow metadata in APIM, and lock down the backend, a practical pattern you can reuse for production agent integrations.

Kalyan Singh Bondili shows a pragmatic way to capture and log ClientConnectionId from SqlConnection in .NET to correlate client connection attempts with Azure SQL diagnostics. This post includes a small console app that emits tidy JDBC-style lines with timestamps and IDs so you can pinpoint intermittent connectivity issues faster.

Damien Bowden shows how to set the amr claim correctly for passkeys with ASP.NET Core Identity in .NET 10 using the OpenID Connect EAP ACR Values so passkey sign ins return pop as expected. This post shares a clean workaround for the current framework behavior and demonstrates requesting phishing resistant authentication with acr_values so LoA and downstream authorization stay accurate.

Mark Downie walks through the Visual Studio 2026 February update that leans into practical AI and diagnostics to keep .NET devs in the flow. This post highlights Copilot powered unit test generation, call stack explanations, and a profiler that runs with your tests, plus a WinForms expert agent, richer IEnumerable DataTips, and faster Razor hot reload that smooths out day to day work.

Viktor Ponamarev walks through how .NET generic math and the INumber interfaces reshape numeric code design, moving from type-switch gymnastics and dynamic to clear constraints and compile time safety. This post highlights when and how to use numeric interfaces to build reusable, fast algorithms across many numeric types, with practical patterns you can apply to sums and other operations without sacrificing correctness.

Lowercasing strings to compare them costs allocations and can break under different cultures (hello, Turkish I). In this video, Michael shows why .ToLower()/.ToUpper() are the wrong tools for comparisons and how StringComparison and StringComparer give you fast, correct behavior. We’ll cover Contains/StartsWith/EndsWith overloads, collection comparers, EF Core caveats, and SQL Server collations. Plus, a tiny benchmark to visualize the allocation difference.

.NET 11 releases big updates to async/await and Nick covers it all in this YouTube video, including performance boosts.

Steven Thewissen shows how upcoming C# expressions in .NET MAUI XAML let you bind with {Name}, use real string interpolation, do inline math, and flip booleans without the usual converter circus, trimming boilerplate and multi-bindings. In this post he notes the feature rides on XAML source generation, is available today behind EnablePreviewFeatures in .NET 10, and even supports inline lambda handlers for quick interactions.

Jeremy D. Miller recaps a whirlwind of Wolverine releases that sharpen concurrency control, durability, and integrations across the .NET stack. This post spotlights inferred message grouping, classic EF Core domain events, fresh transports like HTTP and NATS, and easier idempotency so teams can ship resilient message driven services with less ceremony.

Carl and Richard sit down with Damien Brady on .NET Rocks! to explore what reliable software looks like in 2026 and how AI fits into the picture. This podcast shares pragmatic ways to use LLMs for code analysis and reviews to raise quality, while reminding us that practice, guardrails, and developer judgment still matter.

Mori shares how role checks spiral out of control in real apps, then introduces permission authorization in ASP.NET Core 10 to model what users can do rather than who they are. This post sets the stage for policies, requirements, and permission claims that keep controllers clean and access consistent across UI and business logic.

Serhat Kaçmaz tackles the habit of stuffing every cross-cutting concern into middleware and lays out clear boundaries between middleware, MVC filters, MediatR pipeline behaviors, and decorators. With concise .NET 8 examples, this post shows validation via a MediatR pipeline behavior and caching with a repository decorator to keep business logic clean and HTTP agnostic.

Leomaris Reyes shows how to plug custom fonts into .NET MAUI the right way, from dropping files in Resources/Fonts to wiring up ConfigureFonts and using a clean alias in XAML. This post also highlights when Android's built-in fonts are enough so you can polish your UI without shipping extra assets.

Compile & Conquer demystifies DbContext in EF Core, showing how connection management, change tracking, query translation, transactions, and the identity map quietly drive behavior when your data acts weird. This post explains why scoped lifetime keeps things correct and fast while transient silently loses work and singleton piles up stale, thread-unsafe state, giving you a solid mental model to diagnose bugs and design safer services.

This edition of the .NET AI Community Standup features Bruno Capuano and Brady Gaster discussing Squad, an AI development team that forms to bring your ideas to life. Using five specific agent roles (lead, frontend, backend, tester and scribe), it's not a chatbot wearing hats. Each team member runs in its own context, reads only its own knowledge, and writes back what it learned.

Héctor Pérez walks through Telerik UI for Blazor's Diagram component, from placing a TelerikDiagram and adding shapes and connections to using tree, layered or force layouts so you can sketch workflows and org charts without wrestling with pixel math. This post highlights practical touches like labels, end caps and selection handles, and points to JSON and styling options when you need deeper customization.

Milan Jovanović shows how .NET 9's HybridCache nails speed with L1 plus L2 caching, yet still needs an invalidation backplane to keep multi-node apps consistent. This post implements Redis Pub/Sub with a background listener to fan out cache removals and also highlights FusionCache as a compatible HybridCache option with a built-in backplane.

Leomaris Reyes spotlights six underrated .NET MAUI Button properties, from TextTransform and CharacterSpacing to FontAutoScalingEnabled and LineBreakMode, to help you build buttons that look sharp and behave right on every device. With short XAML examples and practical notes on accessibility and responsiveness, this post shows how to round corners, manage text flow, and keep font sizes aligned with user settings for a more polished app.

MESCIUS shows how to bring MermaidJS text-based diagrams into WinForms using the ComponentOne FlexDiagram control, parsing Mermaid syntax and rendering interactive visuals with a single LoadMermaidGraph call. Beyond the how, this post explains why text-first diagrams fit real apps like workflow editors and documentation tools, with concise C# examples for loading from embedded resources or strings.

Jeremy Likness kicks off .NET AI Essentials by showing how Microsoft.Extensions.AI gives you a single, provider-agnostic API for OpenAI, Azure OpenAI, and Ollama, with DI-friendly patterns, streaming, and typed structured outputs that spare you the JSON wrangling. This post focuses on the real-world bits like standardized options, middleware with logging and OpenTelemetry, Aspire-friendly tracing, and multimodal content that make LLM features production ready, with vectors, agents, and MCP coming next.

El Bruno introduces a .NET library that brings local CLIP image embeddings to your apps using ONNX Runtime, letting you experiment with multimodal search and image RAG without shipping data to the cloud. This post shows the model download scripts, a minimal C# example, and two runnable samples including an interactive Spectre.Console chat so you can get productive fast.

Denis Makarenko walks through Stripe integration options for ASP.NET Core, then implements a tidy server-side flow that creates a Checkout Session and verifies completion with just two minimal API endpoints. This post focuses on the why behind each choice and slips in practical tips like handling minor units, using idempotency keys, and surfacing the session ID for reliable redirects.

Ian Griffiths maps out how to run T4 templates on modern .NET by swapping Visual Studio's legacy engine for the TextTransformCore tool and wiring it into your build with Directory.Build files and a custom MSBuild target. Along the way this post unpacks assembly reference quirks, nesting with DependentUpon, and why teams like Rx.NET still lean on T4 instead of jumping to source generators.

Break down what XAML source generation is, how it works, and why it can improve performance, reliability, and your overall development experience. If you're building apps with .NET MAUI, Daniel Hindrikes offers something you don’t want to miss.

Mori shares a practical guide to function composition in C#, showing how composing small pure functions can turn imperative spaghetti into readable, testable pipelines. This post focuses on real-world refactors like order processing and data flows, explaining the mental model and patterns that make modern C# code easier to reason about and optimize.

Microsoft MVP Gulam Ali H. pulls back the curtain on what arrays really are in C#, from their heap memory layout and reference semantics to the performance cost of bounds checks. By tying arrays to List, Span, strings, and pooling, this post shows how GC behavior and memory patterns quietly shape correctness and speed across your .NET apps.

Nick Cosentino breaks down how Needlr auto-discovers and registers concrete classes and their interfaces in .NET, trimming boilerplate and preventing those sneaky DI runtime errors. This post explains what gets picked up, how lifetimes and exclusions work, and where source generation or reflection fits so you keep convention and manual control in balance.

Joseph Albahari rolls out LINQPad 9, a unified Windows and macOS release with C# 14 support, a redesigned UI, and a smart AI coding agent that can refactor code, write tests, and convert SQL to LINQ. This post highlights how the new provider model, faster editor and SQL tooling, and file-based app support can speed up everyday prototyping and database work across .NET 6-10.

Sam Basu previews the Uno Platform 6.5 community standup, highlighting why these upgrades matter for building real world cross platform .NET apps. This post zeroes in on productivity boosts like Studio's agent-first AI via Antigravity MCP, a default Hot Design visual loop, and a new scope selector, plus core improvements such as Unicode TextBox input, sturdier WebView2, broader Wasm drag and drop, and sharper diagnostics that make C# and XAML work feel smoother.

Vivek Baliyan revisits the Dapper vs EF Core default and shows why the once clear performance win is no longer the deciding factor. This post highlights how EF Core's productivity and evolving features can speed teams up in real apps, with pragmatic notes on when a micro ORM still makes sense.

Jonathan J. Tower talks with Matthew Soucoup about GitHub Copilot's App Modernization agent for .NET, unpacking how it assesses legacy codebases, plans upgrades, and executes tasks with persistent memory to keep teams moving. If you are wrangling aging .NET Framework or multi-version apps, this podcast shows how AI can de-risk migrations to modern .NET and the cloud while complementing helpers like Web Forms to Blazor tooling.

Claudio Bernasconi makes the case for upgrading Blazor apps to .NET 10, not just because it is LTS but for the practical gains it brings. This post highlights smaller payloads for faster startup, a PersistentState attribute that tames prerendering on Blazor Server, new JS interop that can construct JS objects, and NavigationManager.NotFound for consistent 404s across render modes. The focus is on what real apps get in return: quicker loads, less glue code and more correct behavior.