Newsletter Archive

JIN walks through building a production-ready C# integration with Cognex VisionPro for real-time industrial camera acquisition, from device enumeration and connections to single-shot and continuous preview. In this post you pick up pragmatic patterns for safe resource disposal and troubleshooting the classics like 'connected but no frames' and memory leaks so your capture pipeline runs 24/7 without drama.

Rick Strahl explains why WebView2.Reload can leave previews stale and shows how to force a true hard refresh in C#, so images and other dependent resources actually update. In this post he compares a simple URL reset, Profile.ClearBrowsingDataAsync, and a DevTools cache clear, with practical notes for WPF and WinForms and when to use each.

Randomizing large collections without tanking throughput is trickier than it looks, and dotnettips digs into what actually makes a shuffle fast in .NET. This post compares popular techniques with cache friendly in-place algorithms, explains how Random usage and allocations impact scalability, and shares practical snippets you can drop into arrays and lists.

Ricardo Peres tackles those mysterious SaveChanges exceptions by validating EF Core state ahead of time with ChangeTracker metadata, surfacing friendly ValidationResult messages for required and max length issues. This post then shows three practical ways to bring full Data Annotations validation into EF Core using a SaveChanges override, a SaveChangesInterceptor, or the SavingChanges event so you can pick the least intrusive option for your app.

Sudhir Mangla untangles why isolation levels, not just transactions, decide whether your .NET app hits lost updates, phantoms, or deadlocks, especially when RCSI and Snapshot shift behavior in Azure SQL and RDS. This post delivers battle-tested EF Core patterns like RowVersion concurrency, savepoints, targeted UPDLOCK usage, plus outbox and idempotency with Polly retries to keep your data sane under load.

El Bruno introduces ElBruno.LocalEmbeddings, a lightweight NuGet package that generates embeddings locally in .NET with a few lines of C#, perfect for tinkering with Foundry Local or Ollama. This post walks through single and batch generation and cosine similarity to help you prototype semantic search and RAG fast without spinning up cloud vector infrastructure.

Nick Cosentino lays out a step-by-step path to implementing the Abstract Factory pattern in C#, complete with runnable examples that go from interfaces to concrete factories and client code. In this post you will learn how to keep related object families consistent, plug factories into DI, dodge common gotchas, and add new variants without sprinkling conditionals everywhere.

C# 14 is not about syntactic novelty. It is about reducing friction in patterns teams already use: extensions, domain modeling, source generation, and performance-sensitive code.. Anderson Godoy walks us through the changes that will stand out the most.

dotNetDave digs into .NET code analysis rule CA1858 to show why StartsWith is the right tool for string prefix checks compared to IndexOf, covering performance, clarity, and culture-safe comparisons. This post explains when to use StringComparison, what the analyzer is nudging you toward, and how a tiny change can trim allocations in hot paths.

Microsoft's Aspire lifecycle guide walks through inner-loop development with aspire run, local deployment with aspire deploy, and CI/CD publishing via GitHub Actions, all using a single AppHost to keep environments consistent. In this post you follow a Blazor and SQL Server example with persistent volumes and generated Docker Compose artifacts that make it easier to move from local debugging to production-ready containers.

Ashok Reddy shares how he turned sluggish C# and .NET endpoints into snappy APIs with a measured approach that delivered a 20x speedup. This post zeroes in on real bottlenecks through profiling and tackles common culprits like chatty logging and request queuing so your services stay fast when the load gets real.

Michael Preston shares how a one-line EF Core optimization using AsNoTracking trimmed memory and latency but quietly broke identity resolution across queries in the same request scope. This post peeks under EF Core's hood and shows when to keep tracking on, when no-tracking is safe, and how to dodge sneaky relationship bugs.

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.

Sudhir Mangla maps out an architecture-first blueprint for building global .NET apps that behave consistently across platforms by adopting ICU, resolving culture correctly, and keeping formatting in the presentation layer. This post helps you avoid costly i18n pitfalls with concrete patterns for NodaTime, money as structured data, ICU MessageFormat and Fluent, RTL friendly CSS, culture-aware storage and search, plus production-grade caching, testing, and trimming.

Mike Irving shows how to target .NET 10 from Visual Studio 2022 without jumping to the new IDE by installing the .NET SDK and verifying with dotnet --version, so you can keep your project moving. In this post he also shares when an upgrade to Visual Studio 2026 makes sense and mentions alternatives like VS Code with C# Dev Kit or Rider.

Round The Code busts five Minimal API myths with practical patterns for moving logic out of Program.cs, organizing route groups, unit testing handlers, and wiring up authorization, validation, and OpenAPI in .NET 10. If you are coming from controllers, this post shows how to keep Minimal APIs clean, scalable, and well documented so they fit real world apps, not just toy projects.

Rolf Bjarne lays out the dotnet/macios plan for Xcode 26.3 support, from branching and version bumps to API bindings and the xtro and introspection test gauntlet. This post gives a behind the scenes look at how .NET for iOS and macOS track new Xcode releases, and what that means for MAUI dependencies, NuGet packages, and your builds staying green.

Peter Ritchie introduces Pri.ProductivityExtensions.Source, a source-only NuGet that adds internal polyfills for newer BCL types so modern C# features work in .NET Standard libraries without extra assemblies. This post lays out why features like ranges, indices, and CallerArgumentExpression trip up .NET Standard projects and how the package unblocks analyzers and PowerShell modules while keeping wide compatibility.

Ali Hamza Ansari breaks down how .NET 10 and C# 14 turbocharge API model validation by swapping reflection for precomputed metadata, cutting allocations, and streamlining hot paths for steadier p95 and p99 latency. In this post you get a minimal BenchmarkDotNet setup comparing .NET 8 and .NET 10 plus practical context on why these changes can deliver around 3x faster validation in real traffic.

Steven Giesel rolls out a February refresh of his browser-based .NET Toolbox, adding an Options Generator that turns JSON config into C# options classes, a typed DI helper for HttpClient and SignalR, and an SRP analyzer to spot single responsibility drift. This post shows how these open source, client-side tools cut boilerplate and encourage cleaner design, with Roslyn-powered ideas possibly on the horizon.

Anthony Giretti gives a clear, no-drama tour of .NET 10's new post-quantum crypto, covering ML-DSA, SLH-DSA, and ML-KEM with patterns that feel like everyday System.Security.Cryptography. In this post you will learn when each algorithm shines and how to future-proof signatures and key exchange in real apps without rewriting everything.

The Visual Studio team rolls out 2026 updates that weave AI into everyday C# work with Copilot powered test generation, call stack analysis, and NuGet security help from both an MCP server and new audit sources. ASP.NET and Blazor devs get faster Razor Hot Reload with auto restart, a snappier Razor editor with Tag Helper go to definition and better IntelliSense, plus practical IDE polish like speedy scrolling, colorized completions, and cleaner Solution Explorer views.

Mori recounts a production incident where orders vanished after a clean deploy, tracing it to EF Core defaults hiding behind a perfectly normal DbSet. This post shows how to take back control with explicit, centralized configuration for entities, clarifying relationships and delete behavior to keep data safe when version or model changes roll through.

Daniel Hindrikes walks us through the new C# expressions feature for .NET MAUI. C# Expressions is so much more than replacing converters; you can finally write inline, strongly-typed logic directly in XAML, making your UI code cleaner and faster to write. Not to mention its performance boost!

This month's .NET AI Community Standup brought Bruno Capuano, Jeff Fritz, and Maanav Dalal together to explore Foundry Local and how C# developers can use it to run AI models directly on their machines, without cloud dependencies. Watch them discuss architecture, local-first AI scenarios, and how Foundry Local fits into modern .NET and AI workflows.