Targeting net461, HttpClient throws ex when GET request has content, but works with netstandard2.0

Question

I need to use 3rd party web api.
On this specific endpoint I need to make GET request with content body (json).

var jsonPayload = JsonConvert.SerializeObject(myObject);

var request = new HttpRequestMessage(HttpMethod.Get, endpoint)
{
    Content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
};

var client = new HttpClient();
var response = await client.SendAsync(request); //<-- explodes with net461,
//but works with netstandard2.0
var responseContent = await response.Content.ReadAsStringAsync();

I targeted that code to netstandard2.0 and it worked.
However I now need to use in project where I target net461 and it throws exception saying "Cannot send a content-body with this verb-type"

I understand that it is not usual to set content to GET request, but that api is out of my reach.

1. How come HttpClient.Send(request) failed when I target net461, but works well when I target netstandard2.0?
2. What options do I have when I target net461?

Update

A way to reproduce.

ConsoleApp.csproj

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.0</TargetFramework> <!-- toggle this to net461 -->
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
  </ItemGroup>

  <ItemGroup>
    <Reference Include="System.Net.Http" />
  </ItemGroup>

</Project>

Program.cs

using Newtonsoft.Json;
using System;
using System.Net.Http;
using System.Text;

namespace ConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            var jsonPayload = JsonConvert.SerializeObject(new { });
            var request = new HttpRequestMessage(HttpMethod.Get, "http://www.stackoverflow.com")
            {
                Content = new StringContent(jsonPayload, Encoding.UTF8, "application/json")
            };
            var client = new HttpClient();
            var response = client.SendAsync(request).Result;
            var responseContent = response.Content.ReadAsStringAsync().Result;
            Console.WriteLine(responseContent);
        }
    }
}

dotnet --version shows 2.1.104

Answer 1

You didn't mention on which .net version you run it when it works (because you can target net standard but you cannot run on net standard). So I assume that when it works you run it on .NET Core, and when it does not you run on full .NET 4.6.1 as you said.

Then it's just because it was implemented differently in .NET Core and full .NET Framework, as described in this issue. There is nothing wrong with either implementation, because RFC says:

A payload within a GET request message has no defined semantics;
sending a payload body on a GET request might cause some existing
implementations to reject the request.

So, having body in GET (while almost never a good practice) does not by itself contradict that RFC. One implementation (older) was designed to reject it, but another (newer) was designed to allow it, there is nothing more to that.

As for your second question "What options do I have when I target net461". I don't think there are easy workarounds, because that's the behavior of HttpWebRequest, not specifically of HttpClient. And almost anything that makes web requests uses HttpWebRequest internally.

There are ugly hacks using reflections though. Your example can be modified like this (works only when running on full .NET):

static void Main(string[] args) {     
    // UGLY HACK!       
    var verbType = typeof(HttpWebRequest).Assembly.GetType("System.Net.KnownHttpVerb");
    var getMethodField = verbType.GetField("Get", BindingFlags.Static | BindingFlags.NonPublic);
    var getMethod = getMethodField.GetValue(null);
    verbType.GetField("ContentBodyNotAllowed", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(getMethod, false);
    var jsonPayload = JsonConvert.SerializeObject(new { });
    var request = new HttpRequestMessage(HttpMethod.Get, "http://www.stackoverflow.com")
    {
        Content = new StringContent(jsonPayload, Encoding.UTF8, "application/json")
    };
    var client = new HttpClient();
    var response = client.SendAsync(request).Result;
    var responseContent = response.Content.ReadAsStringAsync().Result;
    Console.WriteLine(responseContent);            
}

Basically we use reflection to modify internal field named ContentBodyNotAllowed of KnownHttpVerb.Get to false. Use at your own risk.