Newsletter Archive

PureWeen ships .NET MAUI 10.0.31 SR3.1, a small service release that bumps the patch version and reverts a recent Android SafeAreaEdges Container fix. This post flags a change that may impact label placement under the Android status bar, useful for anyone polishing cross platform layouts.

Edin Kapić recaps Microsoft's OData .NET 9.0.0 Preview 3 with safer defaults, cleaned up APIs, and tighter spec compliance that mean fewer surprises around nullable actions and untyped JSON. This post spotlights the migration gotchas from 8.x, why some legacy bits were trimmed, and how the client stack is marching toward .NET 8 to 10 alongside ASP.NET Core OData.

Compile & Conquer closes out a Clean Architecture in .NET series with this post on pragmatic production readiness. You get a sensible testing plan per layer, from pure domain unit tests with no mocks to application tests with mocked ports and integration tests against a real database. It also flags common traps like anemic models, EF leaking into your domain, and returning entities from handlers so your core stays maintainable.

Raghunath explores the null-conditional assignment operator ?.= for C# 14, a small tweak that trims repetitive null checks when updating optional dependencies. With concrete examples across logging, UI, caching, middleware, and plugins, this post shows how to apply it safely, where to avoid it in core domain updates, and what it compiles down to. Expect a practical decision guide and patterns you can drop into everyday code.

Raghunath explores C# 14's new field keyword and how it gives you direct access to an auto property's backing field inside getters and setters without extra boilerplate. Through clear examples for validation, change tracking, and lazy initialization, this post focuses on where field improves readability and maintainability and when simpler models still win. It wraps with best practices and performance notes that show the feature adds control with no runtime cost.

David Ortinau and Gerald Versluis host the .NET MAUI Community Standup live from MAUI Day London where they discuss various topics, including control customization, build times, and the platform's future. Plus, learn about upcoming features and explore strategies for creating data-driven apps.

Jody Donetti shares the story and design of FusionCache, showing how hybrid caching in .NET avoids cache stampedes, improves resilience, and lets you start in memory then flip on a distributed layer like Redis without rewriting code. Framed around Microsoft's HybridCache and the IHybridCache abstraction, this podcast spotlights real multi-level caching patterns that speed up APIs, scale across pods, and keep data fresh without drama.

Microsoft's Agent Framework for .NET ships a new preview that tightens how agents manage sessions and context, boosts declarative workflow fidelity when mapping ChatMessage, and starts moving from reflection to source generation. In this post you will spot a few intentional breaking changes along with new Anthropic samples and reorganized durable agent examples that make building real-world C# agents smoother.

Carl Franklin and Richard Campbell chat with Jason Bock about when .NET source generators shine, from compile-time regex to safer P/Invoke, and where they can backfire. This podcast offers practical heuristics for deciding if generators will pay off in your codebase, balancing performance wins with complexity, diagnostics, and build-time costs.

Catharsis packages a practical tour of authentication and authorization in ASP.NET Core, showing how JWT-backed sign-in, Identity, and minimal API/controller hooks fit together. It also covers token hardening tips like short expirations, strong signing keys, and refresh flows.

Explore .NET 10's Microsoft Agent Framework and how agent-based apps bring the JARVIS spirit to everyday C# work. If you write C#, you will see how your skills map to defining agents and their tool access with Azure OpenAI or local models.

Mohan Veer Singh explains how interfaces shape clean, testable C# code and why C# 8 added default interface implementations alongside abstract classes. Through DI-friendly examples and an IPaymentService evolution scenario, this post shows how to grow shared contracts in NuGet and microservices without breaking consumers. You will learn where interfaces, abstract classes, and default methods fit in real projects and how they keep enterprise codebases stable.

Ricardo Peres highlights a subtle ASP.NET Core pitfall where the Consumes attribute treats Content-Type and charset as an exact match, which can route requests to nowhere and return a 404. Helpful for API authors chasing sneaky 404s tied to content negotiation.

Milan Jovanović follows message ordering from first principles and shows why most systems need per aggregate ordering, not a global sequence. This post moves from domain events and an Outbox for reliability, through the pitfalls of competing consumers, to sagas as the way to model ordered workflows at scale in .NET, with broker features like Service Bus sessions and Kafka partitions helping but not replacing good patterns.

Chris Woodruff distills how Front Controller and MVC keep ASP.NET Core from devolving into a crowd of tiny frameworks pretending to cooperate. In this post he treats the pipeline as a disciplined gateway for auth, logging, and errors, keeps controllers thin, and shows minimal yet clear examples that centralize cross-cutting concerns. You get before and after code, a compact custom middleware router, and practical advice on when the structure pays off versus when to stay simple.

Damien Bowden demonstrates how to make your .NET apps care about how users authenticated by implementing Level of Authentication with ASP.NET Core Identity and Duende. This post clarifies amr vs loa, issues loa and loi claims on passkey sign-in, and uses DPoP with an authorization handler to allow only phishing resistant sessions to reach your API. Expect practical patterns for Blazor OIDC, Duende profile services, and a small fix for the passkey amr quirk.

Bjoern Meyer walks through converting Markdown to PDF in .NET using TX Text Control, powered by the TXTextControl.Markdown.Core package and ServerTextControl. This post explains why PDF still rules for distribution, then shows a quick start and how to programmatically control page layout, headers and footers, and styles for production-worthy output. If you need Markdown in and branded, accessible PDFs out, the examples are ready to plug into APIs or workflows.

Nate Bennett shows a fast, Office-free way to read Excel in C# using Spire.XLS. The payoff is simpler deployments and better performance than COM interop across different environments.

Leomaris Reyes explains marshal methods in .NET MAUI as your app's interpreter between managed C# and native OS APIs, and why that matters when you tap into device features. This post spotlights .NET 10 updates that affect Android: marshal methods enabled by default for faster startup and a new ArtifactFilename metadata to handle quirky Maven AAR/JAR names. If you ship MAUI apps, you will pick up practical tips on diagnosing startup freezes and keeping Java dependencies reliable.

Janindumaleesha kicks off a beginner-friendly C# series with a plain-English tour of what C# is, how it sits on the .NET platform, and why it is a practical choice for building apps and games. If official docs feel overwhelming, this post sets a low-friction path to installing tools next and turning curiosity into working code.

Steven Giesel explores a C# 15+ proposal that lets collection expressions accept arguments, like capacity or comparers, right in the brackets. This post connects the ergonomic C# 12 syntax with practical needs like pre-sizing lists or setting a HashSet comparer, which can reduce allocations and make intent clear.

Round The Code shows how to add tidy file logging to ASP.NET Core with Serilog, from wiring up UseSerilog and a file sink in appsettings.json to logging from a Minimal API with ILogger. If you want clean rolling log files with a readable template and the right signal to noise, this is a quick win.

Bjoern Meyer shows how to turn messy contract redlines into review ready explanations using .NET C#, TX Text Control, and the OpenAI API. This post pairs tracked changes with their related comments, streams the context to an LLM, and enforces a strict JSON schema so every change is justified or flagged with confidence and evidence.

Sparkle Web maps out a practical path to high performance microservices on .NET 10, starting with design choices like single responsibility, stateless services, and a database per service. Ideal if you want to ship services that scale smoothly without trading off reliability or developer sanity.

Sai Nitesh Palamakula lays out a practical path to API versioning in ASP.NET Core, explaining when to use URL, query string, header, or media type versions and the tradeoffs of each. This post shows how to wire up Asp.Versioning with Swagger and includes controller patterns for every strategy so your APIs can evolve without breaking clients.

Donie Sweeton demystifies launchSettings.json, the ASP.NET Core file that quietly tells Visual Studio and dotnet run how to start your app in development. This post gives a clear mental model of profiles, Kestrel versus IIS Express, and injected environment variables. You will see why machine specific ports cause Git conflicts and how a tidy launchSettings.json makes local ports, HTTPS, and Swagger behave.

Aliaksandr Marozka maps the .NET background job landscape for 2026, comparing .NET 9 BackgroundService, Hangfire, Quartz.NET, and Temporal through hard-won project lessons. This post highlights the production tradeoffs like retries with exponential backoff, observability, schedule complexity, and ops overhead, then boils them into a clear decision path so you know when a simple worker is enough and when to reach for a scheduler or a workflow engine.

Melisa Akkuş gives a crisp tour of C# lambda expressions, from the arrow syntax to when to use single-line vs block forms. This post shows how lambdas unlock readable LINQ, delegate-based APIs, and event handlers, and why so much of modern C# would feel clunky without them. Expect bite-size examples you can drop into everyday code.

Mariyam Ashai introduces the Agent to Agent Standard for interoperable AI and shows how to wire it up in .NET 8 with ASP.NET Core. In this post you build a tiny currency agent and a console client with the A2A and A2A.AspNetCore packages, learning how Agent Cards, Tasks, and message Parts create a reliable contract between agents.

Jeremy Likness gives .NET devs a clear, jargon-free tour of generative AI essentials, from tokens and embeddings to prompts, tools, RAG, MCP, and the idea of agents. If you are deciding how to evaluate models and wire up tool calls or a cloud to local workflow, this post delivers the mental model and vocabulary to move from experiments to real apps.

Ajay Kumar digs into TDD in .NET with a pragmatic lens, showing how common anti-patterns like test obsession, over mocking, and skipping refactoring quietly tank developer confidence and speed. In this post, C# examples contrast brittle implementation focused tests with behavior driven tests, and explain when TDD shines and when prototyping, UI heavy work, or performance sensitive code deserve a different approach. Expect practical guardrails like aiming for meaningful coverage, mocking only externals, and keeping feedback loops fast.

Aprillz's MewUI is an experimental, code-first .NET GUI library built for NativeAOT and trimming that swaps XAML for fluent C# markup. If you want to ship lean utilities that start fast and stay tidy, the samples show how far modern C# can go.

Dave Brock tours .NET 10 and C# 14 from an API developer's perspective, grounded in a realistic order management sample. This post highlights built-in Minimal API validation, OpenAPI 3.1 docs, EF Core 10 named query filters and server-sent events that trim boilerplate and improve safety, plus C# touches like field-backed properties and null-conditional assignment to simplify patches.

Raghunath explores how C# 14 upgrades lambda expressions with parameter modifiers like ref, in, and out, bringing them much closer to full method parity. If you care about intent-driven code, fewer allocations, and more expressive APIs, this reads like a handy roadmap.

James Miller spotlights .NET 10 and C# 14 upgrades that cut ceremony and sharpen performance. This post shows how the field keyword streamlines guarded properties, ref friendly lambdas avoid copies, and EF Core niceties like LeftJoin and JSON partial updates tame data work, with minimal API validation and single-file runs trimming the boilerplate.

Dmitry Tokmachev shows how to connect DevExpress Blazor AI Chat to Agent2Agent compliant AI agents with a lightweight adapter that translates A2A messages into IChatClient. The approach highlights why open agent standards matter for .NET apps by making cross-platform agents pluggable in a familiar chat UI.