Uri Klass

Definition

Namnområde:

System

Sammansättningar:

netstandard.dll, System.Runtime.dll

Källa:

Uri.cs

Ger en objektrepresentation av en enhetlig resursidentifierare (URI) och enkel åtkomst till URI:ns delar.

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

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

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

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

Arv

Object

Uri

Implementeringar

IEquatable<Uri> IFormattable ISpanFormattable ISerializable

Exempel

I följande exempel skapas en instans av Uri klassen och den används för att utföra en GET-begäran med HttpClient.

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

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

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

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

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

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

Följande kodfragment visar exempelvärden för de olika egenskaperna i klassen.

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

Kommentarer

En enhetlig resursidentifierare (URI) är en kompakt representation av en resurs som är tillgänglig för ditt program på intranätet eller Internet. Klassen Uri definierar egenskaper och metoder för hantering av URI:er, inklusive parsning, jämförelse och kombination. Klassegenskaperna Uri är skrivskyddade. Använd UriBuilder klassen för att skapa ett ändringsbart objekt.

Relativa URI:er (till exempel "/new/index.htm") måste utökas med avseende på en bas-URI så att de är absoluta. Metoden MakeRelativeUri tillhandahålls för att konvertera absoluta URI:er till relativa URI:er vid behov.

Konstruktorerna Uri eskaperar inte URI-strängar om strängen är en korrekt formaterad URI, inklusive ett schemanamn.

Egenskaperna Uri returnerar en kanonisk datarepresentation i undantagen kodning, där alla tecken med Unicode-värden som är större än 127 ersätts med deras hexadecimala motsvarigheter. Konstruktorn utför följande steg för att placera URI:n i kanonisk form Uri :

• Konverterar URI-schemat till gemener.
• Konverterar värdnamnet till småbokstäver.
• Om värdnamnet är en IPv6-adress används den kanoniska IPv6-adressen. ScopeId och andra valfria IPv6-data tas bort.
• Tar bort standard- och tomma portnummer.
• Konverterar implicita filsökvägar utan file:// -schemat (till exempel "C:\my\file") till explicita filsökvägar med file://-schemat.
• Undantagna tecken (även kallade procentkodade oktetter) som inte har ett reserverat syfte avkodas (kallas även ej kapslade). Dessa oreserverade tecken inkluderar versaler och gemener (%41-%5A och %61-%7A), decimalsiffror (%30-%39), bindestreck (%2D), period (%2E), understreck (%5F) och tilde (%7E).
• Kanoniserar sökvägen för hierarkiska URI:er genom att komprimera sekvenser som /./ och /../ (oavsett om sekvensen är undantagen eller inte). Observera att det finns vissa scheman som dessa sekvenser inte komprimeras för.
• För hierarkiska URI:er läggs ett till om värden inte avslutas med ett snedstreck (/).
• Som standard är alla reserverade tecken i URI:n undantagna i enlighet med RFC 2396. Det här beteendet ändras om international resource identifiers eller international domain name parsing är aktiverad i vilket fall reserverade tecken i URI:n är undantagna i enlighet med RFC 3986 och RFC 3987.

Som en del av kanonisering i konstruktorn för vissa scheman komprimeras punktsegment (/./ och /../) (med andra ord tas de bort). De scheman som Uri komprimerar segment är http, https, tcp, net.pipe och net.tcp. För vissa andra scheman komprimeras inte dessa sekvenser. Följande kodfragment visar hur komprimering ser ut i praktiken. Escape-sekvenserna avkapslas, om det behövs, och komprimeras sedan.

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

När den här koden körs returneras utdata som liknar följande text.

AbsoluteUri: http://myurl/
PathAndQuery: /

Du kan transformera innehållet i Uri klassen från en escape-kodad URI-referens till en läsbar URI-referens med hjälp ToString av metoden. Observera att vissa reserverade tecken fortfarande kan vara undantagna i metodens ToString utdata. Detta är för att stödja en entydig rekonstruktion av en URI från värdet som returneras av ToString.

Vissa URI:er innehåller en fragmentidentifierare eller en fråga eller båda. En fragmentidentifierare är all text som följer ett taltecken (#), som inte inkluderar taltecknet. fragmenttexten lagras i egenskapen Fragment . Frågeinformation är en text som följer ett frågetecken (?) i URI:n. frågetexten lagras i egenskapen Query .

Note

URI-klassen stöder användning av IP-adresser i både quad-notation för IPv4-protokollet och colon-hexadecimalt för IPv6-protokollet. Kom ihåg att omsluta IPv6-adressen inom hakparenteser, som i http://[::1].

Stöd för internationella resursidentifierare

Webbadresser uttrycks vanligtvis med URI:er som består av en mycket begränsad uppsättning tecken:

• Versaler och gemener ASCII-bokstäver från det engelska alfabetet.
• Siffror från 0 till 9.
• Ett litet antal andra ASCII-symboler.

Specifikationerna för URI:er dokumenteras i RFC 2396, RFC 2732, RFC 3986 och RFC 3987 publicerade av Internet Engineering Task Force (IETF).

Identifierare som underlättar behovet av att identifiera resurser med andra språk än engelska och tillåter icke-ASCII-tecken (tecken i Unicode/ISO 10646-teckenuppsättningen) kallas internationella resursidentifierare (IRI). Specifikationerna för IRI:er dokumenteras i RFC 3987 som publicerats av IETF. Med IRI:er kan en URL innehålla Unicode-tecken. Normaliserings- och teckenkontroll utförs enligt de senaste IRI-reglerna i RFC 3986 och RFC 3987.

IRI- och IDN-bearbetning i Uri klassen kan styras med hjälp av klasserna System.Configuration.IriParsingElement, System.Configuration.IdnElementoch System.Configuration.UriSection konfigurationsinställning. Inställningen System.Configuration.IriParsingElement aktiverar eller inaktiverar IRI-bearbetning i Uri klassen. Inställningen System.Configuration.IdnElement aktiverar eller inaktiverar IDN-bearbetning i Uri klassen.

Konfigurationsinställningarna för System.Configuration.IriParsingElement och System.Configuration.IdnElement läses en gång när den första System.Uri-klassen skapas. Ändringar i konfigurationsinställningarna efter den tiden ignoreras.

Klassen System.GenericUriParser har också utökats så att du kan skapa en anpassningsbar parser som stöder IRI och IDN. Beteendet för ett System.GenericUriParser objekt anges genom att en bitvis kombination av de värden som är tillgängliga i System.GenericUriParserOptions uppräkningen skickas System.GenericUriParser till konstruktorn. Typen GenericUriParserOptions.IriParsing anger att parsern stöder de parsningsregler som anges i RFC 3987 för IRI (International Resource Identifiers).

Typen GenericUriParserOptions.Idn anger att parsern stöder internationaliserad domännamnsparsning (IDN) för värdnamn. I .NET (Core) och .NET Framework 4.5+ används alltid IDN. I tidigare versioner avgör ett konfigurationsalternativ om IDN används.

Stöd för implicit filsökväg

Uri kan också användas för att representera lokala filsystemsökvägar. Dessa sökvägar kan uttryckligen representeras i URI:er som börjar med file://-schemat och implicit i URI:er som inte har file://-schemat. Som ett konkret exempel är följande två URI:er båda giltiga och representerar samma filsökväg:

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.

Dessa implicita filsökvägar är inte kompatibla med URI-specifikationen och bör undvikas när det är möjligt. När du använder .NET Core i Unix-baserade system kan implicita filsökvägar vara särskilt problematiska, eftersom en absolut implicit filsökväg inte kan skiljas från en relativ sökväg. När en sådan tvetydighet finns, ska sökvägen tolkas som en absolut URI som standard.

Säkerhetsfrågor

På grund av säkerhetsskäl bör ditt program vara försiktigt när det accepteras Uri-instanser från opålitliga källor och att dontEscape är inställt på true i konstruktorn. Du kan kontrollera att en URI-sträng är giltig genom att anropa IsWellFormedOriginalString metoden.

När du hanterar ej betrodda användarindata bekräftar du antaganden om den nyligen skapade Uri instansen innan du litar på dess egenskaper. Detta kan göras på följande sätt:

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

Den här valideringen kan användas i andra fall, till exempel när du hanterar UNC-sökvägar, genom att helt enkelt ändra :baseUri

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

Mer information om design- och säkerhetsöverväganden för Uri och UriBuilder finns i följande hotmodelldokument.

• System.Uri-hotmodell
• System.UriBuilder säkerhetsmodell

Prestandaöverväganden

Om du använder en Web.config fil som innehåller URI:er för att initiera programmet krävs ytterligare tid för att bearbeta URI:erna om deras schemaidentifierare inte är standard. I sådana fall initierar du de berörda delarna av programmet när URI:erna behövs, inte vid starttiden.

Konstruktorer

Name	Description
Uri(SerializationInfo, StreamingContext)	Föråldrad. Initierar en ny instans av Uri klassen från de angivna instanserna av SerializationInfo klasserna och StreamingContext .
Uri(String, Boolean)	Föråldrad. Initierar en ny instans av Uri klassen med den angivna URI:n, med explicit kontroll över tecken som flyr.
Uri(String, UriCreationOptions)	Initierar en ny instans av Uri klassen med angiven URI och ytterligare UriCreationOptions.
Uri(String, UriKind)	Initierar en ny instans av Uri klassen med angiven URI. Med den här konstruktorn kan du ange om URI-strängen är en relativ URI, absolut URI eller är obestämd.
Uri(String)	Initierar en ny instans av Uri klassen med angiven URI.
Uri(Uri, String, Boolean)	Föråldrad. Initierar en ny instans av Uri klassen baserat på angivna bas- och relativa URI:er, med explicit kontroll över tecken som flyr.
Uri(Uri, String)	Initierar en ny instans av Uri klassen baserat på den angivna bas-URI:n och den relativa URI-strängen.
Uri(Uri, Uri)	Initierar en ny instans av Uri klassen baserat på kombinationen av en angiven basinstans Uri och en relativ Uri instans.

Fält

Name	Description
SchemeDelimiter	Anger de tecken som skiljer kommunikationsprotokollschemat från adressdelen av URI:n. Detta fält är skrivskyddat.
UriSchemeFile	Anger att URI:n är en pekare till en fil. Detta fält är skrivskyddat.
UriSchemeFtp	Anger att URI:n nås via File Transfer Protocol (FTP). Detta fält är skrivskyddat.
UriSchemeFtps	Anger att URI:n nås via FTPS (File Transfer Protocol Secure). Detta fält är skrivskyddat.
UriSchemeGopher	Anger att URI:n nås via Gopher-protokollet. Detta fält är skrivskyddat.
UriSchemeHttp	Anger att URI:n nås via Hypertext Transfer Protocol (HTTP). Detta fält är skrivskyddat.
UriSchemeHttps	Anger att URI:n nås via HTTPS (Secure Hypertext Transfer Protocol). Detta fält är skrivskyddat.
UriSchemeMailto	Anger att URI:n är en e-postadress och nås via SMTP (Simple Mail Transport Protocol). Detta fält är skrivskyddat.
UriSchemeNetPipe	Anger att URI:n nås via NetPipe-schemat som används av Windows Communication Foundation (WCF). Detta fält är skrivskyddat.
UriSchemeNetTcp	Anger att URI:n nås via NetTcp-schemat som används av Windows Communication Foundation (WCF). Detta fält är skrivskyddat.
UriSchemeNews	Anger att URI:n är en internetnyhetsgrupp och nås via NNTP (Network News Transport Protocol). Detta fält är skrivskyddat.
UriSchemeNntp	Anger att URI:n är en internetnyhetsgrupp och nås via NNTP (Network News Transport Protocol). Detta fält är skrivskyddat.
UriSchemeSftp	Anger att URI:n nås via SSH File Transfer Protocol (SFTP). Detta fält är skrivskyddat.
UriSchemeSsh	Anger att URI:n nås via SSH (Secure Socket Shell Protocol). Detta fält är skrivskyddat.
UriSchemeTelnet	Anger att URI:n nås via Telnet-protokollet. Detta fält är skrivskyddat.
UriSchemeWs	Anger att URI:n nås via WebSocket-protokollet (WS). Detta fält är skrivskyddat.
UriSchemeWss	Anger att URI:n nås via WebSocket Secure Protocol (WSS). Detta fält är skrivskyddat.

Egenskaper

Name	Description
AbsolutePath	Hämtar den absoluta sökvägen för URI:n.
AbsoluteUri	Hämtar den absoluta URI:n.
Authority	Hämtar DNS-värdnamnet (Domain Name System) eller IP-adressen och portnumret för en server.
DnsSafeHost	Hämtar ett värdnamn som, efter att ha blivit ofrånkomlig vid behov, är säkert att använda för DNS-matchning.
Fragment	Hämtar det förrymda URI-fragmentet, inklusive det inledande #-tecknet om det inte är tomt.
Host	Hämtar värdkomponenten för den här instansen.
HostNameType	Hämtar den typ av värdnamn som anges i URI:n.
IdnHost	Hämtar RFC 3490-kompatibelt internationellt domännamn för värden med punycode efter behov. Den här strängen är säker att använda för DNS-matchning efter att den inte har kapslades om det behövs.
IsAbsoluteUri	Hämtar ett värde som anger om instansen Uri är absolut.
IsDefaultPort	Hämtar ett värde som anger om portvärdet för URI:n är standardvärdet för det här schemat.
IsFile	Hämtar ett värde som anger om den angivna Uri är en fil-URI.
IsLoopback	Hämtar ett värde som anger om den angivna Uri refererar till den lokala värden.
IsUnc	Hämtar ett värde som anger om den angivna Uri är en UNC-sökväg (Universal Naming Convention).
LocalPath	Hämtar en lokal operativsystemrepresentation av ett filnamn.
OriginalString	Hämtar den ursprungliga URI-strängen Uri som skickades till konstruktorn.
PathAndQuery	AbsolutePath Hämtar egenskaperna och Query avgränsade med ett frågetecken (?).
Port	Hämtar portnumret för den här URI:n.
Query	Hämtar all frågeinformation som ingår i den angivna URI:n, inklusive det inledande tecknet ? om det inte är tomt.
Scheme	Hämtar schemanamnet för den här URI:n.
Segments	Hämtar en matris som innehåller sökvägssegmenten som utgör den angivna URI:n.
UserEscaped	Hämtar ett värde som anger om URI-strängen var helt undantagen innan instansen Uri skapades.
UserInfo	Hämtar användarnamn, lösenord eller annan användarspecifik information som är associerad med den angivna URI:n.

Metoder

Name	Description
Canonicalize()	Föråldrad. Konverterar den internt lagrade URI:n till kanoniskt format.
CheckHostName(String)	Avgör om det angivna värdnamnet är ett giltigt DNS-namn.
CheckSchemeName(String)	Avgör om det angivna schemanamnet är giltigt.
CheckSecurity()	Föråldrad. Att anropa den här metoden har ingen effekt.
Compare(Uri, Uri, UriComponents, UriFormat, StringComparison)	Jämför de angivna delarna av två URI:er med hjälp av de angivna jämförelsereglerna.
Equals(Object)	Jämför två Uri instanser för likhet.
Equals(Uri)	Jämför två Uri instanser för likhet.
Escape()	Föråldrad. Konverterar eventuella osäkra eller reserverade tecken i sökvägskomponenten till deras hexadecimala teckenrepresentationer.
EscapeDataString(ReadOnlySpan<Char>)	Konverterar ett intervall till den undantagna representationen.
EscapeDataString(String)	Konverterar en sträng till dess undantagna representation.
EscapeString(String)	Föråldrad. Konverterar en sträng till dess undantagna representation.
EscapeUriString(String)	Föråldrad. Konverterar en URI-sträng till dess undantagna representation.
FromHex(Char)	Hämtar decimalvärdet för en hexadecimal siffra.
GetComponents(UriComponents, UriFormat)	Hämtar de angivna komponenterna i den aktuella instansen med den angivna escapeingen för specialtecken.
GetHashCode()	Hämtar hash-koden för URI:n.
GetLeftPart(UriPartial)	Hämtar den angivna delen av en Uri instans.
GetObjectData(SerializationInfo, StreamingContext)	Returnerar de data som behövs för att serialisera den aktuella instansen.
GetType()	Hämtar den aktuella instansen Type . (Ärvd från Object)
HexEscape(Char)	Konverterar ett angivet tecken till dess hexadecimala motsvarighet.
HexUnescape(String, Int32)	Konverterar en angiven hexadecimal representation av ett tecken till tecknet.
IsBadFileSystemCharacter(Char)	Föråldrad. Anger om ett tecken är ogiltigt i ett filsystemnamn.
IsBaseOf(Uri)	Avgör om den aktuella Uri instansen är en bas för den angivna Uri instansen.
IsExcludedCharacter(Char)	Föråldrad. Avgör om det angivna tecknet ska vara undantaget.
IsHexDigit(Char)	Avgör om ett angivet tecken är en giltig hexadecimal siffra.
IsHexEncoding(String, Int32)	Avgör om ett tecken i en sträng är hexadecimalt kodat.
IsReservedCharacter(Char)	Föråldrad. Avgör om det angivna tecknet är ett reserverat tecken.
IsWellFormedOriginalString()	Anger om strängen som användes för att konstruera detta Uri var välformulerad och inte kräver ytterligare utrymning.
IsWellFormedUriString(String, UriKind)	Anger om strängen är välformulerad genom att försöka konstruera en URI med strängen och ser till att strängen inte kräver ytterligare utrymning.
MakeRelative(Uri)	Föråldrad. Avgör skillnaden mellan två Uri instanser.
MakeRelativeUri(Uri)	Avgör skillnaden mellan två Uri instanser.
MemberwiseClone()	Skapar en ytlig kopia av den aktuella Object. (Ärvd från Object)
Parse()	Föråldrad. Parsar URI:n för den aktuella instansen för att säkerställa att den innehåller alla delar som krävs för en giltig URI.
ToString()	Hämtar en kanonisk strängrepresentation för den angivna Uri instansen.
TryCreate(String, UriCreationOptions, Uri)	Skapar en ny Uri med den angivna String instansen och UriCreationOptions.
TryCreate(String, UriKind, Uri)	Skapar en ny Uri med den angivna String instansen och en UriKind.
TryCreate(Uri, String, Uri)	Skapar en ny Uri med angivna bas- och relativa String instanser.
TryCreate(Uri, Uri, Uri)	Skapar en ny Uri med angivna bas- och relativa Uri instanser.
TryEscapeDataString(ReadOnlySpan<Char>, Span<Char>, Int32)	Försöker konvertera ett intervall till dess undantagna representation.
TryFormat(Span<Char>, Int32)	Försöker formatera en kanonisk strängrepresentation för instansen Uri till det angivna intervallet.
TryUnescapeDataString(ReadOnlySpan<Char>, Span<Char>, Int32)	Försöker konvertera ett spann till dess ej kapslade representation.
Unescape(String)	Föråldrad. Konverterar den angivna strängen genom att ersätta eventuella escape-sekvenser med deras ej kapslade representation.
UnescapeDataString(ReadOnlySpan<Char>)	Konverterar ett spann till dess icke kapslade representation.
UnescapeDataString(String)	Konverterar en sträng till dess icke kapslade representation.

Operatorer

Name	Description
Equality(Uri, Uri)	Avgör om två Uri instanser har samma värde.
Inequality(Uri, Uri)	Avgör om två Uri instanser inte har samma värde.

Explicita gränssnittsimplementeringar

Name	Description
IFormattable.ToString(String, IFormatProvider)	Formaterar värdet för den aktuella instansen med det angivna formatet.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Returnerar de data som behövs för att serialisera den aktuella instansen.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Försöker formatera värdet för den aktuella instansen till det angivna intervallet med tecken.

Trådsäkerhet

Alla medlemmar Uri i är trådsäkra och kan användas samtidigt från flera trådar.

Se även

• IdnElement
• IriParsingElement
• UriSection
• DnsSafeHost
• MakeRelative(Uri)
• IsWellFormedOriginalString()
• UriBuilder
• Ändringar i System.Uri-namnområdet i version 2.0
• Stöd för internationella resursidentifierare i System.UriSystem.Uri
• Nätverksprogrammering i .NET Framework