Decompressione del flusso GZip dalla risposta HTTPClient


93

Sto cercando di connettermi a un'API, che restituisce JSON con codifica GZip, da un servizio WCF (servizio WCF al servizio WCF). Sto usando HTTPClient per connettermi all'API e sono stato in grado di restituire l'oggetto JSON come stringa. Tuttavia, devo essere in grado di memorizzare questi dati restituiti in un database e come tale ho pensato che il modo migliore sarebbe stato restituire e memorizzare l'oggetto JSON in un array o byte o qualcosa del genere.

Quello con cui ho problemi in particolare è la decompressione della codifica GZip e ho provato molti esempi diversi ma non riesco ancora a ottenerlo.

Il codice seguente è il modo in cui stabilisco la mia connessione e ricevo una risposta, questo è il codice che restituisce una stringa dall'API.

public string getData(string foo)
{
    string url = "";
    HttpClient client = new HttpClient();
    HttpResponseMessage response;
    string responseJsonContent;
    try
    {
        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
        response = client.GetAsync(url + foo).Result;
        responseJsonContent = response.Content.ReadAsStringAsync().Result;
        return responseJsonContent;
    }
    catch (Exception ex)
    {
        System.Windows.Forms.MessageBox.Show(ex.Message);
        return "";
    }
}

Ho seguito alcuni esempi diversi come queste API StackExchange , MSDN e un paio su stackoverflow, ma non sono riuscito a far funzionare nessuno di questi per me.

Qual è il modo migliore per farlo, sono anche sulla strada giusta?

Grazie ragazzi.


"il modo migliore sarebbe restituire e memorizzare l'oggetto JSON in un array o in un byte" Nota che una stringa è un array di byte.
user3285954

Risposte:


232

Basta istanziare HttpClient in questo modo:

HttpClientHandler handler = new HttpClientHandler()
{
    AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
};

using (var client = new HttpClient(handler))
{
    // your code
}

Aggiornamento del 19 giugno 2020: non è consigliabile utilizzare httpclient in un blocco "using" in quanto potrebbe causare l'esaurimento delle porte.

private static HttpClient client = null;

ContructorMethod()
{
   if(client == null)
   {
        HttpClientHandler handler = new HttpClientHandler()
        {
            AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
        };        
        client = new HttpClient(handler);
   }
// your code            
 }

Se usi .Net Core 2.1+, considera l'utilizzo di IHttpClientFactory e l' inserimento in questo modo nel codice di avvio.

 var timeout = Policy.TimeoutAsync<HttpResponseMessage>(
            TimeSpan.FromSeconds(60));

 services.AddHttpClient<XApiClient>().ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler
        {
            AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
        }).AddPolicyHandler(request => timeout);

Se utilizzo questa struttura, come faccio a recuperare il contenuto della mia risposta da httpClient? Sono super nuovo in c # e non credo di averlo capito.
FoxDeploy

1
@FoxDeploy non è necessario modificare il codice per ottenere il contenuto quando si utilizza questa soluzione. Vedi qui per riferimento: stackoverflow.com/questions/26597665/…
DIG

1
anche se è un vecchio post, questa risposta ha appena risolto il mio problema in .netcore, passando da 1.1 a 2.0 sembra che il client stesse eseguendo automaticamente la decompressione, quindi ho dovuto aggiungere questo codice in 2.0 per farlo funzionare ... Grazie !
Sebastian Castaldi

3
Solo per tornare su @SebastianCastaldi, ma .net core 1.1 aveva AutomaticDecompression impostato correttamente, ma in .net core 2.0 è impostato su NONE. Mi ci è voluto troppo tempo per capire ...
KallDrexx

5
Nota: HttpClientNON deve essere utilizzato all'internousing
imba-tjd

1

Ho usato il codice dal link sottostante per decomprimere il flusso GZip, quindi ho usato l'array di byte decompresso per ottenere l'oggetto JSON richiesto. Spero che possa aiutare qualcuno.

var readTask = result.Content.ReadAsByteArrayAsync().Result;
var decompressedData = Decompress(readTask);
string jsonString = System.Text.Encoding.UTF8.GetString(decompressedData, 0, decompressedData.Length);
ResponseObjectClass responseObject = Newtonsoft.Json.JsonConvert.DeserializeObject<ResponseObjectClass>(jsonString);

https://www.dotnetperls.com/decompress

static byte[] Decompress(byte[] gzip)
{
    using (GZipStream stream = new GZipStream(new MemoryStream(gzip), CompressionMode.Decompress))
    {
        const int size = 4096;
        byte[] buffer = new byte[size];
        using (MemoryStream memory = new MemoryStream())
        {
            int count = 0;
            do
            {
                count = stream.Read(buffer, 0, size);
                if (count > 0)
                {
                    memory.Write(buffer, 0, count);
                }
            }
            while (count > 0);
            return memory.ToArray();
        }
    }
}

0

Ok, alla fine ho risolto il mio problema. Se ci sono modi migliori per favore fatemelo sapere :-)

        public DataSet getData(string strFoo)
    {
        string url = "foo";

        HttpClient client = new HttpClient();
        HttpResponseMessage response;   
        DataSet dsTable = new DataSet();
        try
        {
               //Gets the headers that should be sent with each request
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
              //Returned JSON
            response = client.GetAsync(url).Result;
              //converts JSON to string
            string responseJSONContent = response.Content.ReadAsStringAsync().Result;
              //deserializes string to list
            var jsonList = DeSerializeJsonString(responseJSONContent);
              //converts list to dataset. Bad name I know.
            dsTable = Foo_ConnectAPI.ExtentsionHelpers.ToDataSet<RootObject>(jsonList);
              //Returns the dataset                
            return dsTable;
        }
        catch (Exception ex)
        {
            System.Windows.Forms.MessageBox.Show(ex.Message);
            return null;
        }
    }

       //deserializes the string to a list. Utilizes JSON.net. RootObject is a class that contains the get and set for the JSON elements

    public List<RootObject> DeSerializeJsonString(string jsonString)
    {
          //Initialized the List
        List<RootObject> list = new List<RootObject>();
          //json.net deserializes string
        list = (List<RootObject>)JsonConvert.DeserializeObject<List<RootObject>>(jsonString);

        return list;
    }

RootObject contiene il set get che otterrà i valori di JSON.

public class RootObject
{  
      //These string will be set to the elements within the JSON. Each one is directly mapped to the JSON elements.
      //This only takes into account a JSON that doesn't contain nested arrays
    public string EntityID { get; set; }

    public string Address1 { get; set; }

    public string Address2 { get; set; }

    public string Address3 { get; set; }

}

Il modo più semplice per creare le classi di cui sopra è usare json2charp che lo formatterà di conseguenza e fornirà anche i tipi di dati corretti.

Quanto segue è di un'altra risposta su Stackoverflow che non prende in considerazione JSON nidificato.

    internal static class ExtentsionHelpers
{
    public static DataSet ToDataSet<T>(this List<RootObject> list)
    {
        try
        {
            Type elementType = typeof(RootObject);
            DataSet ds = new DataSet();
            DataTable t = new DataTable();
            ds.Tables.Add(t);

            try
            {
                //add a column to table for each public property on T
                foreach (var propInfo in elementType.GetProperties())
                {
                    try
                    {
                        Type ColType = Nullable.GetUnderlyingType(propInfo.PropertyType) ?? propInfo.PropertyType;

                            t.Columns.Add(propInfo.Name, ColType);

                    }
                    catch (Exception ex)
                    {
                        System.Windows.Forms.MessageBox.Show(ex.Message);
                    }

                }
            }
            catch (Exception ex)
            {
                System.Windows.Forms.MessageBox.Show(ex.Message);
            }

            try
            {
                //go through each property on T and add each value to the table
                foreach (RootObject item in list)
                {
                    DataRow row = t.NewRow();

                    foreach (var propInfo in elementType.GetProperties())
                    {
                        row[propInfo.Name] = propInfo.GetValue(item, null) ?? DBNull.Value;
                    }

                    t.Rows.Add(row);
                }
            }
            catch (Exception ex)
            {
                System.Windows.Forms.MessageBox.Show(ex.Message);
            }

            insert.insertCategories(t);
            return ds.
        }
        catch (Exception ex)
        {
            System.Windows.Forms.MessageBox.Show(ex.Message);

            return null;
        }
    }
};

Quindi, infine, per inserire il set di dati sopra in una tabella con colonne che sono state mappate su JSON, ho utilizzato la copia in blocco SQL e la seguente classe

public class insert
{ 
    public static string insertCategories(DataTable table)
    {     
        SqlConnection objConnection = new SqlConnection();
          //As specified in the App.config/web.config file
        objConnection.ConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["foo"].ToString();

        try
        {                                 
            objConnection.Open();
            var bulkCopy = new SqlBulkCopy(objConnection.ConnectionString);

            bulkCopy.DestinationTableName = "dbo.foo";
            bulkCopy.BulkCopyTimeout = 600;
            bulkCopy.WriteToServer(table);

            return "";
        }
        catch (Exception ex)
        {
            System.Windows.Forms.MessageBox.Show(ex.Message);
            return "";
        }
        finally
        {
            objConnection.Close();
        }         
    }
};

Quindi quanto sopra funziona per inserire JSON da un'API web in un database. Questo è qualcosa su cui riesco a lavorare. Ma non mi aspetto affatto che sia perfetto. Se hai dei miglioramenti, aggiornalo di conseguenza.


2
Dovresti creare il tuo HttpCliente il tuo HttpResponseall'interno di una using()dichiarazione ciascuno per garantire lo smaltimento corretto e tempestivo e la chiusura dei flussi sottostanti.
Ian Mercer
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.