Ricezione di dati JSON indietro dalla richiesta HTTP

Ho una richiesta web che funziona correttamente, ma restituisce solo lo stato OK, ma ho bisogno che l'oggetto che chiedo venga restituito. Non sono sicuro di come ottenere il valore json che sto richiedendo. Sono nuovo nell'uso dell'oggetto HttpClient, c'è una proprietà che mi sto perdendo? Ho davvero bisogno dell'oggetto restituito. Grazie per qualsiasi aiuto

Effettuare la chiamata - funziona correttamente restituisce lo stato OK.

HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Accept
  .Add(new MediaTypeWithQualityHeaderValue("application/json"));
var responseMsg = client.GetAsync(string.Format("http://localhost:5057/api/Photo")).Result;

Il metodo api get

//Cut out alot of code but you get the idea
public string Get()
{
    return JsonConvert.SerializeObject(returnedPhoto);
}

Se si fa riferimento a System.Net.HttpClient in .NET 4.5, è possibile ottenere il contenuto restituito da GetAsync utilizzando la proprietà HttpResponseMessage.Content come oggetto derivato da HttpContent . È quindi possibile leggere il contenuto in una stringa utilizzando il metodo HttpContent.ReadAsStringAsync o come flusso utilizzando il metodo ReadAsStreamAsync .

La documentazione della classe HttpClient include questo esempio:

  HttpClient client = new HttpClient();
  HttpResponseMessage response = await client.GetAsync("http://www.contoso.com/");
  response.EnsureSuccessStatusCode();
  string responseBody = await response.Content.ReadAsStringAsync();

Basandosi sulla risposta di @Panagiotis Kanavos , ecco un metodo di lavoro come esempio che restituirà anche la risposta come oggetto anziché come stringa:

using System.Text;
using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json; // Nuget Package

public static async Task<object> PostCallAPI(string url, object jsonObject)
{
    try
    {
        using (HttpClient client = new HttpClient())
        {
            var content = new StringContent(jsonObject.ToString(), Encoding.UTF8, "application/json");
            var response = await client.PostAsync(url, content);
            if (response != null)
            {
                var jsonString = await response.Content.ReadAsStringAsync();
                return JsonConvert.DeserializeObject<object>(jsonString);
            }
        }
    }
    catch (Exception ex)
    {
        myCustomLogger.LogException(ex);
    }
    return null;
}

Tieni presente che questo è solo un esempio e che probabilmente vorresti usare HttpClientcome istanza condivisa invece di usarlo in una clausola using.

Installa questo pacchetto nuget da Microsoft System.Net.Http.Json. Contiene metodi di estensione.

Quindi aggiungere using System.Net.Http.Json

Ora sarai in grado di vedere questi metodi:

Quindi ora puoi farlo:

await httpClient.GetFromJsonAsync<IList<WeatherForecast>>("weatherforecast");

Fonte: https://www.stevejgordon.co.uk/sending-and-receiving-json-using-httpclient-with-system-net-http-json

Penso che la via più breve sia:

var client = new HttpClient();
string reqUrl = $"http://myhost.mydomain.com/api/products/{ProdId}";
var prodResp = await client.GetAsync(reqUrl);
if (!prodResp.IsSuccessStatusCode){
    FailRequirement();
}
var prods = await prodResp.Content.ReadAsAsync<Products>();

Quello che faccio normalmente, simile a rispondere a uno:

var response = await httpClient.GetAsync(completeURL); // http://192.168.0.1:915/api/Controller/Object

if (response.IsSuccessStatusCode == true)
    {
        string res = await response.Content.ReadAsStringAsync();
        var content = Json.Deserialize<Model>(res);

// do whatever you need with the JSON which is in 'content'
// ex: int id = content.Id;

        Navigate();
        return true;
    }
    else
    {
        await JSRuntime.Current.InvokeAsync<string>("alert", "Warning, the credentials you have entered are incorrect.");
        return false;
    }

Dove "modello" è la classe del modello C #.

Funziona bene per me nel modo seguente:

public async Task<object> TestMethod(TestModel model)
    {
        try
        {
            var apicallObject = new
            {
                Id= model.Id,
                name= model.Name
            };

            if (apicallObject != null)
            {
                var bodyContent = JsonConvert.SerializeObject(apicallObject);
                using (HttpClient client = new HttpClient())
                {
                    var content = new StringContent(bodyContent.ToString(), Encoding.UTF8, "application/json");
                    content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
                    client.DefaultRequestHeaders.Add("access-token", _token); // _token = access token
                    var response = await client.PostAsync(_url, content); // _url =api endpoint url
                    if (response != null)
                    {
                        var jsonString = await response.Content.ReadAsStringAsync();

                        try
                        {
                            var result = JsonConvert.DeserializeObject<TestModel2>(jsonString); // TestModel2 = deserialize object
                        }
                        catch (Exception e){
                            //msg
                            throw e;
                        }
                    }
                }
            }
        }
        catch (Exception ex)
        {
            throw ex;
        }
        return null;
    }