Uri Classe

Definizione

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

Ereditarietà

Object

Uri

Ereditarietà

Object

MarshalByRefObject

Uri

Attributi

SerializableAttribute TypeConverterAttribute

Implementazioni

IEquatable<Uri> IFormattable ISpanFormattable ISerializable

Esempio

L'esempio seguente crea un'istanza della Uri classe e la usa per eseguire una richiesta GET con 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)

Il frammento di codice seguente mostra i valori di esempio delle varie proprietà della 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

Commenti

Un URI (Uniform Resource Identifier) è una rappresentazione compatta di una risorsa disponibile per l'applicazione nella intranet o in Internet. La Uri classe definisce le proprietà e i metodi per la gestione degli URI, tra cui l'analisi, il confronto e la combinazione. Le proprietà della Uri classe sono di sola lettura. Per creare un oggetto modificabile, usare la UriBuilder classe .

Gli URI relativi (ad esempio, "/new/index.htm") devono essere espansi rispetto a un URI di base in modo che siano assoluti. Il MakeRelativeUri metodo viene fornito per convertire gli URI assoluti in URI relativi, se necessario.

I Uri costruttori non sottopongono a escape le stringhe URI se la stringa è un URI ben formata, inclusa un'identificatore di schema.

Le Uri proprietà restituiscono una rappresentazione di dati canonica nella codifica con escape, con tutti i caratteri con valori Unicode maggiori di 127 sostituiti con gli equivalenti esadecimali. Per inserire l'URI in formato canonico, il Uri costruttore esegue i passaggi seguenti:

• Converte lo schema URI in lettere minuscole.
• Converte il nome host in lettere minuscole.
• Se il nome host è un indirizzo IPv6, viene usato l'indirizzo IPv6 canonico. ScopeId e altri dati IPv6 facoltativi vengono rimossi.
• Rimuove i numeri di porta predefiniti e vuoti.
• Converte i percorsi di file impliciti senza lo schema di file:// ,ad esempio "C:\my\file") in percorsi di file espliciti con lo schema file://.
• I caratteri di escape (noti anche come ottetti con codifica percentuale) che non hanno uno scopo riservato vengono decodificati (noti anche come senza caratteri di escape). Questi caratteri non validi includono lettere maiuscole e minuscole (%41-%5A e %61-%7A), cifre decimali (%30-%39), trattino (%2D), punto (%2E), carattere di sottolineatura (%5F) e tilde (%7E).
• Canonizza il percorso per gli URI gerarchici compattando sequenze come /./ e /../ (indipendentemente dal fatto che la sequenza sia preceduta o meno da un escape). Si noti che esistono alcuni schemi per i quali queste sequenze non vengono compattate.
• Per gli URI gerarchici, se l'host non termina con una barra inclinata (/), viene aggiunto uno.
• Per impostazione predefinita, tutti i caratteri riservati nell'URI vengono codificati in base a RFC 2396. Questo comportamento cambia se il parsing degli International Resource Identifiers o degli International Domain Names è abilitato, nel qual caso i caratteri riservati nell'URI vengono escapati in base a RFC 3986 e RFC 3987.

Come parte della canonizzazione nel costruttore per alcuni schemi, i segmenti di punti (/./ e /../) vengono compattati (in altre parole, vengono rimossi). Gli schemi per i quali Uri compatta i segmenti includono http, https, tcp, net.pipe e net.tcp. Per altri schemi, queste sequenze non vengono compattate. Il frammento di codice seguente mostra l'aspetto della compattazione pratica. Le sequenze di escape vengono convertite da forma escapa a non escapa, se necessario, e quindi compattate.

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 questo codice viene eseguito, restituisce un output simile al testo seguente.

AbsoluteUri: http://myurl/
PathAndQuery: /

È possibile trasformare il contenuto della Uri classe da un riferimento URI codificato con escape a un riferimento URI leggibile usando il ToString metodo . Si noti che alcuni caratteri riservati potrebbero comunque essere preceduti da un carattere di escape nell'output del metodo ToString. Ciò consente di supportare la ricostruzione non ambigua di un URI dal valore restituito da ToString.

Alcuni URI includono un identificatore di frammento o una query o entrambi. Un identificatore di frammento è qualsiasi testo che segue un segno di numero (#), senza includere il segno di numero; il testo del frammento viene archiviato nella Fragment proprietà . Le informazioni sulle query sono testo che segue un punto interrogativo (?) nell'URI; il testo della query viene archiviato nella Query proprietà .

Supporto per l'identificatore internazionale delle risorse

Gli indirizzi Web vengono in genere espressi usando URI costituiti da un set di caratteri molto limitato:

• Lettere ASCII maiuscole e minuscole dell'alfabeto inglese.
• Cifre da 0 a 9.
• Numero ridotto di altri simboli ASCII.

Le specifiche per gli URI sono documentate in RFC 2396, RFC 2732, RFC 3986 e RFC 3987 pubblicato da Internet Engineering Task Force (IETF).

Gli identificatori che facilitano la necessità di identificare le risorse usando lingue diverse dall'inglese e consentono caratteri non ASCII (caratteri nel set di caratteri Unicode/ISO 10646) sono noti come Identificatori di risorsa internazionali (IRIs). Le specifiche per gli IRIs sono documentate in RFC 3987 pubblicato da IETF. L'uso di irIs consente a un URL di contenere caratteri Unicode. La normalizzazione e il controllo dei caratteri vengono eseguiti in base alle regole IRI più recenti in RFC 3986 e RFC 3987.

L'elaborazione IRI e IDN nella Uri classe può essere controllata usando le System.Configuration.IriParsingElementclassi di impostazione di configurazione , System.Configuration.IdnElemente System.Configuration.UriSection . L'impostazione System.Configuration.IriParsingElement abilita o disabilita l'elaborazione IRI nella Uri classe . L'impostazione System.Configuration.IdnElement abilita o disabilita l'elaborazione IDN nella Uri classe .

L'impostazione di configurazione per System.Configuration.IriParsingElement e System.Configuration.IdnElement viene letta una volta quando viene costruita la prima System.Uri classe. Le modifiche apportate alle impostazioni di configurazione dopo tale ora vengono ignorate.

La System.GenericUriParser classe è stata estesa anche per consentire la creazione di un parser personalizzabile che supporta IRI e IDN. Il comportamento di un System.GenericUriParser oggetto viene specificato passando una combinazione bit per bit dei valori disponibili nell'enumerazione System.GenericUriParserOptions al System.GenericUriParser costruttore. Il GenericUriParserOptions.IriParsing tipo indica che il parser supporta le regole di analisi specificate in RFC 3987 per gli identificatori di risorse internazionali (IRI).

Il GenericUriParserOptions.Idn tipo indica che il parser supporta l'analisi IDN (Internationalized Domain Name) dei nomi host. In .NET (Core) e .NET Framework 4.5+, viene sempre usato IDN. Nelle versioni precedenti, un'opzione di configurazione determina se viene usato L'IDN.

Supporto del percorso di file implicito

Uri può essere usato anche per rappresentare i percorsi del file system locale. Questi percorsi possono essere rappresentati in modo esplicito negli URI che iniziano con lo schema di file:// e in modo implicito negli URI che non dispongono dello schema file://. Come esempio concreto, i due URI seguenti sono entrambi validi e rappresentano lo stesso percorso di file:

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.

Questi percorsi di file impliciti non sono conformi alla specifica URI e devono essere evitati quando possibile. Quando si usa .NET Core nei sistemi basati su Unix, i percorsi di file impliciti possono risultare particolarmente problematici, perché un percorso di file implicito assoluto è indistinguibile da un percorso relativo. Quando tale ambiguità è presente, Uri per impostazione predefinita viene interpretato il percorso come URI assoluto.

Considerazioni relative alla sicurezza

A causa di problemi di sicurezza, l'applicazione deve prestare attenzione quando si accettano Uri istanze da origini non attendibili e con dontEscape impostato su true nel costruttore. È possibile controllare la validità di una stringa URI chiamando il IsWellFormedOriginalString metodo .

Quando si usa l'input dell'utente non attendibile, verificare i presupposti relativi all'istanza appena creata Uri prima di considerare attendibili le relative proprietà. Questa operazione può essere eseguita nel modo seguente:

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

Questa convalida può essere usata in altri casi, ad esempio quando si gestiscono percorsi UNC, semplicemente modificando :baseUri

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

Per altri dettagli sulle considerazioni sulla progettazione e sulla sicurezza di Uri e UriBuilder, vedere i documenti del modello di minaccia seguenti:

• Modello di minaccia System.Uri
• Modello di minaccia System.UriBuilder

Considerazioni sulle prestazioni

Se si usa un file diWeb.config che contiene URI per inizializzare l'applicazione, è necessario ulteriore tempo per elaborare gli URI se gli identificatori dello schema non sono standard. In questo caso, inizializza le parti interessate dell'applicazione quando sono necessari gli URI, non all'avvio.

Thread safety

Tutti i membri di Uri sono thread-safe e possono essere usati simultaneamente da più thread.

Vedi anche

• IdnElement
• IriParsingElement
• UriSection
• DnsSafeHost
• MakeRelative(Uri)
• IsWellFormedOriginalString()
• UriBuilder
• Modifiche allo spazio dei nomi System.Uri nella versione 2.0
• Supporto dell'identificatore di risorsa internazionale in System.UriSystem.Uri
• programmazione di rete in .NET Framework