C# 14's extension member syntax now covers properties and static members, not just methods, yet a type's own member still silently wins over an identically named extension member. The author reproduces this against the .NET 10 SDK with eight tests: the build reports zero warnings and zero errors while every call site quietly switches to new logic.
The third part of the series moves a local C# agent from free-form tool calling to deterministic Agent Workflows in Microsoft Agent Framework. A workflow collects deployment status, errors and Qdrant documentation in a fixed order, then hands the evidence to a tool-less agent for analysis, with a human approval gate before sensitive actions.
A tutorial that wires .NET 10 into Pinecone, the managed vector database, using HttpClient and the REST data-plane endpoints instead of the archived C# SDK. It covers options binding, DI registration, upsert and similarity query, plus validation that keeps embeddings consistent.
A method that returns IReadOnlyList<T> tells the caller it cannot write, but says nothing about whether the data is an independent copy, a live view or a fixed report. The article separates the declared capability from the ownership and lifetime contract, then evaluates each collection return shape against both layers.
TermForge is a local web application built with .NET and React that merges SSH sessions, file browser, and Docker management into one unified tool. This project offers a modern solution to the challenges faced when switching between terminals and remote file systems across multiple servers.
Saving a lead and then calling Odoo means two writes that can each fail on their own. Anas Amin describes a transactional outbox where the lead and a message describing it commit together, and a Hangfire job delivers the message later. Leased claims, error classification, dead-lettering and idempotent Odoo writes carry the rest of the design.
A developer describes building a live bingo game on .NET 10, shared by a Blazor Web App and a MAUI Blazor Hybrid app over SignalR. The post covers keeping the game lifecycle on the server, using a BackgroundService to announce start times, making joins idempotent, and handling InteractiveAuto components that boot twice. It is a practical read for anyone building real-time Blazor apps.
NebulaGraph has no unique indexes, so duplicates in a graph load usually come from unstable vertex IDs and edge ranks. The author shows how to derive deterministic VIDs from business keys with FNV-1a and pin edge rank, which makes repeated loads safe. A batched .NET ingestion pipeline with checkpoints and retries is included.
This article explains the difference between delegates and events in C#, the subscription boundary an event creates, and how multicast invocation behaves when a handler throws. It also covers what notification does not guarantee: completion of every subscriber, async handling and subscription lifetime. Read it to design event-based notifications with clearer contracts.
Azure SQL Database Hyperscale splits a single-writer SQL engine across separate compute, log, page server and storage tiers, so it is distributed in architecture but not in write capacity. The author explains where that line falls against the usual meaning of distributed SQL, and cites a commissioned benchmark against Aurora PostgreSQL. Useful when you choose a database for a growing workload.
This post explains how a .NET ERP framework applies TableSchema definitions to the physical database without migration scripts. Each upgrade compares the live structure with the definition, then separates compare, plan and execute so the mode (ALTER or rebuild) can be checked before running. It is useful for developers who maintain schemas that already hold production data.
Jeremy D. Miller strongly recommends that Event Sourcing developers model domain logic with the Decider pattern instead of the older AggregateRoot pattern. He explains why pure decide functions in Marten and Wolverine handlers are easier to reason about, test and debug. The post is a useful reference for anyone choosing a design for event-sourced .NET systems.