dotnet10-features

# .NET 10 / C# 14 features relevant to ReactiveProperty This skill curates the **.NET 10** (and its bundled **C# 14**) features that actually matter for this repository, and maps each one to concrete ReactiveProperty scenarios. It is intentionally scoped: it skips .NET 10 features with no bearing on a reactive MVVM library. ## Repository context (read this first) Target frameworks and language version are **not uniform** across the solution, so a C# 14 feature may be unavailable in a given project: | Project | Target framework(s) | C# 14 available? | | --- | --- | --- | | `ReactiveProperty.Core` | `netstandard2.0;net8.0;net9.0;net472` | Only if `LangVersion` is raised; runtime-dependent features stay off on `netstandard2.0`/`net472` | | `ReactiveProperty` (main, `ReactiveProperty.NETStandard`) | `netstandard2.0;net8.0;net9.0;net472` | Same as above | | `ReactiveProperty.Platform.WPF` | `net8.0-windows;net9.0-windows;net472` | Same as above | | `ReactiveProperty.Platform.UWP` | (UWP TFMs) | Same as above | | `ReactiveProperty.Platform.Blazor` | `net8.0;net9.0;net10.0` | Yes on the `net10.0` leg | | `Samples/**`, Blazor samples | include `net10.0` | Yes | Key facts: - `Source/Directory.Build.props` currently pins **`<LangVersion>12.0</LangVersion>`**, so the library compiles as **C# 12** today. Adopting any C# 14 feature in the library requires raising `LangVersion` (to `14` / `latest` / `preview`). - `net10.0` is currently used only by **`ReactiveProperty.Platform.Blazor`** and the **samples**. The core/main/WPF/UWP libraries do **not** target `net10.0`. - The library is **multi-targeted down to `netstandard2.0` and `net472`**. C# 14 *language* features that the compiler can lower (e.g. `field`, extension members, null-conditional assignment, partial members) work across all TFMs once `LangVersion` is raised, but features that depend on the **.NET 10 runtime/BCL** (e.g. first-class `Span<T>` conversions that rely on new BCL APIs) will not light up on the older TFMs. Guard those with `#if NET10_0_OR_GREATER` when needed. ## How to enable C# 14 in a project here ```xml <!-- Raise once in Source/Directory.Build.props, or per-project. --> <LangVersion>14.0</LangVersion> ``` For runtime/BCL-gated features, multi-target and branch with the framework constant: ```csharp #if NET10_0_OR_GREATER // .NET 10-only path #else // fallback for net8.0 / net9.0 / netstandard2.0 / net472 #endif ``` --- ## C# 14 features, ranked by relevance to this repo ### 1. The `field` keyword — HIGH relevance `field` exposes the compiler-synthesized backing field inside a property accessor, so you can add validation/notification without declaring an explicit field. ReactiveProperty exists to serve MVVM/`INotifyPropertyChanged`, and both the library internals and consumer ViewModels are full of hand-written backing fields. Classic INPC property: ```csharp private string _name = ""; public string Name { get => _name; set { if (_name == value) return; _name = value; PropertyChanged?.Invoke(this, new(nameof(Name))); } } ``` With `field`: ```csharp public string Name { get; set { if (field == value) return; field = value; PropertyChanged?.Invoke(this, new(nameof(Name))); } } ``` Notes for this repo: - Watch for the naming collision: identifiers literally named `field` must be disambiguated with `@field` or `this.field`. - Works on all TFMs once `LangVersion >= 14`; this is the lowest-risk C# 14 adoption here. ### 2. Extension members — HIGH relevance ReactiveProperty's public surface is heavily built on **extension methods** in the `Reactive.Bindings` namespace (`ToReactiveProperty`, `ToReadOnlyReactivePropertySlim`, `ObserveProperty`, `CombineLatest` helpers, etc.). C# 14 adds an `extension` block syntax that also enables **extension properties**, **static extension members**, and **extension operators** — grouped by receiver instead of repeating `this T source` on every method. ```csharp public static class ObservableExtensions { extension<T>(IObservable<T> source) { // extension method (same call site as today) public ReactiveProperty<T> ToReactiveProperty(T initialValue = default!) => new ReactiveProperty<T>(source, initialValue); // NEW: extension property public IObservable<T> Shared => source.Publish().RefCount(); } } ``` Notes for this repo: - Lets related operators on `IObservable<T>` / `IReactiveProperty<T>` be grouped in one `extension(...)` block, improving discoverability and enabling property-style helpers. - This is a **language** feature (compiler-lowered), so it can apply across all TFMs once `LangVersion` is raised — but it is an API-shape decision; keep existing extension method signatures for source/binary compatibility and only add new members. ### 3. Null-conditional assignment (`?.`/`?[]` on the left side) — MEDIUM relevance You can now assign through `?.`/`?[]`: ```csharp // before if (viewModel is not null) viewModel.SelectedItem = item; // C# 14 viewModel?.SelectedItem = item; ``` Useful in ViewModel/event-handler glue and in sample apps. Increment/decrement (`++`/`--`) are not allowed on the conditional left side; compound assignments (`+=`, etc.) are. ### 4. First-class `Span<T>` / `ReadOnlySpan<T>` conversions — MEDIUM (performance) C# 14 adds implicit conversions among `Span<T>`, `ReadOnlySpan<T>`, and `T[]`, improving overload resolution and generic inference for span-based, allocation-free code paths. Relevant only in hot paths (e.g. buffer/array handling inside operators). Caveat: the most useful conversions rely on **.NET 10 BCL** support, so gate span-optimized paths with `#if NET10_0_OR_GREATER` and keep an allocating fallback for `net8.0`/`net9.0`/ `netstandard2.0`/`net472`. ### 5. Simple lambda parameters with modifiers — MEDIUM/LOW relevance Modifiers (`ref`, `in`, `out`, `scoped`, `ref readonly`) can now be applied to lambda parameters **without** restating the type: ```csharp delegate bool TryParse<T>(string text, out T result); TryParse<int> parse = (text, out result) => int.TryParse(text, out result); ``` Handy for Rx/LINQ-style lambdas and `TryParse`-shaped converters in samples. `params` still requires an explicit type. ### 6. Partial events and constructors — MEDIUM relevance Instance constructors and events can now be `partial` (one defining + one implementing declaration). This is primarily a **source-generator** enabler. If any INPC/event plumbing in this repo (or a consumer toolkit pattern) is generated, partial events let a generator provide `add`/`remove` accessors while the field-like event is declared by hand. ### 7. `nameof` with unbound generic types — LOW relevance `nameof(ReactiveProperty<>)` now evaluates to `"ReactiveProperty"`. Minor convenience for diagnostics, logging, and tests that reference open generic types. ### 8. User-defined compound assignment operators — LOW relevance You can define `+=`, `-=`, etc. directly (instead of relying on the binary operator plus an assignment). Niche for this library; mentioned for completeness. --- ## ASP.NET Core / Blazor 10 (for `ReactiveProperty.Platform.Blazor` and Blazor samples) `ReactiveProperty.Platform.Blazor` targets `net10.0` and centers on **EditForm validation** (`ReactivePropertiesValidator`, `EditContext.EnableReactivePropertiesValidation()`) plus command helpers. The most relevant .NET 10 Blazor changes: - **Improved form validation** — new opt-in validation (`builder.Services.AddValidation()` + `[ValidatableType]`) that validates nested objects and collection items. This overlaps with ReactiveProperty's `EditContext` validation integration; be aware of how the two interact when both are enabled on the same `EditForm`, and document the recommended combination. - **`OwningComponentBase` now implements `IAsyncDisposable`** — relevant to the disposal pattern in `ReactivePropertiesValidator` (currently `IDisposable` wrapping a `SingleAssignmentDisposable`). Async disposal can be useful where reactive subscriptions own async resources. - **Declarative state persistence (`[PersistentState]`)** — public properties marked `[PersistentState]` are auto-persisted via `PersistentComponentState` during prerendering, removing the manual `RegisterOnPersisting` boilerplate. Useful for ViewModel-held state in prerendered Blazor Web App samples. - **Not Found handling** (`Router` `NotFoundPage` parameter and `NavigationManager`-based Not Found responses) and **Blazor script served as a static web asset** — general improvements worth knowing when updating the Blazor samples to `net10.0`. When bumping the Blazor sample/template projects, also review the version-conditioned `Microsoft.AspNetCore.Components.*` package versions in `Directory.Packages.props` (`10.0.0` entries are gated on `'$(TargetFramework)' == 'net10.0'`). --- ## Adoption caveats (summary) - The core libraries are **C# 12 today** (`LangVersion 12.0`) and do **not** target `net10.0`. Raising `LangVersion` is required before any C# 14 syntax compiles. - Multi-targeting to `netstandard2.0`/`net472` means **runtime/BCL-gated** features must be `#if NET10_0_OR_GREATER`-guarded; language-only features are fine across TFMs. - This is a published NuGet library — preserve existing public/extension API signatures for source and binary compatibility; prefer **adding** members over changing them. ## References (official docs) - What's new in C# 14: <https://learn.microsoft.com/dotnet/csharp/whats-new/csharp-14> - Extension members tutorial: <https://learn.microsoft.com/dotnet/csharp/programming-guide/classes-and-structs/extension-methods> - The `field` keyword: <https://learn.microsoft.com/dotnet/csharp/language-reference/keywords/field> - Null-conditional assignment: <https://learn.microsoft.com/dotnet/csharp/language-reference/operators/member-access-operators> - First-class spans: <https://learn.microsoft.com/dotnet/csharp/language-reference/proposals/csharp-14.0/first-class-span-types> - What's new in .NET 10: <https://learn.microsoft.com/dotnet/core/whats-new/dotnet-10/overview> - What's new in ASP.NET Core in .NET 10: <https://learn.microsoft.com/aspnet/core/release-notes/aspnetcore-10.0>