Uri Classe

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Fornece uma representação de objeto de um URI (Uniform Resource Identifier) e fácil acesso às partes do URI.

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

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

type Uri = class
    interface ISpanFormattable
    interface IFormattable
    interface ISerializable

Public Class Uri
Implements ISerializable, ISpanFormattable

Herança

Object

Uri

Implementações

ISerializable IFormattable ISpanFormattable

Exemplos

O exemplo a seguir cria uma instância da classe e a Uri usa para executar uma solicitação GET com HttpClient.

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)

O snippet de código a seguir mostra valores de exemplo das várias propriedades na classe .

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

Comentários

Um URI é uma representação compacta de um recurso disponível para seu aplicativo na intranet ou na Internet. A Uri classe define as propriedades e os métodos para lidar com URIs, incluindo análise, comparação e combinação. As Uri propriedades de classe são somente leitura; para criar um objeto modificável, use a UriBuilder classe .

URIs relativas (por exemplo, "/new/index.htm") devem ser expandidas em relação a um URI base para que sejam absolutas. O MakeRelativeUri método é fornecido para converter URIs absolutos em URIs relativas quando necessário.

Os Uri construtores não escaparão de cadeias de caracteres de URI se a cadeia de caracteres for um URI bem formado, incluindo um identificador de esquema.

As Uri propriedades retornam uma representação de dados canônica na codificação de escape, com todos os caracteres com valores Unicode maiores que 127 substituídos por seus equivalentes hexadecimal. Para colocar o URI em forma canônica, o Uri construtor executa as seguintes etapas:

• Converte o esquema de URI em letras minúsculas.

• Converte o nome do host em letras minúsculas.

• Se o nome do host for um endereço IPv6, o endereço IPv6 canônico será usado. ScopeId e outros dados IPv6 opcionais são removidos.

• Remove números de porta padrão e vazios.

• Converte caminhos de arquivo implícitos sem o esquema de file:// (por exemplo, "C:\my\file") em caminhos de arquivo explícitos com o esquema de file://.

• Os caracteres de escape (também conhecidos como octetos codificados por porcentagem) que não têm uma finalidade reservada são decodificados (também conhecidos como sem escape). Esses caracteres não reservados incluem letras maiúsculas e minúsculas (%41-%5A e %61-%7A), dígitos decimais (%30-%39), hífen (%2D), período (%2E), sublinhado (%5F) e til (%7E).

• Canoniza o caminho para URIs hierárquicos compactando sequências como /./, /.. /, e // (se a sequência é ou não escapada). Observe que há alguns esquemas para os quais essas sequências não são compactadas.

• Para URIs hierárquicos, se o host não for encerrado com uma barra (/), uma será adicionada.

• Por padrão, todos os caracteres reservados no URI são escapados de acordo com o RFC 2396. Esse comportamento mudará se a análise de Identificadores de Recursos Internacionais ou Nome de Domínio Internacional estiver habilitada, caso em que caracteres reservados no URI serão escapados de acordo com RFC 3986 e RFC 3987.

Como parte da canonização no construtor para alguns esquemas, os segmentos de pontos e os segmentos vazios (/./, /../e //) são compactados (em outras palavras, eles são removidos). Os esquemas para os quais Uri os segmentos de compactações incluem http, https, tcp, net.pipe e net.tcp. Para alguns outros esquemas, essas sequências não são compactadas. O snippet de código a seguir mostra a aparência da compactação na prática. As sequências de escape são sem escape, se necessário, e compactadas.

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

Quando esse código é executado, ele retorna uma saída semelhante ao texto a seguir.

AbsoluteUri: http://myurl/
PathAndQuery: /

Você pode transformar o conteúdo da classe de Uri uma referência de URI codificada em escape para uma referência de URI legível usando o ToString método . Observe que alguns caracteres reservados ainda podem ser escapados na saída do ToString método . Isso é para dar suporte à reconstrução inequívoca de um URI do valor retornado por ToString.

Alguns URIs incluem um identificador de fragmento ou uma consulta ou ambos. Um identificador de fragmento é qualquer texto que segue um sinal numérico (#), não incluindo o sinal de número; o texto do fragmento é armazenado na Fragment propriedade . As informações de consulta são qualquer texto que siga um ponto de interrogação (?) no URI; o texto da consulta é armazenado na Query propriedade .

No .NET Framework versão 1.1, se a cadeia de caracteres especificada para um construtor contiver um esquema desconhecido e "c:\", a classe Uri inserirá "//" após os dois-pontos. Por exemplo, o URI xyz:c:\abc é convertido xyz://c:/abcem . No .NET Framework versão 2.0, esse comportamento foi removido e a cadeia de caracteres de exemplo é convertida xyz:c:/abcem .

Observação

A classe URI dá suporte ao uso de endereços IP em quad-notation para protocolo IPv4 e colon-hexadecimal para protocolo IPv6. Lembre-se de colocar o endereço IPv6 entre colchetes, como em http://[::1].

Suporte ao identificador do recurso internacional

Os endereços Web normalmente são expressos usando identificadores de recursos uniformes que consistem em um conjunto muito restrito de caracteres:

• Letras maiúsculas e minúsculas ASCII do alfabeto inglês.

• Dígitos de 0 a 9.

• Um pequeno número de outros símbolos ASCII.

As especificações para URIs estão documentadas no RFC 2396, RFC 2732, RFC 3986 e RFC 3987 publicados pela Internet Engineering Task Force (IETF).

Com o crescimento da Internet, há uma necessidade crescente de identificar recursos com idiomas diferentes do inglês. Identificadores que facilitam a essa necessidade e permitem que os caracteres não ASCII (caracteres no conjunto de caracteres Unicode/ISO 10646) são conhecidos como IRIs (International Resource Identifiers). As especificações de IRIs estão documentadas na RFC 3987, publicado pela IETF. O uso de IRIs permite que uma URL contenha caracteres Unicode.

A classe existente Uri foi estendida em .NET Framework v3.5, 3.0 SP1 e 2.0 SP1 para fornecer suporte a IRI com base no RFC 3987. Os usuários de .NET Framework versões anteriores à versão 4.5 não verão nenhuma alteração do comportamento do .NET Framework 2.0, a menos que habilitem especificamente a IRI. Isso garante a compatibilidade do aplicativo com versões anteriores do .NET Framework.

No .NET Framework 4.5 e versões posteriores, o IRI está sempre habilitado e não pode ser alterado usando uma opção de configuração. Para habilitar o suporte para IRI em .NET Framework versões anteriores ao .NET Framework 4.5, defina uma opção de configuração no machine.config ou no arquivo app.config. Especificar se a análise do IDN (nome de domínio internacionalizado) deve ser aplicada ao nome do domínio e se as regras de análise do IRI devem ser aplicadas. Por exemplo:

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

Habilitar o IDN converte todos os rótulos Unicode em um nome de domínio em seus equivalentes punycode. Os nomes Punycode contêm apenas caracteres ASCII e sempre começam com o prefixo xn--. A razão para isso é dar suporte a servidores DNS existentes na Internet, pois a maioria dos servidores DNS dá suporte somente a caracteres ASCII (consulte RFC 3940).

Habilitar IRI e IDN afeta o valor da propriedade Uri.DnsSafeHost. Habilitar IRI e IDN também pode alterar o comportamento dos métodos Equals, OriginalString, GetComponents e IsWellFormedOriginalString.

Há três valores possíveis para IDN, dependendo dos servidores DNS que são usados:

• idn habilitado = Todos

  Esse valor converterá todos os nomes de domínio Unicode em seus equivalentes do Punycode (nomes IDN).

• idn habilitado = AllExceptIntranet

  Esse valor converterá todos os nomes de domínio Unicode não na intranet local para usar os equivalentes do Punycode (nomes IDN). Nesse caso, para manipular nomes internacionais na Intranet local, os servidores DNS usados para a Intranet devem dar suporte a resolução de nomes Unicode.

• idn habilitado = Nenhum

  Esse valor não converterá nenhum nome de domínio Unicode para usar o Punycode. Esse é o valor padrão consistente com o comportamento .NET Framework 2.0.

Quando a análise de IRI está habilitada (iriParsing habilitado = true), a normalização e a verificação de caracteres são feitas de acordo com as regras de IRI mais recentes no RFC 3986 e RFC 3987. Quando a análise de IRI é desabilitada, a normalização e a verificação de caracteres são executadas de acordo com RFC 2396 e RFC 2732 (para literais IPv6). Em versões de .NET Framework antes da versão 4.5, o valor padrão é false. No .NET Framework 4.5+, no .NET Core e no .NET 5+, o valor padrão é truee o estado habilitado da análise de IRI não pode ser modificado pelas configurações em um arquivo .config.

O processamento de IRI e IDN na Uri classe também pode ser controlado usando as System.Configuration.IriParsingElementclasses de configuração , System.Configuration.IdnElemente System.Configuration.UriSection . A configuração System.Configuration.IriParsingElement habilita ou desabilita o processamento de IRI na classe Uri. A configuração System.Configuration.IdnElement habilita ou desabilita o processamento de IDN na classe Uri. A configuração System.Configuration.IriParsingElement também controla indiretamente o IDN. O processamento de IRI deve estar habilitado para que o processamento de IDN seja possível. Se o processamento de IRI estiver desabilitado, o processamento de IDN será definido para a configuração padrão, na qual o comportamento do .NET Framework 2.0 será usado para fins de compatibilidade e nomes IDN não serão usados.

A definição de configuração para e System.Configuration.IriParsingElementSystem.Configuration.IdnElement é lida uma vez quando a primeira System.Uri classe é construída. Alterações nas configurações depois desse tempo serão ignoradas.

A classe System.GenericUriParser também foi estendida para permitir a criação de um analisador personalizável que dá suporte a IRI e IDN. O comportamento de um objeto System.GenericUriParser é especificado passando-se uma combinação bit a bit dos valores disponíveis na enumeração System.GenericUriParserOptions para o construtor System.GenericUriParser. O tipo GenericUriParserOptions.IriParsing que indica que o analisador dá suporte às regras de análise especificadas na RFC 3987 para IRI (Identificadores de Recurso Internacional). Se a IRI é usada é ditada pelos valores de configuração discutidos anteriormente.

O GenericUriParserOptions.Idn tipo indica que o analisador dá suporte à análise de IDN (Nome de Domínio Internacionalizado) de nomes de host. No .NET 5 e versões posteriores (incluindo .NET Core) e .NET Framework 4.5+, o IDN é sempre usado. Em versões anteriores, uma opção de configuração determina se o IDN é usado.

Suporte a caminho de arquivo implícito

Uri também pode ser usado para representar caminhos do sistema de arquivos local. Esses caminhos podem ser representados explicitamente em URIs que começam com o esquema de file:// e implicitamente em URIs que não têm o esquema de file://. Como exemplo concreto, os dois URIs a seguir são válidos e representam o mesmo caminho de arquivo:

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.

Esses caminhos de arquivo implícitos não estão em conformidade com a especificação de URI e, portanto, devem ser evitados quando possível. Ao usar o .NET Core em sistemas baseados em Unix, os caminhos de arquivo implícitos podem ser especialmente problemáticos, pois um caminho de arquivo implícito absoluto é indistinguível de um caminho relativo. Quando essa ambiguidade está presente, Uri o padrão é interpretar o caminho como um URI absoluto.

Considerações de segurança

Devido a preocupações de segurança, seu aplicativo deve ter cuidado ao aceitar Uri instâncias de fontes não confiáveis e com dontEscape definido true como no construtor. Você pode marcar uma cadeia de caracteres de URI para validade chamando o IsWellFormedOriginalString método .

Ao lidar com a entrada de usuário não confiável, confirme suposições sobre a instância recém-criada Uri antes de confiar em suas propriedades. Isso pode ser feito da seguinte maneira:

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

Essa validação pode ser usada em outros casos, como ao lidar com caminhos UNC, simplesmente alterando o baseUri:

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

Considerações sobre desempenho

Se você usar um arquivo *Web.config *que contém URIs para inicializar seu aplicativo, será necessário tempo adicional para processar os URIs se os identificadores de esquema não forem padrão. Nesse caso, inicialize as partes afetadas do aplicativo quando os URIs forem necessários, não na hora de início.

Construtores

Uri(SerializationInfo, StreamingContext)	Obsoleto. Inicializa uma nova instância da classe Uri das instâncias especificadas das classes SerializationInfo e StreamingContext.
Uri(String)	Inicializa uma nova instância da classe Uri com URI especificado.
Uri(String, Boolean)	Obsoleto. Inicializa uma nova instância da classe Uri com o URI especificado, com controle explícito de escape de caractere.
Uri(String, UriCreationOptions)	Inicializa uma nova instância da Uri classe com o URI especificado e adicionais UriCreationOptions.
Uri(String, UriKind)	Inicializa uma nova instância da classe Uri com URI especificado. Este construtor permite que você especifique se a cadeia de caracteres do URI é um URI relativo, um URI absoluto ou indeterminado.
Uri(Uri, String)	Inicializa uma nova instância da classe Uri com base no URI base especificado e na cadeia de caracteres do URI relativo.
Uri(Uri, String, Boolean)	Obsoleto. Inicializa uma nova instância da classe Uri baseada nos URIs de base e relativos especificados, com controle explícito de escape de caracteres.
Uri(Uri, Uri)	Inicializa uma nova instância da classe Uri com base na combinação de uma instância base de Uri especificada e uma instância de Uri relativa.

Campos

SchemeDelimiter	Especifica os caracteres que separam o esquema de protocolo de comunicação da parte do endereço do URI. Este campo é somente leitura.
UriSchemeFile	Especifica que o URI é um ponteiro para um arquivo. Este campo é somente leitura.
UriSchemeFtp	Especifica que o URI é acessado por meio do protocolo FTP. Este campo é somente leitura.
UriSchemeFtps	Especifica que o URI é acessado por meio do FTPS (File Transfer Protocol Secure). Este campo é somente leitura.
UriSchemeGopher	Especifica que o URI é acessado por meio do protocolo Gopher. Este campo é somente leitura.
UriSchemeHttp	Especifica que o URI é acessado por meio do protocolo HTTP. Este campo é somente leitura.
UriSchemeHttps	Especifica que o URI é acessado por meio de HTTPS (Secure Hypertext Transfer Protocol). Este campo é somente leitura.
UriSchemeMailto	Especifica que o URI é um endereço de email e é acessado por meio do protocolo SMTP. Este campo é somente leitura.
UriSchemeNetPipe	Especifica que o URI é acessado por meio do esquema NetPipe usado pelo WCF (Windows Communication Foundation). Este campo é somente leitura.
UriSchemeNetTcp	Especifica que o URI é acessado por meio do esquema NetTcp usado pelo WCF (Windows Communication Foundation). Este campo é somente leitura.
UriSchemeNews	Especifica que o URI é um grupo de notícias da Internet e é acessado por meio do NNTP. Este campo é somente leitura.
UriSchemeNntp	Especifica que o URI é um grupo de notícias da Internet e é acessado por meio do NNTP. Este campo é somente leitura.
UriSchemeSftp	Especifica que o URI é acessado por meio do Protocolo de Transferência de Arquivo SSH (SFTP). Este campo é somente leitura.
UriSchemeSsh	Especifica que o URI é acessado por meio do protocolo SSH (Secure Socket Shell). Este campo é somente leitura.
UriSchemeTelnet	Especifica que o URI é acessado por meio do protocolo Telnet. Este campo é somente leitura.
UriSchemeWs	Especifica que o URI é acessado por meio do protocolo WebSocket (WS). Este campo é somente leitura.
UriSchemeWss	Especifica que o URI é acessado por meio do protocolo WebSocket Secure (WSS). Este campo é somente leitura.

Propriedades

AbsolutePath	Obtém o caminho absoluto do URI.
AbsoluteUri	Obtém o URI absoluto.
Authority	Obtém o nome do host do DNS (Sistema de Nomes de Domínio) ou o endereço IP e o número da porta para um servidor.
DnsSafeHost	Obtém um nome do host que, depois de não ser escapada, se necessário, é seguro para ser usado para a resolução de DNS.
Fragment	Obtém o fragmento de URI de escape, incluindo o caractere '#' à esquerda, se não estiver vazio.
Host	Obtém o componente de host desta instância.
HostNameType	Obtém o tipo do nome de host especificado no URI.
IdnHost	Obtém o Nome de Domínio Internacional compatível com RFC 3490 do host, usando Punycode conforme apropriado. Esta cadeia de caracteres, depois de não ser escapada, se necessário, é seguro para ser usado para a resolução de DNS.
IsAbsoluteUri	Obtém um valor que indica se a instância Uri é absoluta.
IsDefaultPort	Obtém um valor que indica se o valor da porta do URI é o padrão para esse esquema.
IsFile	Obtém um valor que indica se o Uri especificado é um URI de arquivo.
IsLoopback	Obtém um valor que indica se o Uri especificado faz referência ao host local.
IsUnc	Obtém um valor que indica se o Uri especificado é um caminho UNC (convenção de nomenclatura universal).
LocalPath	Obtém uma representação local do sistema operacional de um nome de arquivo.
OriginalString	Obtém a cadeia de caracteres do URI original que foi passada para o construtor Uri.
PathAndQuery	Obtém as propriedades AbsolutePath e Query separadas por um ponto de interrogação (?).
Port	Obtém o número da porta desse URI.
Query	Obtém qualquer informação de consulta incluída no URI especificado, incluindo o caractere '?' à esquerda, se não estiver vazio.
Scheme	Obtém o nome do esquema para esse URI.
Segments	Obtém uma matriz contendo os segmentos de caminho que compõem o URI especificado.
UserEscaped	Obtém um valor que indica se a cadeia de caracteres do URI sofreu escape completo antes da criação da instância Uri.
UserInfo	Obtém o nome de usuário, a senha ou outras informações específicas do usuário associado com o URI especificado.

Métodos

Canonicalize()	Obsoleto. Converte o URI armazenado internamente em forma canônica.
CheckHostName(String)	Determina se o nome de host especificado é um nome DNS válido.
CheckSchemeName(String)	Determina se o nome do esquema especificado é válido.
CheckSecurity()	Obsoleto. Chamar esse método não tem nenhum efeito.
Compare(Uri, Uri, UriComponents, UriFormat, StringComparison)	Compara as partes especificadas de dois URIs usando as regras de comparação especificadas.
Equals(Object)	Compara duas instâncias de Uri quanto à igualdade.
Escape()	Obsoleto. Converte caracteres reservados não seguros no componente de caminho para suas representações de caractere hexadecimal.
EscapeDataString(String)	Converte uma cadeia de caracteres em sua representação de escape.
EscapeString(String)	Obsoleto. Converte uma cadeia de caracteres em sua representação de escape.
EscapeUriString(String)	Obsoleto. Converte uma cadeia de caracteres de URI para sua representação de escape.
FromHex(Char)	Obtém o valor decimal de um dígito hexadecimal.
GetComponents(UriComponents, UriFormat)	Obtém os componentes especificados da instância atual usando o escape especificado para caracteres especiais.
GetHashCode()	Obtém o código hash do URI.
GetLeftPart(UriPartial)	Obtém a parte especificada de uma instância de Uri.
GetObjectData(SerializationInfo, StreamingContext)	Retorna os dados necessários para serializar a instância atual.
GetType()	Obtém o Type da instância atual. (Herdado de Object)
HexEscape(Char)	Converte um caractere especificado em seu equivalente hexadecimal.
HexUnescape(String, Int32)	Converte uma representação hexadecimal especificada de um caractere no caractere.
IsBadFileSystemCharacter(Char)	Obsoleto. Indica se um caractere é inválido em um nome de sistema de arquivos.
IsBaseOf(Uri)	Determina se a instância Uri atual é uma base da instância Uri especificada.
IsExcludedCharacter(Char)	Obsoleto. Determina se o caractere especificado deve ter escape.
IsHexDigit(Char)	Determina se um caractere especificado é um dígito hexadecimal válido.
IsHexEncoding(String, Int32)	Determina se um caractere em uma cadeia de caracteres é codificada em hexadecimal.
IsReservedCharacter(Char)	Obsoleto. Determina se o caractere especificado é um caractere reservado.
IsWellFormedOriginalString()	Indica se a cadeia de caracteres usada para construir o Uri foi bem formada e não requer escape adicional.
IsWellFormedUriString(String, UriKind)	Indica se a cadeia de caracteres é bem formada pela tentativa de construir um URI com a cadeia de caracteres e garante que a cadeia de caracteres não requer mais de escape.
MakeRelative(Uri)	Obsoleto. Determina a diferença entre duas instâncias Uri.
MakeRelativeUri(Uri)	Determina a diferença entre duas instâncias Uri.
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
Parse()	Obsoleto. Analisa o URI da instância atual para garantir que contenha todas as partes necessárias para um URI válido.
ToString()	Obtém uma representação de cadeia de caracteres canônica para a instância Uri especificada.
TryCreate(String, UriCreationOptions, Uri)	Cria um novo Uri usando a instância especificada String e UriCreationOptions.
TryCreate(String, UriKind, Uri)	Cria um novo Uri usando a instância String especificada e um UriKind.
TryCreate(Uri, String, Uri)	Cria um novo Uri usando a base especificada e as instâncias de String relativas.
TryCreate(Uri, Uri, Uri)	Cria um novo Uri usando a base especificada e as instâncias de Uri relativas.
TryFormat(Span<Char>, Int32)	Tenta formatar uma representação de cadeia de caracteres canônica para a Uri instância no intervalo especificado.
Unescape(String)	Obsoleto. Converte a cadeia de caracteres especificada substituindo as sequências de escape por sua representação sem escape.
UnescapeDataString(String)	Converte uma cadeia de caracteres em sua representação sem escape.

Operadores

Equality(Uri, Uri)	Determina se duas instâncias Uri têm o mesmo valor.
Inequality(Uri, Uri)	Determina se duas instâncias de Uri não têm o mesmo valor.

Implantações explícitas de interface

IFormattable.ToString(String, IFormatProvider)	Formata o valor da instância atual usando o formato especificado.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Retorna os dados necessários para serializar a instância atual.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tenta formatar o valor da instância atual no intervalo fornecido de caracteres.

Acesso thread-safe

Todos os membros do Uri são thread-safe e podem ser usados simultaneamente de vários threads.

Confira também

• IdnElement
• IriParsingElement
• UriSection
• DnsSafeHost
• MakeRelative(Uri)
• IsWellFormedOriginalString()
• UriBuilder
• Alterações no namespace System.Uri na versão 2.0
• Suporte a identificador de recurso internacional em System.UriSystem.Uri
• Programação de rede no .NET Framework