HttpRequestHeaderCollection Classe

Définition

Espace de noms:

Windows.Web.Http.Headers

Fournit une collection d’en-têtes HTTP associés à une requête HTTP.

public ref class HttpRequestHeaderCollection sealed : IIterable<IKeyValuePair<Platform::String ^, Platform::String ^> ^>, IMap<Platform::String ^, Platform::String ^>, IStringable

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
class HttpRequestHeaderCollection final : IIterable<IKeyValuePair<winrt::hstring, winrt::hstring const&>>, IMap<winrt::hstring, winrt::hstring const&>, IStringable

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
public sealed class HttpRequestHeaderCollection : IDictionary<string,string>, IEnumerable<KeyValuePair<string,string>>, IStringable

Public NotInheritable Class HttpRequestHeaderCollection
Implements IDictionary(Of String, String), IEnumerable(Of KeyValuePair(Of String, String)), IStringable

Héritage

Object Platform::Object IInspectable HttpRequestHeaderCollection

Attributs

ContractVersionAttribute MarshalingBehaviorAttribute

Implémente

IDictionary<String,String> IMap<Platform::String,Platform::String> IMap<winrt::hstring,winrt::hstring> IIterable<IKeyValuePair<K,V>> IEnumerable<KeyValuePair<K,V>> IEnumerable<KeyValuePair<String,String>> IIterable<IKeyValuePair<Platform::String,Platform::String>> IIterable<IKeyValuePair<winrt::hstring,winrt::hstring>> IStringable

Configuration requise pour Windows

Famille d’appareils	Windows 10 (introduit dans 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (introduit dans v1.0)

Exemples

L’exemple de code suivant montre une méthode permettant d’obtenir et de définir des en-têtes de requête sur un objet HttpRequestMessage à l’aide des propriétés de l’objet HttpRequestHeaderCollection. L’espace de noms Windows.Web.Http.Headers possède également un certain nombre de collections d’en-têtes fortement typées et de classes de valeur pour des en-têtes HTTP spécifiques qui peuvent être utilisées pour obtenir et définir des en-têtes avec validation.

using System;
using System.Collections.Generic;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.Web.Http;
using Windows.Web.Http.Headers;

        public void DemonstrateHeaderRequest()
        {
            DemonstrateHeaderRequestAccept();
            DemonstrateHeaderRequestAcceptEncoding();
            DemonstrateHeaderRequestAcceptLanguage();
            DemonstrateHeaderRequestAuthorization();
            DemonstrateHeaderRequestCacheControl();
            DemonstrateHeaderRequestConnection();
            DemonstrateHeaderRequestCookie();
            DemonstrateHeaderRequestDate();
            DemonstrateHeaderRequestFrom();
            DemonstrateHeaderRequestHost();
            DemonstrateHeaderRequestIfModifiedSince();
            DemonstrateHeaderRequestIfUnmodifiedSince();
            DemonstrateHeaderRequestMaxForwards();
            DemonstrateHeaderRequestProxyAuthorization();
            DemonstrateHeaderRequestReferer();
            DemonstrateHeaderRequestUserAgent();
        }

        public void DemonstrateHeaderRequestAccept()
        {
            var request = new HttpRequestMessage();
            bool parsedOk = false;

            // Set the header with a string.
            parsedOk = request.Headers.Accept.TryParseAdd ("audio/*");
            parsedOk = request.Headers.Accept.TryParseAdd ("audio/*; q=0.2");
            parsedOk = request.Headers.Accept.TryParseAdd ("audio/*; q=0.4; mysetting=myvalue");

            // Set the header with a strong type.
            request.Headers.Accept.Add(new HttpMediaTypeWithQualityHeaderValue("audio/*", .6));

            // Get the strong type out
            foreach (var value in request.Headers.Accept)
            {
                System.Diagnostics.Debug.WriteLine("One of the Accept values: {0}={1}", value.MediaType, value.Quality);
            }

            // The ToString() is useful for diagnostics, too.
            System.Diagnostics.Debug.WriteLine("The Accept ToString() results: {0}", request.Headers.Accept.ToString());
        }

        public void DemonstrateHeaderRequestAcceptEncoding()
        {
            var request = new HttpRequestMessage();
            bool parsedOk = false;

            // Set the header with a string.
            parsedOk = request.Headers.AcceptEncoding.TryParseAdd("compress");
            parsedOk = request.Headers.AcceptEncoding.TryParseAdd("gzip;q=1.0");

            // Set the header with a strong type.
            request.Headers.AcceptEncoding.Add(new HttpContentCodingWithQualityHeaderValue("*", 0));

            // Get the strong type out
            foreach (var value in request.Headers.AcceptEncoding)
            {
                System.Diagnostics.Debug.WriteLine("One of the AcceptEncoding values: {0}={1}", value.ContentCoding, value.Quality);
            }

            // The ToString() is useful for diagnostics, too.
            System.Diagnostics.Debug.WriteLine("The AcceptEncoding ToString() results: {0}", request.Headers.AcceptEncoding.ToString());
        }

        public void DemonstrateHeaderRequestAcceptLanguage()
        {
            var request = new HttpRequestMessage();
            bool parsedOk = false;

            // Set the header with a string.
            parsedOk = request.Headers.AcceptLanguage.TryParseAdd("da");
            parsedOk = request.Headers.AcceptLanguage.TryParseAdd("en-gb;q=0.8");

            // Set the header with a strong type.
            request.Headers.AcceptLanguage.Add(new HttpLanguageRangeWithQualityHeaderValue("en", .7));

            // Get the strong type out
            foreach (var value in request.Headers.AcceptLanguage)
            {
                System.Diagnostics.Debug.WriteLine("One of the AcceptLanguage values: {0}={1}", value.LanguageRange, value.Quality);
            }

            // The ToString() is useful for diagnostics, too.
            System.Diagnostics.Debug.WriteLine("The AcceptLanguage ToString() results: {0}", request.Headers.AcceptLanguage.ToString());
        }

        public void DemonstrateHeaderRequestAuthorization()
        {
            var request = new HttpRequestMessage();

            // Set the header with a strong type.
            string username = "user";
            string password = "password";
            var buffer = Windows.Security.Cryptography.CryptographicBuffer.ConvertStringToBinary (username + ":" + password, Windows.Security.Cryptography.BinaryStringEncoding.Utf8);
            string base64token = Windows.Security.Cryptography.CryptographicBuffer.EncodeToBase64String(buffer);
            request.Headers.Authorization = new HttpCredentialsHeaderValue("Basic", base64token);


            // Get the strong type out
            System.Diagnostics.Debug.WriteLine("One of the Authorization values: {0}={1}", 
                request.Headers.Authorization.Scheme,
                request.Headers.Authorization.Token);

            // The ToString() is useful for diagnostics, too.
            System.Diagnostics.Debug.WriteLine("The Authorization ToString() results: {0}", request.Headers.Authorization.ToString());
        }

        public void DemonstrateHeaderRequestCacheControl()
        {
            var request = new HttpRequestMessage();
            bool parsedOk = false;

            // Set the header with a string.
            parsedOk = request.Headers.CacheControl.TryParseAdd("no-store");

            // Set the header with a strong type.
            request.Headers.CacheControl.Add(new HttpNameValueHeaderValue("max-age", "10"));

            // Get the strong type out
            foreach (var value in request.Headers.CacheControl)
            {
                System.Diagnostics.Debug.WriteLine("One of the CacheControl values: {0}={1}", value.Name, value.Value);
            }

            // The ToString() is useful for diagnostics, too.
            System.Diagnostics.Debug.WriteLine("The CacheControl ToString() results: {0}", request.Headers.CacheControl.ToString());
        }


        public void DemonstrateHeaderRequestConnection()
        {
            var request = new HttpRequestMessage();
            bool parsedOk = false;

            // Set the header with a string.
            parsedOk = request.Headers.Connection.TryParseAdd("close");

            // Set the header with a strong type.
            request.Headers.Connection.Add(new HttpConnectionOptionHeaderValue("cache-control"));

            // Get the strong type out
            foreach (var value in request.Headers.Connection)
            {
                System.Diagnostics.Debug.WriteLine("One of the Connection values: {0}", value.Token);
            }

            // The ToString() is useful for diagnostics, too.
            System.Diagnostics.Debug.WriteLine("The Connection ToString() results: {0}", request.Headers.Connection.ToString());
        }

        public void DemonstrateHeaderRequestCookie()
        {
            var request = new HttpRequestMessage();
            bool parsedOk = false;

            // Set the header with a string.
            parsedOk = request.Headers.Cookie.TryParseAdd("cookieName=cookieValue");

            // Set the header with a strong type.
            request.Headers.Cookie.Add(new HttpCookiePairHeaderValue("cookie2", "value2"));

            // Get the strong type out
            foreach (var value in request.Headers.Cookie)
            {
                System.Diagnostics.Debug.WriteLine("One of the Cookie values: {0}={1}", value.Name, value.Value);
            }

            // The ToString() is useful for diagnostics, too.
            System.Diagnostics.Debug.WriteLine("The Cookie ToString() results: {0}", request.Headers.Cookie.ToString());
        }


        public void DemonstrateHeaderRequestDate()
        {
            var request = new HttpRequestMessage();

            // This is not typically set with a string.

            // Set the header with a strong type.
            DateTimeOffset value = DateTimeOffset.UtcNow;
            request.Headers.Date = value;

            // Get the strong type out
            System.Diagnostics.Debug.WriteLine("Date value in ticks: {0}", request.Headers.Date.Value.Ticks);

            // The ToString() is useful for diagnostics, too.
            System.Diagnostics.Debug.WriteLine("The Date ToString() results: {0}", request.Headers.Date.ToString());
        }

        public void DemonstrateHeaderRequestFrom()
        {
            var request = new HttpRequestMessage();

            // Set the header with a string.
            request.Headers.From = "person@example.com";

            // Get the strong type out
            System.Diagnostics.Debug.WriteLine("From value: {0}", request.Headers.From);
        }

        public void DemonstrateHeaderRequestHost()
        {
            var request = new HttpRequestMessage();

            // This is not typically set with a string.

            // Set the header with a strong type.
            // HostName is in the Windows.Networking namespace.
            var value = new Windows.Networking.HostName("example.com");
            request.Headers.Host = value;

            // Get the strong type out
            System.Diagnostics.Debug.WriteLine("Canonical Host name: {0}", request.Headers.Host.CanonicalName);

            // The ToString() is useful for diagnostics, too.
            System.Diagnostics.Debug.WriteLine("The Host ToString() results: {0}", request.Headers.Host.ToString());
        }

        public void DemonstrateHeaderRequestIfModifiedSince()
        {
            var request = new HttpRequestMessage();

            // This is not typically set with a string.

            // Set the header with a strong type.
            var value = DateTimeOffset.Now.AddDays(-1); // Since yesterday.
            request.Headers.IfModifiedSince = value;

            // Get the strong type out
            System.Diagnostics.Debug.WriteLine("IfModifiedSince value in ticks: {0}", request.Headers.IfModifiedSince.Value.Ticks);

            // The ToString() is useful for diagnostics, too.
            System.Diagnostics.Debug.WriteLine("The IfModifiedSince ToString() results: {0}", request.Headers.IfModifiedSince.ToString());
        }

        public void DemonstrateHeaderRequestIfUnmodifiedSince()
        {
            var request = new HttpRequestMessage();

            // This is not typically set with a string.

            // Set the header with a strong type.
            var value = DateTimeOffset.Now.AddDays(-1); // Since yesterday.
            request.Headers.IfUnmodifiedSince = value;

            // Get the strong type out
            System.Diagnostics.Debug.WriteLine("IfUnmodifiedSince value in ticks: {0}", request.Headers.IfUnmodifiedSince.Value.Ticks);

            // The ToString() is useful for diagnostics, too.
            System.Diagnostics.Debug.WriteLine("The IfUnmodfiedSince ToString() results: {0}", request.Headers.IfUnmodifiedSince.ToString());
        }

        public void DemonstrateHeaderRequestMaxForwards()
        {
            var request = new HttpRequestMessage();

            // Set the header with an integer.
            request.Headers.MaxForwards= 2;

            // Get the strong type out
            System.Diagnostics.Debug.WriteLine("MaxForwards value: {0}", request.Headers.MaxForwards);
        }

        public void DemonstrateHeaderRequestProxyAuthorization()
        {
            var request = new HttpRequestMessage();

            // Set the header with a strong type.
            string username = "user";
            string password = "password";
            var buffer = Windows.Security.Cryptography.CryptographicBuffer.ConvertStringToBinary(username + ":" + password, Windows.Security.Cryptography.BinaryStringEncoding.Utf16LE);
            string base64token = Windows.Security.Cryptography.CryptographicBuffer.EncodeToBase64String(buffer);
            request.Headers.ProxyAuthorization = new HttpCredentialsHeaderValue("Basic", base64token);


            // Get the strong type out
            System.Diagnostics.Debug.WriteLine("One of the ProxyAuthorixation values: {0}={1}",
                request.Headers.ProxyAuthorization.Scheme,
                request.Headers.ProxyAuthorization.Token);

            // The ToString() is useful for diagnostics, too.
            System.Diagnostics.Debug.WriteLine("The ProxyAuthorization ToString() results: {0}", request.Headers.ProxyAuthorization.ToString());
        }


        public void DemonstrateHeaderRequestReferer()
        {
            var request = new HttpRequestMessage();

            // This is not typically set with a string.

            // Set the header with a strong type.
            // Uri is either in the Windows.Foundation namespace (JavaScript and C++)
            // or in the System.Net namespace (C#).
            var value = new Uri("http://example.com/");
            request.Headers.Referer = value;

            // Get the strong type out
            System.Diagnostics.Debug.WriteLine("Referer absolute uri: {0}", request.Headers.Referer.AbsoluteUri);

            // The ToString() is useful for diagnostics, too.
            System.Diagnostics.Debug.WriteLine("The Host ToString() results: {0}", request.Headers.Referer.ToString());
        }

        public void DemonstrateHeaderRequestUserAgent()
        {
            var request = new HttpRequestMessage();
            bool parsedOk = false;

            // Set the header with a string.
            parsedOk = request.Headers.UserAgent.TryParseAdd("testprogram/1.0");

            // Set the header with a strong type.
            request.Headers.UserAgent.Add(new HttpProductInfoHeaderValue("myprogram", "2.2"));

            // Get the strong type out
            foreach (var value in request.Headers.UserAgent)
            {
                System.Diagnostics.Debug.WriteLine("One of the UserAgent values: {0} / {1}", value.Product.Name, value.Product.Version);
            }

            // The ToString() is useful for diagnostics, too.
            System.Diagnostics.Debug.WriteLine("The UserAgent ToString() results: {0}", request.Headers.UserAgent.ToString());
        }

Remarques

HttpRequestHeaderCollection est une collection d’en-têtes HTTP associés à une requête HTTP. L’objet HttpRequestHeaderCollection peut être utilisé pour obtenir ou définir les en-têtes spécifiques sur une requête HTTP. La plupart des propriétés de l’objet HttpRequestHeaderCollection donnent accès à la valeur d’un en-tête HTTP spécifique.

La propriété Headers sur HttpRequestMessage retourne un objet HttpRequestHeaderCollection. La propriété DefaultRequestHeaders sur HttpClient renvoie également un objet HttpRequestHeaderCollection. Il s’agit des deux méthodes permettant de construire un objet HttpRequestHeaderCollection.

HttpRequestHeaderCollection représente les en-têtes HTTP d’une requête HTTP qu’un développeur d’application peut définir, pas tous les en-têtes qui peuvent éventuellement être envoyés avec la demande. HttpBaseProtocolFilter ajoute des en-têtes supplémentaires.

Les en-têtes d’une requête HTTP peuvent être modifiés par la pile sous-jacente. C’est pourquoi une application peut souhaiter obtenir une valeur d’en-tête à partir de HttpRequestHeaderCollection une fois la demande terminée.

Énumération de la collection en C# ou Microsoft Visual Basic

Vous pouvez itérer via un objet HttpRequestHeaderCollection en C# ou Microsoft Visual Basic. Dans de nombreux cas, comme l’utilisation de la syntaxe foreach , le compilateur effectue cette cast pour vous et vous n’aurez pas besoin d’effectuer IEnumerable un cast vers explicitement. Si vous avez besoin d’un cast explicite, par exemple si vous souhaitez appeler GetEnumerator, castez l’objet de collection en IEnumerable<T> avec un KeyValuePair de String et String comme contrainte.

Propriétés

Accept	Obtient le HttpMediaTypeWithQualityHeaderValueCollection des objets HttpMediaTypeWithQualityHeaderValue qui représentent la valeur d’un en-tête HTTP Accept sur une requête HTTP.
AcceptEncoding	Obtient le HttpContentCodingWithQualityHeaderValueCollection des objets HttpContentCodingWithQualityHeaderValue qui représentent la valeur d’un en-tête HTTP Accept-Encoding sur une requête HTTP.
AcceptLanguage	Obtient les objets HttpLanguageRangeWithQualityHeaderValueCollection de HttpLanguageRangeWithQualityHeaderValue qui représentent la valeur d’un en-tête HTTP Accept-Language sur une requête HTTP.
Authorization	Obtient ou définit l’objet HttpCredentialsHeaderValue qui représente la valeur d’un en-tête HTTP d’autorisation sur une requête HTTP.
CacheControl	Obtient le HttpCacheDirectiveHeaderValueCollection qui représente la valeur d’un en-tête HTTP Cache-Control sur une requête HTTP.
Connection	Obtient le HttpConnectionOptionHeaderValueCollection des objets HttpConnectionOptionHeaderValue qui représentent la valeur d’un en-tête HTTP de connexion sur une requête HTTP.
Cookie	Obtient le HttpCookiePairHeaderValueCollection des objets HttpCookiePairHeaderValue qui représentent la valeur d’un en-tête HTTP Cookie envoyé sur une requête HTTP.
Date	Obtient ou définit l’objet DateTime qui représente la valeur d’un en-tête HTTP Date sur une requête HTTP.
Expect	Obtient le HttpExpectationHeaderValueCollection des objets HttpExpectationHeaderValue qui représentent la valeur d’un en-tête HTTP Expect sur une requête HTTP.
From	Obtient ou définit la valeur String qui représente la valeur d’un en-tête HTTP From sur une requête HTTP.
Host	Obtient ou définit le HostName qui représente la valeur d’un en-tête HTTP hôte sur une requête HTTP.
IfModifiedSince	Obtient ou définit l’objet DateTime qui représente la valeur d’un en-tête HTTP If-Modified-Since sur une requête HTTP.
IfUnmodifiedSince	Obtient ou définit l’objet DateTime qui représente la valeur d’un en-tête HTTP If-Unmodified-Since sur une requête HTTP.
MaxForwards	Obtient ou définit une valeur entière qui représente la valeur d’un en-tête HTTP Max-Forwards sur une requête HTTP.
ProxyAuthorization	Obtient ou définit l’objet HttpCredentialsHeaderValue qui représente la valeur d’un en-tête HTTP Proxy-Authorization sur une requête HTTP.
Referer	Obtient ou définit l’URI qui représente la valeur d’un en-tête HTTP de referer sur une requête HTTP.
Size	Obtient le nombre d’objets dans httpRequestHeaderCollection.
TransferEncoding	Obtient le HttpTransferCodingHeaderValueCollection des objets HttpTransferCodingHeaderValue qui représentent la valeur d’un en-tête HTTP Transfer-Encoding sur une requête HTTP.
UserAgent	Obtient le HttpProductInfoHeaderValueCollection des objets HttpProductInfoHeaderValue qui représentent la valeur d’un en-tête HTTP User-Agent sur une requête HTTP.

Méthodes

Append(String, String)	Ajoute un nouvel élément à la fin de HttpRequestHeaderCollection.
Clear()	Supprime tous les objets de HttpRequestHeaderCollection.
First()	Récupère un itérateur vers le premier élément de httpRequestHeaderCollection.
GetView()	Renvoie une vue immuable de HttpRequestHeaderCollection.
HasKey(String)	Détermine si httpRequestHeaderCollection contient la clé spécifiée.
Insert(String, String)	Insère ou remplace un élément dans httpRequestHeaderCollection par la clé et la valeur spécifiées.
Lookup(String)	Recherche un élément dans httpRequestHeaderCollection s’il existe.
Remove(String)	Supprime un objet spécifique de HttpRequestHeaderCollection.
ToString()	Renvoie une chaîne qui représente l’objet HttpRequestHeaderCollection actuel.
TryAppendWithoutValidation(String, String)	Essayez d’ajouter l’élément spécifié à HttpRequestHeaderCollection sans validation.

Voir aussi

• DefaultRequestHeaders
• Headers
• HttpBaseProtocolFilter
• HttpClient
• HttpRequestMessage
• IMap<K,V>
• IIterable<T>
• IStringable