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:

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

<!-- 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:

#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:

private string _name = "";
public string Name
{
    get => _name;
    set
    {
        if (_name == value) return;
        _name = value;
        PropertyChanged?.Invoke(this, new(nameof(Name)));
    }
}

With field:

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.

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 ?./?[]:

// 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:

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.