Updated WhenAnyValue and Attributes to minimise AOT warnings (#4096)

<!-- Please be sure to read the
[Contribute](https://github.com/reactiveui/reactiveui#contribute)
section of the README -->

**What kind of change does this PR introduce?**
<!-- Bug fix, feature, docs update, ... -->

Update

**What is the current behavior?**
<!-- You can also link to an open issue here. -->

Large scale reflection, AOT attributes missing or misplaced

**What is the new behavior?**
<!-- If this is a feature change -->

Added [RequiresDynamicCode] and [RequiresUnreferencedCode] attributes to
various methods for .NET 6+ to improve AOT compatibility.

Updated usages of WhenAnyValue and related methods to use property name
overloads and explicit generic type parameters for better AOT support.
Also removed redundant AOT annotations from Activation/ViewForMixins.cs
and made minor code style improvements.

**What might this PR break?**

All tests pass, additional tests added to cover new functions

**Please check if the PR fulfills these requirements**
- [x] Tests for the changes have been added (for bug fixes / features)
- [ ] Docs have been added / updated (for bug fixes / features)

**Other information**:

Part of a larger breaking change

Author: ChrisPulman

src/ReactiveUI.AOTTests/AOTCompatibilityTests.cs

@@ -91,7 +91,7 @@ public void WhenAnyValue_StringPropertyNames_WorksInAOT()
         string? observedValue = null;
 
         // Using string property names should work in AOT
-        obj.WhenAnyValue(x => x.TestProperty)
+        obj.WhenAnyValue<TestReactiveObject, string>(nameof(TestReactiveObject.TestProperty))
            .Subscribe(value => observedValue = value);
 
         obj.TestProperty = "test value";

src/ReactiveUI.AOTTests/StringBasedObservationTests.cs

@@ -0,0 +1,114 @@
+// Copyright (c) 2025 .NET Foundation and Contributors. All rights reserved.
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+
+namespace ReactiveUI.AOTTests;
+
+/// <summary>
+/// StringBasedObservationTests.
+/// </summary>
+public class StringBasedObservationTests
+{
+    /// <summary>
+    /// Observables for property string name emits initial then changes.
+    /// </summary>
+    [Fact]
+    public void ObservableForProperty_StringName_EmitsInitialThenChanges()
+    {
+        var s = new Sample { IntValue = 5 };
+        var values = new List<int>();
+
+        s.ObservableForProperty<Sample, int>(nameof(Sample.IntValue), beforeChange: false, skipInitial: false, isDistinct: true)
+         .Select(x => x.Value)
+         .Subscribe(values.Add);
+
+        s.IntValue = 7;
+        s.IntValue = 7; // distinct should suppress duplicate
+        s.IntValue = 9;
+
+        Assert.Equal(new[] { 5, 7, 9 }, values);
+    }
+
+    /// <summary>
+    /// Observables for property before change emits before setter.
+    /// </summary>
+    [Fact]
+    public void ObservableForProperty_BeforeChange_EmitsBeforeSetter()
+    {
+        var s = new Sample { IntValue = 1 };
+        var before = new List<int>();
+
+        s.ObservableForProperty<Sample, int>(nameof(Sample.IntValue), beforeChange: true, skipInitial: true, isDistinct: false)
+         .Select(x => x.Value)
+         .Subscribe(before.Add);
+
+        s.IntValue = 2; // should emit previous value (1) before change
+        s.IntValue = 3; // should emit 2
+
+        Assert.Equal(new[] { 1, 2 }, before);
+    }
+
+    /// <summary>
+    /// Whens any value string name works and is distinct.
+    /// </summary>
+    [Fact]
+    public void WhenAnyValue_StringName_WorksAndIsDistinct()
+    {
+        var s = new Sample { Name = "a" };
+        var values = new List<string?>();
+
+        s.WhenAnyValue<Sample, string?>(nameof(Sample.Name))
+         .Subscribe(values.Add);
+
+        s.Name = "b";
+        s.Name = "b"; // duplicate should be filtered by default overload
+        s.Name = "c";
+
+        Assert.Equal(new[] { "a", "b", "c" }, values);
+    }
+
+    /// <summary>
+    /// Whens any value string name not distinct when requested.
+    /// </summary>
+    [Fact]
+    public void WhenAnyValue_StringName_NotDistinctWhenRequested()
+    {
+        var s = new Sample { Name = "x" };
+        var values = new List<string?>();
+
+        s.WhenAnyValue<Sample, string?>(nameof(Sample.Name), isDistinct: false)
+         .Subscribe(values.Add);
+
+        s.Name = "y";
+        s.Name = "y"; // should be included
+
+        Assert.Equal(new[] { "x", "y", "y" }, values);
+    }
+
+    private sealed class Sample : ReactiveObject
+    {
+        private int _intValue;
+        private string? _name;
+
+        public int IntValue
+        {
+            get => _intValue;
+            set => this.RaiseAndSetIfChanged(ref _intValue, value);
+        }
+
+        public string? Name
+        {
+            get => _name;
+            set
+            {
+                // Using RaisePropertyChanged to ensure property change notification
+                _name = value;
+                this.RaisePropertyChanged(nameof(Name));
+            }
+        }
+    }
+}

src/ReactiveUI.AOTTests/StringBasedSemanticsTests.cs

@@ -0,0 +1,94 @@
+// Copyright (c) 2025 .NET Foundation and Contributors. All rights reserved.
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+
+namespace ReactiveUI.AOTTests;
+
+/// <summary>
+/// Verifies the string-based ObservableForProperty and WhenAnyValue semantics.
+/// Ensures initial emission, beforeChange behavior, distinct filtering, and tuple combinations.
+/// </summary>
+public class StringBasedSemanticsTests
+{
+    /// <summary>
+    /// ObservableForProperty (string) should emit an initial value followed by updates.
+    /// </summary>
+    [Fact]
+    public void ObservableForProperty_String_Basic_InitialAndUpdate()
+    {
+        var obj = new TestReactiveObject();
+        var seen = new List<string?>();
+
+        obj.ObservableForProperty<TestReactiveObject, string?>(nameof(TestReactiveObject.TestProperty), beforeChange: false, skipInitial: false)
+           .Select(x => x.Value)
+           .Subscribe(seen.Add);
+
+        // initial emission is null, then updated value
+        obj.TestProperty = "v1";
+
+        Assert.True(seen.Count >= 2);
+        Assert.Null(seen[0]);
+        Assert.Equal("v1", seen[^1]);
+    }
+
+    /// <summary>
+    /// ObservableForProperty (string) with beforeChange should provide the previous value when the property changes.
+    /// </summary>
+    [Fact]
+    public void ObservableForProperty_String_BeforeChange_FiresOldValue()
+    {
+        var obj = new TestReactiveObject { TestProperty = "start" };
+        string? observed = null;
+
+        obj.ObservableForProperty<TestReactiveObject, string?>(nameof(TestReactiveObject.TestProperty), beforeChange: true, skipInitial: true)
+           .Select(x => x.Value)
+           .Subscribe(v => observed = v);
+
+        obj.TestProperty = "next";
+
+        Assert.Equal("start", observed);
+    }
+
+    /// <summary>
+    /// WhenAnyValue (string) should apply DistinctUntilChanged by default and include an initial emission.
+    /// </summary>
+    [Fact]
+    public void WhenAnyValue_String_IsDistinct()
+    {
+        var obj = new TestReactiveObject();
+        var seen = new List<string?>();
+
+        obj.WhenAnyValue<TestReactiveObject, string?>(nameof(TestReactiveObject.TestProperty))
+           .Subscribe(seen.Add);
+
+        obj.TestProperty = "same";
+        obj.TestProperty = "same"; // should be filtered by distinct
+        obj.TestProperty = "other";
+
+        // initial null + "same" + "other" => 3 distinct emissions
+        Assert.True(seen.Count >= 3);
+        Assert.Equal(new[] { null, "same", "other" }, seen.TakeLast(3).ToArray());
+    }
+
+    /// <summary>
+    /// WhenAnyValue (string) tuple overload should combine the latest values from two properties.
+    /// </summary>
+    [Fact]
+    public void WhenAnyValue_String_TupleCombine_Works()
+    {
+        var obj = new TestReactiveObject();
+        var tuples = new List<(string?, string?)>();
+
+        obj.WhenAnyValue<TestReactiveObject, string?, string?>(nameof(TestReactiveObject.TestProperty), nameof(TestReactiveObject.ComputedProperty))
+           .Subscribe(tuples.Add);
+
+        obj.TestProperty = "value";
+
+        Assert.True(tuples.Count >= 1);
+        var last = tuples[^1];
+        Assert.Equal("value", last.Item1);
+    }
+}

src/ReactiveUI.AOTTests/ViewLocatorAOTMappingTests.cs

@@ -0,0 +1,84 @@
+// Copyright (c) 2025 .NET Foundation and Contributors. All rights reserved.
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Reactive.Linq;
+
+namespace ReactiveUI.AOTTests;
+
+/// <summary>
+/// Tests for AOT-friendly mapping and ResolveView contract usage.
+/// </summary>
+public class ViewLocatorAOTMappingTests
+{
+    /// <summary>
+    /// Map/Resolve with contract and default fallback works.
+    /// </summary>
+    [Fact]
+    public void Map_ResolveView_UsesAOTMappingWithContract()
+    {
+        var locator = new DefaultViewLocator();
+
+        // Register contract-specific and default mappings
+        locator.Map<VmA, ViewA>(() => new ViewA(), contract: "mobile")
+            .Map<VmA, ViewADefault>(() => new ViewADefault()); // default
+
+        var vm = new VmA();
+
+        var viewMobile = locator.ResolveView(vm, "mobile");
+        Assert.IsType<ViewA>(viewMobile);
+
+        var viewDefaultFromExplicit = locator.ResolveView(vm, string.Empty);
+        Assert.IsType<ViewADefault>(viewDefaultFromExplicit);
+
+        // Unknown contract falls back to default mapping
+        var viewFallback = locator.ResolveView(vm, "unknown");
+        Assert.IsType<ViewADefault>(viewFallback);
+    }
+
+    /// <summary>
+    /// Unmap removes a mapping for a contract.
+    /// </summary>
+    [Fact]
+    public void Unmap_RemovesMapping()
+    {
+        var locator = new DefaultViewLocator();
+        locator.Map<VmB, ViewB>(() => new ViewB(), contract: "c1");
+
+        var vm = new VmB();
+        Assert.IsType<ViewB>(locator.ResolveView(vm, "c1"));
+
+        locator.Unmap<VmB>("c1");
+        Assert.Null(locator.ResolveView(vm, "c1"));
+    }
+
+    private sealed class ViewADefault : IViewFor<VmA>
+    {
+        object? IViewFor.ViewModel { get => ViewModel; set => ViewModel = (VmA?)value; }
+
+        public VmA? ViewModel { get; set; }
+    }
+
+    private sealed class ViewB : IViewFor<VmB>
+    {
+        object? IViewFor.ViewModel { get => ViewModel; set => ViewModel = (VmB?)value; }
+
+        public VmB? ViewModel { get; set; }
+    }
+
+    private sealed class VmA : ReactiveObject
+    {
+    }
+
+    private sealed class VmB : ReactiveObject
+    {
+    }
+
+    private sealed class ViewA : IViewFor<VmA>
+    {
+        object? IViewFor.ViewModel { get => ViewModel; set => ViewModel = (VmA?)value; }
+
+        public VmA? ViewModel { get; set; }
+    }
+}

src/ReactiveUI.Maui/ReactiveUIBuilderMauiExtensions.cs

@@ -31,6 +31,25 @@ public static AppBuilder WithMaui(this Builder.ReactiveUIBuilder builder)
         return builder.WithPlatformModule<Registrations>();
     }
 
+    /// <summary>
+    /// Registers MAUI-specific services (AOT-friendly shortcut for non-builder code).
+    /// </summary>
+    /// <param name="resolver">Resolver to register into.</param>
+    /// <returns>The resolver for chaining.</returns>
+#if NET6_0_OR_GREATER
+    [RequiresDynamicCode("WithMaui uses methods that require dynamic code generation")]
+    [RequiresUnreferencedCode("WithMaui uses methods that may require unreferenced code")]
+#endif
+    public static IMutableDependencyResolver WithMaui(this IMutableDependencyResolver resolver)
+    {
+        resolver.ArgumentNullExceptionThrowIfNull(nameof(resolver));
+
+        // Use the same module the builder uses to avoid duplication.
+        var reg = new Registrations();
+        reg.Register((f, t) => resolver.RegisterConstant(f(), t));
+        return resolver;
+    }
+
     /// <summary>
     /// Registers MAUI-specific services.
     /// </summary>