Uri Klasa

Definicja

Umożliwia reprezentowanie obiektów za pomocą jednolitych identyfikatorów zasobów (URI) oraz łatwy dostęp do elementów identyfikatorów URI.

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
Dziedziczenie
Uri
Dziedziczenie
Atrybuty
Implementuje

Przykłady

Poniższy przykład tworzy wystąpienie Uri klasy i używa go do utworzenia WebRequest wystąpienia.

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

WebRequest wr = WebRequest.Create(contoso);
let contoso = Uri "http://www.contoso.com/"

let wr = WebRequest.Create contoso
Dim siteUri As New Uri("http://www.contoso.com/")
        
Dim wr As WebRequest = WebRequest.Create(siteUri)

Poniższy fragment kodu przedstawia przykładowe wartości różnych właściwości klasy.

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

Uwagi

Identyfikator URI to kompaktowa reprezentacja zasobu dostępnego dla aplikacji w intranecie lub Internecie. Klasa Uri definiuje właściwości i metody obsługi identyfikatorów URI, w tym analizowanie, porównywanie i łączenie. Właściwości Uri klasy są tylko do odczytu. Aby utworzyć obiekt modyfikowalny, użyj UriBuilder klasy .

Względne identyfikatory URI (na przykład "/new/index.htm") muszą być rozwinięte w odniesieniu do podstawowego identyfikatora URI, aby były bezwzględne. Metoda MakeRelativeUri jest udostępniana w celu przekonwertowania bezwzględnych identyfikatorów URI na względne identyfikatory URI w razie potrzeby.

Konstruktory Uri nie unikną ciągów identyfikatora URI, jeśli ciąg jest dobrze sformułowanym identyfikatorem URI, w tym identyfikatorem schematu.

Właściwości Uri zwracają kanoniczną reprezentację danych w kodowaniu ucieczki, a wszystkie znaki z wartościami Unicode większymi niż 127 zastąpione ich odpowiednikami szesnastkowymi. Aby umieścić identyfikator URI w formie kanonicznej, Uri konstruktor wykonuje następujące kroki:

  • Konwertuje schemat identyfikatora URI na małe litery.

  • Konwertuje nazwę hosta na małe litery.

  • Jeśli nazwa hosta jest adresem IPv6, używany jest kanoniczny adres IPv6. Identyfikator ScopeId i inne opcjonalne dane protokołu IPv6 są usuwane.

  • Usuwa domyślne i puste numery portów.

  • Konwertuje niejawne ścieżki plików bez schematu file:// (na przykład "C:\my\file") na jawne ścieżki plików ze schematem file://.

  • Znaki ucieczki (znane również jako oktety zakodowane procentowo), które nie mają zarezerwowanego celu, są dekodowane (nazywane również unescaped). Te zastrzeżone znaki obejmują wielkie i małe litery (%41-%5A i %61-%7A), cyfry dziesiętne (%30-%39), łącznik (%2D), kropkę (%2E), podkreślenie (%5F) i tilde (%7E).

  • Canonicalizuje ścieżkę dla hierarchicznych identyfikatorów URI, kompaktując sekwencje, takie jak /./, /.. /, i // (czy sekwencja jest uniknięta). Należy pamiętać, że istnieją pewne schematy, dla których te sekwencje nie są kompaktowane.

  • W przypadku hierarchicznych identyfikatorów URI, jeśli host nie zostanie zakończony ukośnikiem (/), zostanie dodany.

  • Domyślnie wszystkie zastrzeżone znaki w identyfikatorze URI są ucieczki zgodnie z RFC 2396. To zachowanie zmienia się, jeśli międzynarodowe identyfikatory zasobów lub analizowanie nazw domen międzynarodowych jest włączone w takim przypadku zastrzeżone znaki w identyfikatorze URI są ucieczki zgodnie z RFC 3986 i RFC 3987.

W ramach kanonizacji konstruktora dla niektórych schematów, segmenty kropkowe i puste segmenty (, /../, i //) są kompaktowane (/./innymi słowy, są usuwane). Schematy, dla których Uri segmenty kompaktowania obejmują http, https, tcp, net.pipe i net.tcp. W przypadku niektórych innych schematów te sekwencje nie są kompaktowane. Poniższy fragment kodu pokazuje, jak kompaktowanie wygląda w praktyce. Sekwencje ucieczki są niewyobrażalne, jeśli to konieczne, a następnie zagęszczane.

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

Po wykonaniu tego kodu zwraca dane wyjściowe podobne do poniższego tekstu.

AbsoluteUri: http://myurl/
PathAndQuery: /

Zawartość klasy można przekształcić Uri z odwołania identyfikatora URI zakodowanego w formacie ucieczki do czytelnego odwołania identyfikatora URI przy użyciu ToString metody . Należy pamiętać, że niektóre znaki zarezerwowane mogą być nadal ucieczki w danych wyjściowych ToString metody . Ma to na celu jednoznaczną rekonstrukcję identyfikatora URI z wartości zwróconej przez ToString.

Niektóre identyfikatory URI obejmują identyfikator fragmentu lub zapytanie lub oba te identyfikatory. Identyfikator fragmentu to dowolny tekst, który jest zgodny ze znakiem liczbowym (#), nie zawierającym znaku numeru; tekst fragmentu Fragment jest przechowywany we właściwości . Informacje o kwerendzie to dowolny tekst, który jest zgodny z znakiem zapytania (?) w identyfikatorze URI; tekst zapytania jest przechowywany we Query właściwości .

W .NET Framework wersji 1.1, jeśli ciąg określony w konstruktorze zawiera nieznany schemat i "c:\", klasa Uri wstawia "//" po dwukropku. Na przykład identyfikator URI xyz:c:\abc jest konwertowany na xyz://c:/abc. W .NET Framework w wersji 2.0 to zachowanie zostało usunięte, a przykładowy ciąg jest konwertowany na xyz:c:/abc.

Uwaga

Klasa URI obsługuje używanie adresów IP w obu czworokątach notacji dla protokołu IPv4 i dwukropka szesnastkowatego dla protokołu IPv6. Pamiętaj, aby ująć adres IPv6 w nawiasy kwadratowe, tak jak w http://[::1].

Obsługa identyfikatorów zasobów międzynarodowych

Adresy internetowe są zwykle wyrażane przy użyciu jednolitych identyfikatorów zasobów, które składają się z bardzo ograniczonego zestawu znaków:

  • Wielkie i małe litery ASCII z alfabetu angielskiego.

  • Cyfry od 0 do 9.

  • Niewielka liczba innych symboli ASCII.

Specyfikacje identyfikatorów URI są udokumentowane w dokumentach RFC 2396, RFC 2732, RFC 3986 i RFC 3987 opublikowanych przez Internet Engineering Task Force (IETF).

Wraz ze wzrostem Internetu rośnie potrzeba identyfikowania zasobów przy użyciu języków innych niż angielski. Identyfikatory, które ułatwiają tę potrzebę i zezwalają na znaki inne niż ASCII (znaki w zestawie znaków Unicode/ISO 10646) są nazywane międzynarodowymi identyfikatorami zasobów (IRI). Specyfikacje irI są udokumentowane w dokumencie RFC 3987 opublikowanym przez IETF. Używanie interfejsów IRI umożliwia adresOWI URL zawieranie znaków Unicode.

Istniejąca Uri klasa została rozszerzona w .NET Framework w wersji 3.5, 3.0 SP1 i 2.0 SP1 w celu zapewnienia obsługi IRI na podstawie RFC 3987. Użytkownicy .NET Framework wersji przed wersją 4.5 nie będą widzieć żadnych zmian w zachowaniu .NET Framework 2.0, chyba że w szczególności włączą IRI. Zapewnia to zgodność aplikacji z poprzednimi wersjami .NET Framework.

W wersji .NET Framework 4.5 i nowszych IRI jest zawsze włączona i nie można jej zmienić przy użyciu opcji konfiguracji. Aby włączyć obsługę IRI w wersjach .NET Framework przed .NET Framework 4.5, ustaw opcję konfiguracji w machine.config lub w pliku app.config. Określ, czy ma być stosowane analizowanie nazwy domeny (IDN) internationalized domain name (IDN) oraz czy należy zastosować reguły analizowania IRI. Przykład:

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

Włączenie nazwy IDN konwertuje wszystkie etykiety Unicode w nazwie domeny na ich odpowiedniki Punycode. Nazwy punycode zawierają tylko znaki ASCII i zawsze zaczynają się od prefiksu xn--. Przyczyną tego jest obsługa istniejących serwerów DNS w Internecie, ponieważ większość serwerów DNS obsługuje tylko znaki ASCII (zobacz RFC 3940).

Włączenie IRI i IDN wpływa na wartość Uri.DnsSafeHost właściwości. Włączenie IRI i IDN może również zmienić zachowanie Equalsmetod , OriginalString, GetComponentsi IsWellFormedOriginalString .

Istnieją trzy możliwe wartości dla nazwy IDN w zależności od używanych serwerów DNS:

  • idn enabled = Wszystkie

    Ta wartość spowoduje przekonwertowanie nazw domen Unicode na odpowiedniki punycode (nazwy IDN).

  • idn enabled = AllExceptIntranet

    Ta wartość przekonwertuje wszystkie nazwy domen Unicode, które nie są w lokalnym intranecie, aby używać odpowiedników punycode (nazw IDN). W takim przypadku do obsługi nazw międzynarodowych w lokalnym intranecie serwery DNS używane dla intranetu powinny obsługiwać rozpoznawanie nazw Unicode.

  • idn enabled = None

    Ta wartość nie przekonwertuje żadnych nazw domen Unicode w celu używania programu Punycode. Jest to wartość domyślna zgodna z zachowaniem .NET Framework 2.0.

Po włączeniu analizowania IRI (włączone iriParsing = true), normalizacja i sprawdzanie znaków są wykonywane zgodnie z najnowszymi regułami IRI w RFC 3986 i RFC 3987. Gdy analizowanie IRI jest wyłączone, normalizacja i sprawdzanie znaków są wykonywane zgodnie z RFC 2396 i RFC 2732 (dla literałów IPv6). W wersjach .NET Framework przed wersją 4.5 wartość domyślna to false. W .NET Framework 4.5+, .NET Core i .NET 5+ wartość domyślna to true, a włączony stan analizy IRI nie może zostać zmodyfikowany przez ustawienia w pliku .config.

Przetwarzanie IRI i IDN w Uri klasie można również kontrolować przy użyciu System.Configuration.IriParsingElementklas ustawień , System.Configuration.IdnElementi System.Configuration.UriSection konfiguracji. Ustawienie System.Configuration.IriParsingElement włącza lub wyłącza przetwarzanie IRI w Uri klasie. Ustawienie System.Configuration.IdnElement włącza lub wyłącza przetwarzanie IDN w Uri klasie. Ustawienie System.Configuration.IriParsingElement również pośrednio kontroluje nazwę IDN. Aby możliwe było przetwarzanie IDN, należy włączyć przetwarzanie IRI. Jeśli przetwarzanie IRI jest wyłączone, przetwarzanie IDN zostanie ustawione na domyślne ustawienie, w którym zachowanie .NET Framework 2.0 jest używane do zachowania zgodności i nazw IDN nie są używane.

Ustawienie konfiguracji elementu System.Configuration.IriParsingElement i System.Configuration.IdnElement są odczytywane raz po utworzeniu pierwszej System.Uri klasy. Zmiany ustawień konfiguracji po tym czasie są ignorowane.

Klasa System.GenericUriParser została również rozszerzona, aby umożliwić tworzenie dostosowywalnego analizatora obsługującego IRI i IDN. Zachowanie System.GenericUriParser obiektu jest określone przez przekazanie bitowej kombinacji wartości dostępnych w wyliczenie System.GenericUriParserOptions do konstruktora System.GenericUriParser . Typ GenericUriParserOptions.IriParsing wskazuje analizator obsługuje reguły analizowania określone w RFC 3987 dla międzynarodowych identyfikatorów zasobów (IRI). Niezależnie od tego, czy jest używana usługa IRI, jest określana przez wcześniej omówione wartości konfiguracji.

Typ GenericUriParserOptions.Idn wskazuje, że analizator obsługuje analizowanie nazw hostów pod nazwą IDN (Internationalized Domain Name). W programach .NET 5 i nowszych (w tym .NET Core) i .NET Framework 4.5+, zawsze jest używana sieć IDN. W poprzednich wersjach opcja konfiguracji określa, czy jest używana usługa IDN.

Obsługa niejawnych ścieżek plików

Uri można również użyć do reprezentowania lokalnych ścieżek systemu plików. Te ścieżki można jawnie przedstawić w identyfikatorach URI rozpoczynających się od schematu file:// i niejawnie w identyfikatorach URI, które nie mają schematu file://. W konkretnym przykładzie dwa następujące identyfikatory URI są prawidłowe i reprezentują tę samą ścieżkę pliku:

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.

Te niejawne ścieżki plików nie są zgodne ze specyfikacją identyfikatora URI i należy unikać ich, jeśli jest to możliwe. W przypadku korzystania z platformy .NET Core w systemach opartych na systemie Unix niejawne ścieżki plików mogą być szczególnie problematyczne, ponieważ bezwzględna niejawna ścieżka pliku jest nie do odróżnienia od ścieżki względnej. Gdy taka niejednoznaczność jest obecna, Uri domyślnie interpretuje ścieżkę jako bezwzględny identyfikator URI.

Zagadnienia związane z zabezpieczeniami

Ze względu na obawy dotyczące zabezpieczeń aplikacja powinna zachować ostrożność podczas akceptowania Uri wystąpień z niezaufanych źródeł i ustawionych dontEscape na true wartość w konstruktorze. Ciąg identyfikatora URI można sprawdzić pod kątem ważności, wywołując metodę IsWellFormedOriginalString .

W przypadku czynienia z niezaufanymi danymi wejściowymi użytkownika potwierdź założenia dotyczące nowo utworzonego Uri wystąpienia przed zaufaniem do jego właściwości. Można to zrobić w następujący sposób:

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

Tej walidacji można używać w innych przypadkach, takich jak podczas pracy ze ścieżkami UNC, po prostu zmieniając element baseUri:

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

Zagadnienia dotyczące wydajności

Jeśli używasz *Web.config *pliku zawierającego identyfikatory URI, aby zainicjować aplikację, wymagany jest dodatkowy czas na przetworzenie identyfikatorów URI, jeśli ich identyfikatory schematu są niezgodne z normą. W takim przypadku zainicjuj objęte części aplikacji, gdy są potrzebne identyfikatory URI, a nie w czasie rozpoczęcia.

Konstruktory

Uri(SerializationInfo, StreamingContext)

Inicjuje nowe wystąpienie Uri klasy z określonych wystąpień SerializationInfo klas i StreamingContext .

Uri(String)

Inicjuje Uri nowe wystąpienie klasy przy użyciu określonego identyfikatora URI.

Uri(String, Boolean)
Nieaktualne.
Nieaktualne.
Nieaktualne.

Inicjuje Uri nowe wystąpienie klasy z określonym identyfikatorem URI z jawną kontrolą ucieczki znaków.

Uri(String, UriCreationOptions)

Inicjuje Uri nowe wystąpienie klasy przy użyciu określonego identyfikatora URI i dodatkowego UriCreationOptions.

Uri(String, UriKind)

Inicjuje Uri nowe wystąpienie klasy o określonym identyfikatorze URI. Ten konstruktor umożliwia określenie, czy ciąg identyfikatora URI jest względnym identyfikatorem URI, bezwzględnym identyfikatorem URI lub jest nieokreślony.

Uri(Uri, String)

Inicjuje nowe wystąpienie klasy na podstawie określonego Uri podstawowego identyfikatora URI i względnego ciągu identyfikatora URI.

Uri(Uri, String, Boolean)
Nieaktualne.
Nieaktualne.
Nieaktualne.

Inicjuje Uri nowe wystąpienie klasy na podstawie określonych identyfikatorów URI bazowych i względnych z jawną kontrolą ucieczki znaków.

Uri(Uri, Uri)

Inicjuje nowe wystąpienie Uri klasy na podstawie kombinacji określonego wystąpienia podstawowego Uri i wystąpienia względnego Uri .

Pola

SchemeDelimiter

Określa znaki oddzielające schemat protokołu komunikacyjnego od części adresu identyfikatora URI. To pole jest tylko do odczytu.

UriSchemeFile

Określa, że identyfikator URI jest wskaźnikiem do pliku. To pole jest tylko do odczytu.

UriSchemeFtp

Określa, że dostęp do identyfikatora URI jest uzyskiwany za pośrednictwem protokołu TRANSFERU plików (FTP). To pole jest tylko do odczytu.

UriSchemeFtps

Określa, że dostęp do identyfikatora URI jest uzyskiwany za pośrednictwem protokołu transferu plików Secure (FTPS). To pole jest tylko do odczytu.

UriSchemeGopher

Określa, że dostęp do identyfikatora URI jest uzyskiwany za pośrednictwem protokołu Gopher. To pole jest tylko do odczytu.

UriSchemeHttp

Określa, że dostęp do identyfikatora URI jest uzyskiwany za pośrednictwem protokołu HTTP (Hypertext Transfer Protocol). To pole jest tylko do odczytu.

UriSchemeHttps

Określa, że dostęp do identyfikatora URI jest uzyskiwany za pośrednictwem protokołu SECURE Hypertext Transfer Protocol (HTTPS). To pole jest tylko do odczytu.

UriSchemeMailto

Określa, że identyfikator URI jest adresem e-mail i jest dostępny za pośrednictwem protokołu SMTP (Simple Mail Transport Protocol). To pole jest tylko do odczytu.

UriSchemeNetPipe

Określa, że dostęp do identyfikatora URI jest uzyskiwany za pośrednictwem schematu NetPipe używanego przez Windows Communication Foundation (WCF). To pole jest tylko do odczytu.

UriSchemeNetTcp

Określa, że dostęp do identyfikatora URI jest uzyskiwany za pośrednictwem schematu NetTcp używanego przez Windows Communication Foundation (WCF). To pole jest tylko do odczytu.

UriSchemeNews

Określa, że identyfikator URI jest internetową grupą wiadomości i jest dostępny za pośrednictwem protokołu NNTP (Network News Transport Protocol). To pole jest tylko do odczytu.

UriSchemeNntp

Określa, że identyfikator URI jest internetową grupą wiadomości i jest dostępny za pośrednictwem protokołu NNTP (Network News Transport Protocol). To pole jest tylko do odczytu.

UriSchemeSftp

Określa, że dostęp do identyfikatora URI jest uzyskiwany za pośrednictwem protokołu SSH File Transfer Protocol (SFTP). To pole jest tylko do odczytu.

UriSchemeSsh

Określa, że dostęp do identyfikatora URI jest uzyskiwany za pośrednictwem protokołu Secure Socket Shell (SSH). To pole jest tylko do odczytu.

UriSchemeTelnet

Określa, że dostęp do identyfikatora URI jest uzyskiwany za pośrednictwem protokołu Telnet. To pole jest tylko do odczytu.

UriSchemeWs

Określa, że dostęp do identyfikatora URI jest uzyskiwany za pośrednictwem protokołu WebSocket (WS). To pole jest tylko do odczytu.

UriSchemeWss

Określa, że dostęp do identyfikatora URI jest uzyskiwany za pośrednictwem protokołu Secure protokołu WebSocket (WSS). To pole jest tylko do odczytu.

Właściwości

AbsolutePath

Pobiera ścieżkę bezwzględną identyfikatora URI.

AbsoluteUri

Pobiera bezwzględny identyfikator URI.

Authority

Pobiera nazwę hosta lub adres IP systemu nazw domen (DNS) oraz numer portu serwera.

DnsSafeHost

Pobiera nazwę hosta, która po usunięciu systemu w razie potrzeby jest bezpieczna do rozpoznawania nazw DNS.

Fragment

Pobiera fragment identyfikatora URI o zmienionej uri.

Host

Pobiera składnik hosta tego wystąpienia.

HostNameType

Pobiera typ nazwy hosta określonego w identyfikatorze URI.

IdnHost

Pobiera zgodną międzynarodową nazwę domeny hosta RFC 3490 przy użyciu narzędzia Punycode zgodnie z potrzebami. Ten ciąg, po usunięciu pejzażu w razie potrzeby, jest bezpieczny do użycia na potrzeby rozpoznawania nazw DNS.

IsAbsoluteUri

Pobiera wartość wskazującą, czy Uri wystąpienie jest bezwzględne.

IsDefaultPort

Pobiera wartość wskazującą, czy wartość portu identyfikatora URI jest domyślna dla tego schematu.

IsFile

Pobiera wartość wskazującą, czy określony Uri jest identyfikator URI pliku.

IsLoopback

Pobiera wartość wskazującą, czy określony Uri odwołuje się do hosta lokalnego.

IsUnc

Pobiera wartość wskazującą, czy określona Uri jest ścieżką uniwersalnej konwencji nazewnictwa (UNC).

LocalPath

Pobiera lokalną reprezentację systemu operacyjnego nazwy pliku.

OriginalString

Pobiera oryginalny ciąg identyfikatora URI przekazany do konstruktora Uri .

PathAndQuery

AbsolutePath Pobiera właściwości i Query oddzielone znakiem zapytania (?).

Port

Pobiera numer portu tego identyfikatora URI.

Query

Pobiera wszystkie informacje o kwerendzie zawarte w określonym identyfikatorze URI.

Scheme

Pobiera nazwę schematu dla tego identyfikatora URI.

Segments

Pobiera tablicę zawierającą segmenty ścieżki tworzące określony identyfikator URI.

UserEscaped

Pobiera wartość wskazującą, czy ciąg identyfikatora URI został całkowicie ucieczki przed utworzeniem Uri wystąpienia.

UserInfo

Pobiera nazwę użytkownika, hasło lub inne informacje specyficzne dla użytkownika skojarzone z określonym identyfikatorem URI.

Metody

Canonicalize()
Nieaktualne.
Nieaktualne.
Nieaktualne.

Konwertuje wewnętrznie przechowywany identyfikator URI na postać kanoniczną.

CheckHostName(String)

Określa, czy określona nazwa hosta jest prawidłową nazwą DNS.

CheckSchemeName(String)

Określa, czy określona nazwa schematu jest prawidłowa.

CheckSecurity()
Nieaktualne.
Nieaktualne.
Nieaktualne.

Wywołanie tej metody nie ma wpływu.

Compare(Uri, Uri, UriComponents, UriFormat, StringComparison)

Porównuje określone części dwóch identyfikatorów URI przy użyciu określonych reguł porównania.

CreateObjRef(Type)

Tworzy obiekt zawierający wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikowania się z obiektem zdalnym.

(Odziedziczone po MarshalByRefObject)
Equals(Object)

Porównuje dwa Uri wystąpienia pod kątem równości.

Escape()
Nieaktualne.
Nieaktualne.
Nieaktualne.

Konwertuje wszelkie niebezpieczne lub zastrzeżone znaki w składniku ścieżki na ich reprezentacje znaków szesnastkowe.

EscapeDataString(String)

Konwertuje ciąg na jego reprezentację ucieczki.

EscapeString(String)
Nieaktualne.
Nieaktualne.
Nieaktualne.
Nieaktualne.

Konwertuje ciąg na jego reprezentację ucieczki.

EscapeUriString(String)
Nieaktualne.
Nieaktualne.

Konwertuje ciąg identyfikatora URI na jego reprezentację ucieczki.

FromHex(Char)

Pobiera wartość dziesiętną cyfry szesnastkowej.

GetComponents(UriComponents, UriFormat)

Pobiera określone składniki bieżącego wystąpienia przy użyciu określonego ucieczki dla znaków specjalnych.

GetHashCode()

Pobiera kod skrótu dla identyfikatora URI.

GetLeftPart(UriPartial)

Pobiera określoną część Uri wystąpienia.

GetLifetimeService()
Nieaktualne.

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.

(Odziedziczone po MarshalByRefObject)
GetObjectData(SerializationInfo, StreamingContext)

Zwraca dane potrzebne do serializacji bieżącego wystąpienia.

GetType()

Type Pobiera wartość bieżącego wystąpienia.

(Odziedziczone po Object)
HexEscape(Char)

Konwertuje określony znak na odpowiednik szesnastkowy.

HexUnescape(String, Int32)

Konwertuje określoną reprezentację szesnastkowa znaku na znak.

InitializeLifetimeService()
Nieaktualne.

Uzyskuje obiekt usługi okresu istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia.

(Odziedziczone po MarshalByRefObject)
IsBadFileSystemCharacter(Char)
Nieaktualne.
Nieaktualne.
Nieaktualne.

Wskazuje, czy znak jest nieprawidłowy w nazwie systemu plików.

IsBaseOf(Uri)

Określa, czy bieżące Uri wystąpienie jest bazą określonego Uri wystąpienia.

IsExcludedCharacter(Char)
Nieaktualne.
Nieaktualne.
Nieaktualne.

Określa, czy określony znak ma zostać uniknięci.

IsHexDigit(Char)

Określa, czy określony znak jest prawidłową cyfrą szesnastkowa.

IsHexEncoding(String, Int32)

Określa, czy znak w ciągu jest zakodowany szesnastkowy.

IsReservedCharacter(Char)
Nieaktualne.
Nieaktualne.
Nieaktualne.

Określa, czy określony znak jest znakiem zastrzeżonym.

IsWellFormedOriginalString()

Wskazuje, czy ciąg używany do skonstruowania tej Uri konstrukcji został dobrze sformułowany i nie wymaga dalszego ucieczki.

IsWellFormedUriString(String, UriKind)

Wskazuje, czy ciąg jest dobrze sformułowany, próbując skonstruować identyfikator URI za pomocą ciągu i gwarantuje, że ciąg nie wymaga dalszego ucieczki.

MakeRelative(Uri)
Nieaktualne.
Nieaktualne.
Nieaktualne.
Nieaktualne.

Określa różnicę między dwoma Uri wystąpieniami.

MakeRelativeUri(Uri)

Określa różnicę między dwoma Uri wystąpieniami.

MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy płytkią kopię bieżącego MarshalByRefObject obiektu.

(Odziedziczone po MarshalByRefObject)
Parse()
Nieaktualne.
Nieaktualne.
Nieaktualne.

Analizuje identyfikator URI bieżącego wystąpienia, aby upewnić się, że zawiera wszystkie części wymagane dla prawidłowego identyfikatora URI.

ToString()

Pobiera reprezentację ciągu kanonicznego dla określonego Uri wystąpienia.

TryCreate(String, UriCreationOptions, Uri)

Tworzy nowy Uri przy użyciu określonego String wystąpienia i UriCreationOptions.

TryCreate(String, UriKind, Uri)

Tworzy nowy Uri przy użyciu określonego String wystąpienia i .UriKind

TryCreate(Uri, String, Uri)

Tworzy nowy Uri przy użyciu określonych wystąpień bazowych i względnych String .

TryCreate(Uri, Uri, Uri)

Tworzy nowy Uri przy użyciu określonych wystąpień bazowych i względnych Uri .

Unescape(String)
Nieaktualne.
Nieaktualne.
Nieaktualne.

Konwertuje określony ciąg, zastępując wszystkie sekwencje ucieczki reprezentacją niezaużytą.

UnescapeDataString(String)

Konwertuje ciąg na niezaużytą reprezentację.

Operatory

Equality(Uri, Uri)

Określa, czy dwa Uri wystąpienia mają tę samą wartość.

Inequality(Uri, Uri)

Określa, czy dwa Uri wystąpienia nie mają tej samej wartości.

Jawne implementacje interfejsu

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Zwraca dane potrzebne do serializacji bieżącego wystąpienia.

Dotyczy

Bezpieczeństwo wątkowe

Wszystkie elementy członkowskie Uri są bezpieczne wątkowo i mogą być używane współbieżnie z wielu wątków.

Zobacz też