Where is the PostAsJsonAsync method in ASP.NET Core?

I was looking for the PostAsJsonAsync() extension method in ASP.NET Core. Based on this article, it's available in the Microsoft.AspNet.WebApi.Client assembly.

I had thought Microsoft had changed all of the assembly names from Microsoft.AspNet to Microsoft.AspNetCore to be more specific to .NET Core, however, and yet I cannot find an Microsoft.AspNetCore.WebApi.Client assembly.

Where is the PostAsJsonAsync() extension method in ASP.NET Core?

It comes as part of the library Microsoft.AspNet.WebApi.Client https://www.nuget.org/packages/Microsoft.AspNet.WebApi.Client/

I dont deserve any credit for this. Have a look @danroth27 answer in the following link.

> https://github.com/aspnet/Docs/blob/master/aspnetcore/mvc/controllers/testing/sample/TestingControllersSample/tests/TestingControllersSample.Tests/IntegrationTests/HttpClientExtensions.cs

He uses an extension method. Code as below. (Copied from the above github link). I am using it on .Net Core 2.0.

using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Newtonsoft.Json;

namespace TestingControllersSample.Tests.IntegrationTests
{
    public static class HttpClientExtensions
    {
        public static Task<HttpResponseMessage> PostAsJsonAsync<T>(
            this HttpClient httpClient, string url, T data)
        {
            var dataAsString = JsonConvert.SerializeObject(data);
            var content = new StringContent(dataAsString);
            content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
            return httpClient.PostAsync(url, content);
        }

        public static async Task<T> ReadAsJsonAsync<T>(this HttpContent content)
        {
            var dataAsString = await content.ReadAsStringAsync();
            return JsonConvert.DeserializeObject<T>(dataAsString);
        }
    }
}

As of .NET 5.0, this has been (re)introduced as an extension method off of HttpClient, via the System.Net.Http.Json namespace. See the HttpClientJsonExtensions class for details.

Demonstration

It works something like the following:

var httpClient  = new HttpClient();
var url         = "https://StackOverflow.com"
var data        = new MyDto();
var source      = new CancellationTokenSource();

var response    = await httpClient.PostAsJsonAsync<MyDto>(url, data, source.Token);

And, of course, you'll need to reference some namespaces:

using System.Net.Http;          //HttpClient, HttpResponseMessage
using System.Net.Http.Json;     //HttpClientJsonExtensions
using System.Threading;         //CancellationToken
using System.Threading.Tasks;   //Task

Alternatively, if you're using the .NET 6 SDK's implicit using directives, three of these will be included for you, so you'll just need:

using System.Net.Http.Json;     //HttpClientJsonExtensions

Background

This is based on the design document, which was previously referenced by @erandac—though the design has since changed, particularly for the PostAsJsonAsync() method.

Obviously, this doesn't solve the problem for anyone still using .NET Core, but with .NET 5.0 released, this is now the best option.

That is not part of the ASP.NET Core project. However you can proceed with:

HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, "http://myurl/api");
                
string json = JsonConvert.SerializeObject(myObj);
                
request.Content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
                
HttpClient http = new HttpClient();
HttpResponseMessage response = await http.SendAsync(request);
                
if (response.IsSuccessStatusCode)
    {                
    }
else
    {
    }

You Can Use This Extension for use PostAsJsonAsync method in ASP.NET core

using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Newtonsoft.Json;
public static class HttpClientExtensions
{
    public static Task<HttpResponseMessage> PostAsJsonAsync<T>(this HttpClient httpClient, string url, T data)
    {
        var dataAsString = JsonConvert.SerializeObject(data);
        var content = new StringContent(dataAsString);
        content.Headers.ContentType = new MediaTypeHeaderValue("application/json");

        return httpClient.PostAsync(url, content);
    }

    public static Task<HttpResponseMessage> PutAsJsonAsync<T>(this HttpClient httpClient, string url, T data)
    {
        var dataAsString = JsonConvert.SerializeObject(data);
        var content = new StringContent(dataAsString);
        content.Headers.ContentType = new MediaTypeHeaderValue("application/json");

        return httpClient.PutAsync(url, content);
    }

    public static async Task<T> ReadAsJsonAsync<T>(this HttpContent content)
    {
        var dataAsString = await content.ReadAsStringAsync().ConfigureAwait(false);

        return JsonConvert.DeserializeObject<T>(dataAsString);
    }
}

see: httpclient-extensions

this is coming late but I think it may help someone down the line. So the *AsJsonAsync() methods are not part of the ASP.NET Core project. I created a package that gives you the functionality. You can get it on Nuget.

https://www.nuget.org/packages/AspNetCore.Http.Extensions

using AspNetCore.Http.Extensions;
...
HttpClient client = new HttpClient();
client.PostAsJsonAsync('url', payload);

You need to add Nuget package System.Net.Http.Formatting.Extension to your project.

Or you can use

client.PostAsync(uri, new StringContent(data, Encoding.UTF8, "application/json"));

The methodPostAsJsonAsync (along with other *Async methods of the HttpClient class) is indeed available out of the box – without using directives.

Your .csproj file should start with <Project Sdk="Microsoft.NET.Sdk.Web">, and contain the lines

<ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.App" />
</ItemGroup>

I have given a more elaborated answer to a similar question.

(The PackageReference is no longer needed in .NET Core 3.0.)

To follow on from the answers above, I have a small addition that was required for me to get it to work.

Previously I was using a .NET Core 2.1 web app using the PostAsJsonAsync() method, and when I upgraded to .NET Core 3.1 it no longer worked.

I could not get the above answers to work, and it turned out to be because the text to be posted had to be surrounded by quotes, and any quotes within it had to be escaped. I made the following extension method, which solved my problem:

public static async Task<HttpResponseMessage> PostJsonAsync(this HttpClient client, string uri, string json)
{
    //For some reason, not doing this will cause it to fail:
    json = $"\"{json.Replace("\"", "\\\"")}\"";

    return await client.PostAsync(uri, new StringContent(json, Encoding.UTF8, "application/json"));
}

Note that I am using the System.Text.Json.JsonSerializer as opposed to the Newtonsoft version.

make the extension method truly async:

public static async Task<HttpResponseMessage> PostAsJsonAsync<T>(
    this HttpClient httpClient, string url, T data)
{
    var dataAsString = JsonConvert.SerializeObject(data);
    var content = new StringContent(dataAsString);
    content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
    return await httpClient.PostAsync(url, content);
}

If you are trying to use PostJsonAsync, PutJsonAsync or any other json extension methods in Blazor you need to add a following statement

using Microsoft.AspNetCore.Components;

Dotnet core 3.x runtime itself going to have set of extension methods for HttpClient which uses System.Text.Json Serializer

https://github.com/dotnet/designs/blob/main/accepted/2020/json-http-extensions/json-http-extensions.md

If you are in 2021 and having .Net Core 3.1, make sure in your project file csproj, Microsoft.AspNetCore.App is upto date, the latest is 2.2.8. You can check and update the package as below:

<ItemGroup>
    ...
    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.2.8" />
    ...
</ItemGroup>

then restore your project from cli like this:

dotnet restore

i used this in standard 2.0 library

System.Net.Http.Json

using Microsoft.AspNetCore.Blazor.HttpClient