how to post plain text to ASP.NET Web API endpoint?

Question

I have an ASP.NET Web API endpoint with controller action defined as follows :

[HttpPost]
public HttpResponseMessage Post([FromBody] object text)

If my post request body contains plain text ( i.e. should not be interpreted as json, xml, or any other special format ), then I thought I could just include following header to my request :

Content-Type: text/plain

However, I receive error :

No MediaTypeFormatter is available to read an object of type 'Object' from content with media type 'text/plain'.

If I change my controller action method signature to :

[HttpPost]
public HttpResponseMessage Post([FromBody] string text)

I get a slightly different error message :

No MediaTypeFormatter is available to read an object of type 'String' from content with media type 'text/plain'.

don't you want your "text" parameter to be of the type string then? — Marvin Smit, Sep 02 '14 at 20:43
yes i thought of that idea too but it doesn't help much ( please see my revised question ) — BaltoStar, Sep 02 '14 at 21:37
@BaltoStar I know your question is 8 month old but I faced the same problem. See my answer below. — gwenzek, Apr 28 '15 at 08:38
Hi BaltoStar, could you mark @gzou's answer as the answer? That would help the community seeing it as the answer. Thks — benjguin, May 26 '16 at 16:53

score 69 · Answer 1 · answered Apr 28 '15 at 08:36

Actually it's a shame that web API doesn't have a MediaTypeFormatter for plain text. Here is the one I implemented. It can also be used to Post content.

public class TextMediaTypeFormatter : MediaTypeFormatter
{
    public TextMediaTypeFormatter()
    {
        SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/plain"));
    }

    public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
    {
        var taskCompletionSource = new TaskCompletionSource<object>();
        try
        {
            var memoryStream = new MemoryStream();
            readStream.CopyTo(memoryStream);
            var s = System.Text.Encoding.UTF8.GetString(memoryStream.ToArray());
            taskCompletionSource.SetResult(s);
        }
        catch (Exception e)
        {
            taskCompletionSource.SetException(e);
        }
        return taskCompletionSource.Task;
    }

    public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, System.Net.TransportContext transportContext, System.Threading.CancellationToken cancellationToken)
    {
        var buff = System.Text.Encoding.UTF8.GetBytes(value.ToString());
        return writeStream.WriteAsync(buff, 0, buff.Length, cancellationToken);
    }

    public override bool CanReadType(Type type)
    {
        return type == typeof(string);
    }

    public override bool CanWriteType(Type type)
    {
        return type == typeof(string);
    }
}

You need to "register" this formatter in your HttpConfig by something like that:

config.Formatters.Insert(0, new TextMediaTypeFormatter());

I wonder why not simplify ReadFromStreamAsync method to just: return await new StreamReader(readStream).ReadToEndAsync(); — Marat Asadurian, Jan 03 '19 at 21:01
My MediaTypeFormatter does not have the Cancellation Token parameter on `WriteToStreamAsync`. Works when I removed that argument. — Shiasu-sama, Feb 06 '19 at 09:40

score 18 · Answer 2 · edited Jul 05 '19 at 15:55

18

Since Web API doesn't have out of box formatter for handling text/plain, some options:

Modify your action to have no parameters... reason is having parameters triggers request body de-serialization. Now you can read the request content explicitly by doing await Request.Content.ReadAsStringAsync() to get the string
Write a custom MediaTypeFormatter to handle 'text/plain'... it's actually simple to write in this case and you could keep the parameters on the action.

edited Jul 05 '19 at 15:55

Andrew

13,934
8
78
93

answered Sep 02 '14 at 22:00

Kiran Challa

53,599
15
167
151

Thanks for the response Kiran. Actually, my action signature has additional [FromUri] parameters, which I left out to keep my question simple. So I guess this means I can't avoid implicit de-serialization of request body ? In which case I need to write a custom MediaTypeFormatter to handle 'text/plain' .... – BaltoStar Sep 02 '14 at 23:52
request deserialization would only happen for the parameters which are `normally` considered to be read from body...examples: Explicitly `[FromBody]` decorated parameters, implicitly read from body(ex: complex types)...so my above answer only is for the ones meant to be read from the body...so you should be able to use `FromUri` parameters as usual...but in any case creating a custom formatter is the best approach as it fits well with Web API design.. – Kiran Challa Sep 03 '14 at 11:12
Is it not dangerous to provide this formatter? text/plain is a valid enctype of a HTML form with post method. Be sure to add antiforgery token to prevent cross site request forgery. – yonexbat Apr 08 '18 at 18:43

score 15 · Answer 3 · answered Jul 03 '18 at 09:51

15

In ASP.NET Core 2.0 you simply do the following :-

using (var reader = new StreamReader(Request.Body))
{
      string plainText= reader.ReadToEnd();

      // Do something else

      return Ok(plainText);
}

answered Jul 03 '18 at 09:51

Derek

7,530
9
49
80

1

Simple and perfect! – Fernando JS Aug 18 '18 at 16:32
Helped me out in 2020. It should not have been so difficult to find this answer. Thanks :) – nandtrocity Feb 03 '20 at 11:49

Vitaliy Ulantikov · Answer 4 · 2017-08-31T08:54:43.383

Purified version using of gwenzek's formatter employing async/await:

public class PlainTextFormatter : MediaTypeFormatter
{
    public PlainTextFormatter()
    {
        SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/plain"));
    }

    public override bool CanReadType(Type type) =>
        type == typeof(string);

    public override bool CanWriteType(Type type) =>
        type == typeof(string);

    public override async Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
    {
        var streamReader = new StreamReader(readStream);
        return await streamReader.ReadToEndAsync();
    }

    public override async Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext, CancellationToken cancellationToken)
    {
        var streamReader = new StreamWriter(writeStream);
        await streamReader.WriteAsync((string) value);
    }
}

Please note I intentionally do not dispose StreamReader/StreamWriter, as this will dispose underlying streams and break Web Api flow.

To make use of it, register while building HttpConfiguration:

protected HttpConfiguration CreateHttpConfiguration()
{
    HttpConfiguration httpConfiguration = new HttpConfiguration();
    ...
    httpConfiguration.Formatters.Add(new PlainTextFormatter());
    ...
    return httpConfiguration;
}

What will disposing break specifically? I found that not disposing of them caused error when handling exceptions. — Andrew, Jul 05 '19 at 15:42

score 5 · Answer 5 · answered Sep 29 '16 at 11:15

5

In some situations it might be simpler to let the JsonMediaTypeFormatter let do the work:

var formatter = GlobalConfiguration.Configuration.Formatters.Where(f=>f is System.Net.Http.Formatting.JsonMediaTypeFormatter).FirstOrDefault();
if (!formatter.SupportedMediaTypes.Any( mt => mt.MediaType == "text/plain" ))
    formatter.SupportedMediaTypes.Add( new MediaTypeHeaderValue( "text/plain" ) );

answered Sep 29 '16 at 11:15

mmyta

61
1
2

If I do this and then set the body like this: `resp.Content = new StringContent(outputString, Encoding.UTF8, "text\plain");`, will it just output the string as-is (even if it is not JSON) with the text-plain content-type? – N K Feb 26 '17 at 02:50

score 0 · Answer 6 · answered Feb 11 '20 at 21:57

Very late to this party with a grossly simplified solution. I had success with this code in the controller method:

       public HttpResponseMessage FileHandler()
       {
        HttpResponseMessage response = new HttpResponseMessage();

        using (var reader = new StreamReader(System.Web.HttpContext.Current.Request.GetBufferedInputStream()))
        {
            string plainText = reader.ReadToEnd();
        } .....}

And on the client side, these are the Ajax options I used:

var ajaxOptions = {
url: 'api/fileupload/' + "?" + $.param({ "key": metaKey2, "File-Operation": "Remove", "removalFilePath": $removalFilePath, "Audit-Model": model, "Parent-Id": $parentId, "Audit-Id": $auditId }),
type: 'POST', processData: false, contentType: false, data: "BOB"
};

score 0 · Answer 7 · answered Feb 28 '21 at 20:49

Not a proper answer, but a quick 'n dirty workaround to unblock development...

It turns out that a quote-delimited string by itself is valid JSON. So if you know for sure that the content will always be very simple, you can wrap it in double quotes and call it application/json.

// TODO: Temporary, fix for production
HttpContent content = new StringContent($"\"{command}\"", UTF8Encoding.UTF8, "application/json");

how to post plain text to ASP.NET Web API endpoint?

7 Answers7

Linked