Working with request body in ASP.NET Core

-
During API development, we might often want to read the raw request body for logging or signature validation. In case of ASP.NET Core, we could use EnableRewind() to read the request body multiple times. 


using (var reader = new StreamReader(Request.Body))
{
    var body = reader.ReadToEnd();
    Request.Body.Seek(0, SeekOrigin.Begin);
}


However, if we are to use StreamReader to read the request body, we will dispose the StreamReader using the using statement. This is a mistake if we are to read the request body in the future. Hence, we should use the following way instead. The following snippet is being taken from inside a Controller.







// Read the request body, but do not dispose it
var stream = new StreamReader(httpContextAccessor.HttpContext.Request.Body);            
stream.BaseStream.Position = 0;
requestBody = await stream.ReadToEndAsync();

httpContextAccessor.HttpContext.Request.Body.Seek(0, SeekOrigin.Begin);

Comments

Post a Comment

Popular posts from this blog

ASP.NET Core service locator pattern

-
There are many posts out there which specifically say that we should not use service locator pattern (unless necessary), which we would not be able to determine the dependencies during compile time because the dependencies are hidden. However, I am going to point out an issue in case if you need to use it, in the context of ASP.NET Core projects. I have a class Foo , which will be bind to IFoo , and I will need to configure a named HttpClient for that class via the following extension,   services.AddHttpClient<IFoo, Foo>(); If we do the above, Foo will be treated as an object which is Singleton injected. In case you are not aware, we cannot inject services which has a smaller lifespan than the service itself. Hence, we cannot inject services which are transient or scoped into Foo . Here comes the problem, what should we do? That's where service locator pattern comes to the rescue! There might be other way, but let's say we decide to use the service locator provide
Read more

Caching and generic query using NHibernate [.NET Core]

-
One of the important aspects in API design is to reduce the number of fetch request to database. NHibernate provides 2 levels of caching, with the first level cache persist through a session only, while the 2nd level cache persists across multiple sessions. The second level cache can be implemented by installing the NuGet package of NHibernate.Caches.SysCache . Then, it involves some configuration setup to utilize the cache feature. However, there is an alternative way that exists in .NET Core which we could use to build a simpler cache. The caching that we could use is IMemoryCache . Firstly, we could setup the cache during  ConfigureServices . public void ConfigureServices(IServiceCollection services) { services.AddMemoryCache(); } Then, assuming we want to retrieve all the records from a table called DailySales , and we want to keep the records in the cache for 1 minute, we could do the following. private readonly IMemoryCache cache; public DBHelper(IMemory
Read more