Background and Motivation

Quote from #49982:

I aim to leverage a ProblemDetailsFactory implementation (say the DefaultProblemDetailsFactory class) without adding MVC services to a Minimal API project.

More context: I'm updating older code to support .NET 7-8 that uses the ProblemDetailsFactory to generate ProblemDetails instances. The workaround was to call AddMvcCore then, which was kinda ok since there was only MVC before. However, now that we have Minimal APIs, adding MVC dependencies to a non-MVC project makes no sense.

On top of that, the proposed API will bring the two Problem Details spaces one tiny step closer and more unified without introducing any breaking changes.

Proposed API

The proposed API is to add a new AddDefaultProblemDetailsFactory extension method that registers the default DefaultProblemDetailsFactory class and update the AddMvcCore method to leverage that extension instead.

Since the Microsoft.AspNetCore.Http abstractions seem like a better place than MVC to consolidate Problem Details classes, I suggest adding the extension method there if possible. The suggested AddDefaultProblemDetailsFactory method would look like this:

namespace Microsoft.Extensions.DependencyInjection;
public static class DefaultProblemDetailsFactoryExtensions
{
    public static IServiceCollection AddDefaultProblemDetailsFactory(this IServiceCollection services)
    {
        services.TryAddSingleton<ProblemDetailsFactory, DefaultProblemDetailsFactory>();
        // Optional:
         services.TryAddEnumerable(ServiceDescriptor.Singleton<IProblemDetailsWriter, DefaultApiProblemDetailsWriter>());
    }
}

Update to MVC AddMvcCoreServices method:

// ...
namespace Microsoft.Extensions.DependencyInjection;
public static class MvcCoreServiceCollectionExtensions
{
    // ...
    internal static void AddMvcCoreServices(IServiceCollection services)
    {
        // ...
        // ProblemDetails
+       services.AddDefaultProblemDetailsFactory();
-       services.TryAddSingleton<ProblemDetailsFactory, DefaultProblemDetailsFactory>();
        // Optional: 
-       services.TryAddEnumerable(ServiceDescriptor.Singleton<IProblemDetailsWriter, DefaultApiProblemDetailsWriter>());
    }
}

See the MvcCoreServiceCollectionExtensions class.

In case the team wants to consolidate the optional dependency from the preceding code blocks, they could also consider adapting the AddProblemDetails method of the ProblemDetailsServiceCollectionExtensions class to use this extension as well:

// ...
namespace Microsoft.Extensions.DependencyInjection;
public static class ProblemDetailsServiceCollectionExtensions
{
    // ...
    public static IServiceCollection AddProblemDetails(
        this IServiceCollection services,
        Action<ProblemDetailsOptions>? configure)
    {
        // ...
+       services.AddDefaultProblemDetailsFactory();
-        services.TryAddEnumerable(ServiceDescriptor.Singleton<IProblemDetailsWriter, DefaultProblemDetailsWriter>());
        // ...
    }
}

Of course, doing what the preceding code block suggests would add an additional dependency not used by the ProblemDetailsService class (the ProblemDetailsFactory) but would centralize the registering of the default IProblemDetailsWriter, which would guarantee that both MVC and Minimal APIs are aligned in their default implementation.

Usage Examples

One could register the factory like this (Program.cs):

builder.Services.AddDefaultProblemDetailsFactory();

Alternative Designs

Please refer to the following issue for more info about alternate designs and thoughts put into this proposal in conjunction with @captainsafia: #49982.

Risks

No foreseeable risks.