Attributes added by custom ModelMetadataProvider are not being considered in model-binding

Disclaimer: this is a long one. Unreasonable knowledge of ASP.NET Core MVC internals is almost certainly required. Here be dragons.

Background

I am trying to implement a method for augmenting type metadata in ASP.NET MVC Core.

The reason I want to do this is that my data models are used by multiple projects, so I've shared them by placing them in a NuGet package:

// defined in NuGet package
public class MyModel
{
    public int MyProperty { get; set; }

    public MyNestedModel NestedModel { get; set; }
}

public class MyNestedModel
{
    public bool NestedProperty { get; set; }
}

^{^ Listing 1}

However, some of the projects will need to apply additional metadata to the model types - for example, in the case of an ASP.NET Core project, these models will be used as inputs and therefore participate in model-binding, so they require FromQuery, FromHeader etc. attributes applied. I obviously cannot do this in the package, as different consumer projects will need to apply different attributes depending on their use cases.

The simplest and mostly guaranteed-to-work way is to modify all model properties to be virtual and then have subclasses that override those properties as necessary to add attributes:

// defined in NuGet package
public class MyModel
{
    public virtual int MyProperty { get; set; }

    public virtual MyNestedModel NestedModel { get; set; }
}

public class MyNestedModel
{
    public virtual bool NestedProperty { get; set; }
}

// defined in ASP.NET MVC project consuming above package
public class MyViewModel : MyModel
{
    [FromQuery(Name = "foo")]
    public override int MyProperty { get; set; }

    public new // can't use override, as type is different
        MyNestedViewModel NestedModel { get; set; }
}

[Bind(Prefix = "")]
public class MyNestedViewModel : MyNestedModel
{
    [FromQuery(Name = "bar")]
    public override bool NestedProperty { get; set; }
}

^{^ Listing 2}

I don't want to do this, because in every model that has a child model property, that child model has to be subclassed, and then it cannot be used as an override but has to be re-declared with new - and the semantics of new won't work for me here. Also, I don't really intend for the model types to be subclassed.

I'm aware of ModelMetadataTypeAttribute but the intended usage of that attribute is on the model type to be augmented, not the type doing the augmenting. Since in my case there's no way to know ahead of time what the actual metadata types will be (as they're defined in the consuming projects), I cannot use ModelMetadataTypeAttribute. Subclasses and partial classes will also not work - ModelMetadataTypeAttribute only applies to the class specified, partial cannot span across assemblies.

Solution

Essentially, a "reverse" version of ModelMetadataTypeAttribute that is applied on the type doing the augmenting, pointing back to the model type to be augmented:

// defined in ASP.NET MVC project consuming package from Listing 1
[ReverseModelMetadataType(typeof(MyModel))]
public class MyModelMetadata
{
    [FromQuery(Name = "foo")]
    public int MyProperty { get; set; }

    public MyNestedModel NestedModel { get; set; }
}

[ReverseModelMetadataType(typeof(NestedModel))]
[Bind(Prefix = "")]
public class NestedModelMetadata
{
    [FromQuery(Name = "bar")]
    public bool NestedProperty { get; set; }
}

^{^ Listing 3}

The intention is that at runtime, the model-binding infrastructure will pick up that MyModel.MyProperty should be bound using [FromQuery(Name = "foo")], i.e. from the query string as a variable named foo. Similarly, MyModel.NestedModel.NestedProperty should be simply bound as bar from the query string.

In order to make this work I've implemented a custom ModelMetadataProvider that inherits DefaultModelMetadataProvider and overrides the CreatePropertyDetails method:

// defined in same ASP.NET Core MVC project as Listing 3
public class MyModelMetadataProvider : DefaultModelMetadataProvider
{
    protected override DefaultMetadataDetails[] CreatePropertyDetails(ModelMetadataIdentity key)
    {
        var defaultPropertyDetails = base.CreatePropertyDetails(key);

        // check if the key.ModelType should be augmented
        // if so, mutate the relevant element(s) of the defaultPropertyDetails array to do the augmentation

        return defaultPropertyDetails;
    }
}

The mutation part effectively changes the relevant DefaultMetadataDetails.ModelAttributes member to have the additional attributes applied to the properties of the type(s) decorated with ReverseModelMetadataTypeAttribute. I then get ASP.NET MVC Core to use my provider instead of its DefaultModelMetadataProvider via the following in Startup.cs#ConfigureServices:

services.AddSingleton<IModelMetadataProvider, MyModelMetadataProvider>();

I have verified that provider is registered and the mutation code works correctly: MyModelMetadataProvider.CreatePropertyDetails is hit and the defaultPropertyDetails returned do contain the extra attributes applied by my *ModelMetadata classes from Listing 3.

Problem

Model binding does not work: ASP.NET Core MVC essentially behaves as if the attributes added via Listing 3 do not exist, and I don't know why. As far as I'm aware, the results of the calls to the various IModelMetadataProvider methods are cached then used for all subsequent lookup of metadata that's required, including for the purposes of binding models.

I'm hoping that somebody can provide some advice on how to get this to work, before I have to go through the pain of stepping through the ASP.NET Core source myself.