diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/ContextualOptionsServiceCollectionExtensions.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/ContextualOptionsServiceCollectionExtensions.cs
index 0dd03a5ba31..cdf4b8cbdbd 100644
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/ContextualOptionsServiceCollectionExtensions.cs
+++ b/src/Libraries/Microsoft.Extensions.Options.Contextual/ContextualOptionsServiceCollectionExtensions.cs
@@ -6,6 +6,8 @@
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Options.Contextual;
+using Microsoft.Extensions.Options.Contextual.Internal;
+using Microsoft.Extensions.Options.Contextual.Provider;
 using Microsoft.Shared.Diagnostics;
 
 namespace Microsoft.Extensions.DependencyInjection;
@@ -25,8 +27,8 @@ public static IServiceCollection AddContextualOptions(this IServiceCollection se
         _ = Throw.IfNull(services).AddOptions();
 
         services.TryAdd(ServiceDescriptor.Singleton(typeof(IContextualOptionsFactory<>), typeof(ContextualOptionsFactory<>)));
-        services.TryAdd(ServiceDescriptor.Singleton(typeof(IContextualOptions<>), typeof(ContextualOptions<>)));
-        services.TryAdd(ServiceDescriptor.Singleton(typeof(INamedContextualOptions<>), typeof(ContextualOptions<>)));
+        services.TryAdd(ServiceDescriptor.Singleton(typeof(IContextualOptions<,>), typeof(ContextualOptions<,>)));
+        services.TryAdd(ServiceDescriptor.Singleton(typeof(INamedContextualOptions<,>), typeof(ContextualOptions<,>)));
 
         return services;
     }
@@ -54,14 +56,14 @@ public static IServiceCollection Configure<TOptions>(
     /// <returns>The value of <paramref name="services"/>.</returns>
     public static IServiceCollection Configure<TOptions>(
         this IServiceCollection services,
-        string name,
+        string? name,
         Func<IOptionsContext, CancellationToken, ValueTask<IConfigureContextualOptions<TOptions>>> loadOptions)
         where TOptions : class
         => services
             .AddContextualOptions()
             .AddSingleton<ILoadContextualOptions<TOptions>>(
                 new LoadContextualOptions<TOptions>(
-                    Throw.IfNull(name),
+                    name,
                     Throw.IfNull(loadOptions)));
 
     /// <summary>
@@ -69,11 +71,13 @@ public static IServiceCollection Configure<TOptions>(
     /// </summary>
     /// <typeparam name="TOptions">The options type to be configured.</typeparam>
     /// <param name="services">The <see cref="IServiceCollection"/> to add the services to.</param>
-    /// <param name="configureOptions">The action used to configure the options.</param>
+    /// <param name="configure">The action used to configure the options.</param>
     /// <returns>The value of <paramref name="services"/>.</returns>
-    public static IServiceCollection Configure<TOptions>(this IServiceCollection services, Action<IOptionsContext, TOptions> configureOptions)
+#pragma warning disable S3872 // Parameter names should not duplicate the names of their methods
+    public static IServiceCollection Configure<TOptions>(this IServiceCollection services, Action<IOptionsContext, TOptions> configure)
+#pragma warning restore S3872 // Parameter names should not duplicate the names of their methods
         where TOptions : class
-        => services.Configure(Options.Options.DefaultName, Throw.IfNull(configureOptions));
+        => services.Configure(Options.Options.DefaultName, Throw.IfNull(configure));
 
     /// <summary>
     /// Registers an action used to configure a particular type of options.
@@ -81,81 +85,42 @@ public static IServiceCollection Configure<TOptions>(this IServiceCollection ser
     /// <typeparam name="TOptions">The options type to be configured.</typeparam>
     /// <param name="services">The <see cref="IServiceCollection"/> to add the services to.</param>
     /// <param name="name">The name of the options to configure.</param>
-    /// <param name="configureOptions">The action used to configure the options.</param>
+    /// <param name="configure">The action used to configure the options.</param>
     /// <returns>The value of <paramref name="services"/>.</returns>
-    public static IServiceCollection Configure<TOptions>(this IServiceCollection services, string name, Action<IOptionsContext, TOptions> configureOptions)
+#pragma warning disable S3872 // Parameter names should not duplicate the names of their methods
+    public static IServiceCollection Configure<TOptions>(this IServiceCollection services, string? name, Action<IOptionsContext, TOptions> configure)
+#pragma warning restore S3872 // Parameter names should not duplicate the names of their methods
         where TOptions : class
     {
         return services.AddContextualOptions().AddSingleton<ILoadContextualOptions<TOptions>>(
             new LoadContextualOptions<TOptions>(
-                Throw.IfNull(name),
+                name,
                 (context, _) =>
                     new ValueTask<IConfigureContextualOptions<TOptions>>(
-                        new ConfigureContextualOptions<TOptions>(Throw.IfNull(configureOptions), Throw.IfNull(context)))));
+                        new ConfigureContextualOptions<TOptions>(Throw.IfNull(configure), Throw.IfNull(context)))));
     }
 
     /// <summary>
-    /// Registers an action used to initialize all instances of a particular type of options.
+    /// Registers an action used to configure all instances of a particular type of options.
     /// </summary>
     /// <typeparam name="TOptions">The options type to be configured.</typeparam>
     /// <param name="services">The <see cref="IServiceCollection"/> to add the services to.</param>
-    /// <param name="configureOptions">The action used to configure the options.</param>
-    /// <returns>The value of <paramref name="services"/>.</returns>
-    public static IServiceCollection PostConfigureAll<TOptions>(this IServiceCollection services, Action<IOptionsContext, TOptions> configureOptions)
-        where TOptions : class
-        => services.PostConfigure(null, Throw.IfNull(configureOptions));
-
-    /// <summary>
-    /// Registers an action used to initialize a particular type of options.
-    /// </summary>
-    /// <typeparam name="TOptions">The options type to be configured.</typeparam>
-    /// <param name="services">The <see cref="IServiceCollection"/> to add the services to.</param>
-    /// <param name="configureOptions">The action used to configure the options.</param>
+    /// <param name="loadOptions">The action used to configure the options.</param>
     /// <returns>The value of <paramref name="services"/>.</returns>
-    public static IServiceCollection PostConfigure<TOptions>(this IServiceCollection services, Action<IOptionsContext, TOptions> configureOptions)
+    public static IServiceCollection ConfigureAll<TOptions>(
+        this IServiceCollection services,
+        Func<IOptionsContext, CancellationToken, ValueTask<IConfigureContextualOptions<TOptions>>> loadOptions)
         where TOptions : class
-        => services.PostConfigure(Options.Options.DefaultName, Throw.IfNull(configureOptions));
+        => services.Configure(name: null, Throw.IfNull(loadOptions));
 
     /// <summary>
-    /// Registers an action used to initialize a particular type of options.
+    /// Registers an action used to configure all instances of a particular type of options.
     /// </summary>
     /// <typeparam name="TOptions">The options type to be configured.</typeparam>
     /// <param name="services">The <see cref="IServiceCollection"/> to add the services to.</param>
-    /// <param name="name">The name of the options instance.</param>
-    /// <param name="configureOptions">The action used to configure the options.</param>
-    /// <returns>The value of <paramref name="services"/>.</returns>
-    public static IServiceCollection PostConfigure<TOptions>(this IServiceCollection services, string? name, Action<IOptionsContext, TOptions> configureOptions)
-        where TOptions : class
-        => services
-            .AddContextualOptions()
-            .AddSingleton<IPostConfigureContextualOptions<TOptions>>(
-                new PostConfigureContextualOptions<TOptions>(name, Throw.IfNull(configureOptions)));
-
-    /// <summary>
-    /// Register a validation action for an options type.
-    /// </summary>
-    /// <typeparam name="TOptions">The options type to be validated.</typeparam>
-    /// <param name="services">The <see cref="IServiceCollection"/> to add the services to.</param>
-    /// <param name="validate">The validation function.</param>
-    /// <param name="failureMessage">The failure message to use when validation fails.</param>
+    /// <param name="configure">The action used to configure the options.</param>
     /// <returns>The value of <paramref name="services"/>.</returns>
-    public static IServiceCollection ValidateContextualOptions<TOptions>(this IServiceCollection services, Func<TOptions, bool> validate, string failureMessage)
+    public static IServiceCollection ConfigureAll<TOptions>(this IServiceCollection services, Action<IOptionsContext, TOptions> configure)
         where TOptions : class
-        => services.ValidateContextualOptions(Options.Options.DefaultName, Throw.IfNull(validate), Throw.IfNull(failureMessage));
-
-    /// <summary>
-    /// Register a validation action for an options type.
-    /// </summary>
-    /// <typeparam name="TOptions">The options type to be validated.</typeparam>
-    /// <param name="services">The <see cref="IServiceCollection"/> to add the services to.</param>
-    /// <param name="name">The name of the options instance.</param>
-    /// <param name="validate">The validation function.</param>
-    /// <param name="failureMessage">The failure message to use when validation fails.</param>
-    /// <returns>The value of <paramref name="services"/>.</returns>
-    public static IServiceCollection ValidateContextualOptions<TOptions>(this IServiceCollection services, string name, Func<TOptions, bool> validate, string failureMessage)
-        where TOptions : class
-        => services
-            .AddContextualOptions()
-            .AddSingleton<IValidateContextualOptions<TOptions>>(
-                new ValidateContextualOptions<TOptions>(Throw.IfNull(name), Throw.IfNull(validate), Throw.IfNull(failureMessage)));
+        => services.Configure(name: null, Throw.IfNull(configure));
 }
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/IContextualOptions.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/IContextualOptions.cs
index 92e5073a065..66d9bb750a9 100644
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/IContextualOptions.cs
+++ b/src/Libraries/Microsoft.Extensions.Options.Contextual/IContextualOptions.cs
@@ -10,16 +10,16 @@ namespace Microsoft.Extensions.Options.Contextual;
 /// Used to retrieve configured <typeparamref name="TOptions"/> instances.
 /// </summary>
 /// <typeparam name="TOptions">The type of options being requested.</typeparam>
-public interface IContextualOptions<TOptions>
+/// <typeparam name="TContext">A type defining the context for this request.</typeparam>
+public interface IContextualOptions<TOptions, TContext>
     where TOptions : class
+    where TContext : IOptionsContext
 {
     /// <summary>
     /// Gets the configured <typeparamref name="TOptions"/> instance.
     /// </summary>
-    /// <typeparam name="TContext">A type defining the context for this request.</typeparam>
     /// <param name="context">The context that will be used to create the options.</param>
     /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
     /// <returns>A configured instance of <typeparamref name="TOptions"/>.</returns>
-    ValueTask<TOptions> GetAsync<TContext>(in TContext context, CancellationToken cancellationToken)
-        where TContext : IOptionsContext;
+    ValueTask<TOptions> GetAsync(in TContext context, CancellationToken cancellationToken);
 }
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/INamedContextualOptions.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/INamedContextualOptions.cs
index e60774ca8b0..72f0a427859 100644
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/INamedContextualOptions.cs
+++ b/src/Libraries/Microsoft.Extensions.Options.Contextual/INamedContextualOptions.cs
@@ -10,17 +10,17 @@ namespace Microsoft.Extensions.Options.Contextual;
 /// Used to retrieve named configured <typeparamref name="TOptions"/> instances.
 /// </summary>
 /// <typeparam name="TOptions">The type of options being requested.</typeparam>
-public interface INamedContextualOptions<TOptions> : IContextualOptions<TOptions>
+/// <typeparam name="TContext">A type defining the context for this request.</typeparam>
+public interface INamedContextualOptions<TOptions, TContext> : IContextualOptions<TOptions, TContext>
     where TOptions : class
+    where TContext : IOptionsContext
 {
     /// <summary>
     /// Gets the named configured <typeparamref name="TOptions"/> instance.
     /// </summary>
-    /// <typeparam name="TContext">A type defining the context for this request.</typeparam>
     /// <param name="name">The name of the options to get.</param>
     /// <param name="context">The context that will be used to create the options.</param>
     /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
     /// <returns>A configured instance of <typeparamref name="TOptions"/>.</returns>
-    ValueTask<TOptions> GetAsync<TContext>(string name, in TContext context, CancellationToken cancellationToken)
-        where TContext : IOptionsContext;
+    ValueTask<TOptions> GetAsync(string name, in TContext context, CancellationToken cancellationToken);
 }
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/IOptionsContext.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/IOptionsContext.cs
index 4a55aad24cb..11a7a721415 100644
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/IOptionsContext.cs
+++ b/src/Libraries/Microsoft.Extensions.Options.Contextual/IOptionsContext.cs
@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.Extensions.Options.Contextual.Provider;
+
 namespace Microsoft.Extensions.Options.Contextual;
 
 /// <summary>
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/IPostConfigureContextualOptions.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/IPostConfigureContextualOptions.cs
deleted file mode 100644
index 77688c4ed10..00000000000
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/IPostConfigureContextualOptions.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Microsoft.Extensions.Options.Contextual;
-
-/// <summary>
-/// Represents something that configures the <typeparamref name="TOptions"/> type.
-/// </summary>
-/// <typeparam name="TOptions">Options type being configured.</typeparam>
-public interface IPostConfigureContextualOptions<in TOptions>
-    where TOptions : class
-{
-    /// <summary>
-    /// Invoked to configure a <typeparamref name="TOptions" /> instance.
-    /// </summary>
-    /// <typeparam name="TContext">Options type being configured.</typeparam>
-    /// <param name="name">The name of the options instance being configured.</param>
-    /// <param name="context">The context that will be used to configure the options.</param>
-    /// <param name="options">The options instance to configured.</param>
-    void PostConfigure<TContext>(string name, in TContext context, TOptions options)
-        where TContext : IOptionsContext;
-}
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/IValidateContextualOptions.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/IValidateContextualOptions.cs
deleted file mode 100644
index 21ff8899ec9..00000000000
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/IValidateContextualOptions.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.Extensions.Options;
-
-namespace Microsoft.Extensions.Options.Contextual;
-
-/// <summary>
-/// Interface used to validate options.
-/// </summary>
-/// <typeparam name="TOptions">The options type to validate.</typeparam>
-public interface IValidateContextualOptions<in TOptions>
-    where TOptions : class
-{
-    /// <summary>
-    /// Validates a specific named options instance (or all when name is null).
-    /// </summary>
-    /// <param name="name">The name of the options instance being validated.</param>
-    /// <param name="options">The options instance.</param>
-    /// <returns>The <see cref="ValidateOptionsResult"/> result.</returns>
-    ValidateOptionsResult Validate(string? name, TOptions options);
-}
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/ConfigureContextualOptions.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/Internal/ConfigureContextualOptions.cs
similarity index 92%
rename from src/Libraries/Microsoft.Extensions.Options.Contextual/ConfigureContextualOptions.cs
rename to src/Libraries/Microsoft.Extensions.Options.Contextual/Internal/ConfigureContextualOptions.cs
index 35faff4002c..71c837496c4 100644
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/ConfigureContextualOptions.cs
+++ b/src/Libraries/Microsoft.Extensions.Options.Contextual/Internal/ConfigureContextualOptions.cs
@@ -2,9 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using Microsoft.Extensions.Options.Contextual.Provider;
 using Microsoft.Shared.Diagnostics;
 
-namespace Microsoft.Extensions.Options.Contextual;
+namespace Microsoft.Extensions.Options.Contextual.Internal;
 
 /// <summary>
 /// Configures the <typeparamref name="TOptions"/> type.
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/ContextualOptions.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/Internal/ContextualOptions.cs
similarity index 60%
rename from src/Libraries/Microsoft.Extensions.Options.Contextual/ContextualOptions.cs
rename to src/Libraries/Microsoft.Extensions.Options.Contextual/Internal/ContextualOptions.cs
index 7a09dc90462..bab1a9f9058 100644
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/ContextualOptions.cs
+++ b/src/Libraries/Microsoft.Extensions.Options.Contextual/Internal/ContextualOptions.cs
@@ -5,19 +5,21 @@
 using System.Threading.Tasks;
 using Microsoft.Shared.Diagnostics;
 
-namespace Microsoft.Extensions.Options.Contextual;
+namespace Microsoft.Extensions.Options.Contextual.Internal;
 
 /// <summary>
 /// Used to retrieve configured TOptions instances based on a context.
 /// </summary>
 /// <typeparam name="TOptions">The type of options being requested.</typeparam>
-internal sealed class ContextualOptions<TOptions> : INamedContextualOptions<TOptions>
+/// <typeparam name="TContext">A type defining the context for this request.</typeparam>
+internal sealed class ContextualOptions<TOptions, TContext> : INamedContextualOptions<TOptions, TContext>
     where TOptions : class
+    where TContext : notnull, IOptionsContext
 {
     private readonly IContextualOptionsFactory<TOptions> _factory;
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="ContextualOptions{TOptions}"/> class.
+    /// Initializes a new instance of the <see cref="ContextualOptions{TOptions, TContext}"/> class.
     /// </summary>
     /// <param name="factory">The factory to create instances of <typeparamref name="TOptions"/> with.</param>
     public ContextualOptions(IContextualOptionsFactory<TOptions> factory)
@@ -26,12 +28,10 @@ public ContextualOptions(IContextualOptionsFactory<TOptions> factory)
     }
 
     /// <inheritdoc/>
-    public ValueTask<TOptions> GetAsync<TContext>(in TContext context, CancellationToken cancellationToken)
-        where TContext : notnull, IOptionsContext
-        => GetAsync(Microsoft.Extensions.Options.Options.DefaultName, context, cancellationToken);
+    public ValueTask<TOptions> GetAsync(in TContext context, CancellationToken cancellationToken)
+        => GetAsync(Options.DefaultName, context, cancellationToken);
 
     /// <inheritdoc/>
-    public ValueTask<TOptions> GetAsync<TContext>(string name, in TContext context, CancellationToken cancellationToken)
-        where TContext : notnull, IOptionsContext
+    public ValueTask<TOptions> GetAsync(string name, in TContext context, CancellationToken cancellationToken)
         => _factory.CreateAsync(Throw.IfNull(name), context, cancellationToken);
 }
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/ContextualOptionsFactory.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/Internal/ContextualOptionsFactory.cs
similarity index 66%
rename from src/Libraries/Microsoft.Extensions.Options.Contextual/ContextualOptionsFactory.cs
rename to src/Libraries/Microsoft.Extensions.Options.Contextual/Internal/ContextualOptionsFactory.cs
index f044d9eedd2..a13cb0e32a4 100644
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/ContextualOptionsFactory.cs
+++ b/src/Libraries/Microsoft.Extensions.Options.Contextual/Internal/ContextualOptionsFactory.cs
@@ -9,9 +9,10 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Options.Contextual.Provider;
 using Microsoft.Shared.Diagnostics;
 
-namespace Microsoft.Extensions.Options.Contextual;
+namespace Microsoft.Extensions.Options.Contextual.Internal;
 
 /// <summary>
 /// Implementation of <see cref="IContextualOptionsFactory{TOptions}"/>.
@@ -20,28 +21,29 @@ namespace Microsoft.Extensions.Options.Contextual;
 internal sealed class ContextualOptionsFactory<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] TOptions> : IContextualOptionsFactory<TOptions>
     where TOptions : class
 {
-    private readonly IOptionsFactory<TOptions> _baseFactory;
     private readonly ILoadContextualOptions<TOptions>[] _loaders;
-    private readonly IPostConfigureContextualOptions<TOptions>[] _postConfigures;
-    private readonly IValidateContextualOptions<TOptions>[] _validations;
+
+    private readonly IConfigureOptions<TOptions>[] _setups;
+    private readonly IPostConfigureOptions<TOptions>[] _postConfigures;
+    private readonly IValidateOptions<TOptions>[] _validations;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ContextualOptionsFactory{TOptions}"/> class.
     /// </summary>
-    /// <param name="baseFactory">The factory to create instances of <typeparamref name="TOptions"/> with.</param>
     /// <param name="loaders">The configuration loaders to run.</param>
+    /// <param name="setups">The configuration actions to run.</param>
     /// <param name="postConfigures">The initialization actions to run.</param>
     /// <param name="validations">The validations to run.</param>
     public ContextualOptionsFactory(
-        IOptionsFactory<TOptions> baseFactory,
         IEnumerable<ILoadContextualOptions<TOptions>> loaders,
-        IEnumerable<IPostConfigureContextualOptions<TOptions>> postConfigures,
-        IEnumerable<IValidateContextualOptions<TOptions>> validations)
+        IEnumerable<IConfigureOptions<TOptions>> setups,
+        IEnumerable<IPostConfigureOptions<TOptions>> postConfigures,
+        IEnumerable<IValidateOptions<TOptions>> validations)
     {
-        _baseFactory = baseFactory;
         _loaders = loaders.ToArray();
-        _postConfigures = postConfigures.ToArray();
-        _validations = validations.ToArray();
+        _setups = setups as IConfigureOptions<TOptions>[] ?? setups.ToArray();
+        _postConfigures = postConfigures as IPostConfigureOptions<TOptions>[] ?? postConfigures.ToArray();
+        _validations = validations as IValidateOptions<TOptions>[] ?? validations.ToArray();
     }
 
     /// <inheritdoc/>
@@ -54,7 +56,21 @@ public ValueTask<TOptions> CreateAsync<TContext>(string name, in TContext contex
         _ = Throw.IfNull(context);
 
         cancellationToken.ThrowIfCancellationRequested();
-        var options = _baseFactory.Create(name);
+        TOptions options = Activator.CreateInstance<TOptions>();
+
+        // Set the default setup.
+        foreach (IConfigureOptions<TOptions> setup in _setups)
+        {
+            if (setup is IConfigureNamedOptions<TOptions> namedSetup)
+            {
+                namedSetup.Configure(name, options);
+            }
+            else if (name == Options.DefaultName)
+            {
+                setup.Configure(options);
+            }
+        }
+
         return ConfigureOptions(context);
 
         async ValueTask<TOptions> ConfigureOptions(TContext context)
@@ -108,25 +124,27 @@ async ValueTask<TOptions> ConfigureOptions(TContext context)
 
             cancellationToken.ThrowIfCancellationRequested();
 
-            foreach (var post in _postConfigures)
+            foreach (IPostConfigureOptions<TOptions> post in _postConfigures)
             {
-                post.PostConfigure(name, context, options);
+                post.PostConfigure(name, options);
             }
 
-            List<string>? failures = default;
-            foreach (var validate in _validations)
+            if (_validations.Length > 0)
             {
-                var result = validate.Validate(name, options);
-                if (result.Failed)
+                var failures = new List<string>();
+                foreach (IValidateOptions<TOptions> validate in _validations)
                 {
-                    failures ??= [];
-                    failures.AddRange(result.Failures);
+                    ValidateOptionsResult result = validate.Validate(name, options);
+                    if (result is not null && result.Failed)
+                    {
+                        failures.AddRange(result.Failures);
+                    }
                 }
-            }
 
-            if (failures is not null)
-            {
-                throw new OptionsValidationException(name, typeof(TOptions), failures);
+                if (failures.Count > 0)
+                {
+                    throw new OptionsValidationException(name, typeof(TOptions), failures);
+                }
             }
 
             return options;
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/IContextualOptionsFactory.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/Internal/IContextualOptionsFactory.cs
similarity index 90%
rename from src/Libraries/Microsoft.Extensions.Options.Contextual/IContextualOptionsFactory.cs
rename to src/Libraries/Microsoft.Extensions.Options.Contextual/Internal/IContextualOptionsFactory.cs
index 9438803b17b..73dcf5d953e 100644
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/IContextualOptionsFactory.cs
+++ b/src/Libraries/Microsoft.Extensions.Options.Contextual/Internal/IContextualOptionsFactory.cs
@@ -4,13 +4,13 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Microsoft.Extensions.Options.Contextual;
+namespace Microsoft.Extensions.Options.Contextual.Internal;
 
 /// <summary>
 /// A factory to create instances of <typeparamref name="TOptions"/>.
 /// </summary>
 /// <typeparam name="TOptions">The type of options being created.</typeparam>
-public interface IContextualOptionsFactory<TOptions>
+internal interface IContextualOptionsFactory<TOptions>
     where TOptions : class
 {
     /// <summary>
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/LoadContextualOptions.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/Internal/LoadContextualOptions.cs
similarity index 94%
rename from src/Libraries/Microsoft.Extensions.Options.Contextual/LoadContextualOptions.cs
rename to src/Libraries/Microsoft.Extensions.Options.Contextual/Internal/LoadContextualOptions.cs
index 3c7b1d2af38..e71317ca491 100644
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/LoadContextualOptions.cs
+++ b/src/Libraries/Microsoft.Extensions.Options.Contextual/Internal/LoadContextualOptions.cs
@@ -4,9 +4,10 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Options.Contextual.Provider;
 using Microsoft.Shared.Diagnostics;
 
-namespace Microsoft.Extensions.Options.Contextual;
+namespace Microsoft.Extensions.Options.Contextual.Internal;
 
 /// <summary>
 /// Used to retrieve named configuration data from a contextual options provider implementation.
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/PostConfigureContextualOptions.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/PostConfigureContextualOptions.cs
deleted file mode 100644
index 7bb75f7188a..00000000000
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/PostConfigureContextualOptions.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using Microsoft.Shared.Diagnostics;
-
-namespace Microsoft.Extensions.Options.Contextual;
-
-/// <summary>
-/// Implementation of <see cref="IPostConfigureContextualOptions{TOptions}"/>.
-/// </summary>
-/// <typeparam name="TOptions">Options type being configured.</typeparam>
-internal sealed class PostConfigureContextualOptions<TOptions> : IPostConfigureContextualOptions<TOptions>
-    where TOptions : class
-{
-    /// <summary>
-    /// Initializes a new instance of the <see cref="PostConfigureContextualOptions{TOptions}"/> class.
-    /// </summary>
-    /// <param name="name">The name of the options.</param>
-    /// <param name="action">The action to register.</param>
-    public PostConfigureContextualOptions(string? name, Action<IOptionsContext, TOptions> action)
-    {
-        Name = name;
-        Action = action;
-    }
-
-    /// <summary>
-    /// Gets the options name.
-    /// </summary>
-    public string? Name { get; }
-
-    /// <summary>
-    /// Gets the initialization action.
-    /// </summary>
-    public Action<IOptionsContext, TOptions> Action { get; }
-
-    /// <inheritdoc/>
-    public void PostConfigure<TContext>(string name, in TContext context, TOptions options)
-        where TContext : notnull, IOptionsContext
-    {
-        _ = Throw.IfNull(name);
-        _ = Throw.IfNull(context);
-        _ = Throw.IfNull(options);
-
-        if (Name == null || name == Name)
-        {
-            Action(context, options);
-        }
-    }
-}
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/IConfigureContextualOptions.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/Provider/IConfigureContextualOptions.cs
similarity index 91%
rename from src/Libraries/Microsoft.Extensions.Options.Contextual/IConfigureContextualOptions.cs
rename to src/Libraries/Microsoft.Extensions.Options.Contextual/Provider/IConfigureContextualOptions.cs
index 7e488ada72c..1e8f0c367d5 100644
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/IConfigureContextualOptions.cs
+++ b/src/Libraries/Microsoft.Extensions.Options.Contextual/Provider/IConfigureContextualOptions.cs
@@ -3,7 +3,7 @@
 
 using System;
 
-namespace Microsoft.Extensions.Options.Contextual;
+namespace Microsoft.Extensions.Options.Contextual.Provider;
 
 /// <summary>
 /// Represents something that configures the <typeparamref name="TOptions"/> type.
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/ILoadContextualOptions.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/Provider/ILoadContextualOptions.cs
similarity index 95%
rename from src/Libraries/Microsoft.Extensions.Options.Contextual/ILoadContextualOptions.cs
rename to src/Libraries/Microsoft.Extensions.Options.Contextual/Provider/ILoadContextualOptions.cs
index 14e4d18002f..391b1645157 100644
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/ILoadContextualOptions.cs
+++ b/src/Libraries/Microsoft.Extensions.Options.Contextual/Provider/ILoadContextualOptions.cs
@@ -4,7 +4,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Microsoft.Extensions.Options.Contextual;
+namespace Microsoft.Extensions.Options.Contextual.Provider;
 
 /// <summary>
 /// Used to retrieve named configuration data from a contextual options provider implementation.
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/IOptionsContextReceiver.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/Provider/IOptionsContextReceiver.cs
similarity index 91%
rename from src/Libraries/Microsoft.Extensions.Options.Contextual/IOptionsContextReceiver.cs
rename to src/Libraries/Microsoft.Extensions.Options.Contextual/Provider/IOptionsContextReceiver.cs
index f3342f0d687..a9a78471270 100644
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/IOptionsContextReceiver.cs
+++ b/src/Libraries/Microsoft.Extensions.Options.Contextual/Provider/IOptionsContextReceiver.cs
@@ -1,7 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-namespace Microsoft.Extensions.Options.Contextual;
+namespace Microsoft.Extensions.Options.Contextual.Provider;
 
 /// <summary>
 /// Used by contextual options providers to collect context data.
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/NullConfigureContextualOptions.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/Provider/NullConfigureContextualOptions.cs
similarity index 93%
rename from src/Libraries/Microsoft.Extensions.Options.Contextual/NullConfigureContextualOptions.cs
rename to src/Libraries/Microsoft.Extensions.Options.Contextual/Provider/NullConfigureContextualOptions.cs
index caaa969ee55..324bbaf1702 100644
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/NullConfigureContextualOptions.cs
+++ b/src/Libraries/Microsoft.Extensions.Options.Contextual/Provider/NullConfigureContextualOptions.cs
@@ -1,7 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-namespace Microsoft.Extensions.Options.Contextual;
+namespace Microsoft.Extensions.Options.Contextual.Provider;
 
 /// <summary>
 /// Helper class.
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/NullConfigureContextualOptions_1.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/Provider/NullConfigureContextualOptions_1.cs
similarity index 93%
rename from src/Libraries/Microsoft.Extensions.Options.Contextual/NullConfigureContextualOptions_1.cs
rename to src/Libraries/Microsoft.Extensions.Options.Contextual/Provider/NullConfigureContextualOptions_1.cs
index 61fa72fe68a..8ec2922e110 100644
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/NullConfigureContextualOptions_1.cs
+++ b/src/Libraries/Microsoft.Extensions.Options.Contextual/Provider/NullConfigureContextualOptions_1.cs
@@ -1,7 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-namespace Microsoft.Extensions.Options.Contextual;
+namespace Microsoft.Extensions.Options.Contextual.Provider;
 
 #pragma warning disable SA1649 // File name should match first type name
 
diff --git a/src/Libraries/Microsoft.Extensions.Options.Contextual/ValidateContextualOptions.cs b/src/Libraries/Microsoft.Extensions.Options.Contextual/ValidateContextualOptions.cs
deleted file mode 100644
index 1b8dd972656..00000000000
--- a/src/Libraries/Microsoft.Extensions.Options.Contextual/ValidateContextualOptions.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using Microsoft.Extensions.Options;
-
-namespace Microsoft.Extensions.Options.Contextual;
-
-/// <summary>
-/// Implementation of <see cref="IValidateContextualOptions{TOptions}"/>.
-/// </summary>
-/// <typeparam name="TOptions">The options type to validate.</typeparam>
-internal sealed class ValidateContextualOptions<TOptions> : ValidateOptions<TOptions>, IValidateContextualOptions<TOptions>
-    where TOptions : class
-{
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ValidateContextualOptions{TOptions}"/> class.
-    /// </summary>
-    /// <param name="name">Options name.</param>
-    /// <param name="validation">Validation function.</param>
-    /// <param name="failureMessage">Validation failure message.</param>
-    public ValidateContextualOptions(string? name, Func<TOptions, bool> validation, string failureMessage)
-        : base(name, validation, failureMessage)
-    {
-    }
-}
diff --git a/test/Generators/Microsoft.Gen.ContextualOptions/Generated/ContextualOptionsTests.cs b/test/Generators/Microsoft.Gen.ContextualOptions/Generated/ContextualOptionsTests.cs
index 5dea0143d3f..1bf6eb354e2 100644
--- a/test/Generators/Microsoft.Gen.ContextualOptions/Generated/ContextualOptionsTests.cs
+++ b/test/Generators/Microsoft.Gen.ContextualOptions/Generated/ContextualOptionsTests.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using Microsoft.Extensions.Options.Contextual;
+using Microsoft.Extensions.Options.Contextual.Provider;
 using TestClasses;
 using Xunit;
 
diff --git a/test/Generators/Microsoft.Gen.ContextualOptions/Unit/ContextualOptionsTests.cs b/test/Generators/Microsoft.Gen.ContextualOptions/Unit/ContextualOptionsTests.cs
index 71bfa6797e0..1c0215f3975 100644
--- a/test/Generators/Microsoft.Gen.ContextualOptions/Unit/ContextualOptionsTests.cs
+++ b/test/Generators/Microsoft.Gen.ContextualOptions/Unit/ContextualOptionsTests.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using Microsoft.Extensions.Options.Contextual;
+using Microsoft.Extensions.Options.Contextual.Provider;
 using TestClasses;
 using Xunit;
 
diff --git a/test/Libraries/Microsoft.Extensions.Options.ContextualOptions.Tests/AcceptanceTests.cs b/test/Libraries/Microsoft.Extensions.Options.ContextualOptions.Tests/AcceptanceTests.cs
index bdb9cc1b366..684affd32a1 100644
--- a/test/Libraries/Microsoft.Extensions.Options.ContextualOptions.Tests/AcceptanceTests.cs
+++ b/test/Libraries/Microsoft.Extensions.Options.ContextualOptions.Tests/AcceptanceTests.cs
@@ -9,6 +9,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Hosting.Testing;
+using Microsoft.Extensions.Options.Contextual.Provider;
 using Xunit;
 
 namespace Microsoft.Extensions.Options.Contextual.Test;
@@ -43,10 +44,10 @@ public void Receive<T>(string key, T value)
 
 internal class WeatherForecastService : IWeatherForecastService
 {
-    private readonly IContextualOptions<WeatherForecastOptions> _contextualOptions;
+    private readonly IContextualOptions<WeatherForecastOptions, WeatherForecastContext> _contextualOptions;
     private readonly Random _rng = new(0);
 
-    public WeatherForecastService(IContextualOptions<WeatherForecastOptions> contextualOptions)
+    public WeatherForecastService(IContextualOptions<WeatherForecastOptions, WeatherForecastContext> contextualOptions)
     {
         _contextualOptions = contextualOptions;
     }
diff --git a/test/Libraries/Microsoft.Extensions.Options.ContextualOptions.Tests/ContextualOptionsFactoryTests.cs b/test/Libraries/Microsoft.Extensions.Options.ContextualOptions.Tests/ContextualOptionsFactoryTests.cs
index 9fae5a50bd7..3a92693993a 100644
--- a/test/Libraries/Microsoft.Extensions.Options.ContextualOptions.Tests/ContextualOptionsFactoryTests.cs
+++ b/test/Libraries/Microsoft.Extensions.Options.ContextualOptions.Tests/ContextualOptionsFactoryTests.cs
@@ -8,6 +8,8 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Options.Contextual.Internal;
+using Microsoft.Extensions.Options.Contextual.Provider;
 using Moq;
 using Xunit;
 
@@ -19,12 +21,12 @@ public class ContextualOptionsFactoryTests
     public async Task ContextualOptionsFactoryDoesNothingWithNoOptionalDependenciesProvided()
     {
         var sut = new ContextualOptionsFactory<List<string>>(
-            new OptionsFactory<List<string>>(Enumerable.Empty<IConfigureOptions<List<string>>>(), Enumerable.Empty<IPostConfigureOptions<List<string>>>()),
             Enumerable.Empty<ILoadContextualOptions<List<string>>>(),
-            Enumerable.Empty<IPostConfigureContextualOptions<List<string>>>(),
-            Enumerable.Empty<IValidateContextualOptions<List<string>>>());
+            Enumerable.Empty<IConfigureOptions<List<string>>>(),
+            Enumerable.Empty<IPostConfigureOptions<List<string>>>(),
+            Enumerable.Empty<IValidateOptions<List<string>>>());
 
-        var result = await new ContextualOptions<List<string>>(sut).GetAsync(Mock.Of<IOptionsContext>(), default);
+        var result = await new ContextualOptions<List<string>, IOptionsContext>(sut).GetAsync(Mock.Of<IOptionsContext>(), default);
 
         Assert.Empty(result);
     }
@@ -33,10 +35,10 @@ public async Task ContextualOptionsFactoryDoesNothingWithNoOptionalDependenciesP
     public async Task DefaultValidatorsFailValidationForAnyInstanceName()
     {
         var sut = new ContextualOptionsFactory<List<string>>(
-            new OptionsFactory<List<string>>(Enumerable.Empty<IConfigureOptions<List<string>>>(), Enumerable.Empty<IPostConfigureOptions<List<string>>>()),
             Enumerable.Empty<ILoadContextualOptions<List<string>>>(),
-            Enumerable.Empty<IPostConfigureContextualOptions<List<string>>>(),
-            new[] { new ValidateContextualOptions<List<string>>(null, _ => false, "epic fail") });
+            Enumerable.Empty<IConfigureOptions<List<string>>>(),
+            Enumerable.Empty<IPostConfigureOptions<List<string>>>(),
+            new[] { new ValidateOptions<List<string>>(null, _ => false, "epic fail") });
 
         await Assert.ThrowsAsync<OptionsValidationException>(async () => await sut.CreateAsync(string.Empty, Mock.Of<IOptionsContext>(), default));
         await Assert.ThrowsAsync<OptionsValidationException>(async () => await sut.CreateAsync("A Name", Mock.Of<IOptionsContext>(), default));
@@ -46,10 +48,10 @@ public async Task DefaultValidatorsFailValidationForAnyInstanceName()
     public async Task NamedValidatorsFailValidationOnlyForNamedInstance()
     {
         var sut = new ContextualOptionsFactory<List<string>>(
-            new OptionsFactory<List<string>>(Enumerable.Empty<IConfigureOptions<List<string>>>(), Enumerable.Empty<IPostConfigureOptions<List<string>>>()),
             Enumerable.Empty<ILoadContextualOptions<List<string>>>(),
-            Enumerable.Empty<IPostConfigureContextualOptions<List<string>>>(),
-            new[] { new ValidateContextualOptions<List<string>>("Foo", _ => false, "epic fail") });
+            Enumerable.Empty<IConfigureOptions<List<string>>>(),
+            Enumerable.Empty<IPostConfigureOptions<List<string>>>(),
+            new[] { new ValidateOptions<List<string>>("Foo", _ => false, "epic fail") });
 
         await Assert.ThrowsAsync<OptionsValidationException>(async () => await sut.CreateAsync("Foo", Mock.Of<IOptionsContext>(), default));
         Assert.Empty(await sut.CreateAsync("Bar", Mock.Of<IOptionsContext>(), default));
@@ -66,10 +68,10 @@ public async Task PostConfigureRunsAfterLoad()
             };
 
         var sut = new ContextualOptionsFactory<List<string>>(
-            new OptionsFactory<List<string>>(Enumerable.Empty<IConfigureOptions<List<string>>>(), Enumerable.Empty<IPostConfigureOptions<List<string>>>()),
             loaders,
-            new[] { new PostConfigureContextualOptions<List<string>>(string.Empty, (_, list) => list.Add("post configure")) },
-            Enumerable.Empty<IValidateContextualOptions<List<string>>>());
+            Enumerable.Empty<IConfigureOptions<List<string>>>(),
+            new[] { new PostConfigureOptions<List<string>>(string.Empty, (list) => list.Add("post configure")) },
+            Enumerable.Empty<IValidateOptions<List<string>>>());
 
         var result = await sut.CreateAsync(string.Empty, Mock.Of<IOptionsContext>(), default);
 
@@ -86,11 +88,11 @@ public async Task NamedLoadersLoadOnlyNamedOptions()
                 (context, _) => new ValueTask<IConfigureContextualOptions<List<string>>>(new ConfigureContextualOptions<List<string>>((_, list) => list.Add("configure"), context)))
             };
 
-        var sut = new ContextualOptions<List<string>>(new ContextualOptionsFactory<List<string>>(
-            new OptionsFactory<List<string>>(Enumerable.Empty<IConfigureOptions<List<string>>>(), Enumerable.Empty<IPostConfigureOptions<List<string>>>()),
+        var sut = new ContextualOptions<List<string>, IOptionsContext>(new ContextualOptionsFactory<List<string>>(
             loaders,
-            Enumerable.Empty<IPostConfigureContextualOptions<List<string>>>(),
-            Enumerable.Empty<IValidateContextualOptions<List<string>>>()));
+            Enumerable.Empty<IConfigureOptions<List<string>>>(),
+            Enumerable.Empty<IPostConfigureOptions<List<string>>>(),
+            Enumerable.Empty<IValidateOptions<List<string>>>()));
 
         Assert.Equal(new[] { "configure" }, await sut.GetAsync("Foo", Mock.Of<IOptionsContext>(), default));
         Assert.Empty(await sut.GetAsync("Bar", Mock.Of<IOptionsContext>(), default));
@@ -107,10 +109,10 @@ public async Task DefaultLoadersLoadAllOptions()
             };
 
         var sut = new ContextualOptionsFactory<List<string>>(
-            new OptionsFactory<List<string>>(Enumerable.Empty<IConfigureOptions<List<string>>>(), Enumerable.Empty<IPostConfigureOptions<List<string>>>()),
             loaders,
-            Enumerable.Empty<IPostConfigureContextualOptions<List<string>>>(),
-            Enumerable.Empty<IValidateContextualOptions<List<string>>>());
+            Enumerable.Empty<IConfigureOptions<List<string>>>(),
+            Enumerable.Empty<IPostConfigureOptions<List<string>>>(),
+            Enumerable.Empty<IValidateOptions<List<string>>>());
 
         Assert.Equal(new[] { "configure" }, await sut.CreateAsync("Foo", Mock.Of<IOptionsContext>(), default));
         Assert.Equal(new[] { "configure" }, await sut.CreateAsync("Bar", Mock.Of<IOptionsContext>(), default));
@@ -120,10 +122,10 @@ public async Task DefaultLoadersLoadAllOptions()
     public async Task DefaultPostConfigureConfiguresAllOptions()
     {
         var sut = new ContextualOptionsFactory<List<string>>(
-            new OptionsFactory<List<string>>(Enumerable.Empty<IConfigureOptions<List<string>>>(), Enumerable.Empty<IPostConfigureOptions<List<string>>>()),
             Enumerable.Empty<ILoadContextualOptions<List<string>>>(),
-            new[] { new PostConfigureContextualOptions<List<string>>(null, (_, list) => list.Add("post configure")) },
-            Enumerable.Empty<IValidateContextualOptions<List<string>>>());
+            Enumerable.Empty<IConfigureOptions<List<string>>>(),
+            new[] { new PostConfigureOptions<List<string>>(null, (list) => list.Add("post configure")) },
+            Enumerable.Empty<IValidateOptions<List<string>>>());
 
         Assert.Equal(new[] { "post configure" }, await sut.CreateAsync("Foo", Mock.Of<IOptionsContext>(), default));
         Assert.Equal(new[] { "post configure" }, await sut.CreateAsync("Bar", Mock.Of<IOptionsContext>(), default));
@@ -133,15 +135,29 @@ public async Task DefaultPostConfigureConfiguresAllOptions()
     public async Task NamePostConfigureConfiguresOnlyNamedOptions()
     {
         var sut = new ContextualOptionsFactory<List<string>>(
-            new OptionsFactory<List<string>>(Enumerable.Empty<IConfigureOptions<List<string>>>(), Enumerable.Empty<IPostConfigureOptions<List<string>>>()),
             Enumerable.Empty<ILoadContextualOptions<List<string>>>(),
-            new[] { new PostConfigureContextualOptions<List<string>>("Foo", (_, list) => list.Add("post configure")) },
-            Enumerable.Empty<IValidateContextualOptions<List<string>>>());
+            Enumerable.Empty<IConfigureOptions<List<string>>>(),
+            new[] { new PostConfigureOptions<List<string>>("Foo", (list) => list.Add("post configure")) },
+            Enumerable.Empty<IValidateOptions<List<string>>>());
 
         Assert.Equal(new[] { "post configure" }, await sut.CreateAsync("Foo", Mock.Of<IOptionsContext>(), default));
         Assert.Empty(await sut.CreateAsync("Bar", Mock.Of<IOptionsContext>(), default));
     }
 
+    [Fact]
+    public async Task ConfigureConfiguresOnlyOptions()
+    {
+        var sut = new ContextualOptionsFactory<List<string>>(
+            Enumerable.Empty<ILoadContextualOptions<List<string>>>(),
+            new[] { new ConfigureOptions<List<string>>((list) => list.Add("pre configure")) },
+            Enumerable.Empty<IPostConfigureOptions<List<string>>>(),
+            Enumerable.Empty<IValidateOptions<List<string>>>());
+
+        Assert.Empty(await sut.CreateAsync("Foo", Mock.Of<IOptionsContext>(), default));
+        Assert.Equal(new[] { "pre configure" }, await sut.CreateAsync(Options.DefaultName, Mock.Of<IOptionsContext>(), default));
+        Assert.Empty(await sut.CreateAsync("Bar", Mock.Of<IOptionsContext>(), default));
+    }
+
     [Fact]
     [SuppressMessage(
         "Minor Code Smell",
@@ -176,10 +192,10 @@ public async Task LoadsRunConcurrentlyWhileConfiguresRunSequentially()
         };
 
         var sut = new ContextualOptionsFactory<List<string>>(
-            new OptionsFactory<List<string>>(Enumerable.Empty<IConfigureOptions<List<string>>>(), Enumerable.Empty<IPostConfigureOptions<List<string>>>()),
             loaders,
-            Enumerable.Empty<IPostConfigureContextualOptions<List<string>>>(),
-            Enumerable.Empty<IValidateContextualOptions<List<string>>>());
+            Enumerable.Empty<IConfigureOptions<List<string>>>(),
+            Enumerable.Empty<IPostConfigureOptions<List<string>>>(),
+            Enumerable.Empty<IValidateOptions<List<string>>>());
 
         Assert.Equal(new[] { "1", "2", "3", "4" }, await sut.CreateAsync(string.Empty, Mock.Of<IOptionsContext>(), default));
     }
@@ -198,10 +214,10 @@ public async Task CreateAsyncAggregatesAllExceptions()
         };
 
         var sut = new ContextualOptionsFactory<List<string>>(
-            new OptionsFactory<List<string>>(Enumerable.Empty<IConfigureOptions<List<string>>>(), Enumerable.Empty<IPostConfigureOptions<List<string>>>()),
             loaders,
-            Enumerable.Empty<IPostConfigureContextualOptions<List<string>>>(),
-            Enumerable.Empty<IValidateContextualOptions<List<string>>>());
+            Enumerable.Empty<IConfigureOptions<List<string>>>(),
+            Enumerable.Empty<IPostConfigureOptions<List<string>>>(),
+            Enumerable.Empty<IValidateOptions<List<string>>>());
 
         var exception = await Assert.ThrowsAsync<AggregateException>(async () => await sut.CreateAsync(string.Empty, Mock.Of<IOptionsContext>(), default));
         Assert.Equal(2, exception.InnerExceptions.Count);
@@ -223,10 +239,10 @@ public async Task CreateAsyncCallsDisposeEvenAfterExceptions()
         };
 
         var sut = new ContextualOptionsFactory<List<string>>(
-            new OptionsFactory<List<string>>(Enumerable.Empty<IConfigureOptions<List<string>>>(), Enumerable.Empty<IPostConfigureOptions<List<string>>>()),
             loaders,
-            Enumerable.Empty<IPostConfigureContextualOptions<List<string>>>(),
-            Enumerable.Empty<IValidateContextualOptions<List<string>>>());
+            Enumerable.Empty<IConfigureOptions<List<string>>>(),
+            Enumerable.Empty<IPostConfigureOptions<List<string>>>(),
+            Enumerable.Empty<IValidateOptions<List<string>>>());
 
         var exception = await Assert.ThrowsAsync<AggregateException>(async () => await sut.CreateAsync(string.Empty, Mock.Of<IOptionsContext>(), default));
         Assert.Equal(2, exception.InnerExceptions.Count);
diff --git a/test/Libraries/Microsoft.Extensions.Options.ContextualOptions.Tests/ContextualOptionsServiceCollectionExtensionsTests.cs b/test/Libraries/Microsoft.Extensions.Options.ContextualOptions.Tests/ContextualOptionsServiceCollectionExtensionsTests.cs
index 118831b4586..bd490dda445 100644
--- a/test/Libraries/Microsoft.Extensions.Options.ContextualOptions.Tests/ContextualOptionsServiceCollectionExtensionsTests.cs
+++ b/test/Libraries/Microsoft.Extensions.Options.ContextualOptions.Tests/ContextualOptionsServiceCollectionExtensionsTests.cs
@@ -5,6 +5,8 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options.Contextual.Internal;
+using Microsoft.Extensions.Options.Contextual.Provider;
 using Moq;
 using Xunit;
 
@@ -19,8 +21,8 @@ public void AddContextualOptionsTest()
 
         using var provider = new ServiceCollection().AddContextualOptions().BuildServiceProvider();
 
-        Assert.IsType<ContextualOptions<object>>(provider.GetRequiredService<IContextualOptions<object>>());
-        Assert.IsType<ContextualOptions<object>>(provider.GetRequiredService<INamedContextualOptions<object>>());
+        Assert.IsType<ContextualOptions<object, WeatherForecastContext>>(provider.GetRequiredService<IContextualOptions<object, WeatherForecastContext>>());
+        Assert.IsType<ContextualOptions<object, WeatherForecastContext>>(provider.GetRequiredService<INamedContextualOptions<object, WeatherForecastContext>>());
         Assert.IsType<ContextualOptionsFactory<object>>(provider.GetRequiredService<IContextualOptionsFactory<object>>());
     }
 
@@ -47,57 +49,24 @@ public async Task ConfigureDirectTest()
     }
 
     [Fact]
-    public void PostConfigureAllTest()
+    public void ConfigureAllWithLoadTest()
     {
-        Action<IOptionsContext, string> configureOptions = (_, _) => { };
-        using var provider = new ServiceCollection().PostConfigureAll(configureOptions).BuildServiceProvider();
-        var postConfigure = (PostConfigureContextualOptions<string>)provider.GetRequiredService<IPostConfigureContextualOptions<string>>();
-
-        Assert.Equal(configureOptions, postConfigure.Action);
-        Assert.Null(postConfigure.Name);
-    }
-
-    [Fact]
-    public void PostConfigureDefaultTest()
-    {
-        Action<IOptionsContext, string> configureOptions = (_, _) => { };
-        using var provider = new ServiceCollection().PostConfigure(configureOptions).BuildServiceProvider();
-        var postConfigure = (PostConfigureContextualOptions<string>)provider.GetRequiredService<IPostConfigureContextualOptions<string>>();
+        Func<IOptionsContext, CancellationToken, ValueTask<IConfigureContextualOptions<string>>> loadOptions =
+            (_, _) => new ValueTask<IConfigureContextualOptions<string>>(NullConfigureContextualOptions.GetInstance<string>());
 
-        Assert.Equal(configureOptions, postConfigure.Action);
-        Assert.Equal(string.Empty, postConfigure.Name);
+        using var provider = new ServiceCollection().ConfigureAll(loadOptions).BuildServiceProvider();
+        var loader = (LoadContextualOptions<string>)provider.GetRequiredService<ILoadContextualOptions<string>>();
+        Assert.Equal(loadOptions, loader.LoadAction);
+        Assert.Null(loader.Name);
     }
 
     [Fact]
-    public void PostConfigureNamedTest()
+    public async Task ConfigureAllDirectTest()
     {
         Action<IOptionsContext, string> configureOptions = (_, _) => { };
-        using var provider = new ServiceCollection().PostConfigure("Foo", configureOptions).BuildServiceProvider();
-        var postConfigure = (PostConfigureContextualOptions<string>)provider.GetRequiredService<IPostConfigureContextualOptions<string>>();
-
-        Assert.Equal(configureOptions, postConfigure.Action);
-        Assert.Equal("Foo", postConfigure.Name);
-    }
-
-    [Fact]
-    public void ValidateDefaultTest()
-    {
-        Func<string, bool> validate = _ => true;
-        using var provider = new ServiceCollection().ValidateContextualOptions(validate, "epic fail").BuildServiceProvider();
-        var validateOptions = (ValidateContextualOptions<string>)provider.GetRequiredService<IValidateContextualOptions<string>>();
-
-        Assert.Equal(validate, validateOptions.Validation);
-        Assert.Equal(string.Empty, validateOptions.Name);
-    }
-
-    [Fact]
-    public void ValidateNamedTest()
-    {
-        Func<string, bool> validate = _ => true;
-        using var provider = new ServiceCollection().ValidateContextualOptions("Foo", validate, "epic fail").BuildServiceProvider();
-        var validateOptions = (ValidateContextualOptions<string>)provider.GetRequiredService<IValidateContextualOptions<string>>();
-
-        Assert.Equal(validate, validateOptions.Validation);
-        Assert.Equal("Foo", validateOptions.Name);
+        using var provider = new ServiceCollection().ConfigureAll(configureOptions).BuildServiceProvider();
+        var loader = (LoadContextualOptions<string>)provider.GetRequiredService<ILoadContextualOptions<string>>();
+        Assert.Equal(configureOptions, ((ConfigureContextualOptions<string>)await loader.LoadAction(Mock.Of<IOptionsContext>(), default)).ConfigureOptions);
+        Assert.Null(loader.Name);
     }
 }