HttpRequestHeaderCollection Klasse

Definition

Namespace:

Windows.Web.Http.Headers

Stellt eine Auflistung der HTTP-Header bereit, die einer HTTP-Anforderung zugeordnet sind.

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

Vererbung

Object Platform::Object IInspectable HttpRequestHeaderCollection

Attribute

ContractVersionAttribute MarshalingBehaviorAttribute

Implementiert

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

Windows-Anforderungen

Gerätefamilie	Windows 10 (eingeführt in 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (eingeführt in v1.0)

Beispiele

Der folgende Beispielcode zeigt eine Methode zum Abrufen und Festlegen von Anforderungsheadern für ein HttpRequestMessage-Objekt mithilfe der Eigenschaften des HttpRequestHeaderCollection-Objekts. Der Windows.Web.Http.Headers-Namespace verfügt außerdem über eine Reihe von stark typisierten Headersammlungen und Wertklassen für bestimmte HTTP-Header, die zum Abrufen und Festlegen von Headern mit Validierung verwendet werden können.

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());
        }

Hinweise

Die HttpRequestHeaderCollection ist eine Sammlung der HTTP-Header, die einer HTTP-Anforderung zugeordnet sind. Das HttpRequestHeaderCollection-Objekt kann verwendet werden, um die spezifischen Header für eine HTTP-Anforderung abzurufen oder festzulegen. Die meisten Eigenschaften des HttpRequestHeaderCollection-Objekts bieten Zugriff auf den Wert eines bestimmten HTTP-Headers.

Die Headers-Eigenschaft für HttpRequestMessage gibt ein HttpRequestHeaderCollection-Objekt zurück. Die DefaultRequestHeaders-Eigenschaft für HttpClient gibt auch ein HttpRequestHeaderCollection-Objekt zurück. Dies sind die beiden Methoden zum Erstellen eines HttpRequestHeaderCollection-Objekts.

Die HttpRequestHeaderCollection stellt HTTP-Header für eine HTTP-Anforderung dar, die ein App-Entwickler festlegen kann, nicht alle Header, die möglicherweise mit der Anforderung gesendet werden. Der HttpBaseProtocolFilter fügt einige zusätzliche Header hinzu.

Header für eine HTTP-Anforderung können vom zugrunde liegenden Stapel geändert werden. Aus diesem Grund möchte eine App möglicherweise einen Headerwert aus der HttpRequestHeaderCollection abrufen, nachdem die Anforderung abgeschlossen wurde.

Auflisten der Sammlung in C# oder Microsoft Visual Basic

Sie können ein HttpRequestHeaderCollection-Objekt in C# oder Microsoft Visual Basic durchlaufen. In vielen Fällen, z. B. mit foreach-Syntax , führt der Compiler diese Umwandlung für Sie durch, und Sie müssen nicht explizit in IEnumerable umwandeln. Wenn Sie eine explizite Umwandlung durchführen müssen, z. B. wenn Sie GetEnumerator aufrufen möchten, wandeln Sie das Auflistungsobjekt in IEnumerable<T> mit einem KeyValuePair-Wert von String und String als Einschränkung um.

Eigenschaften

Accept	Ruft die HttpMediaTypeWithQualityHeaderValueCollection von HttpMediaTypeWithQualityHeaderValue-Objekten ab, die den Wert eines Accept-HTTP-Headers für eine HTTP-Anforderung darstellen.
AcceptEncoding	Ruft die HttpContentCodingWithQualityHeaderValueCollection von HttpContentCodingWithQualityHeaderValue-Objekten ab, die den Wert eines Accept-Encoding-HTTP-Headers für eine HTTP-Anforderung darstellen.
AcceptLanguage	Ruft die HttpLanguageRangeWithQualityHeaderValueCollection von HttpLanguageRangeWithQualityHeaderValue-Objekten ab, die den Wert eines Accept-Language-HTTP-Headers für eine HTTP-Anforderung darstellen.
Authorization	Ruft das HttpCredentialsHeaderValue-Objekt ab, das den Wert eines Autorisierungs-HTTP-Headers für eine HTTP-Anforderung darstellt, oder legt es fest.
CacheControl	Ruft die HttpCacheDirectiveHeaderValueCollection ab, die den Wert eines Cache-Control-HTTP-Headers für eine HTTP-Anforderung darstellt.
Connection	Ruft die HttpConnectionOptionHeaderValueCollection von HttpConnectionOptionHeaderValue-Objekten ab, die den Wert eines Connection HTTP-Headers für eine HTTP-Anforderung darstellen.
Cookie	Ruft die HttpCookiePairHeaderValueCollection von HttpCookiePairHeaderValue-Objekten ab, die den Wert eines cookie-HTTP-Headers darstellen, der für eine HTTP-Anforderung gesendet wird.
Date	Ruft das DateTime-Objekt ab, das den Wert eines Date-HTTP-Headers für eine HTTP-Anforderung darstellt, oder legt es fest.
Expect	Ruft die HttpExpectationHeaderValueCollection von HttpExpectationHeaderValue-Objekten ab, die den Wert eines Expect HTTP-Headers für eine HTTP-Anforderung darstellen.
From	Ruft die Zeichenfolge ab, die den Wert eines From HTTP-Headers für eine HTTP-Anforderung darstellt, oder legt diesen fest.
Host	Ruft den HostName ab, der den Wert eines Host-HTTP-Headers für eine HTTP-Anforderung darstellt, oder legt diesen fest.
IfModifiedSince	Ruft das DateTime-Objekt ab, das den Wert eines If-Modified-Since-HTTP-Headers für eine HTTP-Anforderung darstellt, oder legt es fest.
IfUnmodifiedSince	Ruft das DateTime-Objekt ab, das den Wert eines If-Unmodified-Since-HTTP-Headers für eine HTTP-Anforderung darstellt, oder legt es fest.
MaxForwards	Ruft einen ganzzahligen Wert ab, der den Wert eines Max-Forwards-HTTP-Headers für eine HTTP-Anforderung darstellt, oder legt diesen fest.
ProxyAuthorization	Ruft das HttpCredentialsHeaderValue-Objekt ab, das den Wert eines PROXY-Authorization-HTTP-Headers für eine HTTP-Anforderung darstellt, oder legt es fest.
Referer	Ruft den URI ab, der den Wert eines Referer-HTTP-Headers für eine HTTP-Anforderung darstellt, oder legt diesen fest.
Size	Ruft die Anzahl der Objekte in der HttpRequestHeaderCollection ab.
TransferEncoding	Ruft die HttpTransferCodingHeaderValueCollection von HttpTransferCodingHeaderValue-Objekten ab, die den Wert eines Transfer-Encoding-HTTP-Headers für eine HTTP-Anforderung darstellen.
UserAgent	Ruft die HttpProductInfoHeaderValueCollection von HttpProductInfoHeaderValue-Objekten ab , die den Wert eines User-Agent-HTTP-Headers für eine HTTP-Anforderung darstellen.

Methoden

Append(String, String)	Fügt am Ende der HttpRequestHeaderCollection ein neues Element hinzu.
Clear()	Entfernt alle Objekte aus der HttpRequestHeaderCollection.
First()	Ruft einen Iterator zum ersten Element in der HttpRequestHeaderCollection ab.
GetView()	Gibt eine unveränderliche Ansicht der HttpRequestHeaderCollection zurück.
HasKey(String)	Bestimmt, ob die HttpRequestHeaderCollection den angegebenen Schlüssel enthält.
Insert(String, String)	Fügt ein Element in der HttpRequestHeaderCollection ein oder ersetzt es durch den angegebenen Schlüssel und Wert.
Lookup(String)	Sucht ein Element in der HttpRequestHeaderCollection , sofern vorhanden.
Remove(String)	Entfernt ein bestimmtes Objekt aus der HttpRequestHeaderCollection.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle HttpRequestHeaderCollection-Objekt darstellt.
TryAppendWithoutValidation(String, String)	Versuchen Sie, das angegebene Element ohne Validierung an die HttpRequestHeaderCollection anzufügen.

Weitere Informationen

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