Monday, February 23, 2026

Joachim Leonfellner shows off four methods to use local images in MAUI Blazor. Along the way, he covers the pros and cons and identifies a clear winner.

Chris Woodruff explains how the Data Transfer Object pattern keeps ASP.NET Core Minimal API contracts stable by separating domain and persistence models from what clients see, avoiding the pitfalls of returning EF Core entities. This post shares practical mapping techniques, before and after endpoints, and sensible rules for when DTOs matter so your APIs are safer, slimmer, and easier to evolve.

Héctor Pérez walks through the Telerik UI for Blazor Skeleton component and shows how skeleton screens make loading states feel faster while keeping layouts stable. Using a simple IsLoading flag and matching shapes and animations to avatars, text, and images, this post demonstrates a practical pattern you can drop into real Blazor pages for a smoother UX.

Mike James introduces flexible rent-to-own pricing for Avalonia Accelerate, where monthly subscribers receive a permanent license after twelve months and shipped apps keep running thanks to no runtime checks. This post also unveils a refreshed customer portal and reseller redemption that streamlines billing, seat management, upgrades, and support, making professional .NET UI with Avalonia easier to adopt in real teams.

Sudhir Mangla walks through the Valet Key pattern so your ASP.NET Core API authorizes uploads while Azure Blob Storage does the heavy lifting using User Delegation SAS and managed identities. This post delivers a production-ready blueprint with modern .NET snippets for a tiny valet API, browser chunked uploads and integrity checks, plus zero trust essentials like quarantine, scanning, and targeted revocation.

Bjoern Meyer shows how to turn HTML into reliable PDFs in C# with TX Text Control, including a small .NET sample, adding headers and footers, and exporting to PDF/A or PDF/UA. The heart of this post is why PDFs win for invoices, reports, and contracts where consistency, archiving, accessibility, and a defensible layout matter more than browser quirks.

Karen Payne shares a simple pattern for building interactive C# console menus using Spectre.Console with Action delegates, including options that pass parameters for real tasks like saving images or powering dotnet tools. This post explains the tiny set of classes that wire selections to operations and includes tips and sample repos to quickly prototype and organize learning or utility work.

Abe Jaber shows how the new #:package directive in .NET 10 lets you ship a real console app from a single .cs file, complete with NuGet dependencies, no csproj required. This post focuses on practical guardrails for tiny but reliable tools like parsing args, piping stdin, cancellation, predictable exit codes and timeouts so you can build internal utilities fast without the scaffolding overhead.

Ahmad Al-Freihat shows how the Specification Pattern can rescue sprawling business rules by turning them into reusable, testable objects you can use both in memory and in EF Core queries. This post introduces the Masterly.Specification library with composable operators like And, Not, Xor and Implies, a fluent builder, diagnostics and caching so your domain stays a single source of truth and your code stays readable.

Mohammad Shoeb explains how modern C# activators, reflection, and dependency injection can replace most factory classes and make object creation simpler in real applications. Using a multi-tenant payments example, this post shows how Activator plus a container unlocks plugin-style extensibility, fewer deployments, and guidance on when factories still belong.

Laurent Ellerbach shows how .NET nanoFramework brought full VS Code debugging to embedded C#, translating DAP to the device Wire Protocol through a C# bridge and TypeScript adapter without changing device firmware. This post digs into pdbx and portable PDB symbol mapping to land breakpoints on the right lines, while sharing pragmatic architecture choices and AI-assisted workflows you can reuse for your own tooling.

Michael Maurice maps out how reflection turns C# from strongly typed to smartly adaptable, from simple type inspection to on-the-fly invocation, plugin discovery, and even code generation. This post explains where reflection quietly powers your favorite frameworks, when to use it yourself, and how to avoid the performance potholes with practical patterns.