ASP.NET Core Pitfalls – Posting a String

This is another post on my ASP.NET Core pitfalls series. It is actually related to this one ASP.NET Core Pitfalls – Null Models in Post Requests.

What happens if you try to submit a string containing JSON as a POST? I mean, you always submit strings, but this time you don't want for it to be parsed into some class. Like this:
[HttpPost]
public IActionResult PostString([FromBody] string json) { ... }

You may be surprised to find out that this fails with a HTTP 415 Unsupported Media Type.

Now, you might be tempted to add an [Consumes] attribute to it, such as:

[HttpPost]
[Consumes("application/json")]
public IActionResult PostString([FromBody] string json) { ... }

And this will actually work! The problem is, or could be, that it requires the sender to send the appropriate Content-Type header ("application/json").

Another, better, solution is to just read the string from the from the request stream:

[HttpPost]
public IActionResult PostString()
{
    using var reader = new StreamReader(HttpContext.Request.Body));
    var json = reader.ReadToEnd();
    ...
}

Of course, this could be made asynchronous, as StreamReader has a ReadToEndAsync method.

Yet another option is to add a custom input formatter, a class that implements IInputFormatter, one that just accepts a string, which needs to be registered globally:

builder.Services.AddControllersWithViews(static options =>
{
    options.InputFormatters.Insert(0, new StringInputFormatter());
});

One example would be:

internal class StringInputFormatter : IInputFormatter
{
    public bool CanRead(InputFormatterContext context)
    {
        var canRead = context.HttpContext.Request.Method == HttpMethods.Post 
            && context.HttpContext.Request.ContentLength > 0;
        return canRead;
    }

    public async Task<InputFormatterResult> ReadAsync(InputFormatterContext context)
    {
        using var reader = new StreamReader(context.HttpContext.Request.Body);
        var content = await reader.ReadToEndAsync();
        return await InputFormatterResult.SuccessAsync(content);
    }
}

As you can see that there's a lot more involved than with the other two solutions.

Hope this comes useful!

Location: Coimbra, Portugal

Comments

Post a Comment

Popular posts from this blog

Audit Trails in EF Core

Introduction Audit trails is a common feature in database systems. Essentially, it's about knowing, for every table (or some selected ones), who created/updated each record, and when the creates/updates happened. It can also be useful to store the previous values too. Some regulations, such as SOX , require this for compliance. There are some libraries that can do this automatically in EF Core , and there's also the Change Data Capture in SQL Server (and possibly other databases too), of which I wrote about some time ago, but, hey, I wanted to write my own, so here is EFAuditable , my library for doing audit trails in EF Core. This one is designed with some extensibility in mind, so, please, read on. Scenarios EFAuditable  allows the following scenarios: Entities marked for auditing will have the audit columns added and persisted automatically to the database, on the same table Entities marked for history keeping will have their old values (in the case of updates or deletes) ...
Read more

.NET Cancellation Tokens

Introduction Cancellation tokens in .NET were introduced as part of the  .NET 4 Cancellation Framework . Essentially, it is a standard, cooperative, way to request for the cancellation of the execution of an operation. By cooperative it means that the code that uses it must abide to some rules, as opposed to the cancellation just stopping (killing) the execution. One example of cancellation is, on a web app, when the client closes the connection while the server is performing some long operation. In cases such as this, we may want to abort the operation, as we are not sending the results anywhere (or not, as we shall see). Because of this, ASP.NET Core allows us to add a parameter of type  CancellationToken  to our asynchronous actions, it is automatically associated with the client and is therefore signalled when the client connection is closed. A  CancellationToken  is, essentially, behind the scenes, a ManualResetEvent . Throughout this article I will either ...
Read more

Domain Events with .NET

Introduction Domain Events  is a pattern and concept made popular by Domain Driven Design . A Domain Event is something that happened on your system and you want interested-parties to know about. It is a way to publish information in a decoupled, usually asynchronous, way. A publisher publishes (raises) an event, and interested subscribers receive a notification and act accordingly. A subscriber can also be a publisher, of course. In this post I'm going to present a Domain Events library for .NET. It's not the first time that I write about decoupling messages and subscribers in an application, I implemented a few years ago the Postal.NET library which does something similar. Mind you, there are many implementations out there, MediatR coming first to my mind, but this is mine. I obviously got some ideas from other implementations, but mine is substantially different from all the others. Concepts First, a few concepts: An event is just some class that implements IDomainEvent A...
Read more