How to read request body in an asp net core webapi controller

Question

I m trying to read the request body in the OnActionExecuting method  but I always get null for the body  var request   context HttpContext Request  var stream   new StreamReader request Body   var body   stream ReadToEnd     I have tried to explicitly set the stream position to 0  but that also didn t work  Since this is ASP NET Core  things are a little different I think  I can see all the samples here referring to old web API versions  Is there any other way of doing this

User · Answer

The simplest possible way to do this is the following:

In the Controller method you need to extract the body from, add this parameter: [FromBody] SomeClass value
Declare the "SomeClass" as: class SomeClass { public string SomeParameter { get; set; } }

When the raw body is sent as json, .net core knows how to read it very easily.

User · Answer

for read of Body   you can to read asynchronously   use the async method like follow   public async Task lt IActionResult gt  GetBody           string body           using  StreamReader stream   new StreamReader Request Body                      body   await stream ReadToEndAsync                return Json body       Test with postman     It s working well and tested in Asp net core version 2 0   2 1   2 2  3 0   I hope is useful

User · Answer

I also wanted to read the Request Body without automatically map it to some action parameter model  Tested a lot of different ways before solved this  And I didn  t find any working solution described here  This solution is currently based on the  NET Core 3 0 framework   reader readToEnd   seamed like a simple way  even though it compiled  it throwed an runtime exception required me to use async call  So instead I used ReadToEndAsync    however it worked sometimes  and sometimes not  Giving me errors like  cannot read after stream is closed  The problem is that we cannot guarantee that it will return the result in the same thread  even if we use the await   So we need some kind of callback  This solution worked for me    Route   controller   action     public class MyController   ControllerBase                     HttpPost      public async void TheAction                 try                       HttpContext Request EnableBuffering                Request Body Position   0              using  StreamReader stream   new StreamReader HttpContext Request Body                                 var task   stream                      ReadToEndAsync                        ContinueWith t   gt                            var res   t Result                             TODO  Handle the post result                                              await processing of the result                 task Wait                                    catch  Exception ex                         logger LogError ex   Failed to handle post

User · Answer

In ASP Net Core it seems complicated to read several times the body request  however if your first attempt does it the right way  you should be fine for the next attempts    I read several turnaround for example by substituting the body stream  but I think the following is the cleanest   The most important points being    to let the request know that you will read its body twice or more times   to not close the body stream  and  to rewind it to its initial position so the internal process does not get lost     EDIT   As pointed out by Murad  you may also take advantage of the  Net Core 2 1 extension  EnableBuffering It stores large requests onto the disk instead of keeping it in memory  avoiding large-streams issues stored in memory  files  images         You can change the temporary folder by setting ASPNETCORE TEMP environment variable  and files are deleted once the request is over   In an AuthorizationFilter  you can do the following      Helper to enable request stream rewinds using Microsoft AspNetCore Http Internal        public class EnableBodyRewind   Attribute  IAuthorizationFilter       public void OnAuthorization AuthorizationFilterContext context                var bodyStr               var req   context HttpContext Request              Allows using several time the stream in ASP Net Core         req EnableRewind                 Arguments  Stream  Encoding  detect encoding  buffer size             AND  the most important  keep stream opened         using  StreamReader reader                      new StreamReader req Body  Encoding UTF8  true  1024  true                         bodyStr   reader ReadToEnd                          Rewind  so the core is not lost when it looks the body for the request         req Body Position   0              Do whatever work with bodyStr here             public class SomeController   Controller        HttpPost  MyRoute         EnableBodyRewind      public IActionResult SomeAction  FromBody MyPostModel model                    play the body string again           Then you can use the body again in the request handler    In your case if you get a null result  it probably means that the body has already been read at an earlier stage  In that case you may need to use a middleware  see below    However be careful if you handle large streams  that behavior implies that everything is loaded into memory  this should not be triggered in case of a file upload   You may want to use this as a Middleware  Mine looks like this  again  if you download upload large files  this should be disabled to avoid memory issues    public sealed class BodyRewindMiddleware       private readonly RequestDelegate  next       public BodyRewindMiddleware RequestDelegate next                 next   next             public async Task Invoke HttpContext context                try   context Request EnableRewind      catch             await  next context              context Request Body Dipose   might be added to release memory  not tested         public static class BodyRewindExtensions       public static IApplicationBuilder EnableRequestBodyRewind this IApplicationBuilder app                if  app    null                        throw new ArgumentNullException nameof app                       return app UseMiddleware lt BodyRewindMiddleware gt

User · Answer

To those who simply want to get the content  request body  from the request    Use the  FromBody  attribute in your controller method parameter     Route  api mytest     ApiController  public class MyTestController   Controller        HttpPost       Route  content        public async Task lt string gt  ReceiveContent  FromBody  string content                   Do work with content           As doc says  this attribute specifies that a parameter or property should be bound using the request body

User · Answer

The IHttpContextAccessor method does work if you wish to go this route    TLDR    Inject the IHttpContextAccessor Rewind -- HttpContextAccessor HttpContext Request Body Seek 0  System IO SeekOrigin Begin   Read --  System IO StreamReader sr   new System IO StreamReader HttpContextAccessor HttpContext Request Body   JObject asObj   JObject Parse sr ReadToEnd        More -- An attempt at a concise  non-compiling  example of the items you ll need to ensure are in place in order to get at a useable IHttpContextAccessor  Answers have pointed out correctly that you ll need to seek back to the start when you try to read the request body  The CanSeek  Position properties on the request body stream helpful for verifying this    NET Core DI Docs     First -- Make the accessor DI available       Add an IHttpContextAccessor to your ConfigureServices method  found by default    in your Startup cs file     Extraneous junk removed for some brevity  public void ConfigureServices IServiceCollection services           Typical items found in ConfigureServices      services AddMvc config   gt    config Filters Add typeof ExceptionFilterAttribute                           Add or ensure that an IHttpContextAccessor is available within your Dependency Injection container     services AddSingleton lt IHttpContextAccessor  HttpContextAccessor gt           Second -- Inject the accessor       Elsewhere in the constructor of a class in which you want    to access the incoming Http request  typically     in a controller class of yours  public class MyResourceController   Controller       public ILogger lt PricesController gt  Logger   get        public IHttpContextAccessor HttpContextAccessor   get         public CommandController          ILogger lt CommandController gt  logger          IHttpContextAccessor httpContextAccessor                Logger   logger          HttpContextAccessor   httpContextAccessor                            Lastly -- a typical use       Route  command resource-a  id          HttpPut      public ObjectResult PutUpdate  FromRoute  string id   FromBody  ModelObject requestModel                if  HttpContextAccessor HttpContext Request Body CanSeek                        HttpContextAccessor HttpContext Request Body Seek 0  System IO SeekOrigin Begin               System IO StreamReader sr   new System IO StreamReader HttpContextAccessor HttpContext Request Body               JObject asObj   JObject Parse sr ReadToEnd                  var keyVal   asObj ContainsKey  key-a

User · Answer

Writing an extension method is the most efficient way in my opinion  public static string PeekBody this HttpRequest request                        try                               request EnableBuffering                    var buffer   new byte Convert ToInt32 request ContentLength                    request Body Read buffer  0  buffer Length                   return Encoding UTF8 GetString buffer                             finally                               request Body Position   0                           You can use Request Body Peeker Nuget Package as well  source code    Return string var request   HttpContext Request PeekBody       Return in expected type LoginRequest request   HttpContext Request PeekBody lt LoginRequest gt        Return in expected type asynchronously LoginRequest request   await HttpContext Request PeekBodyAsync lt LoginRequest gt

User · Answer

Recently I came across a very elegant solution that take in random JSON that you have no idea the structure        HttpPost      public JsonResult Test  FromBody  JsonElement json                return Json json           Just that easy

User · Answer

I was able to read request body in an asp net core 3 1 application like this  together with a simple middleware that enables buffering -enable rewinding seems to be working for earlier  Net Core versions-     var reader   await Request BodyReader ReadAsync    Request Body Position   0  var buffer   reader Buffer  var body   Encoding UTF8 GetString buffer FirstSpan   Request Body Position   0

User · Answer

I had a similar issue when using ASP NET Core 2 1    I need a custom middleware to read the POSTed data and perform some security checks against it using an authorization filter is not practical  due to large number of actions that are affected I have to allow objects binding in the actions   FromBody  someObject   Thanks to SaoBiz for pointing out this solution    So  the obvious solution is to allow the request to be rewindable  but make sure that after reading the body  the binding still works   EnableRequestRewindMiddleware  public class EnableRequestRewindMiddleware       private readonly RequestDelegate  next           lt inheritdoc  gt      public EnableRequestRewindMiddleware RequestDelegate next                 next   next                  lt summary gt                    lt  summary gt           lt param name  context  gt  lt  param gt           lt returns gt  lt  returns gt      public async Task Invoke HttpContext context                context Request EnableRewind            await  next context             Startup cs   place this at the beginning of Configure method   app UseMiddleware lt EnableRequestRewindMiddleware gt       Some other middleware  This is part of the middleware that requires unpacking of the POSTed information for checking stuff   using  var stream   new MemoryStream             make sure that body is read from the beginning     context Request Body Seek 0  SeekOrigin Begin       context Request Body CopyTo stream       string requestBody   Encoding UTF8 GetString stream ToArray             this is required  otherwise model binding will return null     context Request Body Seek 0  SeekOrigin Begin

User · Answer

A quick way to add response buffering in  NET Core 3 1 is     app Use  context  next    gt                context Request EnableBuffering            return next             in Startup cs  I found this also guarantees that buffering will be enabled before the stream has been read  which was a problem for  Net Core 3 1 with some of the other middleware authorization filter answers I ve seen  Then you can read your request body via HttpContext Request Body in your handler as several others have suggested  Also worth considering is that EnableBuffering has overloads that allow you to limit how much it will buffer in memory before it uses a temporary file  and also an overall limit to you buffer  NB if a request exceeds this limit an exception will be thrown and the request will never reach your handler

User · Answer

To be able to rewind the request body   Jean s answer helped me come up with a solution that seems to work well  I currently use this for Global Exception Handler Middleware but the principle is the same   I created a middleware that basically enables the rewind on the request body  instead of a decorator    using Microsoft AspNetCore Http Internal        public class EnableRequestRewindMiddleware       private readonly RequestDelegate  next       public EnableRequestRewindMiddleware RequestDelegate next                 next   next             public async Task Invoke HttpContext context                context Request EnableRewind            await  next context            public static class EnableRequestRewindExtension       public static IApplicationBuilder UseEnableRequestRewind this IApplicationBuilder builder                return builder UseMiddleware lt EnableRequestRewindMiddleware gt               This can then be used in your Startup cs like so         public void Configure IApplicationBuilder app  IHostingEnvironment env  ILoggerFactory loggerFactory                  app UseEnableRequestRewind                  Using this approach  I have been able to rewind the request body stream successfully

User · Answer

Here s a solution for POSTed JSON body that doesn t require any middleware or extensions  all you need is to override OnActionExecuting to have access to all of the data set in the body or even the arguments in the URL  using System Text Json         public override void OnActionExecuting ActionExecutingContext filterContext        base OnActionExecuting filterContext               You can simply use filterContext ActionArguments to get whatever param that you have set in the action        For instance you can get the  quot json quot  param like this  filterContext ActionArguments  quot json quot          Or better yet just loop through the arguments and find the type     foreach var elem in filterContext ActionArguments                if elem Value is JsonElement                           Convert json obj to string             var json     JsonElement elem Value  GetRawText                break                      HttpPost  public IActionResult Add  FromBody  JsonElement json  string id   1        return Ok  quot v1 quot

User · Answer

A clearer solution  works in ASP Net Core 2 1   3 1  Filter class  using Microsoft AspNetCore Authorization     For ASP NET 2 1 using Microsoft AspNetCore Http Internal     For ASP NET 3 1 using Microsoft AspNetCore Http  using Microsoft AspNetCore Mvc Filters   public class ReadableBodyStreamAttribute   AuthorizeAttribute  IAuthorizationFilter       public void OnAuthorization AuthorizationFilterContext context                   For ASP NET 2 1            context HttpContext Request EnableRewind               For ASP NET 3 1            context HttpContext Request EnableBuffering              In an Controller   HttpPost   ReadableBodyStream  public string SomePostMethod           Note  if you re late and body has already been read  you may need this next line       Note2  if  Note  is true and Body was read using StreamReader too  then it may be necessary to set  leaveOpen  true  for that stream      HttpContext Request Body Seek 0  SeekOrigin Begin        using  StreamReader stream   new StreamReader HttpContext Request Body                 string body   stream ReadToEnd               body    param somevalue amp param2 someothervalue

User · Answer

This is a bit of an old thread  but since I got here  I figured I d post my findings so that they might help others   First  I had the same issue  where I wanted to get the Request Body and do something with that  logging auditing    But otherwise I wanted the endpoint to look the same   So  it seemed like the EnableBuffering   call might do the trick   Then you can do a Seek 0 xxx  on the body and re-read the contents  etc    However  this led to my next issue   I d get  Synchornous operations are disallowed  exceptions when accessing the endpoint   So  the workaround there is to set the property AllowSynchronousIO   true  in the options   There are a number of ways to do accomplish this  but not important to detail here     THEN  the next issue is that when I go to read the Request Body it has already been disposed   Ugh   So  what gives   I am using the Newtonsoft JSON as my  FromBody  parser in the endpiont call   That is what is responsible for the synchronous reads and it also closes the stream when it s done   Solution   Read the stream before it get s to the JSON parsing   Sure  that works and I ended up with this         lt summary gt      quick and dirty middleware that enables buffering the request body      lt  summary gt       lt remarks gt      this allows us to re-read the request body s inputstream so that we can capture the original request as is      lt  remarks gt  public class ReadRequestBodyIntoItemsAttribute   AuthorizeAttribute  IAuthorizationFilter       public void OnAuthorization AuthorizationFilterContext context                if  context    null  return              NEW  enable sync IO beacuse the JSON reader apparently doesn t use async and it throws an exception otherwise         var syncIOFeature   context HttpContext Features Get lt IHttpBodyControlFeature gt             if  syncIOFeature    null                        syncIOFeature AllowSynchronousIO   true               var req   context HttpContext Request               req EnableBuffering                    read the body here as a workarond for the JSON parser disposing the stream             if  req Body CanSeek                                req Body Seek 0  SeekOrigin Begin                       if body  stream  can seek  we can read the body to a string for logging purposes                 using  var reader   new StreamReader                       req Body                       encoding  Encoding UTF8                       detectEncodingFromByteOrderMarks  false                       bufferSize  8192                       leaveOpen  true                                         var jsonString   reader ReadToEnd                            store into the HTTP context Items  request body                       context HttpContext Items Add  request body   jsonString                                         go back to beginning so json reader get s the whole thing                 req Body Seek 0  SeekOrigin Begin                                     So now  I can access the body using the HttpContext Items  request body   in the endpoints that have the  ReadRequestBodyIntoItems  attribute   But man  this seems like way too many hoops to jump through   So here s where I ended  and I m really happy with it   My endpoint started as something like    HttpPost       ReadRequestBodyIntoItems   Consumes  application json    public async Task lt IActionResult gt  ReceiveSomeData  FromBody  MyJsonObjectType value        val bodyString   HttpContext Items  request body           use the body  process the stuff        But it is much more straightforward to just change the signature  like so    HttpPost       Consumes  application json    public async Task lt IActionResult gt  ReceiveSomeData         using  var reader   new StreamReader             Request Body             encoding  Encoding UTF8             detectEncodingFromByteOrderMarks  false                      var bodyString   await reader ReadToEndAsync             var value   JsonConvert DeserializeObject lt MyJsonObjectType gt  bodyString               use the body  process the stuff              I really liked this because it only reads the body stream once  and I have have control of the deserialization   Sure  it s nice if ASP NET core does this magic for me  but here I don t waste time reading the stream twice  perhaps buffering each time   and the code is quite clear and clean   If you need this functionality on lots of endpoints  perhaps the middleware approaches might be cleaner  or you can at least encapsulate the body extraction into an extension function to make the code more concise    Anyways  I did not find any source that touched on all 3 aspects of this issue  hence this post   Hopefully this helps someone   BTW  This was using ASP  NET Core 3 1

[c#] How to read request body in an asp.net core webapi controller?

Examples related to c#

Examples related to asp.net-web-api

Examples related to asp.net-core