Uri Klasse

Definition

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

public ref class Uri
public ref class Uri : System::Runtime::Serialization::ISerializable
public ref class Uri : MarshalByRefObject, System::Runtime::Serialization::ISerializable
public class Uri
public class Uri : 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 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 ISerializable
Public Class Uri
Inherits MarshalByRefObject
Implements ISerializable
Vererbung
Uri
Vererbung
Attribute
Implementiert

Beispiele

Im folgenden Beispiel wird eine Instanz der Uri Klasse erstellt und zum Erstellen einer WebRequest Instanz verwendet.

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 zum Behandeln von URIs, einschließlich Analysieren, Vergleichen und Kombinieren. Die Uri Klasseneigenschaften sind schreibgeschützt; um ein modifizierbares Objekt zu erstellen, verwenden Sie 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 in relative URIs zu konvertieren, wenn erforderlich.

Die Uri Konstruktoren werden keine URI-Zeichenfolgen aus, wenn die Zeichenfolge ein gut gebildeter URI ist, einschließlich eines Schemabezeichners.

Die Uri Eigenschaften geben eine kanonische Datendarstellung in der escaped-Codierung zurück, wobei alle Zeichen mit Unicode-Werten größer als 127 durch ihre Hexadezimaläquivalente 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 als prozent codierte Oktets bezeichnet) die keinen reservierten Zweck haben, werden entschlüsselt (auch bekannt als unescaped). Diese nicht reservierten Zeichen umfassen Groß- und Kleinbuchstaben (%41-%5A und %61-%7A), Dezimalstellen (%30-%39), Bindestrich (%2D), Punkt (%2E), Unterstrich (%5F) und Tilde (%7E).

  • Kanonischisiert den Pfad für hierarchische URIs durch Komprimieren von Sequenzen wie /./, /.. /, und // (unabhängig davon, ob die Sequenz escaped ist). Beachten Sie, dass einige Schemas vorhanden sind, für die diese Sequenzen nicht komprimiert sind.

  • Wenn der Host für hierarchische URIs nicht mit einem Schrägstrich (/) beendet wird, wird eine hinzugefügt.

  • Standardmäßig werden reservierte Zeichen im URI gemäß RFC 2396 escaped. Dieses Verhalten ändert sich, wenn die Analyse internationaler Ressourcennamen oder die Analyse des internationalen Domänennamens aktiviert ist, in welchem Fall reservierte Zeichen im URI gemäß RFC 3986 und RFC 3987 entfernt werden.

Als Teil der Kanonisierung im Konstruktor für einige Schemas werden Punktsegmente und leere Segmente (, /../und //) komprimiert (/./mit anderen Worten, sie werden entfernt). Die Schemas, für die Uri Compacts-Segmente http, https, tcp, net.pipe und net.tcp enthalten. Für einige andere Schemas werden diese Sequenzen nicht komprimiert. Im folgenden Codeausschnitt wird gezeigt, wie die Kompaktierung in der Praxis aussieht. Die entweichten Sequenzen sind bei Bedarf unbildlich 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 die Ausgabe ähnlich dem folgenden Text zurückgegeben.

AbsoluteUri: http://myurl/
PathAndQuery: /

Mithilfe der ToString Methode können Sie den Inhalt der Uri Klasse aus einem escape codierten URI-Verweis auf einen lesbaren URI-Verweis transformieren. Beachten Sie, dass einige reservierte Zeichen möglicherweise noch in der Ausgabe der ToString Methode escapet werden. Dies ist die unterstützung eindeutiger Wiederherstellung eines URI aus dem von ihnen zurückgegebenen ToStringWert.

Einige URIs umfassen einen Fragmentbezeichner oder eine Abfrage oder beides. Ein Fragmentbezeichner ist ein Text, der einem Zahlenzeichen (#) folgt, nicht einschließlich des Nummernzeichens; 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.

In .NET Framework Version 1.1 enthält die für einen Konstruktor angegebene Zeichenfolge ein unbekanntes Schema und "c:\", fügt die Uri-Klasse "//" nach dem Doppelpunkt ein. Beispielsweise wird der URI xyz:c:\abc in xyz://c:/abc. 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 für das Hexadezimalzeichen für das IPv6-Protokoll. Denken Sie daran, die IPv6-Adresse in quadratische Klammern einzuschließen, wie in http://[::1].

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 werden 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. Benutzer von .NET Framework Versionen vor Version 4.5 sehen keine Änderung des .NET Framework 2.0-Verhaltens, sofern sie IRI nicht speziell aktivieren. Dadurch wird die Anwendungskompatibilität mit früheren Versionen von .NET Framework sichergestellt.

In .NET Framework 4.5- und höher-Versionen 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 die Internationalized Domain Name (IDN) analysiert werden soll, die auf den Domänennamen angewendet wird und ob IRI-Analyseregeln angewendet werden sollen. Beispiel:

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

Durch Aktivieren von IDN werden alle Unicode-Bezeichnungen in einen Domänennamen in ihre Punycode-Äquivalente 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 DNS-Servern, die verwendet werden:

  • idn enabled = All

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

  • idn enabled = AllExceptIntranet

    Dieser Wert konvertiert alle Unicode-Domänennamen nicht im lokalen Intranet, um die Punycode-Äquivalente (IDN-Namen) zu verwenden. In diesem Fall, um internationale Namen im lokalen Intranet zu behandeln, sollte die DNS-Server, die für das Intranet verwendet werden, die Unicode-Namensauflösung unterstützen.

  • idn enabled = None

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

Wenn die IRI-Analyse aktiviert ist (iriParsing aktiviert true= ), werden Normalisierung und Zeichenprüfung gemäß den neuesten IRI-Regeln in RFC 3986 und RFC 3987 durchgeführt. Wenn die IRI-Analyse deaktiviert ist, werden normalisierung und Zeichenüberprüfung gemäß RFC 2396 und RFC 2732 (für IPv6 Literals) ausgeführt. In Versionen von .NET Framework vor Version 4.5 ist falseder Standardwert . In .NET Framework 4.5+, .NET Core und .NET 5+ ist 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 Klasse kann auch mithilfe der Uri System.Configuration.IriParsingElementKlassen , System.Configuration.IdnElementund System.Configuration.UriSection Konfigurationseinstellungsklassen 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 die System.Configuration.IriParsingElement und System.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 Internationalized Domain Name (IDN) die Analyse von Hostnamen unterstützt. In .NET 5- und höher-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 für implizite 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 möglichst vermieden werden. Wenn Sie .NET Core auf Unix-basierten Systemen verwenden, können implizite Dateipfade besonders problematisch sein, da ein absoluter impliziter Dateipfad von einem relativen Pfad nicht unterschieden werden kann. Wenn solche Ambiguität vorhanden ist, Uri wird standardmäßig der Pfad als absoluter URI interpretiert.

Sicherheitsüberlegungen

Aufgrund von Sicherheitsbedenken sollte Ihre Anwendung bei der Annahme Uri von Instanzen aus nicht vertrauenswürdigen Quellen und dontEscape mit festgelegtem true Satz im Konstruktor Vorsicht verwenden. Sie können eine URI-Zeichenfolge für Gültigkeit überprüfen, indem Sie die IsWellFormedOriginalString Methode aufrufen.

Beim Umgang mit nicht vertrauenswürdigen Benutzereingaben bestätigen Sie Annahmen über die neu erstellte Uri Instanz, bevor sie ihren 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 die baseUriFolgenden ändern:

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 standardisiert sind. Initialisieren Sie in diesem Fall die betroffenen Teile Ihrer Anwendung, wenn die URIs benötigt werden, nicht zu Beginn.

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.
Veraltet.
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 Instanz 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.
Veraltet.
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 auf den URI über das Sichere Dateiübertragungsprotokoll (FTPS) 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 der 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 Escapezeichen versehene URI-Fragment ab.

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 der angegebene Uri Datei-URI ist.

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 Uri sich um einen universellen Benennungskonventionspfad (UNC) 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 im angegebenen URI enthaltene Abfrageinformationen ab.

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.
Veraltet.
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.
Veraltet.
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.

CreateObjRef(Type)

Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.

(Geerbt von MarshalByRefObject)
Equals(Object)

Überprüft zwei Uri-Instanzen auf Gleichheit.

Escape()
Veraltet.
Veraltet.
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.
Veraltet.
Veraltet.
Veraltet.

Konvertiert eine Zeichenfolge in eine Darstellung mit Escapezeichen.

EscapeUriString(String)
Veraltet.
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.

GetLifetimeService()
Veraltet.

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert.

(Geerbt von MarshalByRefObject)
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.

InitializeLifetimeService()
Veraltet.

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.

(Geerbt von MarshalByRefObject)
IsBadFileSystemCharacter(Char)
Veraltet.
Veraltet.
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.
Veraltet.
Veraltet.

Bestimmt, ob das angegebene Zeichen escaped sein 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.
Veraltet.
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.
Veraltet.
Veraltet.
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)
MemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts.

(Geerbt von MarshalByRefObject)
Parse()
Veraltet.
Veraltet.
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 eine neue Uri Instanz mit der angegebenen String Instanz 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.
Veraltet.
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.

Gilt für

Threadsicherheit

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

Siehe auch