HttpClient Classe

Définition

Espace de noms:: System.Net.Http

Assembly:: System.Net.Http.dll

Assemblys:: netstandard.dll, System.Net.Http.dll

Assembly:: netstandard.dll

Source:: HttpClient.cs

Source:: HttpClient.cs

Source:: HttpClient.cs

Source:: HttpClient.cs

Source:: HttpClient.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Fournit une classe pour l’envoi de requêtes HTTP et la réception de réponses HTTP à partir d’une ressource identifiée par un URI.

public ref class HttpClient : System::Net::Http::HttpMessageInvoker

public class HttpClient : System.Net.Http.HttpMessageInvoker

type HttpClient = class
    inherit HttpMessageInvoker

Public Class HttpClient
Inherits HttpMessageInvoker

Héritage: Object

HttpMessageInvoker
HttpClient

Exemples

// HttpClient is intended to be instantiated once per application, rather than per-use. See Remarks.
static readonly HttpClient client = new HttpClient();

static async Task Main()
{
    // Call asynchronous network methods in a try/catch block to handle exceptions.
    try
    {
        using HttpResponseMessage response = await client.GetAsync("http://www.contoso.com/");
        response.EnsureSuccessStatusCode();
        string responseBody = await response.Content.ReadAsStringAsync();
        // Above three lines can be replaced with new helper method below
        // string responseBody = await client.GetStringAsync(uri);

        Console.WriteLine(responseBody);
    }
    catch (HttpRequestException e)
    {
        Console.WriteLine("\nException Caught!");
        Console.WriteLine("Message :{0} ", e.Message);
    }
}

open System.Net.Http

// HttpClient is intended to be instantiated once per application, rather than per-use. See Remarks.
let client = new HttpClient()

let main =
    task {
        // Call asynchronous network methods in a try/catch block to handle exceptions.
        try
            use! response = client.GetAsync "http://www.contoso.com/"
            response.EnsureSuccessStatusCode() |> ignore
            let! responseBody = response.Content.ReadAsStringAsync()
            // Above three lines can be replaced with new helper method below
            // let! responseBody = client.GetStringAsync uri

            printfn $"{responseBody}"
        with
        | :? HttpRequestException as e ->
            printfn "\nException Caught!"
            printfn $"Message :{e.Message} "
    }

main.Wait()

' HttpClient is intended to be instantiated once per application, rather than per-use. See Remarks.
Shared ReadOnly client As HttpClient = New HttpClient()

Private Shared Async Function Main() As Task
    ' Call asynchronous network methods in a try/catch block to handle exceptions.
    Try
        Using response As HttpResponseMessage = Await client.GetAsync("http://www.contoso.com/")
            response.EnsureSuccessStatusCode()
            Dim responseBody As String = Await response.Content.ReadAsStringAsync()
            ' Above three lines can be replaced with new helper method below
            ' Dim responseBody As String = Await client.GetStringAsync(uri)

            Console.WriteLine(responseBody)
        End Using
    Catch e As HttpRequestException
        Console.WriteLine(Environment.NewLine & "Exception Caught!")
        Console.WriteLine("Message :{0} ", e.Message)
    End Try
End Function

Remarques

L’instance HttpClient de classe agit comme une session pour envoyer des requêtes HTTP. Une HttpClient instance est une collection de paramètres appliqués à toutes les requêtes exécutées par cette instance. En outre, chaque HttpClient instance utilise son propre pool de connexions, isolant ses requêtes des requêtes exécutées par d’autres HttpClient instances.

Instanciation

HttpClient est destiné à être instancié une fois et réutilisé tout au long de la durée d’une application. Dans .NET Core et .NET 5+, HttpClient regroupe les connexions à l’intérieur de l’instance du gestionnaire et réutilise une connexion entre plusieurs requêtes. Si vous instanciez une classe HttpClient à chaque requête, le nombre de sockets disponibles sera épuisé sous de lourdes charges. Cet épuisement entraînera des erreurs SocketException.

Vous pouvez configurer des options supplémentaires en transmettant un « gestionnaire », tel que HttpClientHandler (ou SocketsHttpHandler dans .NET Core 2.1 ou version ultérieure), dans le cadre du constructeur. Les propriétés de connexion du gestionnaire ne peuvent pas être modifiées une fois qu’une demande a été envoyée. Par conséquent, une raison de créer une HttpClient nouvelle instance serait si vous devez modifier les propriétés de connexion. Si différentes demandes nécessitent des paramètres différents, cela peut également entraîner la présence d’une application ayant plusieurs HttpClient instances, où chaque instance est configurée de manière appropriée, puis les demandes sont émises sur le client approprié.

HttpClient résout uniquement les entrées DNS lors de la création d’une connexion. Il ne suit pas les durées de vie (TTL) spécifiées par le serveur DNS. Si les entrées DNS changent régulièrement, ce qui peut se produire dans certains scénarios de conteneur, le client ne respecte pas ces mises à jour. Pour résoudre ce problème, vous pouvez limiter la durée de vie de la connexion en définissant la SocketsHttpHandler.PooledConnectionLifetime propriété afin que la recherche DNS soit requise lorsque la connexion est remplacée.

public class GoodController : ApiController
{
    private static readonly HttpClient httpClient;

    static GoodController()
    {
        var socketsHandler = new SocketsHttpHandler
        {
            PooledConnectionLifetime = TimeSpan.FromMinutes(2)
        };

        httpClient = new HttpClient(socketsHandler);
    }
}

En guise d’alternative à la création d’une HttpClient seule instance, vous pouvez également utiliser IHttpClientFactory pour gérer les HttpClient instances pour vous. Pour plus d’informations, consultez Instructions relatives à l’utilisation de HttpClient.

Dérivation

Il HttpClient agit également en tant que classe de base pour des clients HTTP plus spécifiques. Il s'agit d'un exemple de FacebookHttpClient qui fournit des méthodes supplémentaires spécifiques à un service web Facebook (par exemple, une méthode GetFriends). Les classes dérivées ne doivent pas remplacer les méthodes virtuelles sur la classe. Utilisez plutôt une surcharge de constructeur qui accepte HttpMessageHandler pour configurer tout traitement avant la requête ou après la requête.

Transports

Il HttpClient s’agit d’une API de haut niveau qui encapsule les fonctionnalités de bas niveau disponibles sur chaque plateforme où elle s’exécute.

Sur chaque plateforme, HttpClient tente d’utiliser le meilleur transport disponible :

Hôte/Environnement d'exécution	back-end
Framework Windows/.NET	HttpWebRequest
Windows/Mono	HttpWebRequest
Windows/UWP	Windows natif WinHttpHandler (compatible HTTP 2.0)
Windows/.NET Core 1.0-2.0	Windows natif WinHttpHandler (compatible HTTP 2.0)
macOS/Mono	HttpWebRequest
macOS/.NET Core 1.0-2.0	Transport HTTP basé sur `libcurl` (compatible HTTP 2.0)
Linux/Mono	HttpWebRequest
Linux/.NET Core 1.0-2.0	Transport HTTP basé sur `libcurl` (compatible HTTP 2.0)
.NET Core 2.1 et versions ultérieures	System.Net.Http.SocketsHttpHandler

Les utilisateurs peuvent également configurer un transport spécifique pour HttpClient en appelant le constructeur HttpClient qui prend un HttpMessageHandler.

.NET Framework &Mono

Par défaut, sur .NET Framework et Mono, HttpWebRequest est utilisé pour envoyer des requêtes au serveur. Ce comportement peut être modifié en spécifiant un autre gestionnaire dans l’une des surcharges du constructeur avec un HttpMessageHandler paramètre. Si vous avez besoin de fonctionnalités telles que l’authentification ou la mise en cache, vous pouvez utiliser WebRequestHandler pour configurer les paramètres et l’instance peut être transmise au constructeur. Le gestionnaire retourné peut être passé à une surcharge de constructeur qui a un paramètre HttpMessageHandler.

.NET Core

À compter de .NET Core 2.1, la classe System.Net.Http.SocketsHttpHandler fournit plutôt que HttpClientHandler l’implémentation utilisée par des classes de mise en réseau HTTP de niveau supérieur tels que HttpClient. L'utilisation de SocketsHttpHandler offre un certain nombre d'avantages :

Amélioration significative des performances par rapport à l’implémentation précédente.
L’élimination des dépendances de plateforme, qui simplifie le déploiement et la maintenance. Par exemple, libcurl ne dépend plus de .NET Core pour macOS et .NET Core pour Linux.
Comportement cohérent sur toutes les plateformes .NET.

Si cette modification n’est pas souhaitable, sur Windows, vous pouvez continuer à utiliser WinHttpHandler en référençant son package NuGet et en le transmettant manuellement au constructeur de HttpClient .

Configurer le comportement à l’aide des options de configuration du runtime

Certains aspects du comportement sont HttpClientpersonnalisables via les options de configuration runtime. Toutefois, le comportement de ces commutateurs diffère par le biais des versions de .NET. Par exemple, dans .NET Core 2.1 - 3.1, vous pouvez configurer si SocketsHttpHandler elle est utilisée par défaut, mais cette option n’est plus disponible à partir de .NET 5.

Regroupement de connexions

HttpClient regroupe les connexions HTTP dans la situation où cela est possible et les utilise pour plusieurs requêtes. Cela peut avoir un avantage significatif en matière de performances, en particulier pour les requêtes HTTPS, car la négociation de connexion n’est effectuée qu’une seule fois.

Les propriétés du pool de connexions peuvent être configurées sur un HttpClientHandler ou SocketsHttpHandler transmis lors de la construction, notamment MaxConnectionsPerServer, PooledConnectionIdleTimeout, et PooledConnectionLifetime.

La suppression de l’instance HttpClient ferme les connexions ouvertes et annule les demandes en attente.

Note

Si vous envoyez simultanément des requêtes HTTP/1.1 au même serveur, de nouvelles connexions peuvent être créées. Même si vous réutilisez l’instance HttpClient , si le taux de requêtes est élevé ou s’il existe des limitations de pare-feu, qui peuvent épuiser les sockets disponibles en raison des minuteurs de nettoyage TCP par défaut. Pour limiter le nombre de connexions simultanées, vous pouvez définir la MaxConnectionsPerServer propriété. Par défaut, le nombre de connexions HTTP/1.1 simultanées est illimité.

Mise en mémoire tampon et durée de vie des requêtes

Par défaut, les méthodes HttpClient (sauf GetStreamAsync) mettent en mémoire tampon les réponses du serveur, en lisant tout le corps de la réponse en mémoire avant de renvoyer le résultat asynchrone. Ces demandes continuent jusqu’à ce que l’une des opérations suivantes se produise :

Le Task<TResult> réussit et retourne un résultat.
Le Timeout est atteint, auquel cas le Task<TResult> sera annulé.
Le CancellationToken passable à certaines surcharges de méthode est déclenché.
CancelPendingRequests() est appelé.
HttpClient est supprimé.

Vous pouvez modifier le comportement de mise en mémoire tampon par requête à l’aide du HttpCompletionOption paramètre disponible sur certaines surcharges de méthode. Cet argument peut être utilisé pour spécifier si celui-ci Task<TResult> doit être considéré comme terminé après avoir lu uniquement les en-têtes de réponse, ou après avoir lu et mis en mémoire tampon le contenu de la réponse.

Si votre application qui utilise HttpClient et les classes associées dans l’espace System.Net.Http de noms a l’intention de télécharger de grandes quantités de données (50 mégaoctets ou plus), l’application doit diffuser en continu ces téléchargements et ne pas utiliser la mise en mémoire tampon par défaut. Si vous utilisez la mise en mémoire tampon par défaut, l’utilisation de la mémoire client est très importante, ce qui peut entraîner une réduction substantielle des performances.

Sécurité des threads

Les méthodes suivantes sont sécurisées pour les threads :

Proxies

Par défaut, HttpClient lit la configuration du proxy à partir de variables d’environnement ou de paramètres utilisateur/système, en fonction de la plateforme. Vous pouvez modifier ce comportement en transmettant un WebProxy ou IWebProxy à, dans l’ordre de priorité :

Propriété Proxy sur un HttpClientHandler passé pendant la construction HttpClient
La DefaultProxy propriété statique (affecte toutes les instances)

Vous pouvez désactiver le proxy à l’aide UseProxyde . La configuration par défaut pour les utilisateurs Windows consiste à essayer de détecter un proxy à l’aide de la découverte réseau, ce qui peut être lent. Pour les applications à débit élevé où il est connu qu’un proxy n’est pas nécessaire, vous devez désactiver le proxy.

Les paramètres de proxy (comme Credentials) doivent être modifiés uniquement avant que la première requête ne soit effectuée à l’aide du HttpClient. Les modifications apportées après l’utilisation de la HttpClient première fois peuvent ne pas être reflétées dans les demandes suivantes.

Temps d'attente

Vous pouvez utiliser Timeout pour définir un délai d’expiration par défaut pour toutes les requêtes HTTP de l’instance HttpClient . Le délai d’expiration s’applique uniquement aux méthodes xxxAsync qui provoquent l’initialisation d’une demande/réponse. Si le délai d’expiration est atteint, la Task<TResult> demande est annulée.

Vous pouvez définir des délais d’expiration supplémentaires si vous passez dans une SocketsHttpHandler instance lors de la construction de l’objet HttpClient :

Propriété	Description
ConnectTimeout	Spécifie un délai d’expiration utilisé lorsqu’une demande nécessite la création d’une nouvelle connexion TCP. Si le délai d’expiration se produit, la demande Task<TResult> est annulée.
PooledConnectionLifetime	Spécifie un délai d’expiration à utiliser pour chaque connexion dans le pool de connexions. Si la connexion est inactive, la connexion est immédiatement fermée ; sinon, la connexion est fermée à la fin de la requête actuelle.
PooledConnectionIdleTimeout	Si une connexion dans le pool de connexions est inactive pendant cette période, la connexion est fermée.
Expect100ContinueTimeout	Si la demande a un en-tête « Expect: 100-continue », elle retarde l’envoi du contenu jusqu’à ce que le délai soit écoulé ou qu’une réponse « 100-continue » soit reçue.

HttpClient résout uniquement les entrées DNS lorsque les connexions sont créées. Il ne suit pas les durées de vie (TTL) spécifiées par le serveur DNS. Si les entrées DNS changent régulièrement, ce qui peut se produire dans certains scénarios de conteneur, vous pouvez utiliser pour PooledConnectionLifetime limiter la durée de vie de la connexion afin que la recherche DNS soit requise lors du remplacement de la connexion.

Constructeurs

Nom	Description
HttpClient()	Initialise une nouvelle instance de la classe à l’aide HttpClient d’une HttpClientHandler instance supprimée lorsque cette instance est supprimée.
HttpClient(HttpMessageHandler, Boolean)	Initialise une nouvelle instance de la HttpClient classe avec le gestionnaire fourni et spécifie si ce gestionnaire doit être supprimé lorsque cette instance est supprimée.
HttpClient(HttpMessageHandler)	Initialise une nouvelle instance de la HttpClient classe avec le gestionnaire spécifié. Le gestionnaire est supprimé lorsque cette instance est supprimée.

Propriétés

Nom	Description
BaseAddress	Obtient ou définit l’adresse de base de l’URI (Uniform Resource Identifier) de la ressource Internet utilisée lors de l’envoi de requêtes.
DefaultProxy	Obtient ou définit le proxy HTTP global.
DefaultRequestHeaders	Obtient les en-têtes qui doivent être envoyés avec chaque requête.
DefaultRequestVersion	Obtient ou définit la version HTTP par défaut utilisée sur les requêtes suivantes effectuées par cette HttpClient instance.
DefaultVersionPolicy	Obtient ou définit la stratégie de version par défaut pour les demandes créées implicitement dans les méthodes pratiques, par exemple GetAsync(String) et PostAsync(String, HttpContent).
MaxResponseContentBufferSize	Obtient ou définit le nombre maximal d’octets à mettre en mémoire tampon lors de la lecture du contenu de la réponse.
Timeout	Obtient ou définit l’intervalle de temps à attendre avant l’expiration de la requête.

Méthodes

Nom	Description
CancelPendingRequests()	Annulez toutes les demandes en attente sur cette instance.
DeleteAsync(String, CancellationToken)	Envoyez une requête DELETE à l’URI spécifié avec un jeton d’annulation en tant qu’opération asynchrone.
DeleteAsync(String)	Envoyez une requête DELETE à l’URI spécifié en tant qu’opération asynchrone.
DeleteAsync(Uri, CancellationToken)	Envoyez une requête DELETE à l’URI spécifié avec un jeton d’annulation en tant qu’opération asynchrone.
DeleteAsync(Uri)	Envoyez une requête DELETE à l’URI spécifié en tant qu’opération asynchrone.
Dispose()	Libère les ressources non managées et supprime les ressources managées utilisées par le HttpMessageInvoker. (Hérité de HttpMessageInvoker)
Dispose(Boolean)	Libère les ressources non managées utilisées par les HttpClient ressources gérées et supprime éventuellement les ressources gérées.
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
GetAsync(String, CancellationToken)	Envoyez une requête GET à l’URI spécifié avec un jeton d’annulation en tant qu’opération asynchrone.
GetAsync(String, HttpCompletionOption, CancellationToken)	Envoyez une requête GET à l’URI spécifié avec une option d’achèvement HTTP et un jeton d’annulation en tant qu’opération asynchrone.
GetAsync(String, HttpCompletionOption)	Envoyez une requête GET à l’URI spécifié avec une option d’achèvement HTTP en tant qu’opération asynchrone.
GetAsync(String)	Envoyez une requête GET à l’URI spécifié en tant qu’opération asynchrone.
GetAsync(Uri, CancellationToken)	Envoyez une requête GET à l’URI spécifié avec un jeton d’annulation en tant qu’opération asynchrone.
GetAsync(Uri, HttpCompletionOption, CancellationToken)	Envoyez une requête GET à l’URI spécifié avec une option d’achèvement HTTP et un jeton d’annulation en tant qu’opération asynchrone.
GetAsync(Uri, HttpCompletionOption)	Envoyez une requête GET à l’URI spécifié avec une option d’achèvement HTTP en tant qu’opération asynchrone.
GetAsync(Uri)	Envoyez une requête GET à l’URI spécifié en tant qu’opération asynchrone.
GetByteArrayAsync(String, CancellationToken)	Envoie une requête GET à l’URI spécifié et retourne le corps de la réponse sous forme de tableau d’octets dans une opération asynchrone.
GetByteArrayAsync(String)	Envoie une requête GET à l’URI spécifié et retourne le corps de la réponse sous forme de tableau d’octets dans une opération asynchrone.
GetByteArrayAsync(Uri, CancellationToken)	Envoyez une requête GET à l’URI spécifié et retournez le corps de la réponse sous forme de tableau d’octets dans une opération asynchrone.
GetByteArrayAsync(Uri)	Envoyez une requête GET à l’URI spécifié et retournez le corps de la réponse sous forme de tableau d’octets dans une opération asynchrone.
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetStreamAsync(String, CancellationToken)	Envoyez une requête GET à l’URI spécifié et retournez le corps de la réponse en tant que flux dans une opération asynchrone.
GetStreamAsync(String)	Envoyez une requête GET à l’URI spécifié et retournez le corps de la réponse en tant que flux dans une opération asynchrone.
GetStreamAsync(Uri, CancellationToken)	Envoyez une requête GET à l’URI spécifié et retournez le corps de la réponse en tant que flux dans une opération asynchrone.
GetStreamAsync(Uri)	Envoyez une requête GET à l’URI spécifié et retournez le corps de la réponse en tant que flux dans une opération asynchrone.
GetStringAsync(String, CancellationToken)	Envoyez une requête GET à l’URI spécifié et retournez le corps de la réponse sous forme de chaîne dans une opération asynchrone.
GetStringAsync(String)	Envoyez une requête GET à l’URI spécifié et retournez le corps de la réponse sous forme de chaîne dans une opération asynchrone.
GetStringAsync(Uri, CancellationToken)	Envoyez une requête GET à l’URI spécifié et retournez le corps de la réponse sous forme de chaîne dans une opération asynchrone.
GetStringAsync(Uri)	Envoyez une requête GET à l’URI spécifié et retournez le corps de la réponse sous forme de chaîne dans une opération asynchrone.
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
PatchAsync(String, HttpContent, CancellationToken)	Envoie une requête PATCH avec un jeton d’annulation à un URI représenté sous forme de chaîne en tant qu’opération asynchrone.
PatchAsync(String, HttpContent)	Envoie une requête PATCH à un URI désigné sous la forme d’une chaîne en tant qu’opération asynchrone.
PatchAsync(Uri, HttpContent, CancellationToken)	Envoie une requête PATCH avec un jeton d’annulation en tant qu’opération asynchrone.
PatchAsync(Uri, HttpContent)	Envoie une requête PATCH en tant qu’opération asynchrone.
PostAsync(String, HttpContent, CancellationToken)	Envoyez une requête POST avec un jeton d’annulation en tant qu’opération asynchrone.
PostAsync(String, HttpContent)	Envoyez une requête POST à l’URI spécifié en tant qu’opération asynchrone.
PostAsync(Uri, HttpContent, CancellationToken)	Envoyez une requête POST avec un jeton d’annulation en tant qu’opération asynchrone.
PostAsync(Uri, HttpContent)	Envoyez une requête POST à l’URI spécifié en tant qu’opération asynchrone.
PutAsync(String, HttpContent, CancellationToken)	Envoyez une requête PUT avec un jeton d’annulation en tant qu’opération asynchrone.
PutAsync(String, HttpContent)	Envoyez une requête PUT à l’URI spécifié en tant qu’opération asynchrone.
PutAsync(Uri, HttpContent, CancellationToken)	Envoyez une requête PUT avec un jeton d’annulation en tant qu’opération asynchrone.
PutAsync(Uri, HttpContent)	Envoyez une requête PUT à l’URI spécifié en tant qu’opération asynchrone.
Send(HttpRequestMessage, CancellationToken)	Envoie une requête HTTP avec le jeton de requête et d’annulation spécifiés.
Send(HttpRequestMessage, HttpCompletionOption, CancellationToken)	Envoie une requête HTTP avec la requête, l’option d’achèvement et le jeton d’annulation spécifiés.
Send(HttpRequestMessage, HttpCompletionOption)	Envoie une requête HTTP.
Send(HttpRequestMessage)	Envoie une requête HTTP avec la requête spécifiée.
SendAsync(HttpRequestMessage, CancellationToken)	Envoyez une requête HTTP en tant qu’opération asynchrone.
SendAsync(HttpRequestMessage, HttpCompletionOption, CancellationToken)	Envoyez une requête HTTP en tant qu’opération asynchrone.
SendAsync(HttpRequestMessage, HttpCompletionOption)	Envoyez une requête HTTP en tant qu’opération asynchrone.
SendAsync(HttpRequestMessage)	Envoyez une requête HTTP en tant qu’opération asynchrone.
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)

Méthodes d’extension

Nom	Description
DeleteFromJsonAsync(HttpClient, String, Type, CancellationToken)	Envoie une requête DELETE à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
DeleteFromJsonAsync(HttpClient, String, Type, JsonSerializerContext, CancellationToken)	Envoie une requête DELETE à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
DeleteFromJsonAsync(HttpClient, String, Type, JsonSerializerOptions, CancellationToken)	Envoie une requête DELETE à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
DeleteFromJsonAsync(HttpClient, Uri, Type, CancellationToken)	Envoie une requête DELETE à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
DeleteFromJsonAsync(HttpClient, Uri, Type, JsonSerializerContext, CancellationToken)	Envoie une requête DELETE à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
DeleteFromJsonAsync(HttpClient, Uri, Type, JsonSerializerOptions, CancellationToken)	Envoie une requête DELETE à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
DeleteFromJsonAsync<TValue>(HttpClient, String, CancellationToken)	Envoie une requête DELETE à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
DeleteFromJsonAsync<TValue>(HttpClient, String, JsonSerializerOptions, CancellationToken)	Envoie une requête DELETE à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
DeleteFromJsonAsync<TValue>(HttpClient, String, JsonTypeInfo<TValue>, CancellationToken)	Envoie une requête DELETE à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
DeleteFromJsonAsync<TValue>(HttpClient, Uri, CancellationToken)	Envoie une requête DELETE à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
DeleteFromJsonAsync<TValue>(HttpClient, Uri, JsonSerializerOptions, CancellationToken)	Envoie une requête DELETE à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
DeleteFromJsonAsync<TValue>(HttpClient, Uri, JsonTypeInfo<TValue>, CancellationToken)	Envoie une requête DELETE à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
GetFromJsonAsAsyncEnumerable<TValue>(HttpClient, String, CancellationToken)	Envoie une `HTTP GET`requête à l’élément spécifié `requestUri` et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération énumérable asynchrone.
GetFromJsonAsAsyncEnumerable<TValue>(HttpClient, String, JsonSerializerOptions, CancellationToken)	Envoie une `HTTP GET` requête à l’élément spécifié `requestUri` et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération énumérable asynchrone.
GetFromJsonAsAsyncEnumerable<TValue>(HttpClient, String, JsonTypeInfo<TValue>, CancellationToken)	Envoie une `HTTP GET`requête à l’élément spécifié `requestUri` et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération énumérable asynchrone.
GetFromJsonAsAsyncEnumerable<TValue>(HttpClient, Uri, CancellationToken)	Envoie une `HTTP GET`requête à l’élément spécifié `requestUri` et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération énumérable asynchrone.
GetFromJsonAsAsyncEnumerable<TValue>(HttpClient, Uri, JsonSerializerOptions, CancellationToken)	Envoie une `HTTP GET`requête à l’élément spécifié `requestUri` et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération énumérable asynchrone.
GetFromJsonAsAsyncEnumerable<TValue>(HttpClient, Uri, JsonTypeInfo<TValue>, CancellationToken)	Envoie une `HTTP GET`requête à l’élément spécifié `requestUri` et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération énumérable asynchrone.
GetFromJsonAsync(HttpClient, String, Type, CancellationToken)	Envoie une requête GET à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
GetFromJsonAsync(HttpClient, String, Type, JsonSerializerContext, CancellationToken)	Envoie une requête GET à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
GetFromJsonAsync(HttpClient, String, Type, JsonSerializerOptions, CancellationToken)	Envoie une requête GET à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
GetFromJsonAsync(HttpClient, Uri, Type, CancellationToken)	Envoie une requête GET à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
GetFromJsonAsync(HttpClient, Uri, Type, JsonSerializerContext, CancellationToken)	Envoie une requête GET à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
GetFromJsonAsync(HttpClient, Uri, Type, JsonSerializerOptions, CancellationToken)	Envoie une requête GET à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
GetFromJsonAsync<TValue>(HttpClient, String, CancellationToken)	Envoie une requête GET à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
GetFromJsonAsync<TValue>(HttpClient, String, JsonSerializerOptions, CancellationToken)	Envoie une requête GET à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
GetFromJsonAsync<TValue>(HttpClient, String, JsonTypeInfo<TValue>, CancellationToken)	Envoie une requête GET à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
GetFromJsonAsync<TValue>(HttpClient, Uri, CancellationToken)	Envoie une requête GET à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
GetFromJsonAsync<TValue>(HttpClient, Uri, JsonSerializerOptions, CancellationToken)	Envoie une requête GET à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
GetFromJsonAsync<TValue>(HttpClient, Uri, JsonTypeInfo<TValue>, CancellationToken)	Envoie une requête GET à l’URI spécifié et retourne la valeur qui résulte de la désérialisation du corps de la réponse en tant que JSON dans une opération asynchrone.
PatchAsJsonAsync<TValue>(HttpClient, String, TValue, CancellationToken)	Envoie une requête PATCH à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PatchAsJsonAsync<TValue>(HttpClient, String, TValue, JsonSerializerOptions, CancellationToken)	Envoie une requête PATCH à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PatchAsJsonAsync<TValue>(HttpClient, String, TValue, JsonTypeInfo<TValue>, CancellationToken)	Envoie une requête PATCH à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PatchAsJsonAsync<TValue>(HttpClient, Uri, TValue, CancellationToken)	Envoie une requête PATCH à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PatchAsJsonAsync<TValue>(HttpClient, Uri, TValue, JsonSerializerOptions, CancellationToken)	Envoie une requête PATCH à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PatchAsJsonAsync<TValue>(HttpClient, Uri, TValue, JsonTypeInfo<TValue>, CancellationToken)	Envoie une requête PATCH à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PostAsJsonAsync<TValue>(HttpClient, String, TValue, CancellationToken)	Envoie une requête POST à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PostAsJsonAsync<TValue>(HttpClient, String, TValue, JsonSerializerOptions, CancellationToken)	Envoie une requête POST à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PostAsJsonAsync<TValue>(HttpClient, String, TValue, JsonTypeInfo<TValue>, CancellationToken)	Envoie une requête POST à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PostAsJsonAsync<TValue>(HttpClient, Uri, TValue, CancellationToken)	Envoie une requête POST à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PostAsJsonAsync<TValue>(HttpClient, Uri, TValue, JsonSerializerOptions, CancellationToken)	Envoie une requête POST à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PostAsJsonAsync<TValue>(HttpClient, Uri, TValue, JsonTypeInfo<TValue>, CancellationToken)	Envoie une requête POST à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PutAsJsonAsync<TValue>(HttpClient, String, TValue, CancellationToken)	Envoyez une requête PUT à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PutAsJsonAsync<TValue>(HttpClient, String, TValue, JsonSerializerOptions, CancellationToken)	Envoyez une requête PUT à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PutAsJsonAsync<TValue>(HttpClient, String, TValue, JsonTypeInfo<TValue>, CancellationToken)	Envoyez une requête PUT à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PutAsJsonAsync<TValue>(HttpClient, Uri, TValue, CancellationToken)	Envoyez une requête PUT à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PutAsJsonAsync<TValue>(HttpClient, Uri, TValue, JsonSerializerOptions, CancellationToken)	Envoyez une requête PUT à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.
PutAsJsonAsync<TValue>(HttpClient, Uri, TValue, JsonTypeInfo<TValue>, CancellationToken)	Envoyez une requête PUT à l’URI spécifié contenant le `value` json sérialisé dans le corps de la requête.

S’applique à

Voir aussi

Commentaires

Cette page a-t-elle été utile ?