Newsletter Archive

Sasha Ivanova highlights Rider and ReSharper 2025.3.2, adding ACP agent registry support to Rider's AI Chat and a batch of fixes that smooth everyday C# workflows. In this post Hot Reload is reliable again for Blazor WebAssembly and interceptor scenarios, MAUI analysis and Android deployment are corrected, inspections understand C# 14 extension members, and multi-targeted builds are steadier.

Hariram Subramanian breaks down when to use DatePicker, TimePicker, DateTimePicker, and Picker in .NET MAUI, mapping real app flows to the right control. This post highlights MVVM friendly bindings, cross platform consistency, and practical touches like cascading lists and dialog vs inline modes, topped off with a quick decision checklist and a GitHub sample. Expect guidance you can drop into scheduling, filtering, and everyday forms without fighting the UI.

Safia Abdalla explains how .NET Aspire bridges the configuration gap between Azure Functions triggers and Aspire client integrations using the IResourceWithAzureFunctionsConfig adapter. This post shows how WithReference injects the right environment variables for both emulator connection strings and identity based Azure setups, so Functions bindings and your SDK clients are happy without hand rolled config.

Scott Galloway lays out a beginner friendly, all local pipeline in C# to turn scanned text into structured entities using Tesseract for OCR and a BERT NER model via ONNX Runtime. You will learn how tokenization, inference, and BIO decoding fit together, how to merge WordPiece tokens, and when this deterministic approach beats an LLM on speed, cost, and privacy. A NuGet helper is coming, but the copy paste code here gets you from image to people, orgs, and places today.

Particular Software walks through setting up VS Code to build and debug NServiceBus solutions that span multiple projects. This post explains how to wire up tasks.json and launch.json, launch console and web endpoints, attach to running processes, and use compound configurations to debug several endpoints at once. Great for cross platform .NET work when you want Visual Studio level control in a lighter editor.

Lucy Njeri Muturi walks through Visual Studio 2026's AI-first upgrades, from Copilot's Cloud Agent and context-aware chat to adaptive paste and profiler assistance. This post highlights how these features smooth out real work like debugging failing tests, reviewing PRs, refactoring and setup through MCP while keeping you in control.

Carl Franklin and Richard Campbell talk with Shmueli Englard about real-world paths to ship Windows apps. This podcast digs into MSIX packaging, using the Microsoft Store for updates, licensing and payments, and when rolling your own updater makes more sense. Expect pragmatic pros and cons to help you choose a distribution model that fits your .NET app without surprises.

Walk through building a geo-analytics dashboard in .NET MAUI with Syncfusion Charts and Maps, wired up with MVVM and modular user controls. This post shows how a map selection drives KPIs, trend lines, and circular charts to explore real EV adoption data using XAML and C# bindings, with a sprinkle of mobile-friendly touches like bottom sheets.

Assis Zang digs into why APIs fail in the real world and shows how the Retry pattern keeps flaky integrations from derailing user experience. Using Polly 8 in ASP.NET Core, this post builds a resilience pipeline with exponential backoff, sensible retry conditions, and a minimal API that calls a secondary service.

Steve Gordon kicks off a series on transparently encrypting JSON properties with System.Text.Json using a TypeInfoResolver modifier instead of custom converters. This post shows an attribute-first, DI friendly approach that hooks JsonPropertyInfo get and set delegates so sensitive strings serialize as encrypted values and round-trip cleanly in a minimal API. It grounds the idea in real needs like storing OAuth tokens and sets up Azure Key Vault integration and crypto shredding for the next part.

André Silva shows how to tame scattered feature flags in .NET by composing multiple providers behind a single OpenFeature client. This post walks through wiring OpenFeature.Providers.MultiProvider with dependency injection, choosing strategies like FirstMatchStrategy, and applying patterns such as primary plus fallback, gradual migrations, and tenant routing. A practical path to vendor-agnostic flags without rewriting call sites.

Chris Woodruff opens a free htmx + ASP.NET Core Razor Pages workshop that swaps the SPA tax for server-rendered fragments and a clean hypermedia loop. This post includes step-by-step labs, instructions, and a GitHub repo so you can carry these patterns into real apps with less JavaScript baggage.

Ed Charbeneau shows how to build an AI-powered RMA assistant in Blazor that turns rigid forms into a friendly chat. This post uses Microsoft.Extensions.AI, function tools, and JSON schema to steer the model while binding updates into EditContext and pairing a chat UI with a real form using Telerik components.

Anderson Godoy shows how C# 14 can make domain models more expressive while guarding Clean Architecture boundaries. This post walks through using extension members to keep domain semantics in the right layer, field backed properties for normalization, and expanded partials that play nicely with source generators for IDs and converters. You get simple rules that cut helper sprawl and duplication while keeping real business rules visible.

Mukesh Murugan demystifies environment-based configuration in ASP.NET Core, showing how appsettings files, environment variables, User Secrets, and launch profiles stack in .NET 10. You'll pick up practical patterns and precedence rules to keep secrets safe, tame per-environment overrides, and dodge common mistakes that cause those head-scratching prod bugs.

Mark Heath uncovers a sneaky EF Core ILazyLoader quirk that can fire off pointless database queries as soon as you call Add on a new entity. Build your object graph first, then add to the context right before saving to keep your app snappy.

OpenSilver 3.3 lands with Blazor components running directly inside XAML apps, so you can drop DevExpress, Syncfusion, MudBlazor and more into MVVM views with native bindings and no interop tricks. This post highlights practical integration patterns, why it enables low risk WPF modernization across WebAssembly and MAUI Hybrid, and what else ships like .NET 10 support, a Responsive markup extension, and major WPF compatibility gains.

Rishabh Gupta maps a refreshingly honest path from confusion to clarity in C#, .NET 8, and ASP.NET MVC, highlighting the 2 AM aha moments that turn theory into useful code. This post favors real work over interview trivia, from tracing a request through the MVC pipeline to the realities of migrations, AI tools, and learning while holding a day job. If tutorial hell has you spinning, you will find practical guardrails that save weeks of trial and error.

Mahesh Chand cuts through .NET version churn with a rule of thumb and a plan you can trust. If you are juggling dependencies and deadlines, the decision framework and low risk checklist will save future you some headaches.

Unpack dependency injection in .NET and how Autofac turns the 'don't use new' mantra into testable, maintainable code. If the built-in DI starts to chafe as your app grows, the examples make a grounded case for when Autofac is worth it.

Jean-Baptiste S. shows how to build a self-fixing .NET 10 setup that turns production exceptions into GitHub PRs. Backed by Azure Monitor, Application Insights, Redis dedupe, and a Semantic Kernel agent using Claude, this post covers the tool use loop, smart filtering, and prefetching code context to propose credible fixes. The result is less firefighting and a cost profile that fits real teams, not research labs.

Abe Jaber recounts a near-release scare caused by NuGet version drift across a multi-project .NET repo, where CI and local restores disagreed. This post shows how Central Package Management with a single Directory.Packages.props at the repo root stops mismatched dependencies, yielding deterministic builds and easier upgrades. Perfect for teams juggling multiple APIs, workers, and tests who want fewer restore surprises.

Ali Hamza Ansari benchmarks EF Core 10 on .NET 10 with C# 14 against .NET 8, showing 25 to 50 percent faster read queries in a realistic PostgreSQL setup. This post pairs minimal API and DbContext code with BenchmarkDotNet, then unpacks why production workloads get faster, from JIT inlining and expression tree caching to leaner row materialization and small tweaks like static lambdas and JSON options. Perfect if you want practical steps and the mental model to make data access snappier without rewriting queries.

Toine de Boer shows how to build Android home screen widgets with .NET MAUI by leaning on native RemoteViews, AppWidgetProvider, and Intents from your C# code. Rather than step by step, this post highlights production-minded patterns like data sharing with Preferences, interactive actions via PendingIntent, scheduled refreshes, and a minimal MAUI startup to keep widgets snappy. If you are shipping cross-platform widgets alongside iOS, you will pick up clear guidance on configuration screens, context pitfalls, and reliable update flows.

Playwright v1.58 brings a token efficient, agent friendly Skills CLI along with UI Mode and Trace Viewer polish, plus a new Speedboard timeline for merged reports that makes .NET E2E testing feel smoother. This post also highlights breaking selector removals and a devtools launch change, and adds an isLocal flag for CDP, helpful for keeping ASP.NET Core pipelines speedy and green.

Rishabh Gupta turns Clean Architecture from buzzword soup into a practical guide for .NET Web APIs. This post shows how the dependency rule and a clean four layer split keep your domain independent of frameworks, with code examples and pitfalls that explain why testing and swaps like EF to Dapper get much easier. He also calls out when this approach is overkill so you use it where it truly pays off.

Jeffrey Palermo sits down with Maddy Montaquila, Senior Product Manager on the .NET Aspire team and former MAUI PM, to unpack the latest .NET update and what it means for building cross platform and cloud native apps. This podcast explores where Aspire and MAUI are headed, lessons from the Xamarin to MAUI journey, and practical guidance that can simplify your tooling and app architecture.

Why Azure Maps returns both a view coordinate and a routing coordinate for the same place, and how that split keeps your pins pretty and your directions accurate. In this post you will learn when to use the view coordinate for display and the routing coordinate for ETAs and turn-by-turn, plus which API fields identify each. If you have ever routed to the middle of a building or the wrong side of a divided road, this will help you fix it.

Karen Payne shows how a custom IDisplayMetadataProvider turns FirstName into First Name across your ASP.NET Core views. This post contrasts it with the Display attribute, walks through simple Program.cs wiring and dynamic model discovery, and shares a sample repo that pairs the provider with FluentValidation to keep your UI clean and consistent.

Chris Ayers gives a practical tour of the Aspire CLI for building and running distributed apps across .NET, Python, and JavaScript. If you want less config glue and an easier path to adding databases and caches, this post offers a clean workflow and the why behind it.

Gregor Suttie shares a practical architecture for deploying AI-enabled apps on Azure Web Apps, treating the app as an orchestrator for Azure OpenAI rather than a model host. This post focuses on managed identities instead of API keys, private endpoints, Key Vault backed configuration, and observability with Application Insights, plus a Bicep example that keeps infra clean and auditable.

William McLean walks through building a minimal MCP server in C# that plugs Gemini CLI into Firestore, then iterates by adding new tools directly from the CLI. This post focuses on why MCP makes .NET a solid fit for AI workflows language independence, a simple stdio transport, and Firestore backed tools that enable a real inventory scenario. It is a friendly blueprint for moving from local validation to cloud ready patterns.

Steven Giesel kicks off the year with a free, open source .NET Toolbox built entirely client side to smooth out everyday dev tasks, especially for newcomers to web work. This post highlights a visual Middleware Designer that teaches common ASP.NET pipelines, flags pitfalls like authorization before authentication, and lets you simulate requests, plus a Package Centralizer that generates Directory.Packages.props from your csproj files to simplify version management.

Michael Maurice lays out eight pragmatic steps for building a maintainable CRUD REST API in .NET 10 using Clean Architecture and DDD. This post walks a tiny Products API through domain, application, infrastructure, and API layers so business rules live in the domain, EF Core stays in infrastructure, and controllers remain calm. If your last API grew into a ball of EF queries and if statements, these patterns show how to keep it testable and ready to grow.

John Reilly shows how to wire up end-to-end static typing between an ASP.NET Core Web API and a React TypeScript client by pairing Microsoft.AspNetCore.OpenApi with openapi-ts. He explains why OpenAPI 3.1 surfaces C# nullability more accurately than older tooling and how a couple of schema transformers tame number|string oddities, delivering a lean client and smaller bundles. If keeping front end and back end in sync without hand-written glue sounds good, this post maps out a pragmatic path with scripts you can drop into your workflow.

Mukesh Murugan shows how to build a minimal .NET API that enables S3 bucket versioning, lists an object's history, restores older versions, and recovers deletes by handling delete markers. You will learn how version IDs and delete markers work under the hood, plus practical guardrails like IAM permissions, lifecycle policies to keep costs in check, and MFA delete for critical data. The patterns for audit trails, rollback to last known good, and scheduled cleanup make it easy to bake resilience into real apps.