[FromForm]: Support for Polymorphic Types

[jaliyaudagedara]

Is there an existing issue for this?

• I have searched the existing issues

Describe the bug

Consider the below POCO classes:

public class SomeHttpRequestModel
{
    public OptionsBase Options { get; set; }
}

[JsonDerivedType(typeof(ClassificationOptions), nameof(ClassificationOptions))]
[JsonDerivedType(typeof(AnalyzeOptions), nameof(AnalyzeOptions))]
public class OptionsBase
{
    public string? CommonOption1 { get; set; } = null;
}

public class ClassificationOptions : OptionsBase
{
    public string? ClassificationOption1 { get; set; } = null;
}

public class AnalyzeOptions : OptionsBase
{
    public string? AnalyzeOption1 { get; set; } = null;
}

Now I have the following Controller.

[ApiController]
[Route("[controller]")]
public class ValuesController : ControllerBase
{
    [HttpPost("/FromBody", Name = "PostFromBody")]
    public IActionResult PostFromBody([FromBody] SomeHttpRequestModel someHttpRequestModel)
    {
        return Ok(someHttpRequestModel);
    }

    [HttpPost("/FromForm", Name = "PostFromForm")]
    public IActionResult PostFromForm([FromForm] SomeHttpRequestModel someHttpRequestModel)
    {
        return Ok(someHttpRequestModel);
    }
}

Now when I call /FromBody,

@WebApplication1_HostAddress = http://localhost:5001

POST {{WebApplication1_HostAddress}}/FromBody/
Content-Type: application/json

{
    "options": {
        "$type": "ClassificationOptions",
        "commonOption1": "SomeCommonOption1",
        "classificationOption1": "someClassificationOption1"
    }
}

It's deserializing as expected.

Now when I call /FromForm,

curl --location 'http://localhost:5001/FromForm' `
--form 'options.$type="ClassificationOptions"' `
--form 'options.commonOption1="SomeCommonOption1"' `
--form 'options.classificationOption1="SomeClassificationOption1"'

It's not getting deserialized correctly.

Expected Behavior

FromForm should use same deserialization as FromBody

Steps To Reproduce

https://github.com/jaliyaudagedara/aspnetcore-minimal-repros/tree/main/fromform-jsonderivedtypes

Exceptions (if any)

No response

.NET Version

10.0.100-preview.2.25164.34

Anything else?

No response

[jaliyaudagedara]

I did the following workaround and it appears to be working.
jaliyaudagedara/aspnetcore-minimal-repros@30ba616

public class SomeHttpRequestModelBinder : IModelBinder
{
    private Dictionary<Type, (ModelMetadata, IModelBinder)> binders;

    public SomeHttpRequestModelBinder(Dictionary<Type, (ModelMetadata, IModelBinder)> binders)
    {
        this.binders = binders;
    }

    public async Task BindModelAsync(ModelBindingContext bindingContext)
    {
        string modelKindName = ModelNames.CreatePropertyModelName(bindingContext.ModelName, "$type");
        string? modelTypeValue = bindingContext.ValueProvider.GetValue(modelKindName).FirstValue;

        IModelBinder modelBinder;
        ModelMetadata modelMetadata;
        if (modelTypeValue == nameof(ClassificationOptions))
        {
            (modelMetadata, modelBinder) = binders[typeof(ClassificationOptions)];
        }
        else if (modelTypeValue == nameof(AnalyzeOptions))
        {
            (modelMetadata, modelBinder) = binders[typeof(AnalyzeOptions)];
        }
        else
        {
            bindingContext.Result = ModelBindingResult.Failed();
            return;
        }

        ModelBindingContext newBindingContext = DefaultModelBindingContext.CreateBindingContext(
            bindingContext.ActionContext,
            bindingContext.ValueProvider,
            modelMetadata,
            bindingInfo: null,
            bindingContext.ModelName);

        await modelBinder.BindModelAsync(newBindingContext);
        bindingContext.Result = newBindingContext.Result;

        if (newBindingContext.Result.IsModelSet)
        {
            // Setting the ValidationState ensures properties on derived types are correctly 
            bindingContext.ValidationState[newBindingContext.Result.Model] = new ValidationStateEntry
            {
                Metadata = modelMetadata,
            };
        }
    }
}

public class SomeHttpRequestModelBinderProvider : IModelBinderProvider
{
    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        if (context.Metadata.ModelType != typeof(OptionsBase))
        {
            return null;
        }

        Type[] subclasses = [typeof(ClassificationOptions), typeof(AnalyzeOptions),];

        var binders = new Dictionary<Type, (ModelMetadata, IModelBinder)>();
        foreach (Type type in subclasses)
        {
            ModelMetadata modelMetadata = context.MetadataProvider.GetMetadataForType(type);
            binders[type] = (modelMetadata, context.CreateBinder(modelMetadata));
        }

        return new SomeHttpRequestModelBinder(binders);
    }
}

And register ModelBinderProvider,

builder.Services.AddControllers(options =>
{
    options.ModelBinderProviders.Insert(0, new SomeHttpRequestModelBinderProvider());
});