The .NET 11 tracker

A decision guide and real benchmark for EF Core 11: use ExecuteUpdate for set-based writes by a predicate, and the load-then-SaveChanges path only when you need the change tracker, interceptors, or a complex object graph.

A version-pinned migration guide from EF Core 6.0 to EF Core 11.0, walking the breaking changes across EF7, 8, 9, 10, and 11 that break real apps: Encrypt=True, OPENJSON Contains, PendingModelChangesWarning, the native json column, and the SqlClient 7.0 split.

Pick BackgroundService for in-process loops, raw IHostedService when you need fine lifecycle control, and Hangfire when jobs must survive a restart. A decision matrix with code and the one gotcha that picks for you.

.NET 11 Preview 4 drops support for pre-2013 x86/x64 chips and bumps the JIT baseline to x86-64-v2. Here is what breaks, why, and how to check your hardware before you upgrade.

For a large .NET 11 / C# 14 solution, Claude Code wins on agent quality and runs anywhere a terminal does. Cursor wins if your team wants a GUI and tab completion, as long as you can live without C# Dev Kit. Aider wins on cost and openness.

.NET 11 Preview 4 teaches double, float, and Half to format with the X specifier and parse with NumberStyles.HexFloat, producing the same IEEE-754 hex text as C printf("%a").

Your fire-and-forget task captured a request-scoped DbContext that the DI scope already disposed. Resolve a fresh context inside the task with IServiceScopeFactory or IDbContextFactory.

EF Core 11 Preview 4 lets the dotnet ef tool read default option values from a .config/dotnet-ef.json file, so split solutions no longer force you to pass --project and --startup-project on every command.

When you Include two sibling collections, EF Core 11 returns the cross product and your row count explodes. Here is how AsSplitQuery fixes it, how to turn it on globally, and the consistency and ordering gotchas to watch for.

Calling Task.Run from a controller loses work on shutdown, swallows exceptions, and captures disposed scoped services. The safe pattern is a bounded Channel queue drained by a BackgroundService that opens a fresh scope per work item and drains in-flight work on StopAsync.

A complete guide to ExecuteUpdate and ExecuteDelete in EF Core 11: the SQL they emit, the change-tracker gotcha that silently overwrites your bulk write, transactions, concurrency control with the affected-row count, and the EF Core 10 delegate setters that let you build conditional updates with plain if statements.

A BackgroundService is a singleton, so it cannot inject a scoped service like a DbContext directly. Take IServiceScopeFactory, open one scope per unit of work with CreateAsyncScope, resolve inside it, and dispose it when the work is done.

A step-by-step checklist to replace AutoMapper 15 Profiles, IMapper, ForMember, and ProjectTo with Riok.Mapperly 4.3 source-generated mappers in .NET 11.

A step-by-step checklist to remove MediatR 12-14 and replace IRequest handlers, ISender, pipeline behaviors, and INotification with plain service classes and constructor injection.

A version-pinned playbook for swapping Newtonsoft.Json 13.0.4 for the in-box System.Text.Json on .NET 11: the attribute and settings mappings, the defaults that silently change your wire format, a staged rollout strategy, verification, and the gotchas that bite large codebases.

A version-pinned migration playbook for moving a .NET Framework 4.8 codebase to .NET 11 LTS in 2026, covering the SDK-style csproj rewrite, System.Web to ASP.NET Core, WCF, EF6 to EF Core 11, BinaryFormatter removal, AppDomain replacements, and a realistic rollback plan.

A version-pinned migration checklist from .NET 8 LTS to .NET 11 LTS, covering SDK install, csproj target framework, breaking changes in ASP.NET Core, EF Core, System.Text.Json, and the C# 14 overload-resolution shift, with rollback notes.

End-to-end migration from Xamarin.Forms 5.0 to .NET MAUI 11 GA on net11.0, covering csproj rewrite, custom renderer to handler conversion, AppShell wiring, DependencyService removal, MessagingCenter retirement, Resizetizer assets, and the gotchas that bite a real production codebase.

For a greenfield mobile app in 2026, pick Flutter 3.44 when pixel-identical UI and animation budget matter, React Native 0.82 when your team already lives in TypeScript and you need a real browser sibling, and .NET MAUI 11 when iOS and Android are part of a wider .NET product and you need first-party Microsoft support.

MAUI 10 SR6 (10.0.60) extends Material 3 theming to Button, Entry, SearchBar, DatePicker, Slider, ProgressBar, ImageButton, Switch, and Shell on Android. Opt in with one MSBuild property. No custom renderers, no styles.xml edits.

For a new .NET cross-platform desktop and mobile app in 2026, pick Avalonia when you need a single rendered control set across all targets, Uno when you must reach the browser too, and MAUI only when you actually need native iOS and Android plus first-party Microsoft support.

Pick the isolated worker model for every new Azure Functions app on .NET 11 in 2026, and migrate any remaining in-process apps before the November 10 retirement deadline.

For any new Blazor app on .NET 11, scaffold a Blazor Web App (the template formerly nicknamed Blazor United) and pick render modes per page. Server-only and WebAssembly-only templates only still make sense in narrow cases.

EF Core 11 Preview 4 drops the long-standing shadow-property restriction on SQL Server temporal tables. PeriodStart and PeriodEnd can now be regular CLR properties, configured with strongly-typed HasPeriodStart and HasPeriodEnd lambdas.

List<T> is a growable heap collection; Span<T> and ReadOnlySpan<T> are stack-only views over memory you already own. Use List<T> for anything you store, return from async, or grow; Span<T> for a mutable allocation-free view in a synchronous method; ReadOnlySpan<T> for read-only parsing over strings, u8 literals, and slices.

Use Parallel.ForEach for CPU-bound work over in-memory data, Parallel.ForEachAsync for async I/O over many items with a concurrency cap, and Task.WhenAll for a small fixed fan-out where you want every operation in flight and need the results back.

Use string interpolation for one-shot composition of a fixed set of values; use StringBuilder when you append in a loop or across an unknown number of pieces. The dividing line is the loop, not the number of values.

How to add a custom category to UiPath's Project Settings from your activity package, register fields at design time via IRegisterWorkflowDesignApi, and read those values back at runtime through IExecutorRuntime — with the App Insights instrumentation key as the example.

.NET 11 Preview 4 makes ASP.NET Core OpenAPI generation recognize HTTP QUERY as a first-class operation in OpenAPI 3.2, with a graceful fallback for 3.0 and 3.1 documents.

A modern UiPath custom activity needs more than a CodeActivity: a DesignPropertiesViewModel, an embedded metadata file for the toolbox, private host-supplied references, and the right System.Activities assembly version. Here's the whole recipe.

One repo, three NuGet packages, independent versions. Per-package MinVer tag prefixes, a tag-driven GitHub Actions release that publishes via OIDC trusted publishing (no API key), pinning a cross-package dependency to a real version, and the default-branch gotcha that silently swallows your first tag.

Four ways to guard a critical section in C#, and a decision matrix for picking one. Use System.Threading.Lock for synchronous mutual exclusion on .NET 9+, SemaphoreSlim when the section spans an await, and Monitor only when you need Wait/Pulse.

If you came from Semantic Kernel looking for 'skills,' the Microsoft Agent Framework 1.0 calls them function tools and builds every one from AIFunctionFactory.Create. Here are the three ways to author one in C# -- an inline lambda, a named method, or a class of related tools -- plus what the declarative YAML 'file' approach can and cannot do.

Use the Microsoft.Extensions.Http.Resilience handler for HttpClient calls, since it is Polly with HTTP-aware defaults and telemetry in one line. Reach for Polly's ResiliencePipeline directly only when you protect something that is not an HttpClient.

There's no public hook to run code around every UiPath activity in the Robot. CoreWF's TrackingParticipant gets you the events, and a small reflection bridge into the live executor attaches it from inside a running workflow — so a single Super Initialize activity instruments the whole run.

Three ways to push work onto the thread pool in C#, and which one to reach for. Use Task.Run for almost everything, ThreadPool.QueueUserWorkItem<TState> for allocation-free fire-and-forget, and Task.Factory.StartNew only for LongRunning or a custom scheduler.

Ship a Workflow Analyzer rule inside your UiPath activity package: register it with IRegisterAnalyzerConfiguration, scope it to the workflow so the result lands on the right file, detect the project's entry point, and walk the activity tree — with the gotcha that InspectionResult has no File property.

.NET 11 Preview 4 ships DeflateEncoder, GZipEncoder, and ZLibEncoder plus matching decoders so you can compress straight into a Span<byte> with OperationStatus, no Stream required.

For read-heavy paths in .NET 11, plain EF Core with AsNoTracking is within ~5% of Dapper. Reach for compiled queries on a profiled single-row hot path, and Dapper only for the lowest latency or SQL LINQ can't express.

Never new up HttpClient per request. Use IHttpClientFactory to manage lifetime, and add Refit on top when you want a typed interface instead of hand-written request code. Raw singleton HttpClient is fine only for the simplest cases.

For new code, plain service classes are the better default. MediatR's July 2025 license change matters only if you sit above the $5M Community threshold or refuse the RPL-1.5 copyleft. Keep MediatR when pipeline behaviors are load-bearing.

C# 16 redesigns the unsafe keyword so it propagates a caller obligation instead of silently opening an unsafe context, with inner unsafe blocks now mandatory.

Plain JIT with Dynamic PGO wins steady-state throughput, ReadyToRun cuts startup with zero code changes, and Native AOT gives the smallest, fastest-starting binary at the cost of reflection and dynamic code. Pick by deployment shape, not raw benchmarks.

Pick System.Text.Json for new .NET 11 code: it ships in-box, is roughly 2x faster, and is the only one that works with Native AOT. Reach for Newtonsoft.Json only for JSONPath, TypeNameHandling, or genuinely lenient JSON.

ConfigureAwait(false) is still mandatory in library code that may run under a SynchronizationContext (WinForms, WPF, MAUI). In application code on ASP.NET Core, a console app, or a worker service running on .NET 11, it is a no-op.

Three sequence interfaces, three execution models. Use IQueryable when a database can translate the query, IAsyncEnumerable when the producer is async and you want to stream, IEnumerable for everything else in memory.

Pick minimal APIs by default in ASP.NET Core 11. Use controllers only when you need MVC features that minimal APIs still do not match: convention-based routing across many actions, MVC-style filters, or Razor views.

For bulk inserts in .NET 11, neither EF Core nor Dapper wins. SqlBulkCopy does. This is the benchmark, the why, and the seat each tool deserves.

NuGet Package Pruning shipped on-by-default for net10.0 projects, cutting transitive vulnerability reports by 70% and restore times by up to 50%.

The .NET 6 runtime is gone or mismatched. Either install net6.0 again, roll forward to net8.0 via runtimeconfig, retarget the csproj, or ship self-contained.

.NET 11 Preview 4 bundles the mcpserver project template directly into the SDK. No separate Microsoft.McpServer.ProjectTemplates install, no preview feed dance. Pick stdio or HTTP transport, opt into Native AOT, and dotnet new mcpserver -o MyServer is the whole setup.

The profile Visual Studio picked was generated before this iPhone's UDID was registered. Re-register the device, regenerate the development profile, redownload, redeploy.

Xcode 15+ ships without bundled iOS simulator runtimes. MAUI fails the build when SupportedOSPlatformVersion has no matching runtime installed. Install one with xcodebuild -downloadPlatform iOS or via Xcode Settings, then verify with xcrun simctl list runtimes.

.NET 11 Preview 4 ships new System.Diagnostics.Process APIs that drain stdout and stderr concurrently, plus one-line run-and-capture helpers and KillOnParentExit.

Nine out of ten times the real Gradle error is buried higher in the MSBuild log. JDK 17 path, missing maui-android workload, and Windows long paths are the usual root causes.

System.Text.Json refuses to serialize graphs with back-references. Set ReferenceHandler.IgnoreCycles, project to a DTO, or mark the back-pointer with [JsonIgnore]. Preserve is a last resort.

Migrations use the design-time DbContext, not your runtime CommandTimeout. Set the timeout via UseSqlServer(o => o.CommandTimeout(...)), the connection string Command Timeout, or Database.SetCommandTimeout before Migrate().

.NET 11 Preview 4 makes CoreCLR the default runtime for MAUI on Android, iOS, Mac Catalyst, and tvOS. Mono is still one MSBuild property away. Here is what changes, what breaks, and how to opt out.

.NET 11 Preview 4 turns on dotnet watch for Android devices, Android emulators, and the iOS Simulator. Edit, save, and the running app updates without a manual rebuild. One csproj gotcha applies to iOS.

System.Text.Json throws this when the incoming JSON token doesn't match the CLR target type. Match the JSON to the type, or register a JsonConverter or JsonSerializerOption that bridges them.

The certificate's private key lives in a separate Windows key file the current process identity cannot read. Grant ACL on the key, load the PFX with MachineKeySet, or use EphemeralKeySet.

Your CI runner cannot resolve dotnet because the SDK is not installed for that step, or it is installed but not on PATH. Use actions/setup-dotnet, pin a global.json, and export DOTNET_ROOT and ~/.dotnet/tools.

Runs fine with dotnet run, throws after dotnet publish. The DLL is usually missing from the publish folder, not the runtime. Check deps.json, ProjectReference Private, and trimming.

Replace the Stream.Read or Write call with ReadAsync/WriteAsync. As a last resort, set AllowSynchronousIO on Kestrel, IIS, or per-request via IHttpBodyControlFeature.

Blazor's Razor compiler emits RZ10012 when a PascalCase tag has no matching component type in scope. Add @using for the component's namespace in _Imports.razor, or @namespace in the component, then rebuild.

EF Core's design-time tools could not instantiate your DbContext. Either expose a host via WebApplication.CreateBuilder, point to the right startup project, or implement IDesignTimeDbContextFactory.

MSB3027 means MSBuild retried a file copy 10 times and a process still held the destination. Kill the locking process, exclude bin/obj from antivirus, or raise CopyRetryCount.

CS0246 right after a fresh ProjectReference is almost always a TargetFramework mismatch, a stale obj folder, or a missing using directive. Five fixes in order of likelihood.

ASP.NET Core's scope validation throws this when a singleton would capture a scoped dependency for the rest of the process. Make the consumer scoped, or take IServiceScopeFactory and create a scope on demand.

Native AOT strips the JIT and the interpreter, so reflection emit, expression-tree compilation, and unseen MakeGenericType throw at runtime. Find the call via IL3050 and replace it with a source generator or a pre-baked path.

ASP.NET Core throws this when a constructor asks for a type that was never registered, was registered on the wrong container, or was added after the host was built. Three concrete fixes cover almost every case.

HttpClient throws TaskCanceledException for three different reasons: timeout, caller cancellation, or a connection-level abort. Tell them apart with InnerException and CancellationToken.IsCancellationRequested, then fix the right one.

Microsoft moved Copilot Studio's WASM engine from .NET 8 to .NET 10. The dual JIT/AOT package, fingerprinting, and WasmStripILAfterAOT explain the numbers.

System.Text.Json only accepts ISO 8601 strings for DateTime. Send 2026-05-08T14:00:00Z or register a JsonConverter that parses your format. Empty strings and Unix timestamps both throw.

Wrap an Agent Framework Workflow in Microsoft.Agents.AI.DurableTask and each executor step is checkpointed. Crash, redeploy, restart - the run continues where it stopped.

EF Core 11 throws when two objects share a primary key inside one DbContext. Detach the old one or update it in place. AsNoTracking on the read prevents the collision.

EF Core throws when two awaits run in parallel on the same DbContext. Await each call sequentially, or get a new DbContext per concurrent unit of work via IDbContextFactory.

Step-by-step migration from Xamarin.Forms 5.0 ListView to .NET MAUI 11 CollectionView for apps that already squeezed performance out of ListView. Covers cell recycling, virtualization, grouping, pull-to-refresh, context actions, selection, ItemsLayout, EmptyView, and the gotchas that bite real apps.

Wrap an AIFunction in ApprovalRequiredAIFunction and the agent stops mid-run to ask permission. Here is how the request and response flow works in C#.

Wire a Microsoft.SemanticKernel 1.75.0 plugin into a hosted BackgroundService on .NET 11 and invoke its KernelFunctions on a PeriodicTimer schedule. Covers DI scopes, [KernelFunction] resolution, prompt-cache-friendly invocation, cancellation, and the lifetime gotchas that bite when you move a plugin off the request path.

If GetConnectionString returns null in .NET 11, your appsettings.json is missing the key, not copied to the build output, or the wrong environment file is being selected. Three checks fix 95% of cases.

Wire an EF Core 10 DbContext into a Model Context Protocol server so Claude Code, Cursor, or any compliant client can run safe, scoped queries against your database. Covers IDbContextFactory lifetime, read-only projections, schema discovery tools, AsNoTracking, parameterised filters, row-level scoping, and the destructive-tool gates you need before letting an agent touch UPDATE.

Three ways to wrap a T[] in a ReadOnlyMemory<T> in .NET 11: the implicit conversion, the explicit constructor, and AsMemory(). When each is the right call.

End-to-end guide to packaging a .NET MAUI 11 Windows app as an MSIX, bundling x64/x86/ARM64 into a .msixupload, and submitting through Partner Center: identity reservation, Package.appxmanifest, dotnet publish flags, MakeAppx bundling, and the Store-trusted certificate handoff.

Wire AIFunctionFactory.Create, ChatOptions.Tools, and ChatClientBuilder.UseFunctionInvocation in Microsoft.Extensions.AI 10.5 so an IChatClient can call your .NET methods automatically. Covers OpenAI and Azure OpenAI providers, the FunctionInvokingChatClient knobs that actually matter (iteration limits, concurrent calls, approval prompts, error handling), and streaming responses with tools.

End-to-end drag-and-drop in .NET MAUI 11: DragGestureRecognizer, DropGestureRecognizer, custom DataPackage payloads, AcceptedOperation, gesture position, and the per-platform PlatformArgs traps on Android, iOS, Mac Catalyst, and Windows.

End-to-end dark mode in .NET MAUI 11: AppThemeBinding, SetAppThemeColor, RequestedTheme, UserAppTheme override with persistence, the RequestedThemeChanged event, and the per-platform Info.plist and MainActivity bits that the docs gloss over.

A complete .NET 11 setup for Tailwind CSS v4 in a Blazor WebAssembly app: standalone CLI (no Node), MSBuild target, @source directives for Razor and CSS isolation files, and a publish pipeline that survives Native AOT.

Microsoft's new Microsoft.AgentGovernance package wraps MCP tool calls with a policy kernel, a security scanner, and a response sanitizer. Here is what each piece does and how the wiring looks in C#.

A practical guide to spotting N+1 queries in EF Core 11: what the pattern looks like in real code, how to surface it via logging, diagnostic interceptors, OpenTelemetry, and a test that fails the build when a hot path regresses.

A practical guide to EF Core 11 compiled queries: when EF.CompileAsyncQuery actually wins, the static-field pattern, the Include and tracking gotchas, and how to benchmark before and after so you can prove it was worth the extra ceremony.

Strip Android and iOS from a .NET MAUI 11 project so it ships Windows and Mac Catalyst only: the csproj edits, the workload commands, and the multi-targeting that keeps your code clean.

Take an existing Semantic Kernel plugin with [KernelFunction] methods and turn it into a Model Context Protocol server other agents can call. Covers the drop-in WithTools(kernel) bridge, the native [McpServerTool] rewrite, parameter binding, dependency injection, and the gotchas that bite during the cutover.

A complete guide to wiring Serilog 4.x and Seq 2025.2 into a .NET 11 ASP.NET Core app: AddSerilog vs UseSerilog, two-stage bootstrap logging, JSON configuration, enrichers, request logging, OpenTelemetry trace correlation, API keys, and the production gotchas around buffering, retention, and signal level.

Wire OpenTelemetry traces, metrics, and logs into a .NET 11 ASP.NET Core app with the OTLP exporter, then ship them to a free, self-hosted backend: the standalone Aspire Dashboard for local dev, Jaeger and SigNoz for self-hosted production, and the OpenTelemetry Collector when you need both.

A complete guide to running ASP.NET Core integration tests against a real SQL Server 2022 using Testcontainers 4.11 and EF Core 11: WebApplicationFactory wiring, IAsyncLifetime, swapping the DbContext registration, applying migrations, parallelism, Ryuk cleanup, and CI gotchas.

.NET 11 Preview 4 and Visual Studio 18.8 ship a VSTest that no longer flows Newtonsoft.Json into your test projects. Builds that quietly used the transitive copy will break with a single PackageReference fix.

Claude Code v2.1.122 adds the ANTHROPIC_BEDROCK_SERVICE_TIER environment variable, sent as the X-Amzn-Bedrock-Service-Tier header. Set it to flex for a 50 percent discount on agent calls or priority for faster responses, without touching SDK code.

A complete guide to per-endpoint rate limiting in ASP.NET Core 11: when to pick fixed window vs sliding window vs token bucket vs concurrency, how RequireRateLimiting and [EnableRateLimiting] differ, partitioning by user or IP, the OnRejected handler, and the distributed deployment pitfall everyone hits.

Stream Claude responses from an ASP.NET Core 11 minimal API end-to-end: the official Anthropic .NET SDK, TypedResults.ServerSentEvents, SseItem, IAsyncEnumerable, cancellation flow, and the gotchas that buffer your tokens silently. With Claude Sonnet 4.6 and Opus 4.7 examples.

System.Threading.Lock arrived in .NET 9 and is the default synchronization primitive on .NET 11 and C# 14. This guide shows how to migrate from lock(object), how EnterScope works, and the gotchas around await, dynamic, and downlevel targets.

A complete guide to building your own incremental source generator for INotifyPropertyChanged in C# 14 and .NET 11: the IIncrementalGenerator pipeline, marker attributes, partial-class output, the SetProperty pattern, and how to stay AOT-friendly.

FileSystemWatcher fires Changed before the writer is done. Three reliable patterns for .NET 11 to know a file is fully written: open with FileShare.None, debounce with size stabilization, and the producer-side rename trick that avoids the problem entirely.

The single biggest source of validation drift in a Blazor WebAssembly + ASP.NET Core app is the urge to write the rules twice. This guide walks the only layout that scales in .NET 11: a Shared class library that owns the DTOs and their validators, consumed by both the WASM client (EditForm + DataAnnotationsValidator or Blazored.FluentValidation) and the server (minimal API endpoint filter or MVC model binding), with a tested round-trip that maps server-side ValidationProblemDetails back into the EditContext.

SearchValues<T> beats IndexOfAny by 5x to 250x but only when you use it the way the runtime expects. The cache-as-static rule, the StringComparison gotcha, when not to bother, and the IndexOfAnyExcept inversion trick that nobody documents.

SkiaSharp 4.0 Preview 1 lands with Uno Platform as co-maintainer alongside the .NET team. SKPath becomes immutable behind a new SKPathBuilder, and HarfBuzzSharp gets full OpenType variable font axis control.

In .NET 11 the OpenAPI document is generated by Microsoft.AspNetCore.OpenApi and Swagger UI is no longer in the template. Here is how to wire Bearer, OAuth2 with PKCE, and OpenID Connect so the Authorize button actually works.

Two working paths in .NET 11: the built-in MapIdentityApi /refresh endpoint, and a custom JWT setup with refresh token rotation, family tracking, and reuse detection.

Upload multi-GB files to Azure Blob Storage from .NET 11 without loading them into memory. BlockBlobClient.UploadAsync with StorageTransferOptions, MultipartReader for ASP.NET Core uploads, and the buffering traps that put your payload on the LOH.

A practical, version-specific playbook for cutting .NET 11 Lambda cold starts. Covers Native AOT on provided.al2023, ReadyToRun, SnapStart on the managed dotnet10 runtime, memory tuning, static reuse, trim safety, and how to actually read INIT_DURATION.

A complete .NET 11 walkthrough for shipping an ASP.NET Core minimal API with Native AOT: PublishAot, CreateSlimBuilder, source-generated JSON, the AddControllers limitation, IL2026 / IL3050 warnings, and EnableRequestDelegateGenerator for library projects.

EF Core builds its conceptual model lazily on the first DbContext access, which is why the first query in a fresh process is several hundred milliseconds slower than every query after it. This guide covers the three real fixes in EF Core 11: a startup IHostedService that touches Model and opens a connection, dotnet ef dbcontext optimize to ship a precompiled model, and the cache-key footguns that silently rebuild the model anyway.

A complete guide to global exception handling in ASP.NET Core 11: why IExceptionFilter is the wrong tool, how IExceptionHandler and UseExceptionHandler work together, ProblemDetails responses, multi-handler chains, and the .NET 10 diagnostics suppression breaking change.

Build a working Model Context Protocol server in C# 14 / .NET 11 using the official ModelContextProtocol 1.2 SDK. Covers stdio transport, [McpServerTool] attributes, dependency injection, the stderr logging trap, and registration with Claude Code, Claude Desktop, and VS Code.

Mocking DbContext directly silently breaks ChangeTracker, which is why Microsoft discourages it. This guide shows the two patterns that actually work in EF Core 11: SQLite in-memory with a kept-open connection so the real ChangeTracker runs, and the repository pattern that lifts EF Core out of the test entirely.

A complete guide to testing HttpClient in .NET 11: why you should not mock HttpClient directly, how to write a stub HttpMessageHandler, swapping the primary handler with IHttpClientFactory, verifying Polly retries, and the WireMock.Net option.

Aspire 13.2.4 ships an OpenTelemetry bump for CVE-2026-40894, a Gen0 allocation amplification in baggage, B3, and Jaeger propagator parsing. Update OpenTelemetry.Api and OpenTelemetry.Extensions.Propagators to 1.15.3 even if you are not on Aspire.

A complete guide to profiling .NET 11 apps with dotnet-trace: install, pick the right profile, capture from startup, and read the .nettrace output in PerfView, Visual Studio, Speedscope, or Perfetto.

System.Threading.Channels is the async-first replacement for BlockingCollection in .NET 11. This guide shows how to migrate, how to choose bounded vs unbounded, and how to handle backpressure, cancellation, and graceful shutdown without deadlocking.

A complete guide to writing custom JsonConverter<T> for System.Text.Json in .NET 11: when you actually need one, how to navigate Utf8JsonReader correctly, how to handle generics with JsonConverterFactory, and how to stay AOT-friendly.

Ubuntu 26.04 Resolute Raccoon ships with .NET 10 in the archive, introduces -resolute container tags to replace -noble, and packages Native AOT tooling via dotnet-sdk-aot-10.0.

Use Kiota, Microsoft's official OpenAPI code generator, to produce a fluent, strongly typed C# client from any OpenAPI spec. Step-by-step: install, generate, wire into ASP.NET Core DI, and handle authentication.

Stream a multi-gigabyte CSV in .NET 11 without OutOfMemoryException. File.ReadLines, CsvHelper, Sylvan, and Pipelines compared with code and measurements.

Serve large files from ASP.NET Core 11 without loading them into memory. Three tiers: PhysicalFileResult for on-disk files, Results.Stream for arbitrary streams, and Response.BodyWriter for generated payloads -- with code for each.

EF Core 11 Preview 3 introduces RemoveDbContext, RemoveExtension, and a parameterless AddPooledDbContextFactory overload, removing the boilerplate around swapping providers in tests and centralizing pooled factory configuration.

Cooperative cancellation with CancellationToken, CancelAsync, Task.WaitAsync, and linked tokens in .NET 11. Plus the blocking patterns that turn a clean cancel into a deadlock.

EF Core 11 queries implement IAsyncEnumerable<T> directly. Here is how to stream rows with await foreach, when to prefer it over ToListAsync, and the gotchas around connections, tracking, and cancellation.

A HMAC validation flaw in Microsoft.AspNetCore.DataProtection 10.0.0 through 10.0.6 lets attackers forge ciphertexts. .NET 10.0.7 is the mandatory fix.

A practical guide to mixing C# records and EF Core 11. Where records fit, where they break change tracking, and how to model value objects, entities, and projections without fighting the framework.

Visual Studio 18.5 GA ships a guided Debugger Agent workflow in Copilot Chat that forms a hypothesis, sets breakpoints, rides along through a repro, validates against runtime state, and proposes a fix.

.NET 11 Preview 3 lets Kestrel serve HTTP/3 requests before the peer's control stream and SETTINGS frame arrive, shaving handshake latency off the first request on every new QUIC connection.

EF Core 11 auto-translates LINQ Contains over JSON collections to the new SQL Server 2025 JSON_CONTAINS function, and adds EF.Functions.JsonContains for path-scoped and mode-specific queries that can hit a JSON index.

Seven ways to return more than one value from a C# 14 method: named tuples, out parameters, records, structs, deconstruction, and the extension-member trick for types you don't own. Real benchmarks and a decision matrix at the end.

Visual Studio 2026 18.5.0 lets GitHub Copilot load Agent Skills from .github/skills, .claude/skills, and ~/.copilot/skills. Reusable SKILL.md instruction packs travel with your repo.

.NET 11 Preview 3 teaches RyuJIT to eliminate redundant bounds checks on consecutive index-from-end access and on i + constant < length patterns, cutting branch pressure in tight loops.

.NET 11 Preview 3 adds RegexOptions.AnyNewLine so ^, $, \Z, and . recognize every Unicode newline sequence, including \r\n, NEL, LS, and PS, with \r\n treated as one atomic break.

Aspire 13.2 ships an --isolated flag that gives each aspire run its own random ports and secrets store. It unblocks multi-checkout work, agent worktrees, and integration tests that need a live AppHost.

dotnet run -e in .NET 11 Preview 3 passes environment variables straight from the CLI and surfaces them as MSBuild RuntimeEnvironmentVariable items.

.NET 11 Preview 3 teaches dotnet sln to create, add, remove, and list projects in .slnf solution filters, so large mono-repos can load a subset without opening Visual Studio.

dotnet watch gains Aspire app host integration, automatic relaunch after crashes, and fixed Ctrl+C handling for Windows desktop apps in .NET 11 Preview 3.

EF Core 11 Preview 3 removes redundant to-one joins from split queries and drops unneeded ORDER BY keys. One reported scenario got 29% faster, another 22%. Here is what the SQL now looks like.

.NET 11 Preview 3 finishes the naming-policy story in System.Text.Json: JsonNamingPolicy.PascalCase, a member-level [JsonNamingPolicy] attribute, and a type-level [JsonIgnore] default for cleaner DTOs.

ASP.NET Core in .NET 11 Preview 3 teaches the Virtualize component to measure items at runtime, fixing the spacing and scroll jitter that uniform-height assumptions caused.

.NET MAUI 11 Preview 3 adds built-in pin clustering to the Map control on Android and iOS, with ClusteringIdentifier groups and a ClusterClicked event.

EF Core 11 Preview 3 introduces ChangeTracker.GetEntriesForState, a state-filtered enumerator that avoids an extra DetectChanges pass in hot paths like SaveChanges interceptors and audit hooks.

.NET MAUI 11 Preview 3 adds LongPressGestureRecognizer as a first-party gesture, with duration, movement threshold, state events, and command binding, replacing the common Community Toolkit behavior.

Loic Baumann's Typhon project targets 1-2 microsecond ACID commits using ref structs, hardware intrinsics, and pinned memory, proving C# can compete at the systems programming level.

C# strings sent through Dapper default to nvarchar(4000), forcing SQL Server into implicit conversions and full index scans. Here's how to fix it with DbType.AnsiString.

EF Core 11 groups Cosmos DB writes into transactional batches per container and partition on every SaveChanges, giving best-effort atomicity and fewer roundtrips without any code changes.

GitHub Copilot Modernization is pitched as an Assess, Plan, Execute loop for migrating legacy .NET apps. The assessment phase is where the value lives: an inventory report, categorized blockers, and file-level remediation guidance you can diff like code.

Visual Studio 2026 adds HotReloadAutoRestart, a project-level opt-in that restarts the app when a rude edit would otherwise end the debug session. It is especially useful for Razor and Aspire projects.

ASP.NET Core in .NET 11 Preview 2 brings TempData to Blazor static server-side rendering, enabling flash messages and Post-Redirect-Get flows without workarounds.

C# 15 adds the with(...) element to collection expressions, letting you pass capacity, comparers, and other constructor arguments directly in the initializer.

.NET 11 Preview 1 ships ZstandardStream, ZstandardEncoder, and ZstandardDecoder in System.IO.Compression, giving you fast, inbox zstd support with no third-party packages.

The dotnet ef database update command now accepts --add to scaffold and apply a migration in a single step. Here is how it works, why it matters for containers and .NET Aspire, and what to watch for.

EF Core 11 Preview 2 supports SQL Server 2025 VECTOR_SEARCH() and DiskANN vector indexes directly from LINQ. Here is how to set up the index, run approximate queries, and what changes from the EF Core 10 VectorDistance approach.

Rider 2026.1 adds a .NET Disassembler plugin that lets you inspect machine code generated by the JIT, ReadyToRun, and NativeAOT compilers without leaving the IDE.

ASP.NET Core in .NET 11 Preview 2 adds OpenTelemetry semantic attributes directly to HTTP server activity, removing the need for OpenTelemetry.Instrumentation.AspNetCore.

C# 15 introduces the union keyword for type unions with exhaustive pattern matching and implicit conversions. Available now in .NET 11 Preview 2.

Kestrel's HTTP/1.1 request parser in .NET 11 replaces BadHttpRequestException with a result struct, cutting malformed-request overhead by up to 40%.

Microsoft Agent Framework hits 1.0 with stable APIs, multi-provider connectors, multi-agent orchestration, and A2A/MCP interop. Here is what it looks like in practice on .NET 10.

Runtime Async in .NET 11 moves async/await handling from compiler-generated state machines into the runtime itself, producing readable stack traces, correct breakpoints, and fewer heap allocations.

A new project template in .NET 11 Preview 2 scaffolds the JS plumbing, WebWorkerClient, and JSExport boilerplate needed to run .NET code in a browser Web Worker.

The .NET team shares ten months of real data on running GitHub's Copilot Coding Agent in dotnet/runtime: 878 PRs, a 67.9% merge rate, and clear lessons on where AI-assisted development helps and where it still falls short.

Microsoft's free generative AI course for .NET developers ships Version 2, rebuilt for .NET 10 and migrated from Semantic Kernel to Microsoft.Extensions.AI's IChatClient pattern.

A community discussion proposed using C# 14 interceptors to rewrite JsonSerializer calls so they automatically use a generated JsonSerializerContext, keeping AOT-friendly source generation with cleaner call sites.

A new Polars.NET project is trending after a Feb 6, 2026 community post. The headline is simple: a .NET-friendly DataFrame API backed by Rust Polars, with a stable C ABI and LibraryImport-based interop to keep overhead low.

Starting with Windows 11 Build 27965, .NET Framework 3.5 is no longer an optional Windows component. Here is what breaks in CI, provisioning, and golden images, and how to fix it.

TrailBase is an open-source, single-executable backend built on Rust, SQLite, and Wasmtime. Version 0.23.7 ships UI fixes and improved error handling.

Defend your .NET packages against NuGet ownership request spam. Lock files, Package Source Mapping, and Central Package Management practices for .NET 9 and .NET 10.

If your Bearer token works in Postman but not in Scalar, the problem is likely your OpenAPI document. Here is how to declare a proper security scheme in .NET 10.

How to enforce TreatWarningsAsErrors in Release builds and CI while keeping Debug flexible for local development in .NET 10, using Directory.Build.props.

A practical profiling loop for .NET 9 and .NET 10: capture traces with dotnet-trace, visualize them in Perfetto, and iterate on CPU, GC, and thread pool issues.

Miyanyedi Quick Note is a WinUI 3 + SQLite note-taking app that is offline-first and privacy-friendly. Here is why local-only is a feature, plus a minimal SQLite snippet for .NET 8 desktop apps.

SshManager is an open-source WPF SSH manager built on .NET 8. It shows a practical pattern: xterm.js inside WebView2 for terminal rendering, EF Core + SQLite for persistence, and DPAPI for local credential protection.

CV Shortlist is an open-source .NET 10 SaaS that pairs Azure Document Intelligence with an OpenAI model. The stack, config discipline, and AI integration boundary are worth studying.

ModularPipelines V3 lets you write CI pipelines in C# instead of YAML. Run them locally with dotnet run, get compile-time safety, and debug with breakpoints.

Deploy .NET 9 and .NET 10 services on a Linux VM using Podman and systemd. Get stable restarts, real logs via journald, and a containerized app managed like a proper service -- no Kubernetes required.

How to wire Model Context Protocol (MCP) servers in C# on .NET 10 using microsoft/mcp. Covers tool contracts, input validation, auth, observability, and production-readiness patterns.

Four common traps when hosting gRPC in containers with .NET 9 and .NET 10: HTTP/2 protocol mismatches, TLS termination confusion, broken health checks, and proxy misconfiguration -- with fixes for each.

Monitor BackgroundService jobs in .NET 9 and .NET 10 without Hangfire using heartbeat health checks, duration metrics, and failure alerts with a practical code example.

.NET 10 adds #:include support for file-based apps, letting dotnet run scripts span multiple .cs files without creating a full project.

How to track NuGet dependencies and container OS packages for a .NET Docker image using CycloneDX, Syft, and Dependency-Track -- and why one SBOM is not enough.

Albatross.CommandLine v8 builds on System.CommandLine v2 with a source generator, DI integration, and hosting layer to eliminate CLI boilerplate in .NET 9 and .NET 10 apps.

Wave-IDE shows that WinForms and Roslyn on .NET 10 are enough to build a working C# IDE. Here is the minimum plumbing for incremental analysis, completion, and diagnostics.

AWS Lambda now supports .NET 10, but the runtime upgrade is not the hard part. Here is a practical checklist covering cold starts, trimming, native AOT, and deployment shape.

How to filter GetAllNetworkInterfaces() in .NET 10 when virtual adapters from Hyper-V, Docker, WSL, and VPNs flood the list. Includes a two-stage filter with explicit tradeoffs.

The MongoDB EF Core provider now supports Queryable Encryption and vector search. Here is what that means for .NET 9 and .NET 10 apps that already use EF Core.

SwitchMediator v3 targets zero-allocation, AOT-friendly dispatch for .NET 9 and .NET 10 CQRS services. Here is what that means and how to benchmark your own mediator.

Use SearchValues in .NET 10 for high-performance multi-string searching. Replaces foreach loops with SIMD-accelerated matching using Aho-Corasick and Teddy algorithms.

.NET 9 introduces Task.WhenEach, which returns an IAsyncEnumerable of tasks as they complete. Here is how it simplifies processing parallel results as they arrive.

C# 13 finally eliminates the hidden array allocation behind params. You can now use params with Span, ReadOnlySpan, List, and other collection types for zero-allocation variadic methods.

.NET 9 introduces System.Threading.Lock, a dedicated lightweight synchronization primitive that replaces lock(object) with better performance and clearer intent.

Replace GroupBy with CountBy in .NET 9 for cleaner, more efficient frequency counting. Reduces allocations from O(N) to O(K) by skipping intermediate grouping structures.

In .NET 10, the JIT can stack-allocate small fixed-size arrays of value types, eliminating heap allocations and delivering up to 60% faster performance compared to .NET 9.

A summary of new features, improvements, and breaking changes in .NET MAUI 10, released with .NET 10 and C# 14 in November 2025.

How to change the SearchBar icon color in .NET MAUI using the new SearchIconColor property introduced in .NET 10.

C# 14 allows using ref, out, in, scoped, and ref readonly modifiers on implicitly typed lambda parameters, eliminating the need to explicitly declare parameter types.

C# 14 lets you declare instance constructors and events as partial members, splitting definitions across files for cleaner code generation and separation of concerns.

C# 14 enhances the nameof expression to support unbound generic types like List<> and Dictionary<,>, eliminating the need for placeholder type arguments.

C# 14 adds built-in implicit conversions between Span, ReadOnlySpan, arrays, and strings, enabling cleaner APIs, better type inference, and fewer manual AsSpan() calls.

In .NET 10, the JIT compiler reduces the overhead of iterating arrays through interfaces. See benchmarks comparing .NET 9 vs .NET 10 with foreach, IEnumerable, and conditional escape analysis.

C# 14 introduces the field contextual keyword for property accessors, letting you add custom logic to auto-properties without declaring a separate backing field.

.NET 9 significantly improves ToArray performance using InlineArray, making it faster and more memory-efficient than ToList. See benchmarks comparing .NET 8 vs .NET 9.

C# 13 extends the params modifier beyond arrays to support Span, ReadOnlySpan, IEnumerable, and other collection types, reducing boilerplate and improving flexibility.

How to fix 'Feature is not available in C# 12.0' and switch your project to C# 13 by changing the target framework or setting LangVersion in your .csproj file.

A summary of all new features in C# 14.0, including the field keyword, extension members, null-conditional assignment, implicit span conversions, and more.

What's new in .NET 10: LTS release with 3 years of support, new JIT optimizations, array devirtualization, stack allocation improvements, and more.

The evolution of C# has transformed it into a modern, high-performance language. This guide tracks every major milestone. The Early Years (C# 1.0 – 1.2) C# launched in 2002 as a primary language for the .NET Framework. It felt like Java but with a focus on Windows development. Version 1.2 arrived shortly after with small…

Convert a Dictionary to a FrozenDictionary with `ToFrozenDictionary()` in .NET 8 for faster reads. Benchmark, when to use it, and the build-time tradeoff.

Learn how to display AdMob banner ads in your .NET MAUI app on both Android and iOS, with step-by-step setup and platform-specific handler implementations.

A step-by-step guide to building your first .NET Aspire application, covering project structure, service discovery, and the Aspire dashboard.

Install .NET Aspire via `dotnet workload install aspire`. Step-by-step setup of .NET 8, the Aspire workload, and Docker on Windows, macOS, Linux.

An overview of .NET Aspire, the cloud-oriented framework for building scalable distributed applications, covering orchestration, components, and tooling.

In C#, you can randomly select items from a list using Random.GetItems, a method introduced in .NET 8. Learn how it works with practical examples.

Learn how to publish a .NET 8 container as a tar.gz archive using the ContainerArchiveOutputPath property with dotnet publish.

Learn how to register view handlers and services from within a .NET MAUI library using the builder pattern and MauiAppBuilder extension methods.

Fix the C# error where sizeof cannot be used with Point outside an unsafe context. Two solutions: enabling unsafe code or using Marshal.SizeOf instead.

Use UnsafeAccessorAttribute in .NET 8 to access auto-generated backing fields of private auto-properties in C# without reflection.

.NET 8 includes new CreateFromDirectory and ExtractToDirectory overloads that let you create and extract ZIP files directly to and from a Stream, without writing to disk.

Benchmarking GetGenericTypeDefinition in .NET 8 vs .NET 7 shows nearly 10x faster performance. See benchmark code and results using BenchmarkDotNet.

Learn how to capture a screenshot of your entire desktop from a .NET console application using System.Windows.Forms. Windows-only solution covering all displays.

Learn how to update a readonly field in C# using UnsafeAccessor, an alternative to reflection without the performance penalty. Available in .NET 8.

Benchmarking UnsafeAccessor vs Reflection in .NET 8. See how UnsafeAccessor achieves zero-overhead performance compared to traditional reflection.

Use the `[UnsafeAccessor]` attribute in .NET 8 to read private fields and call private methods at zero overhead — no reflection, fully AOT-compatible.

Starting with C# 12, a new ExperimentalAttribute lets you mark types, methods, properties, or assemblies as experimental. Learn how to use it with diagnosticId, pragma tags, and UrlFormat.

The ref readonly modifier in C# provides a more transparent way of passing read-only references. Learn how it improves on the in modifier with better constraints and caller visibility.

The easiest way to shuffle an array in C# is using Random.Shuffle, introduced in .NET 8. It works in-place on both arrays and spans.

Use the new WithAddedModifier extension method in .NET 8 to easily modify any IJsonTypeInfoResolver serialization contract without creating a new resolver from scratch.

The new GetFromJsonAsAsyncEnumerable extension method in .NET 8 deserializes HTTP response JSON into an IAsyncEnumerable. Learn how to use it with await foreach.

Explore the new .NET 8 API additions to JsonNode and JsonArray, including GetValueKind, GetPropertyName, GetElementIndex, ReplaceWith, and ParseAsync.

Learn how to use the new DeepClone() and DeepEquals() methods on JsonNode in .NET 8 for deep cloning and comparing JSON nodes.

Learn how to disable reflection-based serialization in System.Text.Json starting with .NET 8 for trimmed and native AOT applications using the JsonSerializerIsReflectionEnabledByDefault property.

Learn how to add or remove TypeInfoResolver instances on existing JsonSerializerOptions using the new TypeInfoResolverChain property in .NET 8.

Prevent WPF file dialog selections from appearing in Windows Explorer recents and the Start Menu by setting AddToRecent to false in .NET 8.

Use the ClientGuid property in .NET 8 to persist individual dialog states like window size, position, and last used folder across WPF file dialogs.

Learn about C# 12 interceptors, an experimental .NET 8 compiler feature that lets you replace method calls at compile time using the InterceptsLocation attribute.

Learn how to constrain the WPF OpenFileDialog folder tree to a specific root folder using the RootDirectory property in .NET 8.

Learn how to enable WPF hardware acceleration over RDP in .NET 8 for improved performance and a more responsive remote desktop experience.

Use the new .NET 8 `OpenFolderDialog` in WPF to let users open and select one or multiple folders. Replaces the old WinForms FolderBrowserDialog hack.

Fix the ASP.NET Core Identity error where AppDbContext can't be converted to IUserStore by adding AddEntityFrameworkStores to your identity configuration.

.NET 8 adds support for serializing properties from interface hierarchies, including all properties from all interfaces depending on the declared variable type.

Learn how to deserialize JSON into non-public properties in .NET 8 using the JsonInclude attribute and parameterized constructors.

Learn how to use the new JsonStringEnumConverter<TEnum> in .NET 8 for native AOT-compatible enum serialization with System.Text.Json.

How to fix error CS0246 for InterceptsLocationAttribute in C# interceptors by defining the attribute yourself.

Learn how to mark JsonSerializerOptions instances as read-only in .NET 8 using MakeReadOnly, and how to check the IsReadOnly property.

System.Text.Json in .NET 8 adds built-in serialization support for the Half, Int128, and UInt128 numeric types.

Starting with .NET 8, both Memory<byte> and ReadOnlyMemory<byte> are serialized as Base64 strings, while other types like Memory<int> remain JSON arrays.

Learn how to include private, protected, and internal properties in JSON serialization in .NET 8 using the JsonInclude attribute.

Use the `dotnet workload clean` command to remove leftover .NET workload packs after an SDK or Visual Studio update — when to use it, what it removes, and gotchas.

Learn how to deserialize JSON into read-only properties without a setter in .NET 8 using JsonObjectCreationHandling or JsonSerializerOptions.

Learn how to throw exceptions for unmapped JSON properties during deserialization in .NET 8 using JsonUnmappedMemberHandling.

dotnet script enables you to run C# scripts (.CSX) from the .NET CLI. The only requirement is to have .NET 6 or newer installed on your machine. You can use the following command to install dotnet-script globally: Then to execute a script file you simply call dotnet script <file_path> like in the example below: How…

You can use the WaitForExit method to wait for the process to complete. Your code will wait synchronously for the process to finish, then it will resume execution. Let’s look at an example: The code above will start a new cmd.exe process, and execute the timeout 5 command. The process.WaitForExit() call will force your program…

Use the new .NET 8 `JsonNamingPolicy.SnakeCaseLower` (and SnakeCaseUpper, KebabCaseLower, KebabCaseUpper) to serialize snake_case / kebab-case JSON via System.Text.Json — no custom converter needed.

Fix the '-aot is not a valid option' error by using the correct double-hyphen syntax: dotnet new api --aot.

A beginner's guide to getting started with C# programming, from setting up Visual Studio to writing your first program and finding learning resources.

.NET 8 was released on November 14, 2023 as an LTS (Long Term Support) version, meaning it will continue to receive support, updates, and bug fixes for at least three years from its release date. As usual, .NET 8 brings support for a new version of the C# language, namely C# 12. Check out our dedicated page…