Uri Klasse

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Stellt eine Objektdarstellung eines URIs (Uniform Resource Identifier) und einfachen Zugriff auf die Teile des URIs bereit.

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

public class Uri : System.Runtime.Serialization.ISerializable

type Uri = class
    interface ISerializable

Public Class Uri
Implements ISerializable

Vererbung

Object

Uri

Implementiert

ISerializable

Beispiele

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

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

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

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 ist eine kompakte Darstellung einer Ressource, die Ihrer Anwendung im Intranet oder Internet zur Verfügung steht. Die Uri -Klasse definiert die Eigenschaften und Methoden für die Behandlung von URIs, einschließlich Analyse, Vergleich und Kombination. Die Uri Klasseneigenschaften sind schreibgeschützt. Verwenden Sie die UriBuilder -Klasse, um ein änderbares Objekt zu erstellen.

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

Die Uri Konstruktoren enthalten keine Escape-URI-Zeichenfolgen, wenn die Zeichenfolge ein wohlgeformten URI einschließlich eines Schemabezeichners ist.

Die Uri Eigenschaften geben eine kanonische Datendarstellung in Escapecodierung zurück, wobei alle Zeichen mit Unicode-Werten größer als 127 durch ihre hexadezimalen Entsprechungen ersetzt werden. Um den URI in kanonische Form zu setzen, 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.

• Mit Escapezeichen versehene Zeichen (auch als prozentcodierte Oktette bezeichnet), die keinen reservierten Zweck haben, werden decodiert (auch als unescaped bezeichnet). Diese nicht reservierten Zeichen enthalten Groß- und Kleinbuchstaben (%41-%5A und %61-%7A), Dezimalstellen (%30-%39), Bindestrich (%2D), Punkt (%2E), Unterstrich (%5F) und Tilde (%7E).

• Kanonisiert den Pfad für hierarchische URIs durch Komprimieren von Sequenzen wie /./, /.. /, und // (unabhängig davon, ob die Sequenz mit Escapezeichen versehen wird). Beachten Sie, dass es einige Schemas gibt, für die diese Sequenzen nicht komprimiert werden.

• Wenn der Host bei hierarchischen URIs nicht mit einem Schrägstrich (/) beendet wird, wird einer hinzugefügt.

• Standardmäßig werden alle reservierten Zeichen im URI gemäß RFC 2396 mit Escapezeichen versehen. Dieses Verhalten ändert sich, wenn die Analyse von internationalen Ressourcenbezeichnern oder internationalen Domänennamen aktiviert ist. In diesem Fall werden reservierte Zeichen im URI gemäß RFC 3986 und RFC 3987 mit Escapezeichen versehen.

Im Rahmen der Kanonisierung im Konstruktor für einige Schemas werden Punktsegmente und leere Segmente (/./, /../und //) komprimiert (d. h. 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 komprimieren in der Praxis aussieht. Die Mit Escapezeichen versehenen Sequenzen werden bei Bedarf nicht als Escapezeichen dargestellt und dann komprimiert.

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 eine Ausgabe ähnlich dem folgenden Text zurückgegeben.

AbsoluteUri: http://myurl/
PathAndQuery: /

Sie können den Inhalt der Uri Klasse von einem Escape-codierten URI-Verweis in einen lesbaren URI-Verweis transformieren, indem Sie die ToString -Methode verwenden. Beachten Sie, dass einige reservierte Zeichen in der Ausgabe der ToString -Methode möglicherweise weiterhin mit Escapezeichen versehen werden. Dies soll die eindeutige Rekonstruktion eines URI aus dem von ToStringzurückgegebenen Wert unterstützen.

Einige URIs enthalten einen Fragmentbezeichner oder eine Abfrage oder beides. Ein Fragmentbezeichner ist jeder Text, der einem Nummernzeichen (#) folgt, ohne das Nummernzeichen; 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.

Wenn in .NET Framework Version 1.1 die für einen Konstruktor angegebene Zeichenfolge ein unbekanntes Schema und "c:\" enthält, fügt die Uri-Klasse "//" nach dem Doppelpunkt ein. Beispielsweise wird der URI xyz:c:\abc in xyz://c:/abckonvertiert. In der .NET Framework Version 2.0 wurde dieses Verhalten entfernt, und die Beispielzeichenfolge wird in xyz:c:/abckonvertiert.

Hinweis

Die URI-Klasse unterstützt die Verwendung von IP-Adressen sowohl in der Quad-Notation für das IPv4-Protokoll als auch im Doppelpunkt-Hexadezimal für das IPv6-Protokoll. Denken Sie daran, die IPv6-Adresse wie in http://[::1] in eckige Klammern einzuschließen.

Unterstützung für internationale Ressourcenbezeichner

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

• ASCII-Großbuchstaben und -Kleinbuchstaben des englischen Alphabets

• Ziffern von 0 bis 9

• einer kleinen Anzahl weiterer 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.

Durch das ständige Wachstum des Internets wird es immer notwendiger, Ressourcen in anderen Sprachen als in Englisch zu bezeichnen. Bezeichner, die dies ermöglichen und die Nicht-ASCII-Zeichen (Zeichen des Unicode-/ISO-Zeichensatzes 10646) zulassen, werden als International Resource Identifiers (IRIs) bezeichnet. Die IRI-Spezifikationen werden in RFC 3987 dokumentiert, die von der IETF veröffentlicht wird. Wenn IRIs verwendet werden, kann eine URL Unicode-Zeichen enthalten.

Die vorhandene Uri Klasse wurde in .NET Framework v3.5, 3.0 SP1 und 2.0 SP1 erweitert, um IRI-Unterstützung basierend auf RFC 3987 bereitzustellen. Benutzern von .NET Framework Versionen vor Version 4.5 wird keine Änderung des .NET Framework 2.0-Verhaltens angezeigt, es sei denn, sie aktivieren IRI ausdrücklich. Dadurch wird die Anwendungskompatibilität mit früheren Versionen von .NET Framework sichergestellt.

In .NET Framework Version 4.5 und höher ist IRI immer aktiviert und kann nicht mithilfe einer Konfigurationsoption geändert werden. Um die Unterstützung für IRI in .NET Framework Versionen vor .NET Framework 4.5 zu aktivieren, legen Sie eine Konfigurationsoption im machine.config oder in der app.config-Datei fest. Geben Sie an, ob das IDN-Parsing auf Domänennamen angewendet werden soll und ob IRI-Analyseregeln anzuwenden sind. Beispiel:

<configuration>
  <uri>
    <idn enabled="All" />
    <iriParsing enabled="true" />
  </uri>
</configuration>

Durch aktivieren von IDN werden alle Unicode-Bezeichnungen in einem Domänennamen in die entsprechenden Punycode-Entsprechungen konvertiert. Punycode-Namen enthalten nur ASCII-Zeichen und beginnen immer mit dem Präfix „xn--“. So werden vorhandene DNS-Server im Internet unterstützt, da die meisten DNS-Server nur ASCII-Zeichen unterstützen (siehe RFC 3940).

Das Aktivieren von IRI und IDN wirkt sich auf den Wert der Eigenschaft Uri.DnsSafeHost aus. Das Aktivieren von IRI und IDN kann auch das Verhalten der Methoden Equals, OriginalString, GetComponents und IsWellFormedOriginalString verändern.

Es gibt drei mögliche Werte für IDN, abhängig von den verwendeten DNS-Servern:

• idn enabled = All

  Durch diesen Wert werden alle Unicode-Domänennamen in ihre Punycode-Entsprechungen (IDN-Namen) konvertiert.

• idn enabled = AllExceptIntranet

  Durch diesen Wert werden alle Unicode-Domänennamen, die sich nicht im lokalen Intranet befinden, so konvertiert, dass die Punycode-Entsprechungen (IDN-Namen) verwendet werden. Wenn internationale Namen im lokalen Intranet verarbeitet werden sollen, müssen die DNS-Server im Intranet das Auflösen von Unicode-Namen unterstützen.

• idn enabled = None

  Durch diesen Wert werden keine Unicode-Domänennamen in ihre Punycode-Entsprechungen konvertiert. Dies ist der Standardwert, der mit dem verhalten von .NET Framework 2.0 konsistent ist.

Wenn die IRI-Analyse aktiviert ist (iriParsing aktiviert = true), erfolgt die Normalisierung und Zeichenüberprüfung gemäß den neuesten IRI-Regeln in RFC 3986 und RFC 3987. Wenn die IRI-Analyse deaktiviert ist, werden Normalisierung und Zeichenüberprüfung gemäß RFC 2396 und RFC 2732 (für IPv6-Literale) durchgeführt. In Versionen von .NET Framework vor Version 4.5 ist falseder Standardwert . In .NET Framework 4.5 und höher, .NET Core und .NET 5 und höher lautet trueder Standardwert , und der aktivierte Zustand der IRI-Analyse kann nicht durch Einstellungen in einer .config-Datei geändert werden.

Die IRI- und IDN-Verarbeitung in der Uri -Klasse kann auch mithilfe der Konfigurationseinstellungsklassen System.Configuration.IriParsingElement, System.Configuration.IdnElementund System.Configuration.UriSection gesteuert werden. Die Einstellung System.Configuration.IriParsingElement aktiviert oder deaktiviert die IRI-Verarbeitung in der Klasse Uri. Die Einstellung System.Configuration.IdnElement aktiviert oder deaktiviert die IDN-Verarbeitung in der Klasse Uri. Die Einstellung System.Configuration.IriParsingElement steuert indirekt auch IDN. Die IRI-Verarbeitung muss aktiviert werden, damit die IDN-Verarbeitung überhaupt möglich ist. Ist die IRI-Verarbeitung deaktiviert, wird die IDN-Verarbeitung auf die Standardeinstellung festgelegt. Darin wird aus Kompatibilitätsgründen das .NET Framework 2.0-Verhalten verwendet, und IDN-Namen werden nicht verwendet.

Die Konfigurationseinstellung für und System.Configuration.IriParsingElementSystem.Configuration.IdnElement werden einmal gelesen, wenn die erste System.Uri Klasse erstellt wird. Später vorgenommene Änderungen an den Konfigurationseinstellungen werden anschließend ignoriert.

Die Klasse System.GenericUriParser wurde ebenfalls erweitert, um das Erstellen eines anpassbaren Parsers zu ermöglichen, der IRI und IDN unterstützt. Das Verhalten eines System.GenericUriParser-Objekts wird durch Übergabe einer bitweisen Kombination von Werten angegeben, die in der System.GenericUriParserOptions-Enumeration des System.GenericUriParser-Konstruktors verfügbar sind. Der GenericUriParserOptions.IriParsing-Typ gibt an, dass der Parser die in RFC 3987 angegebenen Analyseregeln für International Resource Identifiers (IRI) unterstützt. Ob IRI verwendet wird, wird von den zuvor erläuterten Konfigurationswerten bestimmt.

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

Unterstützung impliziter Dateipfade

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 daher nach Möglichkeit vermieden werden. Bei Verwendung von .NET Core auf Unix-basierten Systemen können implizite Dateipfade besonders problematisch sein, da ein absoluter impliziter Dateipfad nicht von einem relativen Pfad zu unterscheiden ist. Wenn eine solche Mehrdeutigkeit vorhanden ist, Uri wird der Pfad standardmäßig als absoluter URI interpretiert.

Sicherheitsüberlegungen

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

Bestätigen Sie beim Umgang mit nicht vertrauenswürdigen Benutzereingaben Annahmen über die neu erstellte Uri instance, bevor Sie den Eigenschaften vertrauen. Dies kann wie folgt 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 ändern baseUri:

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

Überlegungen zur Leistung

Wenn Sie eine *Web.config *-Datei verwenden, die URIs enthält, um Ihre Anwendung zu initialisieren, 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 benötigt werden, nicht zur Startzeit.

Konstruktoren

Uri(SerializationInfo, StreamingContext)	Initialisiert eine neue Instanz der Uri-Klasse aus den angegebenen Instanzen der SerializationInfo-Klasse und der StreamingContext-Klasse.
Uri(String)	Initialisiert eine neue Instanz der Uri-Klasse mit dem angegebenen URI.
Uri(String, Boolean)	Veraltet. Initialisiert eine neue Instanz der Uri-Klasse mit dem angegebenen URI, wobei die Verwendung der Escapezeichen explizit gesteuert werden kann.
Uri(String, UriCreationOptions)	Initialisiert eine neue instance der Uri -Klasse mit dem angegebenen URI und zusätzlichen UriCreationOptions.
Uri(String, UriKind)	Initialisiert eine neue Instanz der Uri-Klasse mit dem angegebenen URI. Mit diesem Konstruktor können Sie angeben, ob die URI-Zeichenfolge ein relativer URI, ein absoluter URI oder unbestimmt ist.
Uri(Uri, String)	Initialisiert eine neue Instanz der Uri-Klasse auf Grundlage des angegebenen Basis-URIs und der relativen URI-Zeichenfolge.
Uri(Uri, String, Boolean)	Veraltet. Initialisiert eine neue Instanz der Uri-Klasse auf Grundlage des angegebenen Basis-URIs und des angegebenen relativen URIs mit expliziter Steuerung der Escapesequenzen.
Uri(Uri, Uri)	Initialisiert eine neue Instanz der Uri-Klasse auf Grundlage der Kombination einer angegebenen Uri-Instanz als Basis und einer relativen Uri-Instanz.

Felder

SchemeDelimiter	Gibt die Zeichen an, die das Schema des Kommunikationsprotokolls vom Adressteil des URIs trennen. Dieses Feld ist schreibgeschützt.
UriSchemeFile	Gibt an, dass der URI ein Zeiger auf eine Datei ist. Dieses Feld ist schreibgeschützt.
UriSchemeFtp	Gibt an, dass auf den URI über FTP (File Transfer Protocol) zugegriffen wird. Dieses Feld ist schreibgeschützt.
UriSchemeFtps	Gibt an, dass über FTPS (File Transfer Protocol Secure) auf den URI zugegriffen wird. Dieses Feld ist schreibgeschützt.
UriSchemeGopher	Gibt an, dass auf den URI über das Gopher-Protokoll zugegriffen wird. Dieses Feld ist schreibgeschützt.
UriSchemeHttp	Gibt an, dass auf den URI über HTTP (Hypertext Transfer Protocol) zugegriffen wird. Dieses Feld ist schreibgeschützt.
UriSchemeHttps	Gibt an, dass auf den URI über HTTPS (Secure Hypertext Transfer Protocol) zugegriffen wird. Dieses Feld ist schreibgeschützt.
UriSchemeMailto	Gibt an, dass der URI eine E-Mail-Adresse ist und der Zugriff über SMTP (Simple Mail Transport Protocol) erfolgt. Dieses Feld ist schreibgeschützt.
UriSchemeNetPipe	Gibt an, dass auf den URI über das von Windows Communication Foundation (WCF) verwendete NetPipe-Schema zugegriffen wird. Dieses Feld ist schreibgeschützt.
UriSchemeNetTcp	Gibt an, dass auf den URI über das von Windows Communication Foundation (WCF) verwendete NetTcp-Schema zugegriffen wird. Dieses Feld ist schreibgeschützt.
UriSchemeNews	Gibt an, dass der URI eine Internetnewsgroup ist, auf die über NNTP (Network News Transport Protocol) zugegriffen wird. Dieses Feld ist schreibgeschützt.
UriSchemeNntp	Gibt an, dass der URI eine Internetnewsgroup ist, auf die über NNTP (Network News Transport Protocol) zugegriffen wird. Dieses Feld ist schreibgeschützt.
UriSchemeSftp	Gibt an, dass auf den URI über das SSH File Transfer Protocol (SFTP) zugegriffen wird. Dieses Feld ist schreibgeschützt.
UriSchemeSsh	Gibt an, dass auf den URI über das Secure Socket Shell-Protokoll (SSH) zugegriffen wird. Dieses Feld ist schreibgeschützt.
UriSchemeTelnet	Gibt an, dass auf den URI über das Telnet-Protokoll zugegriffen wird. Dieses Feld ist schreibgeschützt.
UriSchemeWs	Gibt an, dass auf den URI über das WebSocket-Protokoll (WS) zugegriffen wird. Dieses Feld ist schreibgeschützt.
UriSchemeWss	Gibt an, dass auf den URI über das WebSocket Secure-Protokoll (WSS) zugegriffen wird. Dieses Feld ist schreibgeschützt.

Eigenschaften

AbsolutePath	Ruft den absoluten Pfad des URIs ab.
AbsoluteUri	Ruft den absoluten URI ab.
Authority	Ruft den DNS-Hostnamen (Domain Name System) oder die IP-Adresse und die Anschlussnummer für einen Server ab.
DnsSafeHost	Ruft einen Hostnamen, der sicher für die DNS-Auflösung verwendet werden kann, da er keine Escapezeichen enthält.
Fragment	Ruft das mit Escape versehene URI-Fragment ab, einschließlich des führenden Zeichens "#", falls nicht leer.
Host	Ruft die Hostkomponente dieser Instanz ab.
HostNameType	Ruft den Typ des im URI angegebenen Hostnamens ab.
IdnHost	Ruft den mit RFC 3490 kompatiblen IDN (Internationaler Domänenname) des Hosts ab, wofür ggf. Punycode verwendet wird. Diese Zeichenfolge kann sicher für die DNS-Auflösung verwendet werden, da sie keine Escapezeichen enthält.
IsAbsoluteUri	Ruft einen Wert ab, der angibt, ob die Uri-Instanz absolut ist.
IsDefaultPort	Ruft einen Wert ab, der angibt, ob der Portwert im URI der Standardwert für dieses Schema ist.
IsFile	Ruft einen Wert ab, der angibt, ob es sich bei dem angegebenen Uri um einen Datei-URI handelt.
IsLoopback	Ruft einen Wert ab, der angibt, ob der angegebene Uri auf den lokalen Host verweist.
IsUnc	Ruft einen Wert ab, der angibt, ob es sich bei dem angegebenen Uri um einen UNC-Pfad (Universal Naming Convention) handelt.
LocalPath	Ruft die Darstellung eines Dateinamens im lokalen Betriebssystem ab.
OriginalString	Ruft die ursprüngliche URI-Zeichenfolge ab, die an den Uri-Konstruktor übergeben wurde.
PathAndQuery	Ruft die durch ein Fragezeichen (?) getrennten Werte der AbsolutePath-Eigenschaft und der Query-Eigenschaft ab.
Port	Ruft die Anschlussnummer dieses URIs ab.
Query	Ruft alle Abfrageinformationen ab, die im angegebenen URI enthalten sind, einschließlich des führenden Zeichens "?", wenn nicht leer.
Scheme	Ruft den Namen des Schemas für diesen URI ab.
Segments	Ruft ein Array mit den Pfadsegmenten ab, aus denen sich der angegebene URI zusammensetzt.
UserEscaped	Ruft einen Wert ab, der angibt, ob die URI-Zeichenfolge vor dem Erstellen der Uri-Instanz vollständig mit Escapezeichen versehen war.
UserInfo	Ruft Benutzernamen, Kennwort oder weitere benutzerspezifische Informationen ab, die dem angegebenen URI zugeordnet sind.

Methoden

Canonicalize()	Veraltet. Konvertiert den intern gespeicherten URI in kanonische Form.
CheckHostName(String)	Bestimmt, ob der angegebene Hostname ein gültiger DNS-Name ist.
CheckSchemeName(String)	Bestimmt, ob der angegebene Schemaname gültig ist.
CheckSecurity()	Veraltet. Das Aufrufen dieser Methode hat keine Auswirkung.
Compare(Uri, Uri, UriComponents, UriFormat, StringComparison)	Vergleicht die angegebenen Teile von zwei URIs gemäß den angegebenen Vergleichsregeln.
Equals(Object)	Überprüft zwei Uri-Instanzen auf Gleichheit.
Escape()	Veraltet. Konvertiert alle unsicheren oder reservierten Zeichen in der Pfadkomponente in die entsprechenden Hexadezimaldarstellungen.
EscapeDataString(String)	Konvertiert eine Zeichenfolge in eine Darstellung mit Escapezeichen.
EscapeString(String)	Veraltet. Konvertiert eine Zeichenfolge in eine Darstellung mit Escapezeichen.
EscapeUriString(String)	Veraltet. Konvertiert eine URI-Zeichenfolge in eine Darstellung mit Escapezeichen.
FromHex(Char)	Ruft den Dezimalwert einer Hexadezimalziffer ab.
GetComponents(UriComponents, UriFormat)	Ruft die angegebenen Komponenten der aktuellen Instanz mit dem angegebenen Escapeverhalten für Sonderzeichen ab.
GetHashCode()	Ruft den Hashcode für den URI ab.
GetLeftPart(UriPartial)	Ruft den angegebenen Teil einer Uri-Instanz ab.
GetObjectData(SerializationInfo, StreamingContext)	Gibt die Daten zurück, die zum Serialisieren der aktuellen Instanz benötigt werden.
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
HexEscape(Char)	Konvertiert ein angegebenes Zeichen in die entsprechende Hexadezimaldarstellung.
HexUnescape(String, Int32)	Konvertiert eine angegebene Hexadezimaldarstellung eines Zeichens in das Zeichen selbst.
IsBadFileSystemCharacter(Char)	Veraltet. Gibt an, ob ein Zeichen in einem Dateisystemnamen ungültig ist.
IsBaseOf(Uri)	Bestimmt, ob die aktuelle Uri-Instanz eine Basis der angegebenen Uri-Instanz ist.
IsExcludedCharacter(Char)	Veraltet. Bestimmt, ob das angegebene Zeichen mit einem Escapezeichen versehen werden soll.
IsHexDigit(Char)	Bestimmt, ob ein angegebenes Zeichen eine gültige Hexadezimalziffer ist.
IsHexEncoding(String, Int32)	Bestimmt, ob ein Zeichen in einer Zeichenfolge hexadezimal codiert ist.
IsReservedCharacter(Char)	Veraltet. Bestimmt, ob das angegebene Zeichen ein reserviertes Zeichen ist.
IsWellFormedOriginalString()	Gibt an, ob die zum Erstellen dieses Uri verwendete Zeichenfolge wohlgeformt war und keine weiteren Escapezeichen eingefügt werden müssen.
IsWellFormedUriString(String, UriKind)	Gibt an, ob eine Zeichenfolge wohlgeformt ist, indem versucht wird, einen URI aus der Zeichenfolge zu erstellen. Es wird sichergestellt, dass keine weiteren Escapezeichen in die Zeichenfolge eingefügt werden müssen.
MakeRelative(Uri)	Veraltet. Bestimmt den Unterschied zwischen zwei Uri-Instanzen.
MakeRelativeUri(Uri)	Bestimmt den Unterschied zwischen zwei Uri-Instanzen.
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
Parse()	Veraltet. Analysiert den URI der aktuellen Instanz, um sicherzustellen, dass alle für einen gültigen URI erforderlichen Teile enthalten sind.
ToString()	Ruft eine kanonische Zeichenfolgenentsprechung der angegebenen Uri-Instanz ab.
TryCreate(String, UriCreationOptions, Uri)	Erstellt einen neuen Uri unter Verwendung der angegebenen String instance und UriCreationOptions.
TryCreate(String, UriKind, Uri)	Erstellt mit der angegebenen Uri-Instanz und einer String einen neuen UriKind.
TryCreate(Uri, String, Uri)	Erstellt mit der angegebenen Basis und den relativen Uri-Instanzen einen neuen String.
TryCreate(Uri, Uri, Uri)	Erstellt mit der angegebenen Basis und den relativen Uri-Instanzen einen neuen Uri.
Unescape(String)	Veraltet. Konvertiert die angegebene Zeichenfolge, indem alle Escapesequenzen durch die entsprechende Darstellung ohne Escapezeichen ersetzt werden.
UnescapeDataString(String)	Konvertiert eine Zeichenfolge in eine Darstellung ohne Escapezeichen.

Operatoren

Equality(Uri, Uri)	Bestimmt, ob zwei Uri-Instanzen denselben Wert haben.
Inequality(Uri, Uri)	Bestimmt, ob zwei Uri-Instanzen verschiedene Werte haben.

Explizite Schnittstellenimplementierungen

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Gibt die Daten zurück, die zum Serialisieren der aktuellen Instanz benötigt werden.

Threadsicherheit

Alle Member von Uri sind threadsicher und können gleichzeitig von 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 in .NET Framework