Path Classe

Definizione

Spazio dei nomi:

System.IO

Assembly:

System.Runtime.Extensions.dll

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Esegue operazioni sulle istanze String che contengono informazioni sul percorso di file o directory. Le operazioni vengono eseguite su più piattaforme.

public ref class Path abstract sealed

public ref class Path sealed

public static class Path

public sealed class Path

[System.Runtime.InteropServices.ComVisible(true)]
public static class Path

type Path = class

[<System.Runtime.InteropServices.ComVisible(true)>]
type Path = class

Public Class Path

Public NotInheritable Class Path

Ereditarietà

Object

Path

Attributi

ComVisibleAttribute

Esempio

Nell'esempio seguente vengono illustrati alcuni dei membri principali della Path classe .

using namespace System;
using namespace System::IO;
int main()
{
   String^ path1 = "c:\\temp\\MyTest.txt";
   String^ path2 = "c:\\temp\\MyTest";
   String^ path3 = "temp";
   if ( Path::HasExtension( path1 ) )
   {
      Console::WriteLine( "{0} has an extension.", path1 );
   }

   if (  !Path::HasExtension( path2 ) )
   {
      Console::WriteLine( "{0} has no extension.", path2 );
   }

   if (  !Path::IsPathRooted( path3 ) )
   {
      Console::WriteLine( "The string {0} contains no root information.", path3 );
   }

   Console::WriteLine( "The full path of {0} is {1}.", path3, Path::GetFullPath( path3 ) );
   Console::WriteLine( "{0} is the location for temporary files.", Path::GetTempPath() );
   Console::WriteLine( "{0} is a file available for use.", Path::GetTempFileName() );
   Console::WriteLine( "\r\nThe set of invalid characters in a path is:" );
   Console::WriteLine( "(Note that the wildcard characters '*' and '?' are not invalid.):" );
   Collections::IEnumerator^ myEnum = Path::InvalidPathChars->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Char c =  *safe_cast<Char^>(myEnum->Current);
      Console::WriteLine( c );
   }
}

using System;
using System.IO;

class Test
{
    
    public static void Main()
    {
        string path1 = @"c:\temp\MyTest.txt";
        string path2 = @"c:\temp\MyTest";
        string path3 = @"temp";

        if (Path.HasExtension(path1))
        {
            Console.WriteLine("{0} has an extension.", path1);
        }

        if (!Path.HasExtension(path2))
        {
            Console.WriteLine("{0} has no extension.", path2);
        }

        if (!Path.IsPathRooted(path3))
        {
            Console.WriteLine("The string {0} contains no root information.", path3);
        }

        Console.WriteLine("The full path of {0} is {1}.", path3, Path.GetFullPath(path3));
        Console.WriteLine("{0} is the location for temporary files.", Path.GetTempPath());
        Console.WriteLine("{0} is a file available for use.", Path.GetTempFileName());

        /* This code produces output similar to the following:
         * c:\temp\MyTest.txt has an extension.
         * c:\temp\MyTest has no extension.
         * The string temp contains no root information.
         * The full path of temp is D:\Documents and Settings\cliffc\My Documents\Visual Studio 2005\Projects\ConsoleApplication2\ConsoleApplication2\bin\Debug\temp.
         * D:\Documents and Settings\cliffc\Local Settings\Temp\8\ is the location for temporary files.
         * D:\Documents and Settings\cliffc\Local Settings\Temp\8\tmp3D.tmp is a file available for use.
         */
    }
}

Imports System.IO

Public Class Test

    Public Shared Sub Main()
        Dim path1 As String = "c:\temp\MyTest.txt"
        Dim path2 As String = "c:\temp\MyTest"
        Dim path3 As String = "temp"

        If Path.HasExtension(path1) Then
            Console.WriteLine("{0} has an extension.", path1)
        End If

        If Path.HasExtension(path2) = False Then
            Console.WriteLine("{0} has no extension.", path2)
        End If

        If Path.IsPathRooted(path3) = False Then
            Console.WriteLine("The string {0} contains no root information.", path3)
        End If

        Console.WriteLine("The full path of {0} is {1}.", path3, Path.GetFullPath(path3))
        Console.WriteLine("{0} is the location for temporary files.", Path.GetTempPath())
        Console.WriteLine("{0} is a file available for use.", Path.GetTempFileName())

        ' This code produces output similar to the following:
        ' c:\temp\MyTest.txt has an extension.
        ' c:\temp\MyTest has no extension.
        ' The string temp contains no root information.
        ' The full path of temp is D:\Documents and Settings\cliffc\My Documents\Visual Studio 2005\Projects\ConsoleApplication2\ConsoleApplication2\bin\Debug\temp.
        ' D:\Documents and Settings\cliffc\Local Settings\Temp\8\ is the location for temporary files.
        ' D:\Documents and Settings\cliffc\Local Settings\Temp\8\tmp3D.tmp is a file available for use.

    End Sub
End Class

Commenti

Un percorso è una stringa che fornisce il percorso di un file o di una directory. Un percorso non punta necessariamente a una posizione sul disco; Ad esempio, un percorso potrebbe essere mappato a una posizione in memoria o in un dispositivo. Il formato esatto di un percorso è determinato dalla piattaforma corrente. Ad esempio, in alcuni sistemi, un percorso può iniziare con un'unità o una lettera di volume, mentre questo elemento non è presente in altri sistemi. In alcuni sistemi, i percorsi di file possono contenere estensioni, che indicano il tipo di informazioni archiviate nel file. Il formato di un'estensione del nome di file dipende dalla piattaforma; Ad esempio, alcuni sistemi limitano le estensioni a tre caratteri (ad esempio FAT16 comunemente usato in archiviazione flash più piccola e versioni precedenti di ISO 9660 usate su supporti ottici) e altri no. La piattaforma corrente determina anche il set di caratteri utilizzati per separare gli elementi di un percorso e il set di caratteri che non possono essere utilizzati quando si specificano i percorsi. A causa di queste differenze, i campi della Path classe e il comportamento esatto di alcuni membri della Path classe sono dipendenti dalla piattaforma.

Un percorso può contenere informazioni sulla posizione assoluta o relativa. I percorsi assoluti specificano completamente un percorso: il file o la directory possono essere identificati in modo univoco indipendentemente dal percorso corrente. I percorsi relativi specificano una posizione parziale: la posizione corrente viene usata come punto iniziale quando si individua un file specificato con un percorso relativo. Per determinare la directory corrente, chiamare Directory.GetCurrentDirectory.

.NET Core 1.1 e versioni successive e .NET Framework 4.6.2 e versioni successive supportano anche l'accesso agli oggetti del file system che sono nomi di dispositivo, ad esempio "\\?\ C:\".

Per altre informazioni sui formati di percorso di file in Windows, vedere Formati di percorso di file nei sistemi Windows.

La maggior parte dei membri della Path classe non interagisce con il file system e non verifica l'esistenza del file specificato da una stringa di percorso. Path I membri della classe che modificano una stringa di percorso, ad esempio ChangeExtension, non hanno alcun effetto sui nomi dei file nel file system.

Alcuni Path membri convalidano il contenuto di una stringa di percorso specificata e generano un'eccezione ArgumentException se la stringa contiene caratteri non validi nelle stringhe di percorso, come definito nei caratteri restituiti dal GetInvalidPathChars metodo . Ad esempio, nelle piattaforme desktop basate su Windows, i caratteri di percorso non validi possono includere virgolette ("), minori di (<), greater than (>), pipe (|), backspace (\b), null (\0) e caratteri Unicode da 16 a 18 e da 20 a 25. Questo comportamento di convalida varia tra le versioni di .NET:

• Nelle versioni di .NET Framework e .NET Core precedenti alla 2.1: tutti i Path membri che accettano un percorso come argomento generano un'eccezione ArgumentException se rilevano caratteri di percorso non validi.

• In .NET Core 2.1 e versioni successive: GetFullPath è l'unico membro che genera un'eccezione ArgumentException se la stringa contiene caratteri di percorso non validi.

I membri della Path classe consentono di eseguire rapidamente e facilmente operazioni comuni, ad esempio determinare se un'estensione di file fa parte di un percorso e combinare due stringhe in un unico nome di percorso.

Tutti i membri della Path classe sono statici e possono quindi essere chiamati senza disporre di un'istanza di un percorso.

Nota

Nei membri che accettano un percorso come stringa di input, tale percorso deve essere ben formato o viene generata un'eccezione. Ad esempio, se un percorso è completo ma inizia con uno spazio, il percorso non viene tagliato nei metodi della classe . Pertanto, il percorso è in formato non valido e viene generata un'eccezione. Analogamente, un percorso o una combinazione di percorsi non può essere completo due volte. Ad esempio, "c:\temp c:\windows" genera anche un'eccezione nella maggior parte dei casi. Assicurarsi che i percorsi siano ben formati quando si usano metodi che accettano una stringa di percorso.

Nei membri che accettano un percorso, il percorso può fare riferimento a un file o solo a una directory. Il percorso specificato può anche fare riferimento a un percorso relativo o a un percorso UNC (Universal Naming Convention) per un server e un nome di condivisione. Ad esempio, tutti i percorsi seguenti sono accettabili:

• "c:\\MyDir\\MyFile.txt" in C#, o "c:\MyDir\MyFile.txt" in Visual Basic.

• "c:\\MyDir" in C#, o "c:\MyDir" in Visual Basic.

• "MyDirMySubdir\\" in C#, o "MyDirMySubDir\" in Visual Basic.

• "\\\\MyServerMyShare\\" in C#, o "\\MyServerMyShare\" in Visual Basic.

Poiché tutte queste operazioni vengono eseguite su stringhe, è impossibile verificare che i risultati siano validi in tutti gli scenari. Ad esempio, il GetExtension metodo analizza una stringa passata e restituisce l'estensione da tale stringa. Tuttavia, questo non significa che un file con tale estensione esiste sul disco.

Per un elenco delle attività di I/O comuni, vedere Attività di I/O comuni.

Campi

AltDirectorySeparatorChar	Fornisce un carattere alternativo specifico della piattaforma usato per separare i livelli di directory in una stringa di percorso che riflette un'organizzazione di file system gerarchica.
DirectorySeparatorChar	Fornisce un carattere specifico della piattaforma usato per separare i livelli di directory in una stringa di percorso che riflette un'organizzazione di file system gerarchica.
InvalidPathChars	Obsoleta. Obsoleta. Obsoleta. Fornisce una matrice di caratteri specifici della piattaforma che non possono essere usati negli argomenti della stringa di percorso passati ai membri della classe Path.
PathSeparator	Carattere separatore specifico della piattaforma, usato per separare le stringhe di percorso nelle variabili di ambiente.
VolumeSeparatorChar	Fornisce un carattere separatore di volume specifico della piattaforma.

Metodi

ChangeExtension(String, String)	Cambia l'estensione di una stringa di percorso.
Combine(String, String)	Combina due stringhe in un percorso.
Combine(String, String, String)	Combina tre stringhe in un percorso.
Combine(String, String, String, String)	Combina quattro stringhe in un percorso.
Combine(String[])	Combina una matrice di stringhe in un percorso.
EndsInDirectorySeparator(ReadOnlySpan<Char>)	Restituisce un valore che indica se il percorso, specificato come intervallo di sola lettura, termina in un separatore di directory.
EndsInDirectorySeparator(String)	Restituisce un valore che indica se il percorso specificato termina in un separatore di directory.
Exists(String)	Determina se il file o la directory specificata esiste.
GetDirectoryName(ReadOnlySpan<Char>)	Restituisce le informazioni sulla directory per il percorso specificato rappresentato da un intervallo di caratteri.
GetDirectoryName(String)	Restituisce le informazioni sulla directory per il percorso specificato.
GetExtension(ReadOnlySpan<Char>)	Restituisce l'estensione di un percorso di file che è rappresentato da un intervallo di caratteri di sola lettura.
GetExtension(String)	Restituisce l'estensione, incluso il punto ("."), della stringa del percorso specificato.
GetFileName(ReadOnlySpan<Char>)	Restituisce il nome file e l'estensione di un percorso di file che è rappresentato da un intervallo di caratteri di sola lettura.
GetFileName(String)	Restituisce il nome del file e l'estensione della stringa di percorso specificata.
GetFileNameWithoutExtension(ReadOnlySpan<Char>)	Restituisce il nome file senza l'estensione di un percorso di file che è rappresentato da un intervallo di caratteri di sola lettura.
GetFileNameWithoutExtension(String)	Restituisce il nome del file della stringa di percorso specificata senza estensione.
GetFullPath(String)	Restituisce il percorso assoluto della stringa di percorso specificata.
GetFullPath(String, String)	Restituisce un percorso assoluto da un percorso relativo e un percorso di base completo.
GetInvalidFileNameChars()	Ottiene una matrice contenente i caratteri non consentiti nei nomi di file.
GetInvalidPathChars()	Ottiene una matrice contenente i caratteri non consentiti nei nomi di percorso.
GetPathRoot(ReadOnlySpan<Char>)	Ottiene la directory radice dal percorso contenuto nell'intervallo di caratteri specificato.
GetPathRoot(String)	Ottiene le informazioni sulla directory radice dal percorso contenuto nella stringa specificata.
GetRandomFileName()	Restituisce un nome casuale di cartella o di file.
GetRelativePath(String, String)	Restituisce un percorso relativo da un percorso all'altro.
GetTempFileName()	Crea un file temporaneo a zero byte con nome univoco sul disco e restituisce il percorso intero di quel file.
GetTempPath()	Restituisce il percorso della cartella temporanea dell'utente corrente.
HasExtension(ReadOnlySpan<Char>)	Determina se il percorso rappresentato dall'intervallo di caratteri specificato include un'estensione di file.
HasExtension(String)	Determina se un percorso include un'estensione di nome di file.
IsPathFullyQualified(ReadOnlySpan<Char>)	Restituisce un valore che indica se il percorso di file rappresentato dall'intervallo di caratteri specificato è fisso in un'unità specifica o in un percorso UNC.
IsPathFullyQualified(String)	Restituisce un valore che indica se il percorso di file specificato è fisso in un'unità specifica o in un percorso UNC.
IsPathRooted(ReadOnlySpan<Char>)	Restituisce un valore che indica se l'intervallo di caratteri specificato che rappresenta un percorso di file contiene una radice.
IsPathRooted(String)	Restituisce un valore che indica se la stringa di percorso specificata contiene una radice.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena due componenti del percorso in un unico percorso.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena tre componenti del percorso in un unico percorso.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatena quattro componenti del percorso in un unico percorso.
Join(String, String)	Concatena due percorsi in un unico percorso.
Join(String, String, String)	Concatena tre percorsi in un unico percorso.
Join(String, String, String, String)	Concatena quattro percorsi in un unico percorso.
Join(String[])	Concatena una matrice di percorsi in un unico percorso.
TrimEndingDirectorySeparator(ReadOnlySpan<Char>)	Taglia un separatore di directory finale oltre la radice del percorso specificato.
TrimEndingDirectorySeparator(String)	Taglia un separatore di directory finale oltre la radice del percorso specificato.
TryJoin(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, Span<Char>, Int32)	Tenta di concatenare tre componenti del percorso a un singolo intervallo di caratteri preallocato e restituisce un valore che indica se l'operazione ha avuto esito positivo.
TryJoin(ReadOnlySpan<Char>, ReadOnlySpan<Char>, Span<Char>, Int32)	Prova a concatenare due componenti del percorso in un singolo intervallo di caratteri preallocati e restituisce un valore che indica se l'operazione è riuscita.

Vedi anche

• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere testo in un file
• Procedura: Leggere e scrivere in un file di dati appena creato
• Formati dei percorsi di file nei sistemi Windows