I have a .NET 8 web API controller with the following endpoint method in it :

[HttpPost()]
[Route("someRoute")]
[ProducesResponseType(typeof(SomeResponse), StatusCodes.Status200OK)]
public async Task<IActionResult> GetSomething([FromForm] SomeComplexRequest request, CancellationToken cancellationToken)
{
    //Map request to some MediatR command, send and get result

    return Ok(result.Value);
}

What it actually does internally is irrelevant to my issue. This endpoint worked perfectly prior to me introducing Refit to my project (I was using custom-built HttpClient implementations).

The SomeComplexRequest class looks like this :

public sealed class SomeComplexRequest
{
    [Required]
    [FromForm(Name = "SomeID")]
    public Guid? SomeID { get; set; }

    [Required]
    [FromForm(Name = "Offset")]
    public int? Offset { get; set; }

    [Required]
    [FromForm(Name = "Length")]
    public int? Length { get; set; }

    public SomeComplexRequest(Guid? someID, int? offset, int? length)
    {
        SomeID = someID;
        Offset = offset;
        Length = length;
    }

    public SomeComplexRequest()
    {
    }
}

My issue is that my Refit method ONLY works if it’s written like this :

[Post("/api/SomeController/someRoute")]
[Multipart]
Task<ApiResponse<IEnumerable<SomeResponse>>> GetSomething(string someID, int offset, int length);

My understanding of the SomeID’s Guid vs. string situation is that Refit does not actually support Guid as a parameter type. That is not ideal but is really not a huge issue as the controller ultimately still understands that parameter regardless if it’s sent as a Guid or string. What I find extremely annoying though is that the Refit method seems to require listing all the individual parameters that constitute my request instead of just accepting an instance of SomeComplexRequest regardless of the Id being a Guid or string. It seems to be unable to break down the request into it’s individual parameters. This signature does not work :

[Post("/api/SomeController/someRoute")]
[Multipart]
Task<ApiResponse<IEnumerable<SomeResponse>>> GetSomething(SomeComplexRequest request);

I have tons of non-Multipart endpoints (annotated with FromBody in the api controller method) and those work fine with similar complex request objects (which have Guids in them as well mind you). This is one of them :

[Post("/api/SomeOtherController")]
Task<ApiResponse<SomeOtherResponse>> AddSomeComplexThing(SomeEvenMoreComplexRequest);

I won’t show that request for brevity but it has 8 parameters including strings, Guids and Enums. That method has FromBody in the endpoint method’s parameter and it works fine.

Is it expected that Multipart methods do not support complex objects as input parameters like normal JSON bodied method do?