Uri Klas

Definitie

public ref class Uri

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

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

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

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

public class Uri

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

public class Uri : System.Runtime.Serialization.ISerializable

public class Uri : ISpanFormattable, 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 IEquatable<Uri>
    interface IFormattable
    interface ISpanFormattable
    interface ISerializable

type Uri = class
    interface ISerializable

type Uri = class
    interface ISpanFormattable
    interface IFormattable
    interface ISerializable

type Uri = class
    interface IFormattable
    interface ISpanFormattable
    interface IEquatable<Uri>
    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 IEquatable(Of Uri), ISerializable, ISpanFormattable

Public Class Uri
Implements ISerializable

Public Class Uri
Implements ISerializable, ISpanFormattable

Public Class Uri
Inherits MarshalByRefObject
Implements ISerializable

Overname

Object

Uri

Overname

Object

MarshalByRefObject

Uri

Kenmerken

SerializableAttribute TypeConverterAttribute

Implementeringen

IEquatable<Uri> IFormattable ISpanFormattable ISerializable

Voorbeelden

In het volgende voorbeeld wordt een exemplaar van de Uri klasse gemaakt en gebruikt voor het uitvoeren van een GET-aanvraag met 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)

In het volgende codefragment ziet u voorbeeldwaarden van de verschillende eigenschappen in de 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

Opmerkingen

Een URI (Uniform Resource Identifier) is een compacte weergave van een resource die beschikbaar is voor uw toepassing op het intranet of internet. De Uri klasse definieert de eigenschappen en methoden voor het verwerken van URI's, waaronder parseren, vergelijken en combineren. De Uri klasse-eigenschappen zijn alleen-lezen. Als u een wijzigbaar object wilt maken, gebruikt u de UriBuilder klasse.

Relatieve URI's (bijvoorbeeld "/new/index.htm") moeten worden uitgebreid met betrekking tot een basis-URI, zodat ze absoluut zijn. De MakeRelativeUri methode wordt gegeven om absolute URI's zo nodig te converteren naar relatieve URI's.

De Uri constructors ontsnappen niet aan URI-tekenreeksen als de tekenreeks een goed gevormde URI is, inclusief een schema-id.

De Uri eigenschappen retourneren een canonieke gegevensweergave in escape-codering, waarbij alle tekens met Unicode-waarden groter dan 127 zijn vervangen door hun hexadecimale equivalenten. Als u de URI in canonieke vorm wilt plaatsen, voert de Uri constructor de volgende stappen uit:

• Converteert het URI-schema naar kleine letters.
• Converteert de hostnaam naar kleine letters.
• Als de hostnaam een IPv6-adres is, wordt het canonieke IPv6-adres gebruikt. ScopeId en andere optionele IPv6-gegevens worden verwijderd.
• Hiermee verwijdert u standaard- en lege poortnummers.
• Converteert impliciete bestandspaden zonder het file:// schema (bijvoorbeeld 'C:\my\file') naar expliciete bestandspaden met het file:// schema.
• Escape-tekens (ook wel bekend als octetten met procentcodering) die geen gereserveerd doel hebben, worden gedecodeerd (ook wel unescaped genoemd). Deze niet-gereserveerde tekens bevatten hoofdletters en kleine letters (%41-%5A en %61-%7A), decimale cijfers (%30-%39), afbreekstreepje (%2D), punt (%2E), onderstrepingsteken (%5F) en tilde (%7E).
• Maakt het pad voor hiërarchische URI's canoniek door sequenties zoals /./ en /../ (ongeacht of de reeks geëscaped is) samen te voegen. Houd er rekening mee dat er een aantal schema's zijn waarvoor deze reeksen niet worden gecomprimeerd.
• Voor hiërarchische URI's wordt er een toegevoegd als de host niet wordt beëindigd met een slash (/).
• Standaard worden gereserveerde tekens in de URI gecodeerd volgens RFC 2396. Dit gedrag verandert als International Resource Identifiers of International Domain Name Parsing is ingeschakeld in welk geval gereserveerde tekens in de URI worden ontsnapt in overeenstemming met RFC 3986 en RFC 3987.

Als onderdeel van canonicalisatie in de constructor voor sommige schema's worden puntsegmenten (/./ en /../) gecomprimeerd (met andere woorden, ze worden verwijderd). De schema's waarvoor Uri segmenten worden gecomprimeerd, zijn http, https, tcp, net.pipe en net.tcp. Voor sommige andere schema's worden deze reeksen niet gecomprimeerd. In het volgende codefragment ziet u hoe comprimeren er in de praktijk uitziet. De escape-reeksen worden, indien nodig, ongedaan gemaakt en vervolgens gecomprimeerd.

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

Wanneer deze code wordt uitgevoerd, wordt uitvoer geretourneerd die vergelijkbaar is met de volgende tekst.

AbsoluteUri: http://myurl/
PathAndQuery: /

U kunt de inhoud van de Uri klasse transformeren van een escape-gecodeerde URI-verwijzing naar een leesbare URI-verwijzing met behulp van de ToString methode. Houd er rekening mee dat sommige gereserveerde tekens mogelijk nog steeds geëscaped zijn in de uitvoer van de ToString methode. Dit is voor het eenduidig reconstrueren van een URI uit de waarde die wordt geretourneerd door ToString.

Sommige URI's bevatten een fragment-id of een query of beide. Een fragment-id is een tekst die volgt op een nummerteken (#), niet inclusief het nummerteken; de fragmenttekst wordt opgeslagen in de Fragment eigenschap. Querygegevens zijn tekst die volgt op een vraagteken (?) in de URI; de querytekst wordt opgeslagen in de Query eigenschap.

Ondersteuning voor internationale resource-id's

Webadressen worden meestal uitgedrukt met behulp van URI's die bestaan uit een zeer beperkte set tekens:

• ASCII-letters uit het Engelse alfabet in hoofd- en kleine letters.
• Cijfers van 0 tot 9.
• Een klein aantal andere ASCII-symbolen.

De specificaties voor URI's worden beschreven in RFC 2396, RFC 2732, RFC 3986 en RFC 3987 gepubliceerd door de Internet Engineering Task Force (IETF).

Identificatoren die voorzien in de noodzaak om bronnen te identificeren met andere talen dan Engels en die niet-ASCII-tekens (tekens in de Unicode/ISO 10646-tekenset) toestaan, worden ook wel International Resource Identifiers (IRI's) genoemd. De specificaties voor IURI's worden beschreven in RFC 3987 gepubliceerd door IETF. Als u IRI's gebruikt, kan een URL Unicode-tekens bevatten. Normalisatie en tekencontrole worden uitgevoerd volgens de nieuwste IRI-regels in RFC 3986 en RFC 3987.

IRI- en IDN-verwerking in de Uri klasse kunnen worden beheerd met behulp van de System.Configuration.IriParsingElementklassen en System.Configuration.IdnElementSystem.Configuration.UriSection configuratie-instellingen. De System.Configuration.IriParsingElement instelling schakelt IRI-verwerking in of uit in de Uri klasse. De System.Configuration.IdnElement instelling schakelt idN-verwerking in of uit in de Uri klasse.

De configuratie-instelling voor de System.Configuration.IriParsingElement en System.Configuration.IdnElement worden eenmaal gelezen wanneer de eerste System.Uri klasse wordt samengesteld. Wijzigingen in configuratie-instellingen na die tijd worden genegeerd.

De System.GenericUriParser klasse is ook uitgebreid om een aanpasbare parser te maken die ondersteuning biedt voor IRI en IDN. Het gedrag van een System.GenericUriParser object wordt opgegeven door een bitwise combinatie van de waarden die beschikbaar zijn in de System.GenericUriParserOptions opsomming door te geven aan de System.GenericUriParser constructor. Het GenericUriParserOptions.IriParsing type geeft aan dat de parser de parseerregels ondersteunt die zijn opgegeven in RFC 3987 voor International Resource Identifiers (IRI).

Het GenericUriParserOptions.Idn type geeft aan dat de parser het parseren van hostnamen met Internationalized Domain Name (IDN) ondersteunt. In .NET (Core) en .NET Framework 4.5+ wordt IDN altijd gebruikt. In eerdere versies bepaalt een configuratieoptie of IDN wordt gebruikt.

Ondersteuning voor impliciet bestandspad

Uri kan ook worden gebruikt om lokale bestandssysteempaden weer te geven. Deze paden kunnen expliciet worden weergegeven in URI's die beginnen met het file:// schema en impliciet in URI's die niet over het file:// schema beschikken. Als concreet voorbeeld zijn de volgende twee URI's beide geldig en vertegenwoordigen hetzelfde bestandspad:

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.

Deze impliciete bestandspaden voldoen niet aan de URI-specificatie en moeten indien mogelijk worden vermeden. Wanneer u .NET Core op Unix-systemen gebruikt, kunnen impliciete bestandspaden met name problematisch zijn, omdat een absoluut impliciet bestandspad niet kan worden onderscheiden van een relatief pad. Wanneer dergelijke dubbelzinnigheid aanwezig is, Uri wordt het pad standaard geïnterpreteerd als een absolute URI.

Beveiligingsoverwegingen

Vanwege beveiligingsproblemen moet uw toepassing voorzichtig zijn bij het accepteren van Uri-exemplaren van niet-vertrouwde bronnen en met dontEscape ingesteld op true in de constructor. U kunt een URI-tekenreeks controleren op geldigheid door de methode aan te IsWellFormedOriginalString roepen.

Als u te maken hebt met onbetrouwbare gebruikersinvoer, verifieer uw aannames over het zojuist gemaakte Uri exemplaar voordat u de attributen ervan vertrouwt. Dit kan op de volgende manier:

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

Deze validatie kan worden gebruikt in andere gevallen, zoals bij het omgaan met UNC-paden, door simpelweg het baseUrivolgende te wijzigen:

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

Raadpleeg de volgende documenten over het bedreigingsmodel voor meer informatie over het ontwerp en de beveiligingsoverwegingen:UriUriBuilder

• System.Uri-bedreigingsmodel
• System.UriBuilder threat model

Prestatie-overwegingen

Als u een Web.config-bestand gebruikt dat URI's bevat om uw toepassing te initialiseren, is extra tijd nodig om de URI's te verwerken als hun schema-id's niet standaard zijn. Initialiseer in dat geval de betrokken onderdelen van uw toepassing wanneer de URI's nodig zijn, niet bij het opstarten.

Veiligheid thread

Alle leden van Uri zijn thread-veilig en kunnen gelijktijdig worden gebruikt vanuit meerdere threads.

Zie ook

• IdnElement
• IriParsingElement
• UriSection
• DnsSafeHost
• MakeRelative(Uri)
• IsWellFormedOriginalString()
• UriBuilder
• Wijzigingen in de System.Uri-naamruimte in versie 2.0
• Ondersteuning voor internationale resource-id's in System.UriSystem.Uri
• Netwerkprogrammering in het .NET Framework