Uri Klasse

Definition

public ref class Uri

public ref class Uri : IEquatable<Uri ^>, ISpanFormattable, System::Runtime::Serialization::ISerializable

public ref class Uri : System::Runtime::Serialization::ISerializable

public ref class Uri : ISpanFormattable, System::Runtime::Serialization::ISerializable

public ref class Uri : MarshalByRefObject, System::Runtime::Serialization::ISerializable

public class Uri

public class Uri : IEquatable<Uri>, ISpanFormattable, System.Runtime.Serialization.ISerializable

public class Uri : System.Runtime.Serialization.ISerializable

public class Uri : ISpanFormattable, System.Runtime.Serialization.ISerializable

[System.Serializable]
public class Uri : MarshalByRefObject, System.Runtime.Serialization.ISerializable

[System.Serializable]
[System.ComponentModel.TypeConverter(typeof(System.UriTypeConverter))]
public class Uri : System.Runtime.Serialization.ISerializable

type Uri = class

type Uri = class
    interface IEquatable<Uri>
    interface IFormattable
    interface ISpanFormattable
    interface ISerializable

type Uri = class
    interface ISerializable

type Uri = class
    interface ISpanFormattable
    interface IFormattable
    interface ISerializable

type Uri = class
    interface IFormattable
    interface ISpanFormattable
    interface IEquatable<Uri>
    interface ISerializable

[<System.Serializable>]
type Uri = class
    inherit MarshalByRefObject
    interface ISerializable

[<System.Serializable>]
[<System.ComponentModel.TypeConverter(typeof(System.UriTypeConverter))>]
type Uri = class
    interface ISerializable

Public Class Uri

Public Class Uri
Implements IEquatable(Of Uri), ISerializable, ISpanFormattable

Public Class Uri
Implements ISerializable

Public Class Uri
Implements ISerializable, ISpanFormattable

Public Class Uri
Inherits MarshalByRefObject
Implements ISerializable

Vererbung

Object

Uri

Vererbung

Object

MarshalByRefObject

Uri

Attribute

SerializableAttribute TypeConverterAttribute

Implementiert

IEquatable<Uri> IFormattable ISpanFormattable ISerializable

Beispiele

Im folgenden Beispiel wird eine Instanz der Uri Klasse erstellt und zum Ausführen einer GET-Anforderung mit HttpClient.

Uri siteUri = new Uri("http://www.contoso.com/");

// HttpClient lifecycle management best practices:
// https://learn.microsoft.com/dotnet/fundamentals/networking/http/httpclient-guidelines#recommended-use
HttpClient client = new HttpClient();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, siteUri);
HttpResponseMessage response = client.Send(request);

let siteUri = Uri "http://www.contoso.com/"

// HttpClient lifecycle management best practices:
// https://learn.microsoft.com/dotnet/fundamentals/networking/http/httpclient-guidelines#recommended-use
use client = new HttpClient ()
use request = new HttpRequestMessage (HttpMethod.Get, siteUri)
use response = client.Send request

Dim siteUri As New Uri("http://www.contoso.com/")

' HttpClient lifecycle management best practices:
' https://learn.microsoft.com/dotnet/fundamentals/networking/http/httpclient-guidelines#recommended-use
Dim client As New HttpClient()
Dim request As New HttpRequestMessage(HttpMethod.Get, siteUri)
Dim response As HttpResponseMessage = client.Send(request)

Der folgende Codeausschnitt zeigt Beispielwerte der verschiedenen Eigenschaften der Klasse.

Uri uri = new Uri("https://user:password@www.contoso.com:80/Home/Index.htm?q1=v1&q2=v2#FragmentName");

Console.WriteLine($"AbsolutePath: {uri.AbsolutePath}");
Console.WriteLine($"AbsoluteUri: {uri.AbsoluteUri}");
Console.WriteLine($"DnsSafeHost: {uri.DnsSafeHost}");
Console.WriteLine($"Fragment: {uri.Fragment}");
Console.WriteLine($"Host: {uri.Host}");
Console.WriteLine($"HostNameType: {uri.HostNameType}");
Console.WriteLine($"IdnHost: {uri.IdnHost}");
Console.WriteLine($"IsAbsoluteUri: {uri.IsAbsoluteUri}");
Console.WriteLine($"IsDefaultPort: {uri.IsDefaultPort}");
Console.WriteLine($"IsFile: {uri.IsFile}");
Console.WriteLine($"IsLoopback: {uri.IsLoopback}");
Console.WriteLine($"IsUnc: {uri.IsUnc}");
Console.WriteLine($"LocalPath: {uri.LocalPath}");
Console.WriteLine($"OriginalString: {uri.OriginalString}");
Console.WriteLine($"PathAndQuery: {uri.PathAndQuery}");
Console.WriteLine($"Port: {uri.Port}");
Console.WriteLine($"Query: {uri.Query}");
Console.WriteLine($"Scheme: {uri.Scheme}");
Console.WriteLine($"Segments: {string.Join(", ", uri.Segments)}");
Console.WriteLine($"UserEscaped: {uri.UserEscaped}");
Console.WriteLine($"UserInfo: {uri.UserInfo}");

// AbsolutePath: /Home/Index.htm
// AbsoluteUri: https://user:password@www.contoso.com:80/Home/Index.htm?q1=v1&q2=v2#FragmentName
// DnsSafeHost: www.contoso.com
// Fragment: #FragmentName
// Host: www.contoso.com
// HostNameType: Dns
// IdnHost: www.contoso.com
// IsAbsoluteUri: True
// IsDefaultPort: False
// IsFile: False
// IsLoopback: False
// IsUnc: False
// LocalPath: /Home/Index.htm
// OriginalString: https://user:password@www.contoso.com:80/Home/Index.htm?q1=v1&q2=v2#FragmentName
// PathAndQuery: /Home/Index.htm?q1=v1&q2=v2
// Port: 80
// Query: ?q1=v1&q2=v2
// Scheme: https
// Segments: /, Home/, Index.htm
// UserEscaped: False
// UserInfo: user:password

let uri = Uri "https://user:password@www.contoso.com:80/Home/Index.htm?q1=v1&q2=v2#FragmentName"

printfn $"AbsolutePath: {uri.AbsolutePath}"
printfn $"AbsoluteUri: {uri.AbsoluteUri}"
printfn $"DnsSafeHost: {uri.DnsSafeHost}"
printfn $"Fragment: {uri.Fragment}"
printfn $"Host: {uri.Host}"
printfn $"HostNameType: {uri.HostNameType}"
printfn $"IdnHost: {uri.IdnHost}"
printfn $"IsAbsoluteUri: {uri.IsAbsoluteUri}"
printfn $"IsDefaultPort: {uri.IsDefaultPort}"
printfn $"IsFile: {uri.IsFile}"
printfn $"IsLoopback: {uri.IsLoopback}"
printfn $"IsUnc: {uri.IsUnc}"
printfn $"LocalPath: {uri.LocalPath}"
printfn $"OriginalString: {uri.OriginalString}"
printfn $"PathAndQuery: {uri.PathAndQuery}"
printfn $"Port: {uri.Port}"
printfn $"Query: {uri.Query}"
printfn $"Scheme: {uri.Scheme}"
printfn $"""Segments: {String.Join(", ", uri.Segments)}"""
printfn $"UserEscaped: {uri.UserEscaped}"
printfn $"UserInfo: {uri.UserInfo}"

// AbsolutePath: /Home/Index.htm
// AbsoluteUri: https://user:password@www.contoso.com:80/Home/Index.htm?q1=v1&q2=v2#FragmentName
// DnsSafeHost: www.contoso.com
// Fragment: #FragmentName
// Host: www.contoso.com
// HostNameType: Dns
// IdnHost: www.contoso.com
// IsAbsoluteUri: True
// IsDefaultPort: False
// IsFile: False
// IsLoopback: False
// IsUnc: False
// LocalPath: /Home/Index.htm
// OriginalString: https://user:password@www.contoso.com:80/Home/Index.htm?q1=v1&q2=v2#FragmentName
// PathAndQuery: /Home/Index.htm?q1=v1&q2=v2
// Port: 80
// Query: ?q1=v1&q2=v2
// Scheme: https
// Segments: /, Home/, Index.htm
// UserEscaped: False
// UserInfo: user:password

Hinweise

Ein URI (Uniform Resource Identifier) ist eine kompakte Darstellung einer Ressource, die für Ihre Anwendung im Intranet oder Internet verfügbar ist. Die Uri Klasse definiert die Eigenschaften und Methoden für die Behandlung von URIs, einschließlich Analysieren, Vergleichen und Kombinieren. Die Uri Klasseneigenschaften sind schreibgeschützt. Verwenden Sie zum Erstellen eines modifizierbaren Objekts die UriBuilder Klasse.

Relative URIs (z. B. "/new/index.htm") müssen in Bezug auf einen Basis-URI erweitert werden, sodass sie absolut sind. Die MakeRelativeUri Methode wird bereitgestellt, um absolute URIs bei Bedarf in relative URIs zu konvertieren.

Die Uri-Konstruktoren führen kein Escape von URI-Zeichenfolgen durch, wenn die Zeichenfolge eine wohlgeformte URI mit einem Schema-Bezeichner ist.

Die Uri Eigenschaften geben eine kanonische Datendarstellung in escaped-Codierung zurück, wobei alle Zeichen mit Unicode-Werten größer als 127 durch ihre hexadezimalen Entsprechungen ersetzt werden. Um den URI in kanonischer Form zu platzieren, führt der Uri Konstruktor die folgenden Schritte aus:

• Konvertiert das URI-Schema in Kleinbuchstaben.
• Konvertiert den Hostnamen in Kleinbuchstaben.
• Wenn der Hostname eine IPv6-Adresse ist, wird die kanonische IPv6-Adresse verwendet. ScopeId und andere optionale IPv6-Daten werden entfernt.
• Entfernt Standard- und leere Portnummern.
• Konvertiert implizite Dateipfade ohne das file:// Schema (z. B. "C:\my\file") in explizite Dateipfade mit dem file://-Schema.
• Escaped-Zeichen (auch bekannt als prozentcodierte Oktetts), die keinen reservierten Zweck haben, werden decodiert (auch bekannt als Nicht-Escaped-Zeichen). Diese nicht reservierten Zeichen umfassen Groß- und Kleinbuchstaben (%41-%5A und %61-%7A), Dezimalziffern (%30-%39), Bindestrich (%2D), Punkt (%2E), Unterstrich (%5F) und Tilde (%7E).
• Kanonisiert den Pfad für hierarchische URIs, indem Sequenzen wie /./ und /../ komprimiert werden (unabhängig davon, ob die Sequenz escaped ist). Beachten Sie, dass es einige Schemas gibt, für die diese Sequenzen nicht komprimiert werden.
• Bei hierarchischen URIs wird eine hinzugefügt, wenn der Host nicht mit einem Schrägstrich (/) beendet wird.
• Standardmäßig werden alle reservierten Zeichen in der URI gemäß RFC 2396 escaped. Dieses Verhalten ändert sich, wenn International Resource Identifiers oder International Domain Name Parsing aktiviert ist. In diesem Fall werden reservierte Zeichen im URI in Übereinstimmung mit RFC 3986 und RFC 3987 escaped.

Im Rahmen der Kanonisierung im Konstruktor für einige Schemas werden Punktsegmente (/./ und /../) komprimiert (mit anderen Worten, sie werden entfernt). Zu den Schemas, für die Uri Segmente komprimiert werden, gehören http, https, tcp, net.pipe und net.tcp. Bei einigen anderen Schemas werden diese Sequenzen nicht komprimiert. Der folgende Codeausschnitt zeigt, wie die Komprimierung in der Praxis aussieht. Die Escapesequenzen werden, falls erforderlich, unescaped und dann verdichtet.

var uri = new Uri("http://myUrl/../.."); // http scheme, unescaped
OR
var uri = new Uri("http://myUrl/%2E%2E/%2E%2E"); // http scheme, escaped
OR
var uri = new Uri("ftp://myUrl/../.."); // ftp scheme, unescaped
OR
var uri = new Uri("ftp://myUrl/%2E%2E/%2E%2E"); // ftp scheme, escaped

Console.WriteLine($"AbsoluteUri: {uri.AbsoluteUri}");
Console.WriteLine($"PathAndQuery: {uri.PathAndQuery}");

Wenn dieser Code ausgeführt wird, wird die Ausgabe ähnlich dem folgenden Text zurückgegeben.

AbsoluteUri: http://myurl/
PathAndQuery: /

Sie können den Inhalt der Uri Klasse aus einem escapecodierten URI-Verweis in einen lesbaren URI-Verweis mithilfe der ToString Methode transformieren. Beachten Sie, dass einige reservierte Zeichen in der Ausgabe der ToString-Methode möglicherweise noch als Escapezeichen angezeigt werden. Dies dient der Unterstützung einer eindeutigen Wiederherstellung eines URI aus dem zurückgegebenen Wert von ToString.

Einige URIs enthalten einen Fragmentbezeichner oder eine Abfrage oder beides. Ein Fragmentbezeichner ist jeder Text, der auf ein Nummernzeichen (#) folgt und nicht das Nummernzeichen enthält; Der Fragmenttext wird in der Fragment Eigenschaft gespeichert. Abfrageinformationen sind Text, der einem Fragezeichen (?) im URI folgt; der Abfragetext wird in der Query Eigenschaft gespeichert.

Unterstützung internationaler Ressourcenbezeichner

Webadressen werden in der Regel mithilfe von URIs ausgedrückt, die aus einem sehr eingeschränkten Satz von Zeichen bestehen:

• Groß- und Kleinbuchstaben ASCII-Buchstaben aus dem englischen Alphabet.
• Ziffern von 0 bis 9.
• Eine kleine Anzahl anderer ASCII-Symbole.

Die Spezifikationen für URIs sind in RFC 2396, RFC 2732, RFC 3986 und RFC 3987 dokumentiert, die von der Internet Engineering Task Force (IETF) veröffentlicht wurden.

Bezeichner, die die Notwendigkeit erleichtern, Ressourcen mit anderen Sprachen als Englisch zu identifizieren und nicht-ASCII-Zeichen (Zeichen im Unicode/ISO 10646-Zeichensatz) zuzulassen, werden als internationale Ressourcenbezeichner (IRIs) bezeichnet. Die Spezifikationen für IRIs sind in RFC 3987 dokumentiert, die von IETF veröffentlicht wurden. Durch die Verwendung von IRIs kann eine URL Unicode-Zeichen enthalten. Normalisierung und Zeichenüberprüfung erfolgen gemäß den neuesten IRI-Regeln in RFC 3986 und RFC 3987.

Die IRI- und IDN-Verarbeitung in der Uri Klasse kann mithilfe der System.Configuration.IriParsingElementKlassen und System.Configuration.IdnElementSystem.Configuration.UriSection Konfigurationseinstellungsklassen gesteuert werden. Die System.Configuration.IriParsingElement Einstellung aktiviert oder deaktiviert die IRI-Verarbeitung in der Uri Klasse. Die System.Configuration.IdnElement Einstellung aktiviert oder deaktiviert die IDN-Verarbeitung in der Uri Klasse.

Die Konfigurationseinstellung für die System.Configuration.IriParsingElement und System.Configuration.IdnElement werden einmal gelesen, wenn die erste System.Uri Klasse erstellt wird. Änderungen an den Konfigurationseinstellungen nach diesem Zeitpunkt werden ignoriert.

Die System.GenericUriParser Klasse wurde auch erweitert, um das Erstellen eines anpassbaren Parsers zu ermöglichen, der IRI und IDN unterstützt. Das Verhalten eines System.GenericUriParser Objekts wird angegeben, indem eine bitweise Kombination der werte übergeben wird, die in der System.GenericUriParserOptions Enumeration an den System.GenericUriParser Konstruktor verfügbar sind. Der GenericUriParserOptions.IriParsing Typ gibt an, dass der Parser die in RFC 3987 für International Resource Identifiers (IRI) angegebenen Analyseregeln unterstützt.

Der GenericUriParserOptions.Idn Typ gibt an, dass der Parser die Analyse von Hostnamen (Internationalized Domain Name, IDN) unterstützt. In .NET (Core) und .NET Framework 4.5+ wird IDN immer verwendet. In früheren Versionen bestimmt eine Konfigurationsoption, ob IDN verwendet wird.

Implizite Dateipfadunterstützung

Uri kann auch verwendet werden, um lokale Dateisystempfade darzustellen. Diese Pfade können explizit in URIs dargestellt werden, die mit dem file://-Schema beginnen, und implizit in URIs, die nicht über das file://-Schema verfügen. Als konkretes Beispiel sind die folgenden beiden URIs gültig und stellen denselben Dateipfad dar:

Uri uri1 = new Uri("C:/test/path/file.txt") // Implicit file path.
Uri uri2 = new Uri("file:///C:/test/path/file.txt") // Explicit file path.

Diese impliziten Dateipfade sind nicht mit der URI-Spezifikation kompatibel und sollten möglichst vermieden werden. Bei der Verwendung von .NET Core auf Unix-basierten Systemen können implizite Dateipfade besonders problematisch sein, da ein absoluter impliziter Dateipfad von einem relativen Pfad nicht unterschieden werden kann . Wenn eine solche Zweideutigkeit vorliegt, interpretiert Uri den Pfad standardmäßig als absolute URI.

Sicherheitsüberlegungen

Aufgrund von Sicherheitsbedenken sollte Ihre Anwendung Vorsicht walten lassen, wenn Sie Uri-Instanzen aus nicht vertrauenswürdigen Quellen und mit dontEscape auf true im Konstruktor akzeptieren. Sie können eine URI-Zeichenfolge auf Gültigkeit überprüfen, indem Sie die IsWellFormedOriginalString Methode aufrufen.

Wenn Sie mit nicht vertrauenswürdigen Benutzereingaben umgehen, bestätigen Sie Annahmen über die neu erstellte Uri-Instanz, bevor Sie deren Eigenschaften vertrauen. Dies kann auf folgende Weise erfolgen:

string userInput = ...;

Uri baseUri = new Uri("https://myWebsite/files/");

if (!Uri.TryCreate(baseUri, userInput, out Uri newUri))
{
    // Fail: invalid input.
}

if (!baseUri.IsBaseOf(newUri))
{
    // Fail: the Uri base has been modified - the created Uri is not rooted in the original directory.
}

Diese Überprüfung kann in anderen Fällen verwendet werden, z. B. beim Umgang mit UNC-Pfaden, indem Sie einfach folgendes baseUriändern:

Uri baseUri = new Uri(@"\\host\share\some\directory\name\");

Weitere Informationen zu den Entwurfs- und Sicherheitsaspekten von Uri und UriBuilder erhalten Sie, indem Sie die folgenden Dokumente zum Bedrohungsmodell überprüfen:

• System.Uri-Bedrohungsmodell
• System.UriBuilder-Bedrohungsmodell

Leistungsüberlegungen

Wenn Sie eine Web.config-Datei verwenden, die URIs zum Initialisieren Ihrer Anwendung enthält, ist zusätzliche Zeit erforderlich, um die URIs zu verarbeiten, wenn ihre Schemabezeichner nicht standardmäßig sind. Initialisieren Sie in einem solchen Fall die betroffenen Teile Ihrer Anwendung, wenn die URIs erforderlich sind, nicht zum Startzeitpunkt.

Threadsicherheit

Alle Member von Uri sind threadsicher und können gleichzeitig aus mehreren Threads verwendet werden.

Weitere Informationen

• IdnElement
• IriParsingElement
• UriSection
• DnsSafeHost
• MakeRelative(Uri)
• IsWellFormedOriginalString()
• UriBuilder
• Änderungen am System.Uri-Namespace in Version 2.0
• Unterstützung für internationale Ressourcenbezeichner in System.UriSystem.Uri
• Netzwerkprogrammierung im .NET-Framework