Allow configuring current UI framework to avoid exceptions during dependency registrations

src/ReactiveUI.Tests/Resolvers/DependencyResolverTests.cs

@@ -28,7 +28,7 @@ public void AllDefaultServicesShouldBeRegistered()
         {
             using (_resolver.WithResolver())
             {
-                foreach (var shouldRegistered in GetServicesThatShouldBeRegistered())
+                foreach (var shouldRegistered in GetServicesThatShouldBeRegistered(DependencyResolverMixins.DefaultRegistrationNamespaces))
                 {
                     IEnumerable<object> resolvedServices = _resolver.GetServices(shouldRegistered.Key);
                     Assert.Equal(shouldRegistered.Value.Count, resolvedServices.Count());
@@ -41,12 +41,58 @@ public void AllDefaultServicesShouldBeRegistered()
             }
         }
 
+        [Fact]
+        public void AllDefaultServicesShouldBeRegisteredPerRegistrationNamespace()
+        {
+            using (_resolver.WithResolver())
+            {
+                var registrationNamespaces = new[] { DependencyResolverMixins.RegistrationNamespace.Wpf };
+
+                DependencyResolverMixins.SetRegistrationNamespaces(registrationNamespaces);
+
+                foreach (var shouldRegistered in GetServicesThatShouldBeRegistered(registrationNamespaces))
+                {
+                    IEnumerable<object> resolvedServices = _resolver.GetServices(shouldRegistered.Key);
+                    Assert.Equal(shouldRegistered.Value.Count, resolvedServices.Count());
+                    foreach (Type implementationType in shouldRegistered.Value)
+                    {
+                        var isRegistered = resolvedServices.Any(rs => rs.GetType() == implementationType);
+                        Assert.Equal(true, isRegistered);
+                    }
+                }
+
+                DependencyResolverMixins.SetRegistrationNamespaces(DependencyResolverMixins.DefaultRegistrationNamespaces.ToArray());
+            }
+        }
+
         public void Dispose()
         {
             _resolver?.Dispose();
         }
 
-        private static Dictionary<Type, List<Type>> GetServicesThatShouldBeRegistered()
+        private static IEnumerable<string> GetServiceRegistrationTypeNames(
+            IEnumerable<DependencyResolverMixins.RegistrationNamespace> registrationNamespaces)
+        {
+            foreach (DependencyResolverMixins.RegistrationNamespace registrationNamespace in registrationNamespaces)
+            {
+                if (registrationNamespace == DependencyResolverMixins.RegistrationNamespace.Wpf)
+                {
+                    yield return "ReactiveUI.Wpf.Registrations, ReactiveUI.Wpf";
+                }
+
+                if (registrationNamespace == DependencyResolverMixins.RegistrationNamespace.XamForms)
+                {
+                    yield return "ReactiveUI.XamForms.Registrations, ReactiveUI.XamForms";
+                }
+
+                if (registrationNamespace == DependencyResolverMixins.RegistrationNamespace.Winforms)
+                {
+                    yield return "ReactiveUI.Winforms.Registrations, ReactiveUI.Winforms";
+                }
+            }
+        }
+
+        private static Dictionary<Type, List<Type>> GetServicesThatShouldBeRegistered(IReadOnlyList<DependencyResolverMixins.RegistrationNamespace> onlyNamespaces)
         {
             Dictionary<Type, List<Type>> serviceTypeToImplementationTypes = new Dictionary<Type, List<Type>>();
 
@@ -72,12 +118,7 @@ private static Dictionary<Type, List<Type>> GetServicesThatShouldBeRegistered()
                 implementationTypes.Add(factory().GetType());
             });
 
-            var typeNames = new[]
-            {
-                "ReactiveUI.XamForms.Registrations, ReactiveUI.XamForms",
-                "ReactiveUI.Winforms.Registrations, ReactiveUI.Winforms",
-                "ReactiveUI.Wpf.Registrations, ReactiveUI.Wpf"
-            };
+            var typeNames = GetServiceRegistrationTypeNames(onlyNamespaces);
 
             typeNames.ForEach(typeName => GetRegistrationsForPlatform(typeName, serviceTypeToImplementationTypes));
 

src/ReactiveUI/Mixins/DependencyResolverMixins.cs

@@ -4,6 +4,7 @@
 // See the LICENSE file in the project root for full license information.
 
 using System;
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.IO;
@@ -19,6 +20,73 @@ namespace ReactiveUI
     /// </summary>
     public static class DependencyResolverMixins
     {
+        private static IReadOnlyList<RegistrationNamespace> defaultRegistrationNamespaces =
+            (RegistrationNamespace[])Enum.GetValues(typeof(RegistrationNamespace));
+
+        private static HashSet<RegistrationNamespace> registrationNamespacesToInitialize =
+            new HashSet<RegistrationNamespace>(defaultRegistrationNamespaces);
+
+        /// <summary>
+        /// Platforms or other registration namespaces for the dependency resolver to consider when initializing.
+        /// </summary>
+        public enum RegistrationNamespace
+        {
+            /// <summary>
+            /// Xamarin Forms
+            /// </summary>
+            XamForms,
+
+            /// <summary>
+            /// Windows Forms
+            /// </summary>
+            Winforms,
+
+            /// <summary>
+            /// WPF
+            /// </summary>
+            Wpf,
+
+            /// <summary>
+            /// Uno
+            /// </summary>
+            Uno,
+
+            /// <summary>
+            /// Blazor
+            /// </summary>
+            Blazor,
+
+            /// <summary>
+            /// Splat.Drawing
+            /// </summary>
+            Drawing
+        }
+
+        /// <summary>
+        /// Gets the default registration namespaces for the dependency resolver to consider, consisting of all registration namespaces.
+        /// </summary>
+        public static IReadOnlyList<RegistrationNamespace> DefaultRegistrationNamespaces =>
+            defaultRegistrationNamespaces;
+
+        // The reason SetRegistrationNamespaces is a separate method and not a parameter to InitializeReactiveUI
+        // is because InitializeReactiveUI is called from within the RxApp static constructor, and there's no
+        // way to directly pass it parameters.
+
+        /// <summary>
+        /// This method allows you to initialize which platforms <see cref="InitializeReactiveUI"/>
+        /// attempts to discover registrations for. If this method is not called, all platforms are assumed.
+        /// </summary>
+        /// <remarks>Call this before <see cref="InitializeReactiveUI"/>.</remarks>
+        /// <param name="registrationNamespaces">Which platforms to use.</param>
+        public static void SetRegistrationNamespaces(params RegistrationNamespace[] registrationNamespaces)
+        {
+            registrationNamespacesToInitialize.Clear();
+            foreach (var platform in registrationNamespaces)
+            {
+                registrationNamespacesToInitialize.Add(platform);
+            }
+        }
+
         /// <summary>
         /// This method allows you to initialize resolvers with the default
         /// ReactiveUI types. All resolvers used as the default
@@ -28,16 +96,22 @@ public static class DependencyResolverMixins
         [SuppressMessage("Globalization", "CA1307: operator could change based on locale settings", Justification = "Replace() does not have third parameter on all platforms")]
         public static void InitializeReactiveUI(this IMutableDependencyResolver resolver)
         {
-            var extraNs = new[]
+            var possibleNamespaces = new Dictionary<RegistrationNamespace, string>
             {
-                "ReactiveUI.XamForms",
-                "ReactiveUI.Winforms",
-                "ReactiveUI.Wpf",
-                "ReactiveUI.Uno",
-                "ReactiveUI.Blazor",
-                "ReactiveUI.Drawing"
+                { RegistrationNamespace.XamForms, "ReactiveUI.XamForms" },
+                { RegistrationNamespace.Winforms, "ReactiveUI.Winforms" },
+                { RegistrationNamespace.Wpf, "ReactiveUI.Wpf" },
+                { RegistrationNamespace.Uno, "ReactiveUI.Uno" },
+                { RegistrationNamespace.Blazor, "ReactiveUI.Blazor" },
+                { RegistrationNamespace.Drawing, "ReactiveUI.Drawing" }
             };
 
+            var extraNs =
+                possibleNamespaces
+                    .Where(kvp => registrationNamespacesToInitialize.Contains(kvp.Key))
+                    .Select(kvp => kvp.Value)
+                    .ToArray();
+
             // Set up the built-in registration
             new Registrations().Register((f, t) => resolver.RegisterConstant(f(), t));
             new PlatformRegistrations().Register((f, t) => resolver.RegisterConstant(f(), t));