Enhance DI integration and update dependencies (#57)

* Enhance DI integration and update dependencies

Improves and documents extension methods for integrating ReactiveUI with various DI containers (Autofac, DryIoc, Microsoft DI, Ninject) in Avalonia applications. Updates test mocks to match expanded IDependencyResolver interface. Refactors and documents AppBuilderExtensions and related classes for clarity and extensibility. Updates dependencies: Avalonia to 11.3.11, Splat to 19.2.1, and ReactiveUI to 23.1.0-beta.1.

* Update test setup and builder to use WithSuspensionHost

Refactored AutoSuspendHelperTests setup to use ReactiveUIBuilder and WithSuspensionHost for improved test isolation. Updated AppBuilderExtensions to chain WithSuspensionHost<Unit>() in the builder configuration.

* Refactor method signatures for readability

Method signatures in AvaloniaCreatesCommandBinding.cs have been reformatted to use multi-line parameter lists for improved readability. The BindCommandToObject overload with custom event handlers now returns Disposable.Empty instead of throwing NotImplementedException.

* Fix XML doc comment formatting in ReactiveWindow

Corrected the summary comment in the ReactiveWindow constructor to fix a line break and improve readability.

* Fix XML doc comment formatting in RoutedViewHost

Corrected a line break in the XML documentation comment for the RoutedViewHost constructor to improve readability and maintain consistency.

* Fix XML doc comment punctuation in constructor summary

Removed an unnecessary period at the end of the first sentence in the XML documentation for the ViewModelViewHost constructor to improve consistency and style.

Author: ChrisPulman

src/Directory.Packages.props

@@ -4,7 +4,7 @@
     <CentralPackageTransitivePinningEnabled>true</CentralPackageTransitivePinningEnabled>
     <AvaloniaVersion>11.3.11</AvaloniaVersion>
     <AvaloniaLatestVersion>11.3.*</AvaloniaLatestVersion>
-    <SplatVersion>18.1.1</SplatVersion>
+    <SplatVersion>19.2.1</SplatVersion>
   </PropertyGroup>
   <ItemGroup>
     <PackageVersion Include="coverlet.collector" Version="6.0.4">
@@ -19,7 +19,7 @@
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
     <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />
     <PackageVersion Include="Nerdbank.GitVersioning" Version="3.9.50" />
-    <PackageVersion Include="ReactiveUI" Version="22.3.1" />
+    <PackageVersion Include="ReactiveUI" Version="23.1.0-beta.1" />
     <PackageVersion Include="Roslynator.Analyzers" Version="4.15.0" />
     <PackageVersion Include="Splat" Version="$(SplatVersion)" />
     <PackageVersion Include="Splat.Autofac" Version="$(SplatVersion)" />

src/ReactiveUI.Avalonia.Autofac/AvaloniaMixins.cs

@@ -5,73 +5,34 @@
 
 using Autofac;
 using ReactiveUI.Builder;
-using Splat;
 using Splat.Autofac;
 using Splat.Builder;
 using AppBuilder = Avalonia.AppBuilder;
 
 namespace ReactiveUI.Avalonia.Splat;
 
 /// <summary>
-/// Avalonia Mixins.
+/// Provides extension methods for configuring Avalonia applications to use ReactiveUI with Autofac as the dependency
+/// injection container.
 /// </summary>
+/// <remarks>This class contains extension methods that integrate Autofac with ReactiveUI in Avalonia
+/// applications. These methods are intended to be used during application startup to set up dependency resolution and
+/// enable further customization of the application's composition and ReactiveUI configuration.</remarks>
 public static class AvaloniaMixins
 {
     /// <summary>
-    /// Uses the splat with dry ioc.
+    /// Configures the application to use ReactiveUI with Autofac as the dependency injection container.
     /// </summary>
-    /// <param name="builder">The builder.</param>
-    /// <param name="containerConfig">The configure.</param>
-    /// <param name="withResolver">The get resolver.</param>
-    /// <returns>
-    /// An App Builder.
-    /// </returns>
-    /// <exception cref="System.ArgumentNullException">builder.</exception>
-    public static AppBuilder UseReactiveUIWithAutofac(this AppBuilder builder, Action<ContainerBuilder> containerConfig, Action<AutofacDependencyResolver>? withResolver = null) =>
-        builder switch
-        {
-            null => throw new ArgumentNullException(nameof(builder)),
-            _ => builder.UseReactiveUI().AfterPlatformServicesSetup(_ =>
-            {
-                if (AppLocator.CurrentMutable is null)
-                {
-                    return;
-                }
-#if NETSTANDARD
-                if (containerConfig is null)
-                {
-                    throw new ArgumentNullException(nameof(containerConfig));
-                }
-#else
-                ArgumentNullException.ThrowIfNull(containerConfig);
-#endif
-                var containerBuilder = new ContainerBuilder();
-                var autofacResolver = containerBuilder.UseAutofacDependencyResolver();
-                containerBuilder.RegisterInstance(autofacResolver);
-                autofacResolver.InitializeReactiveUI(RegistrationNamespace.Avalonia);
-                RxSchedulers.MainThreadScheduler = AvaloniaScheduler.Instance;
-                containerConfig(containerBuilder);
-                var container = containerBuilder.Build();
-                autofacResolver.SetLifetimeScope(container);
-
-                if (withResolver is not null)
-                {
-                    withResolver(autofacResolver);
-                }
-            })
-        };
-
-    /// <summary>
-    /// Uses the reactive UI with autofac.
-    /// </summary>
-    /// <param name="builder">The builder.</param>
-    /// <param name="containerConfig">The container configuration.</param>
-    /// <param name="withResolver">The with resolver.</param>
-    /// <param name="withReactiveUIBuilder">The with reactive UI builder.</param>
-    /// <returns>
-    /// An App Builder.
-    /// </returns>
-    /// <exception cref="ArgumentNullException">builder.</exception>
+    /// <remarks>This method integrates Autofac with ReactiveUI by registering the Autofac dependency resolver
+    /// and allowing custom container configuration. Additional customization of the resolver and ReactiveUI builder can
+    /// be performed using the optional delegates. This extension should be called during application startup before
+    /// registering views and view models.</remarks>
+    /// <param name="builder">The application builder used to configure the app. Cannot be null.</param>
+    /// <param name="containerConfig">A delegate that configures the Autofac container by registering services and components. Cannot be null.</param>
+    /// <param name="withResolver">An optional delegate that allows further customization of the Autofac dependency resolver after it is created.</param>
+    /// <param name="withReactiveUIBuilder">An optional delegate that allows additional configuration of the ReactiveUI builder.</param>
+    /// <returns>The application builder instance, enabling further configuration or chaining.</returns>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="builder"/> or <paramref name="containerConfig"/> is null.</exception>
     public static AppBuilder UseReactiveUIWithAutofac(this AppBuilder builder, Action<ContainerBuilder> containerConfig, Action<AutofacDependencyResolver>? withResolver = null, Action<ReactiveUIBuilder>? withReactiveUIBuilder = null)
     {
         if (builder is null)

src/ReactiveUI.Avalonia.DryIoc/AvaloniaMixins.cs

@@ -13,52 +13,24 @@
 namespace ReactiveUI.Avalonia.Splat;
 
 /// <summary>
-/// Avalonia Mixins.
+/// Provides extension methods for configuring Avalonia applications to use ReactiveUI with DryIoc as the dependency
+/// injection container.
 /// </summary>
 public static class AvaloniaMixins
 {
     /// <summary>
-    /// Uses the splat with dry ioc.
+    /// Configures the application to use ReactiveUI with DryIoc as the dependency injection container.
     /// </summary>
-    /// <param name="builder">The builder.</param>
-    /// <param name="containerConfig">The configure.</param>
-    /// <returns>An App Builder.</returns>
-    public static AppBuilder UseReactiveUIWithDryIoc(this AppBuilder builder, Action<Container> containerConfig) =>
-        builder switch
-        {
-            null => throw new ArgumentNullException(nameof(builder)),
-            _ => builder.UseReactiveUI().AfterPlatformServicesSetup(_ =>
-            {
-                if (AppLocator.CurrentMutable is null)
-                {
-                    return;
-                }
-
-#if NETSTANDARD
-                if (containerConfig is null)
-                {
-                    throw new ArgumentNullException(nameof(containerConfig));
-                }
-#else
-                ArgumentNullException.ThrowIfNull(containerConfig);
-#endif
-
-                var container = new Container();
-                container.UseDryIocDependencyResolver();
-                AppLocator.CurrentMutable.RegisterConstant(container);
-                RxSchedulers.MainThreadScheduler = AvaloniaScheduler.Instance;
-                containerConfig(container);
-            })
-        };
-
-    /// <summary>
-    /// Uses the reactive UI with dry ioc.
-    /// </summary>
-    /// <param name="builder">The builder.</param>
-    /// <param name="containerConfig">The container configuration.</param>
-    /// <param name="withReactiveUIBuilder">The with reactive UI builder.</param>
-    /// <returns>An App Builder.</returns>
-    /// <exception cref="ArgumentNullException">builder.</exception>
+    /// <remarks>This method integrates DryIoc with ReactiveUI, allowing services and dependencies to be
+    /// registered using DryIoc. The provided <paramref name="containerConfig"/> delegate can be used to register
+    /// application-specific services. If additional ReactiveUI configuration is required, supply the <paramref
+    /// name="withReactiveUIBuilder"/> delegate.</remarks>
+    /// <param name="builder">The application builder used to configure the app pipeline. Cannot be null.</param>
+    /// <param name="containerConfig">A delegate that configures the DryIoc container. This is called after the container is created and registered.</param>
+    /// <param name="withReactiveUIBuilder">An optional delegate to further configure the ReactiveUI builder. If provided, it is invoked after DryIoc
+    /// integration.</param>
+    /// <returns>The application builder instance, configured to use ReactiveUI with DryIoc.</returns>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="builder"/> or <paramref name="containerConfig"/> is null.</exception>
     public static AppBuilder UseReactiveUIWithDryIoc(this AppBuilder builder, Action<Container> containerConfig, Action<ReactiveUIBuilder>? withReactiveUIBuilder = null) =>
         builder switch
         {

src/ReactiveUI.Avalonia.DryIoc1.Tests/AvaloniaMixinsDryIocMoreTests.cs

@@ -31,7 +31,8 @@ public void UseReactiveUIWithDIContainer_Generic_Returns_Builder()
             builder,
             containerFactory: () => new Container(),
             containerConfig: _ => { },
-            dependencyResolverFactory: c => new DryIocDependencyResolver(c));
+            dependencyResolverFactory: c => new DryIocDependencyResolver(c),
+            _ => { });
 
         Assert.That(result, Is.SameAs(builder));
     }

src/ReactiveUI.Avalonia.DryIoc1.Tests/AvaloniaMixinsDryIocTests.cs

@@ -33,7 +33,8 @@ public void UseReactiveUIWithDIContainer_ThrowsOnNullBuilder()
                 builder!,
                 () => new Container(),
                 _ => { },
-                c => new DryIocDependencyResolver(c)));
+                c => new DryIocDependencyResolver(c),
+                _ => { }));
     }
 
     [Test]
@@ -45,7 +46,8 @@ public void UseReactiveUIWithDIContainer_ReturnsBuilder_NoThrow()
         var result = builder.UseReactiveUIWithDIContainer(
             containerFactory: () => container,
             containerConfig: _ => { },
-            dependencyResolverFactory: c => new DryIocDependencyResolver(c));
+            dependencyResolverFactory: c => new DryIocDependencyResolver(c),
+            _ => { });
 
         Assert.That(result, Is.SameAs(builder));
     }
@@ -56,11 +58,15 @@ public void DryIocDependencyResolver_Register_And_Resolve_WithAndWithoutContract
         var container = new Container();
         var resolver = new DryIocDependencyResolver(container);
 
-        resolver.Register(() => "a", typeof(string));
-        resolver.Register(() => "b", typeof(string), "x");
+        resolver.Register<string>(() => "a");
+        resolver.Register<string>(() => "b");
+        resolver.Register<string>(() => "c", "x");
 
-        var last = resolver.GetService(typeof(string));
-        Assert.That(last, Is.EqualTo("b"));
+        var noContract = resolver.GetService(typeof(string));
+        Assert.That(noContract, Is.EqualTo("b"));
+
+        var withContract = resolver.GetService(typeof(string), "x");
+        Assert.That(withContract, Is.EqualTo("c"));
 
         var all = resolver.GetServices(typeof(string)).ToArray();
         Assert.That(all, Does.Contain("a"));

src/ReactiveUI.Avalonia.Microsoft.Extensions.DependencyInjection/AvaloniaMixins.cs

@@ -13,63 +13,32 @@
 namespace ReactiveUI.Avalonia.Splat;
 
 /// <summary>
-/// Avalonia Mixins.
+/// Provides extension methods for integrating ReactiveUI with Avalonia applications using the Microsoft dependency
+/// resolver.
 /// </summary>
+/// <remarks>This static class contains mixin methods that enable the use of ReactiveUI in Avalonia applications
+/// with dependency injection support via Microsoft's IServiceCollection and IServiceProvider. These methods facilitate
+/// the configuration of services and the setup of the dependency resolver, streamlining the integration process for
+/// applications that leverage both Avalonia and ReactiveUI.</remarks>
 public static class AvaloniaMixins
 {
     /// <summary>
-    /// Uses the splat with microsoft dependency resolver.
+    /// Configures the application to use ReactiveUI with the Microsoft dependency injection system, allowing services
+    /// to be registered and resolved via IServiceCollection and IServiceProvider.
     /// </summary>
-    /// <param name="builder">The builder.</param>
-    /// <param name="containerConfig">The configure.</param>
-    /// <param name="withResolver">The get service provider.</param>
-    /// <returns>An App Builder.</returns>
-    public static AppBuilder UseReactiveUIWithMicrosoftDependencyResolver(this AppBuilder builder, Action<IServiceCollection> containerConfig, Action<IServiceProvider?>? withResolver = null) =>
-        builder switch
-        {
-            null => throw new ArgumentNullException(nameof(builder)),
-            _ => builder.UseReactiveUI().AfterPlatformServicesSetup(_ =>
-            {
-                if (AppLocator.CurrentMutable is null)
-                {
-                    return;
-                }
-
-#if NETSTANDARD
-                if (containerConfig is null)
-                {
-                    throw new ArgumentNullException(nameof(containerConfig));
-                }
-#else
-                ArgumentNullException.ThrowIfNull(containerConfig);
-#endif
-
-                IServiceCollection serviceCollection = new ServiceCollection();
-                serviceCollection.UseMicrosoftDependencyResolver();
-                AppLocator.CurrentMutable.RegisterConstant(serviceCollection);
-                RxSchedulers.MainThreadScheduler = AvaloniaScheduler.Instance;
-                containerConfig(serviceCollection);
-                var serviceProvider = serviceCollection.BuildServiceProvider();
-                serviceProvider.UseMicrosoftDependencyResolver();
-
-                if (withResolver is not null)
-                {
-                    withResolver(serviceProvider);
-                }
-            })
-        };
-
-    /// <summary>
-    /// Uses the splat with microsoft dependency resolver.
-    /// </summary>
-    /// <param name="builder">The builder.</param>
-    /// <param name="containerConfig">The configure.</param>
-    /// <param name="withResolver">The get service provider.</param>
-    /// <param name="withReactiveUIBuilder">The with reactive UI builder.</param>
-    /// <returns>
-    /// An App Builder.
-    /// </returns>
-    /// <exception cref="ArgumentNullException">builder.</exception>
+    /// <remarks>This method integrates ReactiveUI with Microsoft's dependency injection by registering
+    /// services in an IServiceCollection and building an IServiceProvider. It is typically used during application
+    /// startup to enable service resolution throughout the app. The optional delegates allow for advanced customization
+    /// of both the dependency resolver and ReactiveUI configuration.</remarks>
+    /// <param name="builder">The application builder used to configure the app. Cannot be null.</param>
+    /// <param name="containerConfig">A delegate that configures the IServiceCollection for dependency injection. This is used to register services
+    /// required by the application. Cannot be null.</param>
+    /// <param name="withResolver">An optional delegate invoked with the IServiceProvider after it has been built, allowing additional
+    /// configuration or initialization using the resolved services.</param>
+    /// <param name="withReactiveUIBuilder">An optional delegate invoked with the ReactiveUIBuilder to allow further customization of ReactiveUI
+    /// configuration.</param>
+    /// <returns>The application builder instance, configured to use ReactiveUI with Microsoft dependency injection.</returns>
+    /// <exception cref="ArgumentNullException">Thrown if builder or containerConfig is null.</exception>
     public static AppBuilder UseReactiveUIWithMicrosoftDependencyResolver(this AppBuilder builder, Action<IServiceCollection> containerConfig, Action<IServiceProvider?>? withResolver = null, Action<ReactiveUIBuilder>? withReactiveUIBuilder = null) =>
         builder switch
         {