feature: splat init checks for pre registrations

README.md

@@ -100,8 +100,6 @@ There are 2 parts to the locator design:
 * **Locator.Current** The property to use to **retrieve** services. Locator.Current is a static variable that can be set on startup, to adapt Splat to other DI/IoC frameworks. We're currently working from v7 onward to make it easier to use your DI/IoC framework of choice. (see below)
 * **Locator.CurrentMutable** The property to use to **register** services
 
-**Note:** Currently these properties point to the same object and you can use CurrentMutable to also GetServices, but this is not the intention and the interfaces may be adjusted in future to lock this down (and make it more obvious what the use cases are).
-
 To get a service:
 
 ```cs
@@ -132,6 +130,10 @@ Locator.CurrentMutable.RegisterLazySingleton(() => new LazyToaster(), typeof(ITo
 ### Dependency Resolver Packages
 For each of the provided dependency resolver adapters, there is a specific package that allows the service locator to be implemented by another ioc container.
 
+Please note: If you are adjusting behaviours of Splat by working with your custom container directly. Please read the relevant projects documentation on
+REPLACING the registration. If the container supports appending\ multiple registrations you may get undesired behaviours, such as the wrong logger factory
+being used.
+
 | Container | NuGet | Read Me
 |---------|-------|-------|
 | [Splat.Autofac][SplatAutofacNuGet] | [![SplatAutofacBadge]][SplatAutofacNuGet] | [Setup Autofac][SplatAutofacReadme]

src/Splat.Autofac/AutofacDependencyResolver.cs

@@ -63,6 +63,12 @@ public virtual IEnumerable<object> GetServices(Type serviceType, string contract
             }
         }
 
+        /// <inheritdoc />
+        public bool HasRegistration(Type serviceType)
+        {
+            return _componentContext.IsRegistered(serviceType);
+        }
+
         /// <summary>
         /// Register a function with the resolver which will generate a object
         /// for the specified service type.

src/Splat.DryIoc.Tests/DependencyResolverTests.cs

@@ -170,5 +170,37 @@ public void DryIocDependencyResolver_Should_Throw_If_ServiceRegistionCallback_Ca
 
             result.ShouldBeOfType<NotImplementedException>();
         }
+
+        /// <summary>
+        /// Check to ensure the correct logger is returned.
+        /// </summary>
+        /// <remarks>
+        /// Introduced for Splat #331.
+        /// </remarks>
+        [Fact]
+        public void DryIocDependencyResolver_Should_ReturnRegisteredLogger()
+        {
+            var c = new Container();
+            c.UseDryIocDependencyResolver();
+            c.Register<ILogger, ConsoleLogger>(ifAlreadyRegistered: IfAlreadyRegistered.Replace);
+            var d = Splat.Locator.Current.GetService<ILogger>();
+            Assert.IsType<ConsoleLogger>(d);
+        }
+
+        /// <summary>
+        /// Test that a pre-init logger isn't overriden.
+        /// </summary>
+        /// <remarks>
+        /// Introduced for Splat #331.
+        /// </remarks>
+        [Fact]
+        public void DryIocDependencyResolver_PreInit_Should_ReturnRegisteredLogger()
+        {
+            var c = new Container();
+            c.Register<ILogger, ConsoleLogger>();
+            c.UseDryIocDependencyResolver();
+            var d = Splat.Locator.Current.GetService<ILogger>();
+            Assert.IsType<ConsoleLogger>(d);
+        }
     }
 }

src/Splat.DryIoc/DryIocDependencyResolver.cs

@@ -5,6 +5,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using DryIoc;
 
 namespace Splat.DryIoc
@@ -39,16 +40,22 @@ public virtual IEnumerable<object> GetServices(Type serviceType, string contract
                 ? _container.ResolveMany(serviceType)
                 : _container.ResolveMany(serviceType, serviceKey: contract);
 
+        /// <inheritdoc />
+        public bool HasRegistration(Type serviceType)
+        {
+            return _container.GetServiceRegistrations().Any(x => x.ServiceType == serviceType);
+        }
+
         /// <inheritdoc />
         public virtual void Register(Func<object> factory, Type serviceType, string contract = null)
         {
             if (string.IsNullOrEmpty(contract))
             {
-                _container.UseInstance(serviceType, factory(), IfAlreadyRegistered.AppendNewImplementation);
+                _container.UseInstance(serviceType, factory(), IfAlreadyRegistered.Replace);
             }
             else
             {
-                _container.UseInstance(serviceType, factory(), IfAlreadyRegistered.AppendNewImplementation, serviceKey: contract);
+                _container.UseInstance(serviceType, factory(), IfAlreadyRegistered.Replace, serviceKey: contract);
             }
         }
 

src/Splat.Ninject/NinjectDependencyResolver.cs

@@ -38,6 +38,12 @@ public virtual IEnumerable<object> GetServices(Type serviceType, string contract
                 ? _kernel.GetAll(serviceType)
                 : _kernel.GetAll(serviceType, contract);
 
+        /// <inheritdoc />
+        public bool HasRegistration(Type serviceType)
+        {
+            return _kernel.CanResolve(serviceType);
+        }
+
         /// <inheritdoc />
         public virtual void Register(Func<object> factory, Type serviceType, string contract = null) =>
             _kernel.Bind(serviceType).ToMethod(_ => factory());

src/Splat.SimpleInjector/SimpleInjectorDependencyResolver.cs

@@ -5,6 +5,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using SimpleInjector;
 
 namespace Splat.SimpleInjector
@@ -27,12 +28,21 @@ public SimpleInjectorDependencyResolver(Container container)
         }
 
         /// <inheritdoc />
-        public object GetService(Type serviceType, string contract = null) => _container.GetInstance(serviceType);
+        public object GetService(Type serviceType, string contract = null)
+        {
+            return _container.GetInstance(serviceType);
+        }
 
         /// <inheritdoc />
         public IEnumerable<object> GetServices(Type serviceType, string contract = null) =>
             _container.GetAllInstances(serviceType);
 
+        /// <inheritdoc />
+        public bool HasRegistration(Type serviceType)
+        {
+            return _container.GetCurrentRegistrations().Any(x => x.ServiceType == serviceType);
+        }
+
         /// <inheritdoc />
         public void Register(Func<object> factory, Type serviceType, string contract = null) =>
             _container.Register(serviceType, factory);

src/Splat.Tests/API/ApiApprovalTests.SplatProject.net472.approved.txt

@@ -217,6 +217,7 @@ namespace Splat
         protected virtual void Dispose(bool isDisposing) { }
         public object GetService(System.Type serviceType, string contract = null) { }
         public System.Collections.Generic.IEnumerable<object> GetServices(System.Type serviceType, string contract = null) { }
+        public bool HasRegistration(System.Type serviceType) { }
         public void Register(System.Func<object> factory, System.Type serviceType, string contract = null) { }
         public System.IDisposable ServiceRegistrationCallback(System.Type serviceType, string contract, System.Action<System.IDisposable> callback) { }
         public void UnregisterAll(System.Type serviceType, string contract = null) { }
@@ -440,6 +441,7 @@ namespace Splat
     }
     public interface IMutableDependencyResolver
     {
+        bool HasRegistration(System.Type serviceType);
         void Register(System.Func<object> factory, System.Type serviceType, string contract = null);
         System.IDisposable ServiceRegistrationCallback(System.Type serviceType, string contract, System.Action<System.IDisposable> callback);
         void UnregisterAll(System.Type serviceType, string contract = null);
@@ -689,6 +691,7 @@ namespace Splat
         public Splat.ModernDependencyResolver Duplicate() { }
         public object GetService(System.Type serviceType, string contract = null) { }
         public System.Collections.Generic.IEnumerable<object> GetServices(System.Type serviceType, string contract = null) { }
+        public bool HasRegistration(System.Type serviceType) { }
         public void Register(System.Func<object> factory, System.Type serviceType, string contract = null) { }
         public System.IDisposable ServiceRegistrationCallback(System.Type serviceType, string contract, System.Action<System.IDisposable> callback) { }
         public void UnregisterAll(System.Type serviceType, string contract = null) { }

src/Splat.Tests/API/ApiApprovalTests.SplatProject.netcoreapp2.1.approved.txt

@@ -206,6 +206,7 @@ namespace Splat
         protected virtual void Dispose(bool isDisposing) { }
         public object GetService(System.Type serviceType, string contract = null) { }
         public System.Collections.Generic.IEnumerable<object> GetServices(System.Type serviceType, string contract = null) { }
+        public bool HasRegistration(System.Type serviceType) { }
         public void Register(System.Func<object> factory, System.Type serviceType, string contract = null) { }
         public System.IDisposable ServiceRegistrationCallback(System.Type serviceType, string contract, System.Action<System.IDisposable> callback) { }
         public void UnregisterAll(System.Type serviceType, string contract = null) { }
@@ -429,6 +430,7 @@ namespace Splat
     }
     public interface IMutableDependencyResolver
     {
+        bool HasRegistration(System.Type serviceType);
         void Register(System.Func<object> factory, System.Type serviceType, string contract = null);
         System.IDisposable ServiceRegistrationCallback(System.Type serviceType, string contract, System.Action<System.IDisposable> callback);
         void UnregisterAll(System.Type serviceType, string contract = null);
@@ -678,6 +680,7 @@ namespace Splat
         public Splat.ModernDependencyResolver Duplicate() { }
         public object GetService(System.Type serviceType, string contract = null) { }
         public System.Collections.Generic.IEnumerable<object> GetServices(System.Type serviceType, string contract = null) { }
+        public bool HasRegistration(System.Type serviceType) { }
         public void Register(System.Func<object> factory, System.Type serviceType, string contract = null) { }
         public System.IDisposable ServiceRegistrationCallback(System.Type serviceType, string contract, System.Action<System.IDisposable> callback) { }
         public void UnregisterAll(System.Type serviceType, string contract = null) { }

src/Splat.Tests/API/ApiApprovalTests.SplatProject.netcoreapp3.0.approved.txt

@@ -217,6 +217,7 @@ namespace Splat
         protected virtual void Dispose(bool isDisposing) { }
         public object GetService(System.Type serviceType, string contract = null) { }
         public System.Collections.Generic.IEnumerable<object> GetServices(System.Type serviceType, string contract = null) { }
+        public bool HasRegistration(System.Type serviceType) { }
         public void Register(System.Func<object> factory, System.Type serviceType, string contract = null) { }
         public System.IDisposable ServiceRegistrationCallback(System.Type serviceType, string contract, System.Action<System.IDisposable> callback) { }
         public void UnregisterAll(System.Type serviceType, string contract = null) { }
@@ -440,6 +441,7 @@ namespace Splat
     }
     public interface IMutableDependencyResolver
     {
+        bool HasRegistration(System.Type serviceType);
         void Register(System.Func<object> factory, System.Type serviceType, string contract = null);
         System.IDisposable ServiceRegistrationCallback(System.Type serviceType, string contract, System.Action<System.IDisposable> callback);
         void UnregisterAll(System.Type serviceType, string contract = null);
@@ -689,6 +691,7 @@ namespace Splat
         public Splat.ModernDependencyResolver Duplicate() { }
         public object GetService(System.Type serviceType, string contract = null) { }
         public System.Collections.Generic.IEnumerable<object> GetServices(System.Type serviceType, string contract = null) { }
+        public bool HasRegistration(System.Type serviceType) { }
         public void Register(System.Func<object> factory, System.Type serviceType, string contract = null) { }
         public System.IDisposable ServiceRegistrationCallback(System.Type serviceType, string contract, System.Action<System.IDisposable> callback) { }
         public void UnregisterAll(System.Type serviceType, string contract = null) { }

src/Splat/ServiceLocation/DependencyResolverMixins.cs

@@ -162,13 +162,38 @@ public static void UnregisterAll<T>(this IMutableDependencyResolver resolver, st
         /// <param name="resolver">The resolver to register the needed service types against.</param>
         public static void InitializeSplat(this IMutableDependencyResolver resolver)
         {
-            resolver.Register(() => new DefaultLogManager(), typeof(ILogManager));
-            resolver.RegisterConstant(new DebugLogger(), typeof(ILogger));
+            RegisterDefaultLogManager(resolver);
+            RegisterLogger(resolver);
+#if !NETSTANDARD
+            RegisterPlatformBitmapLoader(resolver);
+#endif
+        }
+
+        private static void RegisterDefaultLogManager(IMutableDependencyResolver resolver)
+        {
+            if (!resolver.HasRegistration(typeof(ILogManager)))
+            {
+                resolver.Register(() => new DefaultLogManager(), typeof(ILogManager));
+            }
+        }
+
+        private static void RegisterLogger(IMutableDependencyResolver resolver)
+        {
+            if (!resolver.HasRegistration(typeof(ILogger)))
+            {
+                resolver.RegisterConstant(new DebugLogger(), typeof(ILogger));
+            }
+        }
 
 #if !NETSTANDARD
+        private static void RegisterPlatformBitmapLoader(IMutableDependencyResolver resolver)
+        {
             // not supported in netstandard2.0
-            resolver.RegisterLazySingleton(() => new PlatformBitmapLoader(), typeof(IBitmapLoader));
-#endif
+            if (!resolver.HasRegistration(typeof(IBitmapLoader)))
+            {
+                resolver.RegisterLazySingleton(() => new PlatformBitmapLoader(), typeof(IBitmapLoader));
+            }
         }
+#endif
     }
 }

src/Splat/ServiceLocation/FuncDependencyResolver.cs

@@ -60,6 +60,12 @@ public IEnumerable<object> GetServices(Type serviceType, string contract = null)
             return _innerGetServices(serviceType, contract);
         }
 
+        /// <inheritdoc />
+        public bool HasRegistration(Type serviceType)
+        {
+            return _innerGetServices(serviceType, null) != null;
+        }
+
         /// <inheritdoc />
         public void Register(Func<object> factory, Type serviceType, string contract = null)
         {

src/Splat/ServiceLocation/IMutableDependencyResolver.cs

@@ -12,6 +12,13 @@ namespace Splat
     /// </summary>
     public interface IMutableDependencyResolver
     {
+        /// <summary>
+        /// Check to see if a resolvers has a registration for a type.
+        /// </summary>
+        /// <param name="serviceType">The type to check for registration.</param>
+        /// <returns>Whether there is a registration for the type.</returns>
+        bool HasRegistration(Type serviceType);
+
         /// <summary>
         /// Register a function with the resolver which will generate a object
         /// for the specified service type.

src/Splat/ServiceLocation/ModernDependencyResolver.cs

@@ -49,6 +49,13 @@ protected ModernDependencyResolver(Dictionary<Tuple<Type, string>, List<Func<obj
             _callbackRegistry = new Dictionary<Tuple<Type, string>, List<Action<IDisposable>>>();
         }
 
+        /// <inheritdoc />
+        public bool HasRegistration(Type serviceType)
+        {
+            var pair = Tuple.Create(serviceType, string.Empty);
+            return _registry.ContainsKey(pair);
+        }
+
         /// <inheritdoc />
         public void Register(Func<object> factory, Type serviceType, string contract = null)
         {