Postman Form Data to ASP.NET Core 2.2 Controller not binding to Command with private setters

user_1127683 0
Viewed 694

Tools

  • Visual Studio 2017
  • ASP.NET Core 2.2
  • Postman v7.2.0

What I'm trying to do

Send FormData from Postman to an ASP.NET Core controller and have the data from the request bind to to a command class that has properties with private setters.

I've sent JSON data using the same setup (private setters) with no problem. The FromBody attribute deserialises the JSON string to the model without errors.

The Problem

Properties that are primitive types do not bind if the model has a private setter. However, complex types do regardless of the access modifier.

Controller

[HttpPost]
[ProducesResponseType((int)HttpStatusCode.OK)]
[ProducesResponseType((int)HttpStatusCode.BadRequest)]
public async Task<IActionResult> CreateItemAsync([FromForm]CreateItemCommand command)
{
    bool result = false;

    commandResult = await _mediator.Send(command);

    if (!commandResult)
    {
        return BadRequest();
    }

    return Ok();
}

Command

Note: The Title property has been left with a public setter deliberately to illustrate the behviour

[DataContract]
public class CreateItemCommand
    :IRequest<bool>
{
    [DataMember]
    public string Title { get; set; }

    [DataMember]
    public string Description { get; private set; }

    [DataMember]
    public int Count { get; private set; }

    [DataMember]
    public HashSet<string> Tags { get; private set; }

    [DataMember]
    public string ItemDate { get; private set; }

    [DataMember]
    public List<IFormFile> Documents { get; private set; }

    public CreateItemCommand()
    {
        Skills = new HashSet<string>();
        Systems = new HashSet<string>();
    }

    public CreateItemCommand(string title, string description, 
        int count, HashSet<string> tags, string itemDate, 
        List<IFormFile> documents)
        : this()
    {
        Title = title;
        Description = description;
        Count = count
        Tags = tags;
        ItemDate = itemDate;
        Documents = documents;
    }
}

In Postman I now setup the request as follows:

enter image description here

I've had to obfuscate some of the information, but you can see that the primitive types with private setters are not set.

enter image description here

Questions

  1. Why does the property access modifier only affect properties with primitive types?
  2. Why does this happens when the parameter attribute is set to FromForm but not when it's set to FromBody
postman asp.net-core c#
1 Answers

Why does the property access modifier only affect properties with primitive types?

For Asp.Net Core ModelBinder, it will check whether the property is private access setter by ComplexTypeModelBinder code below: 

protected virtual object CreateModel(ModelBindingContext bindingContext)
{
    if (bindingContext == null)
    {
        throw new ArgumentNullException(nameof(bindingContext));
    }

    // If model creator throws an exception, we want to propagate it back up the call stack, since the
    // application developer should know that this was an invalid type to try to bind to.
    if (_modelCreator == null)
    {
        // The following check causes the ComplexTypeModelBinder to NOT participate in binding structs as
        // reflection does not provide information about the implicit parameterless constructor for a struct.
        // This binder would eventually fail to construct an instance of the struct as the Linq's NewExpression
        // compile fails to construct it.
        var modelTypeInfo = bindingContext.ModelType.GetTypeInfo();
        if (modelTypeInfo.IsAbstract || modelTypeInfo.GetConstructor(Type.EmptyTypes) == null)
        {
            var metadata = bindingContext.ModelMetadata;
            switch (metadata.MetadataKind)
            {
                case ModelMetadataKind.Parameter:
                    throw new InvalidOperationException(
                        Resources.FormatComplexTypeModelBinder_NoParameterlessConstructor_ForParameter(
                            modelTypeInfo.FullName,
                            metadata.ParameterName));
                case ModelMetadataKind.Property:
                    throw new InvalidOperationException(
                        Resources.FormatComplexTypeModelBinder_NoParameterlessConstructor_ForProperty(
                            modelTypeInfo.FullName,
                            metadata.PropertyName,
                            bindingContext.ModelMetadata.ContainerType.FullName));
                case ModelMetadataKind.Type:
                    throw new InvalidOperationException(
                        Resources.FormatComplexTypeModelBinder_NoParameterlessConstructor_ForType(
                            modelTypeInfo.FullName));
            }
        }

        _modelCreator = Expression
            .Lambda<Func<object>>(Expression.New(bindingContext.ModelType))
            .Compile();
    }

    return _modelCreator();
}

Why does this happens when the parameter attribute is set to FromForm but not when it's set to FromBody

For FromBody, it is used JsonInputFormatter to bind the model from the body request, it's used JsonConvert.DeserializeObject to deserilize the object and Newtonsoft.Json support deserize the object which contains private setter from json string.

user_62656200
Related