diff --git a/src/Splat.Common.Test/IViewModelOne.cs b/src/Splat.Common.Test/IViewModelOne.cs
new file mode 100644
index 000000000..d0de11aa5
--- /dev/null
+++ b/src/Splat.Common.Test/IViewModelOne.cs
@@ -0,0 +1,14 @@
+// Copyright (c) 2021 .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.
+
+namespace Splat.Common.Test
+{
+    /// <summary>
+    /// Interface for ViewModelOne.
+    /// </summary>
+    public interface IViewModelOne
+    {
+    }
+}
diff --git a/src/Splat.Common.Test/ViewModelOne.cs b/src/Splat.Common.Test/ViewModelOne.cs
index 56babd24d..f2da11f66 100644
--- a/src/Splat.Common.Test/ViewModelOne.cs
+++ b/src/Splat.Common.Test/ViewModelOne.cs
@@ -8,7 +8,13 @@ namespace Splat.Common.Test
     /// <summary>
     /// View Model One.
     /// </summary>
-    public class ViewModelOne
+    public class ViewModelOne : IViewModelOne
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ViewModelOne"/> class.
+        /// </summary>
+        public ViewModelOne()
+        {
+        }
     }
 }
diff --git a/src/Splat.Microsoft.Extensions.DependencyInjection/MicrosoftDependencyResolver.cs b/src/Splat.Microsoft.Extensions.DependencyInjection/MicrosoftDependencyResolver.cs
index 7a393e659..b7348d478 100644
--- a/src/Splat.Microsoft.Extensions.DependencyInjection/MicrosoftDependencyResolver.cs
+++ b/src/Splat.Microsoft.Extensions.DependencyInjection/MicrosoftDependencyResolver.cs
@@ -115,7 +115,7 @@ public virtual IEnumerable<object> GetServices(Type serviceType, string? contrac
                 services = dic?
                     .GetFactories(contract)
                     .Select(f => f())
-                    ?? Enumerable.Empty<object>();
+                    ?? Array.Empty<object>();
             }
 
             return services;
@@ -370,7 +370,7 @@ public bool TryRemoveContract(string contract) =>
             public IEnumerable<Func<object>> GetFactories(string contract) =>
                 _dictionary.TryGetValue(contract, out var collection)
                 ? collection ?? Enumerable.Empty<Func<object>>()
-                : Enumerable.Empty<Func<object>>();
+                : Array.Empty<Func<object>>();
 
             public void AddFactory(string contract, Func<object> factory) =>
                 _dictionary.AddOrUpdate(contract, _ => new List<Func<object>> { factory }, (_, list) =>
diff --git a/src/Splat.SimpleInjector/SimpleInjectorDependencyResolver.cs b/src/Splat.SimpleInjector/SimpleInjectorDependencyResolver.cs
index 1d88f6161..92452ed7a 100644
--- a/src/Splat.SimpleInjector/SimpleInjectorDependencyResolver.cs
+++ b/src/Splat.SimpleInjector/SimpleInjectorDependencyResolver.cs
@@ -66,7 +66,7 @@ public IEnumerable<object> GetServices(Type serviceType, string? contract = null
                     return new[] { registration.GetInstance() };
                 }
 
-                return Enumerable.Empty<object>();
+                return Array.Empty<object>();
             }
         }
 
diff --git a/src/Splat.Tests/API/ApiApprovalTests.SplatProject.net5.0.approved.txt b/src/Splat.Tests/API/ApiApprovalTests.SplatProject.net5.0.approved.txt
index c11747f59..f53faf455 100644
--- a/src/Splat.Tests/API/ApiApprovalTests.SplatProject.net5.0.approved.txt
+++ b/src/Splat.Tests/API/ApiApprovalTests.SplatProject.net5.0.approved.txt
@@ -163,6 +163,8 @@ namespace Splat
         public static System.Collections.Generic.IEnumerable<T> GetServices<T>(this Splat.IReadonlyDependencyResolver resolver, string? contract = null) { }
         public static void Register<T>(this Splat.IMutableDependencyResolver resolver, System.Func<T> factory, string? contract = null)
             where T :  notnull { }
+        public static void Register<TAs, T>(this Splat.IMutableDependencyResolver resolver, string? contract = null)
+            where T : new() { }
         public static void RegisterConstant(this Splat.IMutableDependencyResolver resolver, object value, System.Type serviceType, string? contract = null) { }
         public static void RegisterConstant<T>(this Splat.IMutableDependencyResolver resolver, T value, string? contract = null)
             where T :  notnull { }
@@ -568,6 +570,23 @@ namespace Splat
         public static System.Tuple<System.Drawing.RectangleF, System.Drawing.RectangleF> DivideWithPadding(this System.Drawing.RectangleF value, float sliceAmount, float padding, Splat.RectEdge fromEdge) { }
         public static System.Drawing.RectangleF InvertWithin(this System.Drawing.RectangleF value, System.Drawing.RectangleF containingRect) { }
     }
+    public static class ResolverMixins
+    {
+        public static Splat.IMutableDependencyResolver RegisterAnd<T>(this Splat.IMutableDependencyResolver resolver, string? contract = null)
+            where T : new() { }
+        public static Splat.IMutableDependencyResolver RegisterAnd<T>(this Splat.IMutableDependencyResolver resolver, System.Func<T> factory, string? contract = null) { }
+        public static Splat.IMutableDependencyResolver RegisterAnd<TAs, T>(this Splat.IMutableDependencyResolver resolver, string? contract = null)
+            where T : new() { }
+        public static Splat.IMutableDependencyResolver RegisterAnd<TAs, T>(this Splat.IMutableDependencyResolver resolver, System.Func<T> factory, string? contract = null) { }
+        public static Splat.IMutableDependencyResolver RegisterConstantAnd(this Splat.IMutableDependencyResolver resolver, object value, System.Type serviceType, string? contract = null) { }
+        public static Splat.IMutableDependencyResolver RegisterConstantAnd<T>(this Splat.IMutableDependencyResolver resolver, string? contract = null)
+            where T : new() { }
+        public static Splat.IMutableDependencyResolver RegisterConstantAnd<T>(this Splat.IMutableDependencyResolver resolver, T value, string? contract = null) { }
+        public static Splat.IMutableDependencyResolver RegisterLazySingletonAnd(this Splat.IMutableDependencyResolver resolver, System.Func<object> valueFactory, System.Type serviceType, string? contract = null) { }
+        public static Splat.IMutableDependencyResolver RegisterLazySingletonAnd<T>(this Splat.IMutableDependencyResolver resolver, string? contract = null)
+            where T : new() { }
+        public static Splat.IMutableDependencyResolver RegisterLazySingletonAnd<T>(this Splat.IMutableDependencyResolver resolver, System.Func<T> valueFactory, string? contract = null) { }
+    }
     public static class ServiceLocationInitialization
     {
         public static void InitializeSplat(this Splat.IMutableDependencyResolver resolver) { }
diff --git a/src/Splat.Tests/API/ApiApprovalTests.SplatProject.netcoreapp3.1.approved.txt b/src/Splat.Tests/API/ApiApprovalTests.SplatProject.netcoreapp3.1.approved.txt
index 2b7497bd6..fee459022 100644
--- a/src/Splat.Tests/API/ApiApprovalTests.SplatProject.netcoreapp3.1.approved.txt
+++ b/src/Splat.Tests/API/ApiApprovalTests.SplatProject.netcoreapp3.1.approved.txt
@@ -163,6 +163,8 @@ namespace Splat
         public static System.Collections.Generic.IEnumerable<T> GetServices<T>(this Splat.IReadonlyDependencyResolver resolver, string? contract = null) { }
         public static void Register<T>(this Splat.IMutableDependencyResolver resolver, System.Func<T> factory, string? contract = null)
             where T :  notnull { }
+        public static void Register<TAs, T>(this Splat.IMutableDependencyResolver resolver, string? contract = null)
+            where T : new() { }
         public static void RegisterConstant(this Splat.IMutableDependencyResolver resolver, object value, System.Type serviceType, string? contract = null) { }
         public static void RegisterConstant<T>(this Splat.IMutableDependencyResolver resolver, T value, string? contract = null)
             where T :  notnull { }
@@ -568,6 +570,23 @@ namespace Splat
         public static System.Tuple<System.Drawing.RectangleF, System.Drawing.RectangleF> DivideWithPadding(this System.Drawing.RectangleF value, float sliceAmount, float padding, Splat.RectEdge fromEdge) { }
         public static System.Drawing.RectangleF InvertWithin(this System.Drawing.RectangleF value, System.Drawing.RectangleF containingRect) { }
     }
+    public static class ResolverMixins
+    {
+        public static Splat.IMutableDependencyResolver RegisterAnd<T>(this Splat.IMutableDependencyResolver resolver, string? contract = null)
+            where T : new() { }
+        public static Splat.IMutableDependencyResolver RegisterAnd<T>(this Splat.IMutableDependencyResolver resolver, System.Func<T> factory, string? contract = null) { }
+        public static Splat.IMutableDependencyResolver RegisterAnd<TAs, T>(this Splat.IMutableDependencyResolver resolver, string? contract = null)
+            where T : new() { }
+        public static Splat.IMutableDependencyResolver RegisterAnd<TAs, T>(this Splat.IMutableDependencyResolver resolver, System.Func<T> factory, string? contract = null) { }
+        public static Splat.IMutableDependencyResolver RegisterConstantAnd(this Splat.IMutableDependencyResolver resolver, object value, System.Type serviceType, string? contract = null) { }
+        public static Splat.IMutableDependencyResolver RegisterConstantAnd<T>(this Splat.IMutableDependencyResolver resolver, string? contract = null)
+            where T : new() { }
+        public static Splat.IMutableDependencyResolver RegisterConstantAnd<T>(this Splat.IMutableDependencyResolver resolver, T value, string? contract = null) { }
+        public static Splat.IMutableDependencyResolver RegisterLazySingletonAnd(this Splat.IMutableDependencyResolver resolver, System.Func<object> valueFactory, System.Type serviceType, string? contract = null) { }
+        public static Splat.IMutableDependencyResolver RegisterLazySingletonAnd<T>(this Splat.IMutableDependencyResolver resolver, string? contract = null)
+            where T : new() { }
+        public static Splat.IMutableDependencyResolver RegisterLazySingletonAnd<T>(this Splat.IMutableDependencyResolver resolver, System.Func<T> valueFactory, string? contract = null) { }
+    }
     public static class ServiceLocationInitialization
     {
         public static void InitializeSplat(this Splat.IMutableDependencyResolver resolver) { }
diff --git a/src/Splat.Tests/LocatorSerialRegisterTests.cs b/src/Splat.Tests/LocatorSerialRegisterTests.cs
new file mode 100644
index 000000000..ca5f7f1f7
--- /dev/null
+++ b/src/Splat.Tests/LocatorSerialRegisterTests.cs
@@ -0,0 +1,370 @@
+// Copyright (c) 2021 .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;
+
+using FluentAssertions;
+using Splat.Tests.Mocks;
+using Xunit;
+
+namespace Splat.Tests
+{
+    /// <summary>
+    /// Tests to confirm that the locator is working.
+    /// </summary>
+    public class LocatorSerialRegisterTests
+    {
+        /// <summary>
+        /// Tests if the registrations are not empty on no external registrations.
+        /// </summary>
+        [Fact]
+        public void InitializeSplat_RegistrationsNotEmptyNoRegistrations()
+        {
+            // this is using the internal constructor
+            var testLocator = new InternalLocator();
+            var logManager = testLocator.Current.GetService(typeof(ILogManager));
+            var logger = testLocator.Current.GetService(typeof(ILogger));
+
+            Assert.NotNull(logManager);
+            Assert.NotNull(logger);
+
+            Assert.IsType<DebugLogger>(logger);
+            Assert.IsType<DefaultLogManager>(logManager);
+        }
+
+        /// <summary>
+        /// Tests that if we use a contract it returns null entries for that type.
+        /// </summary>
+        [Fact]
+        public void InitializeSplat_ContractRegistrationsNullNoRegistration()
+        {
+            var testLocator = new InternalLocator();
+            var logManager = testLocator.Current.GetService(typeof(ILogManager), "test");
+            var logger = testLocator.Current.GetService(typeof(ILogger), "test");
+
+            Assert.Null(logManager);
+            Assert.Null(logger);
+        }
+
+        /// <summary>
+        /// Tests using the extension methods that the retrieving of the default InitializeSplat() still work.
+        /// </summary>
+        [Fact]
+        public void InitializeSplat_ExtensionMethodsNotNull()
+        {
+            var testLocator = new InternalLocator();
+            var logManager = testLocator.Current.GetService<ILogManager>();
+            var logger = testLocator.Current.GetService<ILogger>();
+
+            Assert.NotNull(logManager);
+            Assert.NotNull(logger);
+
+            Assert.IsType<DebugLogger>(logger);
+            Assert.IsType<DefaultLogManager>(logManager);
+        }
+
+        /// <summary>
+        /// Tests to make sure that the locator's fire the resolver changed notifications.
+        /// </summary>
+        [Fact]
+        public void WithoutSuppress_NotificationsHappen()
+        {
+            var testLocator = new InternalLocator();
+            var originalLocator = testLocator.Internal;
+
+            int numberNotifications = 0;
+            Action notificationAction = () => numberNotifications++;
+
+            testLocator.RegisterResolverCallbackChanged(notificationAction);
+
+            testLocator.SetLocator(new ModernDependencyResolver());
+            testLocator.SetLocator(new ModernDependencyResolver());
+
+            // 2 for the changes, 1 for the callback being immediately called.
+            Assert.Equal(3, numberNotifications);
+
+            testLocator.SetLocator(originalLocator);
+        }
+
+        /// <summary>
+        /// Tests to make sure that the locator's don't fire the resolver changed notifications if they are suppressed.
+        /// </summary>
+        [Fact]
+        public void WithSuppression_NotificationsDontHappen()
+        {
+            var testLocator = new InternalLocator();
+            var originalLocator = testLocator.Internal;
+
+            using (testLocator.SuppressResolverCallbackChangedNotifications())
+            {
+                int numberNotifications = 0;
+                Action notificationAction = () => numberNotifications++;
+
+                testLocator.RegisterResolverCallbackChanged(notificationAction);
+
+                testLocator.SetLocator(new ModernDependencyResolver());
+                testLocator.SetLocator(new ModernDependencyResolver());
+
+                Assert.Equal(0, numberNotifications);
+
+                testLocator.SetLocator(originalLocator);
+            }
+        }
+
+        /// <summary>
+        /// Tests to make sure that the locator's don't fire the resolver changed notifications if we use WithResolver().
+        /// </summary>
+        [Fact]
+        public void WithResolver_NotificationsDontHappen()
+        {
+            int numberNotifications = 0;
+            Action notificationAction = () => numberNotifications++;
+
+            var testLocator = new InternalLocator();
+            testLocator.RegisterResolverCallbackChanged(notificationAction);
+
+            using (testLocator.Internal.WithResolver())
+            {
+                using (testLocator.Internal.WithResolver())
+                {
+                }
+            }
+
+            // 1 due to the fact the callback is called when we register.
+            Assert.Equal(1, numberNotifications);
+        }
+
+        /// <summary>
+        /// Tests to make sure that the locator's don't fire the resolver changed notifications if we use WithResolver().
+        /// </summary>
+        [Fact]
+        public void WithResolver_NotificationsNotSuppressedHappen()
+        {
+            int numberNotifications = 0;
+            Action notificationAction = () => numberNotifications++;
+
+            Locator.RegisterResolverCallbackChanged(notificationAction);
+
+            using (Locator.GetLocator().WithResolver(false))
+            {
+                using (Locator.GetLocator().WithResolver(false))
+                {
+                }
+            }
+
+            // 1 due to the fact the callback is called when we register.
+            // 2 for, 1 for change to resolver, 1 for change back
+            // 2 for, 1 for change to resolver, 1 for change back
+            Assert.Equal(5, numberNotifications);
+        }
+
+        /// <summary>
+        /// Tests to make sure that the unregister all functions correctly.
+        /// This is a test when there are values registered.
+        /// </summary>
+        [Fact]
+        public void ModernDependencyResolver_UnregisterAll_WithValuesWorks()
+        {
+            var currentMutable = new ModernDependencyResolver();
+
+            var dummy1 = new DummyObjectClass1();
+            var dummy2 = new DummyObjectClass2();
+            var dummy3 = new DummyObjectClass3();
+
+            var testContracts = new[] { string.Empty, "test" };
+
+            foreach (var testContract in testContracts)
+            {
+                currentMutable.RegisterConstantAnd<IDummyInterface>(dummy1, testContract)
+                                .RegisterConstantAnd<IDummyInterface>(dummy2, testContract)
+                                .RegisterConstant<IDummyInterface>(dummy3, testContract);
+            }
+
+            foreach (var testContract in testContracts)
+            {
+                var items = currentMutable.GetServices<IDummyInterface>(testContract);
+
+                items.Should().BeEquivalentTo(new IDummyInterface[] { dummy1, dummy2, dummy3 });
+
+                currentMutable.UnregisterAll<IDummyInterface>(testContract);
+
+                items = currentMutable.GetServices<IDummyInterface>(testContract);
+
+                items.Should().BeEmpty();
+            }
+        }
+
+        /// <summary>
+        /// Tests to make sure that the unregister all functions correctly.
+        /// This is a test when there are values not registered.
+        /// </summary>
+        [Fact]
+        public void ModernDependencyResolver_UnregisterAll_NoValuesWorks()
+        {
+            var currentMutable = new ModernDependencyResolver();
+
+            var items = currentMutable.GetServices<IDummyInterface>();
+
+            items.Should().BeEmpty();
+
+            currentMutable.UnregisterAll<IDummyInterface>();
+
+            items = currentMutable.GetServices<IDummyInterface>();
+
+            items.Should().BeEmpty();
+        }
+
+        /// <summary>
+        /// Tests tomake sure that the unregister current functions correctly.
+        /// This is a test when there are values registered.
+        /// </summary>
+        [Fact]
+        public void ModernDependencyResolver_ConstantUnregisterCurrent_WithValuesWorks()
+        {
+            var dummy1 = new DummyObjectClass1();
+            var dummy2 = new DummyObjectClass2();
+            var dummy3 = new DummyObjectClass3();
+
+            var currentMutable = new ModernDependencyResolver();
+
+            var testContracts = new[] { string.Empty, "test" };
+
+            foreach (var testContract in testContracts)
+            {
+                currentMutable.RegisterConstantAnd<IDummyInterface>(dummy1, testContract)
+                                .RegisterConstantAnd<IDummyInterface>(dummy2, testContract)
+                                .RegisterConstant<IDummyInterface>(dummy3, testContract);
+            }
+
+            foreach (var testContract in testContracts)
+            {
+                var items = currentMutable.GetServices<IDummyInterface>(testContract);
+
+                items.Should().BeEquivalentTo(new IDummyInterface[] { dummy1, dummy2, dummy3 });
+
+                currentMutable.UnregisterCurrent<IDummyInterface>(testContract);
+
+                items = currentMutable.GetServices<IDummyInterface>(testContract);
+
+                items.Should().BeEquivalentTo(new IDummyInterface[] { dummy1, dummy2 });
+            }
+        }
+
+        /// <summary>
+        /// Tests tomake sure that the unregister current functions correctly.
+        /// This is a test when there are values registered.
+        /// </summary>
+        [Fact]
+        public void ModernDependencyResolver_UnregisterCurrent_WithValuesWorks()
+        {
+            var currentMutable = new ModernDependencyResolver();
+
+            var testContracts = new[] { string.Empty, "test" };
+
+            foreach (var testContract in testContracts)
+            {
+                currentMutable.RegisterAnd<IDummyInterface, DummyObjectClass1>(testContract)
+                                .RegisterAnd<IDummyInterface, DummyObjectClass2>(testContract)
+                                .Register<IDummyInterface, DummyObjectClass3>(testContract);
+            }
+
+            foreach (var testContract in testContracts)
+            {
+                var items = currentMutable.GetServices<IDummyInterface>(testContract);
+
+                items.Should().HaveCount(3);
+
+                currentMutable.UnregisterCurrent<IDummyInterface>(testContract);
+
+                items = currentMutable.GetServices<IDummyInterface>(testContract);
+
+                items.Should().HaveCount(2);
+            }
+        }
+
+        /// <summary>
+        /// Tests to make sure that the unregister all functions correctly.
+        /// This is a test when there are values not registered.
+        /// </summary>
+        [Fact]
+        public void ModernDependencyResolver_UnregisterCurrent_NoValuesWorks()
+        {
+            var currentMutable = new ModernDependencyResolver();
+            var items = currentMutable.GetServices<IDummyInterface>();
+
+            items.Should().BeEmpty();
+
+            currentMutable.UnregisterCurrent<IDummyInterface>();
+
+            items = currentMutable.GetServices<IDummyInterface>();
+
+            items.Should().BeEmpty();
+        }
+
+        /// <summary>
+        /// Tests to make sure that the unregister all functions correctly.
+        /// This is a test when there are values not registered.
+        /// </summary>
+        [Fact]
+        public void FuncDependencyResolver_UnregisterAll()
+        {
+            bool unregisterAllCalled = false;
+            Type type = null;
+            string contract = null;
+
+            var currentMutable = new FuncDependencyResolver(
+                (funcType, funcContract) => Array.Empty<object>(),
+                unregisterAll: (passedType, passedContract) =>
+                {
+                    unregisterAllCalled = true;
+                    contract = passedContract;
+                    type = passedType;
+                });
+
+            currentMutable.UnregisterAll<IDummyInterface>();
+            type.Should().Be(typeof(IDummyInterface));
+            contract.Should().BeNull();
+            unregisterAllCalled.Should().BeTrue();
+
+            unregisterAllCalled = false;
+            currentMutable.UnregisterAll<IEnableLogger>("test");
+            type.Should().Be(typeof(IEnableLogger));
+            contract.Should().Be("test");
+            unregisterAllCalled.Should().BeTrue();
+        }
+
+        /// <summary>
+        /// Tests tomake sure that the unregister current functions correctly.
+        /// This is a test when there are values registered.
+        /// </summary>
+        [Fact]
+        public void FuncDependencyResolver_UnregisterCurrent()
+        {
+            bool unregisterAllCalled = false;
+            Type type = null;
+            string contract = null;
+
+            var currentMutable = new FuncDependencyResolver(
+                (funcType, funcContract) => Array.Empty<object>(),
+                unregisterCurrent: (passedType, passedContract) =>
+                {
+                    unregisterAllCalled = true;
+                    contract = passedContract;
+                    type = passedType;
+                });
+
+            currentMutable.UnregisterCurrent<IDummyInterface>();
+            type.Should().Be(typeof(IDummyInterface));
+            contract.Should().BeNull();
+            unregisterAllCalled.Should().BeTrue();
+
+            unregisterAllCalled = false;
+            currentMutable.UnregisterCurrent<IEnableLogger>("test");
+            type.Should().Be(typeof(IEnableLogger));
+            contract.Should().Be("test");
+            unregisterAllCalled.Should().BeTrue();
+        }
+    }
+}
diff --git a/src/Splat.Tests/ServiceLocation/BaseDependencyResolverTests.cs b/src/Splat.Tests/ServiceLocation/BaseDependencyResolverTests.cs
index 1f4f036da..20516c2e6 100644
--- a/src/Splat.Tests/ServiceLocation/BaseDependencyResolverTests.cs
+++ b/src/Splat.Tests/ServiceLocation/BaseDependencyResolverTests.cs
@@ -6,6 +6,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using Splat.Common.Test;
 using Splat.NLog;
 using Xunit;
 
@@ -159,6 +160,57 @@ public void ILogManager_Resolvable()
             Assert.NotNull(lm);
         }
 
+        /// <summary>
+        /// Nulls the resolver tests.
+        /// </summary>
+        [Fact]
+        public void NullResolverTests()
+        {
+            IReadonlyDependencyResolver resolver = default;
+            IMutableDependencyResolver resolver1 = default;
+            IDependencyResolver resolver2 = default;
+            Assert.Throws<ArgumentNullException>(() => resolver.GetService<ILogManager>());
+            Assert.Throws<ArgumentNullException>(() => resolver.GetServices<ILogManager>());
+            Assert.Throws<ArgumentNullException>(() => resolver1.ServiceRegistrationCallback(typeof(ILogManager), (IDisposable d) => { d.Dispose(); }));
+            Assert.Throws<ArgumentNullException>(() => resolver2.WithResolver().Dispose());
+            Assert.Throws<ArgumentNullException>(() => resolver1.Register<ILogManager>(() => new DefaultLogManager()));
+            Assert.Throws<ArgumentNullException>(() => resolver1.RegisterConstant<ILogManager>(new DefaultLogManager()));
+            Assert.Throws<ArgumentNullException>(() => resolver1.RegisterLazySingleton(() => new DefaultLogManager(), typeof(ILogManager)));
+            Assert.Throws<ArgumentNullException>(() => resolver1.RegisterLazySingletonAnd(() => new DefaultLogManager(), typeof(ILogManager)));
+            Assert.Throws<ArgumentNullException>(() => resolver1.RegisterLazySingleton(() => new DefaultLogManager()));
+            Assert.Throws<ArgumentNullException>(() => resolver1.RegisterLazySingletonAnd<ViewModelOne>("eight"));
+            Assert.Throws<ArgumentNullException>(() => resolver1.RegisterLazySingletonAnd<DefaultLogManager>(() => new DefaultLogManager(), "seven"));
+            Assert.Throws<ArgumentNullException>(() => resolver1.UnregisterCurrent<ILogManager>());
+            Assert.Throws<ArgumentNullException>(() => resolver1.UnregisterAll<ILogManager>());
+            Assert.Throws<ArgumentNullException>(() => resolver1.RegisterAnd<ViewModelOne>());
+            Assert.Throws<ArgumentNullException>(() => resolver1.RegisterAnd(() => new DefaultLogManager()));
+            Assert.Throws<ArgumentNullException>(() => resolver1.RegisterAnd<IViewModelOne>(() => new ViewModelOne()));
+            Assert.Throws<ArgumentNullException>(() => resolver1.Register<IViewModelOne, ViewModelOne>());
+            Assert.Throws<ArgumentNullException>(() => resolver1.RegisterConstantAnd(new ViewModelOne()));
+            Assert.Throws<ArgumentNullException>(() => resolver1.RegisterConstantAnd(new ViewModelOne(), typeof(ViewModelOne)));
+            Assert.Throws<ArgumentNullException>(() => resolver1.RegisterConstantAnd<ViewModelOne>());
+        }
+
+        /// <summary>
+        /// Registers the and tests.
+        /// </summary>
+        [Fact]
+        public void RegisterAndTests()
+        {
+            var resolver = GetDependencyResolver();
+            Assert.Throws<ArgumentNullException>(() => resolver.RegisterAnd<IViewModelOne>(null));
+            resolver.RegisterAnd<ViewModelOne>("one")
+                    .RegisterAnd<IViewModelOne, ViewModelOne>("two")
+                    .RegisterAnd(() => new DefaultLogManager(), "three")
+                    .RegisterAnd<IViewModelOne>(() => new ViewModelOne(), "four")
+                    .RegisterConstantAnd<ViewModelOne>("five")
+                    .RegisterConstantAnd(new ViewModelOne(), typeof(ViewModelOne), "six")
+                    .RegisterLazySingletonAnd(() => new DefaultLogManager(), typeof(ILogManager), "seven")
+                    .RegisterLazySingletonAnd<ViewModelOne>("eight")
+                    .RegisterLazySingletonAnd<DefaultLogManager>(() => new DefaultLogManager(), "seven")
+                    .Register<IViewModelOne, ViewModelOne>();
+        }
+
         /// <summary>
         /// Gets an instance of a dependency resolver to test.
         /// </summary>
diff --git a/src/Splat.Tests/Splat.Tests.csproj b/src/Splat.Tests/Splat.Tests.csproj
index 88b9f9b32..18cfb75db 100644
--- a/src/Splat.Tests/Splat.Tests.csproj
+++ b/src/Splat.Tests/Splat.Tests.csproj
@@ -12,6 +12,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\Splat.ApplicationInsights\Splat.ApplicationInsights.csproj" />
+    <ProjectReference Include="..\Splat.Common.Test\Splat.Common.Test.csproj" />
     <ProjectReference Include="..\Splat.Exceptionless\Splat.Exceptionless.csproj" />
     <ProjectReference Include="..\Splat.AppCenter\Splat.AppCenter.csproj" />
     <ProjectReference Include="..\Splat.Log4Net\Splat.Log4Net.csproj" />
diff --git a/src/Splat/ServiceLocation/DependencyResolverMixins.cs b/src/Splat/ServiceLocation/DependencyResolverMixins.cs
index be913d30e..77a7714c4 100644
--- a/src/Splat/ServiceLocation/DependencyResolverMixins.cs
+++ b/src/Splat/ServiceLocation/DependencyResolverMixins.cs
@@ -115,6 +115,24 @@ public static void Register<T>(this IMutableDependencyResolver resolver, Func<T>
             resolver.Register(() => factory(), typeof(T), contract);
         }
 
+        /// <summary>
+        /// Registers a factory for the given <typeparamref name="T" />.
+        /// </summary>
+        /// <typeparam name="TAs">The type to register as.</typeparam>
+        /// <typeparam name="T">The service type to register for.</typeparam>
+        /// <param name="resolver">The resolver to register the service type with.</param>
+        /// <param name="contract">A optional contract value which will indicates to only generate the value if this contract is specified.</param>
+        public static void Register<TAs, T>(this IMutableDependencyResolver resolver, string? contract = null)
+            where T : new()
+        {
+            if (resolver is null)
+            {
+                throw new ArgumentNullException(nameof(resolver));
+            }
+
+            resolver.Register(() => new T(), typeof(TAs), contract);
+        }
+
         /// <summary>
         /// Registers a constant value which will always return the specified object instance.
         /// </summary>
diff --git a/src/Splat/ServiceLocation/FuncDependencyResolver.cs b/src/Splat/ServiceLocation/FuncDependencyResolver.cs
index 4b898ad4e..440c890a2 100644
--- a/src/Splat/ServiceLocation/FuncDependencyResolver.cs
+++ b/src/Splat/ServiceLocation/FuncDependencyResolver.cs
@@ -51,7 +51,7 @@ public FuncDependencyResolver(
         /// <inheritdoc />
         public object? GetService(Type serviceType, string? contract = null)
         {
-            return (GetServices(serviceType, contract) ?? Enumerable.Empty<object>()).LastOrDefault();
+            return (GetServices(serviceType, contract) ?? Array.Empty<object>()).LastOrDefault();
         }
 
         /// <inheritdoc />
diff --git a/src/Splat/ServiceLocation/ModernDependencyResolver.cs b/src/Splat/ServiceLocation/ModernDependencyResolver.cs
index a4cdece1b..1515c06f7 100644
--- a/src/Splat/ServiceLocation/ModernDependencyResolver.cs
+++ b/src/Splat/ServiceLocation/ModernDependencyResolver.cs
@@ -133,13 +133,13 @@ public IEnumerable<object> GetServices(Type serviceType, string? contract = null
         {
             if (_registry is null)
             {
-                return Enumerable.Empty<object>();
+                return Array.Empty<object>();
             }
 
             var pair = GetKey(serviceType, contract);
             if (!_registry.ContainsKey(pair))
             {
-                return Enumerable.Empty<object>();
+                return Array.Empty<object>();
             }
 
             return _registry[pair].Select(x => x()).ToList();
diff --git a/src/Splat/ServiceLocation/ResolverMixins.cs b/src/Splat/ServiceLocation/ResolverMixins.cs
new file mode 100644
index 000000000..4f9265c50
--- /dev/null
+++ b/src/Splat/ServiceLocation/ResolverMixins.cs
@@ -0,0 +1,223 @@
+// Copyright (c) 2021 .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;
+using System.Threading;
+
+namespace Splat
+{
+    /// <summary>
+    /// Resolver Mixins.
+    /// </summary>
+    public static class ResolverMixins
+    {
+        /// <summary>
+        /// Registers a factory for the given <typeparamref name="T" />.
+        /// </summary>
+        /// <typeparam name="T">The service type to register for.</typeparam>
+        /// <param name="resolver">The resolver to register the service type with.</param>
+        /// <param name="contract">A optional contract value which will indicates to only generate the value if this contract is specified.</param>
+        /// <returns>The resolver.</returns>
+        public static IMutableDependencyResolver RegisterAnd<T>(this IMutableDependencyResolver resolver, string? contract = null)
+            where T : new()
+        {
+            if (resolver is null)
+            {
+                throw new ArgumentNullException(nameof(resolver));
+            }
+
+            resolver.Register(() => new T(), typeof(T), contract);
+            return resolver;
+        }
+
+        /// <summary>
+        /// Registers a factory for the given <typeparamref name="T" />.
+        /// </summary>
+        /// <typeparam name="T">The service type to register for.</typeparam>
+        /// <param name="resolver">The resolver to register the service type with.</param>
+        /// <param name="factory">A factory method for generating a object of the specified type.</param>
+        /// <param name="contract">A optional contract value which will indicates to only generate the value if this contract is specified.</param>
+        /// <returns>The resolver.</returns>
+        public static IMutableDependencyResolver RegisterAnd<T>(this IMutableDependencyResolver resolver, Func<T> factory, string? contract = null)
+        {
+            if (resolver is null)
+            {
+                throw new ArgumentNullException(nameof(resolver));
+            }
+
+            if (factory is null)
+            {
+                throw new ArgumentNullException(nameof(factory));
+            }
+
+            resolver.Register(() => factory()!, typeof(T), contract);
+            return resolver;
+        }
+
+        /// <summary>
+        /// Registers a factory for the given <typeparamref name="T" />.
+        /// </summary>
+        /// <typeparam name="TAs">The type to register as.</typeparam>
+        /// <typeparam name="T">The service type to register for.</typeparam>
+        /// <param name="resolver">The resolver to register the service type with.</param>
+        /// <param name="contract">A optional contract value which will indicates to only generate the value if this contract is specified.</param>
+        /// <returns>The resolver.</returns>
+        public static IMutableDependencyResolver RegisterAnd<TAs, T>(this IMutableDependencyResolver resolver, string? contract = null)
+            where T : new()
+        {
+            if (resolver is null)
+            {
+                throw new ArgumentNullException(nameof(resolver));
+            }
+
+            resolver.Register(() => new T(), typeof(TAs), contract);
+            return resolver;
+        }
+
+        /// <summary>
+        /// Registers a factory for the given <typeparamref name="T" />.
+        /// </summary>
+        /// <typeparam name="TAs">The type to register as.</typeparam>
+        /// <typeparam name="T">The service type to register for.</typeparam>
+        /// <param name="resolver">The resolver to register the service type with.</param>
+        /// <param name="factory">A factory method for generating a object of the specified type.</param>
+        /// <param name="contract">A optional contract value which will indicates to only generate the value if this contract is specified.</param>
+        /// <returns>The resolver.</returns>
+        public static IMutableDependencyResolver RegisterAnd<TAs, T>(this IMutableDependencyResolver resolver, Func<T> factory, string? contract = null)
+        {
+            if (resolver is null)
+            {
+                throw new ArgumentNullException(nameof(resolver));
+            }
+
+            if (factory is null)
+            {
+                throw new ArgumentNullException(nameof(factory));
+            }
+
+            resolver.Register(() => factory()!, typeof(TAs), contract);
+            return resolver;
+        }
+
+        /// <summary>
+        /// Registers a constant value which will always return the specified object instance.
+        /// </summary>
+        /// <param name="resolver">The resolver to register the service type with.</param>
+        /// <param name="value">The specified instance to always return.</param>
+        /// <param name="serviceType">The type of service to register.</param>
+        /// <param name="contract">A optional contract value which will indicates to only return the value if this contract is specified.</param>
+        /// <returns>The resolver.</returns>
+        public static IMutableDependencyResolver RegisterConstantAnd(this IMutableDependencyResolver resolver, object value, Type serviceType, string? contract = null)
+        {
+            if (resolver is null)
+            {
+                throw new ArgumentNullException(nameof(resolver));
+            }
+
+            resolver.Register(() => value, serviceType, contract);
+            return resolver;
+        }
+
+        /// <summary>
+        /// Registers a constant value which will always return the specified object instance.
+        /// </summary>
+        /// <typeparam name="T">The service type to register for.</typeparam>
+        /// <param name="resolver">The resolver to register the service type with.</param>
+        /// <param name="contract">A optional contract value which will indicates to only return the value if this contract is specified.</param>
+        /// <returns>The resolver.</returns>
+        public static IMutableDependencyResolver RegisterConstantAnd<T>(this IMutableDependencyResolver resolver, string? contract = null)
+            where T : new()
+        {
+            if (resolver is null)
+            {
+                throw new ArgumentNullException(nameof(resolver));
+            }
+
+            var value = new T();
+            return resolver.RegisterAnd(() => value, contract);
+        }
+
+        /// <summary>
+        /// Registers a constant value which will always return the specified object instance.
+        /// </summary>
+        /// <typeparam name="T">The service type to register for.</typeparam>
+        /// <param name="resolver">The resolver to register the service type with.</param>
+        /// <param name="value">The specified instance to always return.</param>
+        /// <param name="contract">A optional contract value which will indicates to only return the value if this contract is specified.</param>
+        /// <returns>The resolver.</returns>
+        public static IMutableDependencyResolver RegisterConstantAnd<T>(this IMutableDependencyResolver resolver, T value, string? contract = null)
+        {
+            if (resolver is null)
+            {
+                throw new ArgumentNullException(nameof(resolver));
+            }
+
+            return resolver.RegisterAnd(() => value, contract);
+        }
+
+        /// <summary>
+        /// Registers a lazy singleton value which will always return the specified object instance once created.
+        /// The value is only generated once someone requests the service from the resolver.
+        /// </summary>
+        /// <param name="resolver">The resolver to register the service type with.</param>
+        /// <param name="valueFactory">A factory method for generating a object of the specified type.</param>
+        /// <param name="serviceType">The type of service to register.</param>
+        /// <param name="contract">A optional contract value which will indicates to only return the value if this contract is specified.</param>
+        /// <returns>The resolver.</returns>
+        public static IMutableDependencyResolver RegisterLazySingletonAnd(this IMutableDependencyResolver resolver, Func<object> valueFactory, Type serviceType, string? contract = null)
+        {
+            if (resolver is null)
+            {
+                throw new ArgumentNullException(nameof(resolver));
+            }
+
+            var val = new Lazy<object>(valueFactory, LazyThreadSafetyMode.ExecutionAndPublication);
+            resolver.Register(() => val.Value, serviceType, contract);
+            return resolver;
+        }
+
+        /// <summary>
+        /// Registers a lazy singleton value which will always return the specified object instance once created.
+        /// The value is only generated once someone requests the service from the resolver.
+        /// </summary>
+        /// <typeparam name="T">The service type to register for.</typeparam>
+        /// <param name="resolver">The resolver to register the service type with.</param>
+        /// <param name="contract">A optional contract value which will indicates to only return the value if this contract is specified.</param>
+        /// <returns>The resolver.</returns>
+        public static IMutableDependencyResolver RegisterLazySingletonAnd<T>(this IMutableDependencyResolver resolver, string? contract = null)
+            where T : new()
+        {
+            if (resolver is null)
+            {
+                throw new ArgumentNullException(nameof(resolver));
+            }
+
+            var val = new Lazy<object>(() => new T(), LazyThreadSafetyMode.ExecutionAndPublication);
+            resolver.Register(() => val.Value, typeof(T), contract);
+            return resolver;
+        }
+
+        /// <summary>
+        /// Registers a lazy singleton value which will always return the specified object instance once created.
+        /// The value is only generated once someone requests the service from the resolver.
+        /// </summary>
+        /// <typeparam name="T">The service type to register for.</typeparam>
+        /// <param name="resolver">The resolver to register the service type with.</param>
+        /// <param name="valueFactory">A factory method for generating a object of the specified type.</param>
+        /// <param name="contract">A optional contract value which will indicates to only return the value if this contract is specified.</param>
+        /// <returns>The resolver.</returns>
+        public static IMutableDependencyResolver RegisterLazySingletonAnd<T>(this IMutableDependencyResolver resolver, Func<T> valueFactory, string? contract = null)
+        {
+            if (resolver is null)
+            {
+                throw new ArgumentNullException(nameof(resolver));
+            }
+
+            var val = new Lazy<object>(() => valueFactory()!, LazyThreadSafetyMode.ExecutionAndPublication);
+            resolver.Register(() => val.Value, typeof(T), contract);
+            return resolver;
+        }
+    }
+}