Path Classe

Definizione

Esegue operazioni sulle istanze String che contengono informazioni sul percorso di file o directory.Performs operations on String instances that contain file or directory path information. Le operazioni vengono eseguite su più piattaforme.These operations are performed in a cross-platform manner.

public ref class Path abstract sealed
[System.Runtime.InteropServices.ComVisible(true)]
public static class Path
type Path = class
Public Class Path
Ereditarietà
Path
Attributi

Esempi

Nell'esempio seguente vengono illustrati alcuni dei principali membri della classe Path.The following example demonstrates some of the main members of the Path class.

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 specifica il percorso di un file o di una directory.A path is a string that provides the location of a file or directory. Un percorso non punta necessariamente a una posizione su disco; ad esempio, è possibile eseguire il mapping di un percorso a una posizione in memoria o in un dispositivo.A path does not necessarily point to a location on disk; for example, a path might map to a location in memory or on a device. Il formato esatto di un percorso è determinato dalla piattaforma corrente.The exact format of a path is determined by the current platform. In alcuni sistemi, ad esempio, un percorso può iniziare con un'unità o una lettera del volume, mentre questo elemento non è presente in altri sistemi.For example, on some systems, a path can start with a drive or volume letter, while this element is not present in other systems. In alcuni sistemi, i percorsi dei file possono contenere estensioni, che indicano il tipo di informazioni archiviate nel file.On some systems, file paths can contain extensions, which indicate the type of information stored in the file. Il formato di un'estensione del nome di file è dipendente dalla piattaforma. alcuni sistemi, ad esempio, limitano le estensioni a tre caratteri e altre no.The format of a file name extension is platform-dependent; for example, some systems limit extensions to three characters, and others do not. La piattaforma corrente determina anche il set di caratteri usato per separare gli elementi di un percorso e il set di caratteri che non possono essere usati quando si specificano i percorsi.The current platform also determines the set of characters used to separate the elements of a path, and the set of characters that cannot be used when specifying paths. A causa di queste differenze, i campi della classe Path e il comportamento esatto di alcuni membri della classe Path sono dipendenti dalla piattaforma.Because of these differences, the fields of the Path class as well as the exact behavior of some members of the Path class are platform-dependent.

Un percorso può contenere informazioni relative al percorso assoluto o relativo.A path can contain absolute or relative location information. I percorsi assoluti specificano completamente un percorso: il file o la directory possono essere identificati in modo univoco indipendentemente dalla posizione corrente.Absolute paths fully specify a location: the file or directory can be uniquely identified regardless of the current location. Percorsi relativi specificano un percorso parziale: il percorso corrente viene usato come punto di partenza per l'individuazione di un file specificato con un percorso relativo.Relative paths specify a partial location: the current location is used as the starting point when locating a file specified with a relative path. Per determinare la directory corrente, chiamare Directory.GetCurrentDirectory.To determine the current directory, call Directory.GetCurrentDirectory.

.NET Core 1,1 e versioni successive e .NET Framework 4.6.2 e versioni successive supportano anche l'accesso a file system oggetti che sono nomi di dispositivo, ad esempio "\? \c: "..NET Core 1.1 and later versions and .NET Framework 4.6.2 and later versions also support access to file system objects that are device names, such as "\?\C:".

Per ulteriori informazioni sui formati dei percorsi di file in Windows, vedere formati di percorso file nei sistemi Windows.For more information on file path formats on Windows, see File path formats on Windows systems.

La maggior parte dei membri della classe Path non interagiscono con il file system e non verificano l'esistenza del file specificato da una stringa di percorso.Most members of the Path class do not interact with the file system and do not verify the existence of the file specified by a path string. i membri della classe Path che modificano una stringa di percorso, ad esempio ChangeExtension, non hanno alcun effetto sui nomi dei file nell'file system.Path class members that modify a path string, such as ChangeExtension, have no effect on names of files in the file system. i membri Path, tuttavia, 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 metodo GetInvalidPathChars.Path members do, however, validate the contents of a specified path string, and throw an ArgumentException exception if the string contains characters that are not valid in path strings, as defined in the characters returned from the GetInvalidPathChars method. Nelle piattaforme desktop basate su Windows, ad esempio, i caratteri di percorso non validi possono includere virgolette ("), minori di (<), maggiori di (>|), pipe (), BACKSPACE (\b), null (\ 0) e caratteri Unicode da 16 a 18 e da 20 a 25.For example, on Windows-based desktop platforms, invalid path characters might include quote ("), less than (<), greater than (>), pipe (|), backspace (\b), null (\0), and Unicode characters 16 through 18 and 20 through 25.

I membri della classe Path consentono di eseguire in modo rapido e semplice operazioni comuni, ad esempio determinare se un'estensione del nome di file fa parte di un percorso e combinare due stringhe in un nome di percorso.The members of the Path class enable you to quickly and easily perform common operations such as determining whether a file name extension is part of a path, and combining two strings into one path name.

Tutti i membri della classe Path sono statici e possono quindi essere chiamati senza avere un'istanza di un percorso.All members of the Path class are static and can therefore be called without having an instance of a path.

Nota

Nei membri che accettano un percorso come stringa di input, il percorso deve essere ben formato o viene generata un'eccezione.In members that accept a path as an input string, that path must be well-formed or an exception is raised. Se, ad esempio, un percorso è completo ma inizia con uno spazio, il percorso non viene tagliato nei metodi della classe.For example, if a path is fully qualified but begins with a space, the path is not trimmed in methods of the class. Pertanto, il percorso non è valido e viene generata un'eccezione.Therefore, the path is malformed and an exception is raised. Analogamente, un percorso o una combinazione di percorsi non possono essere completati due volte.Similarly, a path or a combination of paths cannot be fully qualified twice. Ad esempio, "c:\temp c:\Windows" genera anche un'eccezione nella maggior parte dei casi.For example, "c:\temp c:\windows" also raises an exception in most cases. Verificare che i percorsi siano ben formati quando si usano metodi che accettano una stringa di percorso.Ensure that your paths are well-formed when using methods that accept a path string.

Nei membri che accettano un percorso, il percorso può fare riferimento a un file o solo a una directory.In members that accept a path, the path can refer to a file or just a directory. Il percorso specificato può anche fare riferimento a un percorso relativo o a un percorso di Universal Naming Convention (UNC) per un server e un nome di condivisione.The specified path can also refer to a relative path or a Universal Naming Convention (UNC) path for a server and share name. Ad esempio, tutti i percorsi seguenti sono accettabili:For example, all the following are acceptable paths:

  • "c: \ \ MyDir @ no__t-1\MyFile.txt" in C#o "c:\mydir\myfile.txt" in Visual Basic."c:\\MyDir\\MyFile.txt" in C#, or "c:\MyDir\MyFile.txt" in Visual Basic.

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

  • "MyDir @ no__t-0\MySubdir" in C#o "MyDir\MySubDir" in Visual Basic."MyDir\\MySubdir" in C#, or "MyDir\MySubDir" in Visual Basic.

  • "\ @ no__t-1 @ no__t-2\MyServer @ no__t-3\MyShare" in C#o "\ \ MyServer\MyShare" in Visual Basic."\\\\MyServer\\MyShare" in C#, or "\\MyServer\MyShare" in Visual Basic.

Poiché tutte queste operazioni vengono eseguite sulle stringhe, non è possibile verificare che i risultati siano validi in tutti gli scenari.Because all these operations are performed on strings, it is impossible to verify that the results are valid in all scenarios. Il metodo GetExtension, ad esempio, analizza una stringa passata e restituisce l'estensione da tale stringa.For example, the GetExtension method parses a string that you pass to it and returns the extension from that string. Tuttavia, ciò non significa che un file con tale estensione esista sul disco.However, this does not mean that a file with that extension exists on the disk.

Per un elenco delle attività di I/O comuni, vedere attività di i/o comuni.For a list of common I/O tasks, see Common I/O Tasks.

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.Provides a platform-specific alternate character used to separate directory levels in a path string that reflects a hierarchical file system organization.

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.Provides a platform-specific character used to separate directory levels in a path string that reflects a hierarchical file system organization.

InvalidPathChars

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.Provides a platform-specific array of characters that cannot be specified in path string arguments passed to members of the Path class.

PathSeparator

Carattere separatore specifico della piattaforma, usato per separare le stringhe di percorso nelle variabili di ambiente.A platform-specific separator character used to separate path strings in environment variables.

VolumeSeparatorChar

Fornisce un carattere separatore di volume specifico della piattaforma.Provides a platform-specific volume separator character.

Metodi

ChangeExtension(String, String)

Cambia l'estensione di una stringa di percorso.Changes the extension of a path string.

Combine(String, String)

Combina due stringhe in un percorso.Combines two strings into a path.

Combine(String, String, String)

Combina tre stringhe in un percorso.Combines three strings into a path.

Combine(String, String, String, String)

Combina quattro stringhe in un percorso.Combines four strings into a path.

Combine(String[])

Combina una matrice di stringhe in un percorso.Combines an array of strings into a path.

EndsInDirectorySeparator(ReadOnlySpan<Char>)

Restituisce un valore che indica se il percorso, specificato come intervallo di sola lettura, termina in un separatore di directory.Returns a value that indicates whether the path, specified as a read-only span, ends in a directory separator.

EndsInDirectorySeparator(String)

Restituisce un valore che indica se il percorso specificato termina in un separatore di directory.Returns a value that indicates whether the specified path ends in a directory separator.

GetDirectoryName(ReadOnlySpan<Char>)

Restituisce le informazioni sulla directory per il percorso specificato rappresentato da un intervallo di caratteri.Returns the directory information for the specified path represented by a character span.

GetDirectoryName(String)

Restituisce le informazioni sulla directory per la stringa di percorso specificata.Returns the directory information for the specified path string.

GetExtension(ReadOnlySpan<Char>)

Restituisce l'estensione di un percorso di file che è rappresentato da un intervallo di caratteri di sola lettura.Returns the extension of a file path that is represented by a read-only character span.

GetExtension(String)

Restituisce l'estensione, incluso il punto ("."), della stringa del percorso specificato.Returns the extension (including the period ".") of the specified path string.

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.Returns the file name and extension of a file path that is represented by a read-only character span.

GetFileName(String)

Restituisce il nome del file e l'estensione della stringa di percorso specificata.Returns the file name and extension of the specified path string.

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.Returns the file name without the extension of a file path that is represented by a read-only character span.

GetFileNameWithoutExtension(String)

Restituisce il nome del file della stringa di percorso specificata senza estensione.Returns the file name of the specified path string without the extension.

GetFullPath(String)

Restituisce il percorso assoluto della stringa di percorso specificata.Returns the absolute path for the specified path string.

GetFullPath(String, String)

Restituisce un percorso assoluto da un percorso base completo e un percorso relativo.Returns an absolute path from a fully qualified base path and a relative path.

GetInvalidFileNameChars()

Ottiene una matrice contenente i caratteri non consentiti nei nomi di file.Gets an array containing the characters that are not allowed in file names.

GetInvalidPathChars()

Ottiene una matrice contenente i caratteri non consentiti nei nomi di percorso.Gets an array containing the characters that are not allowed in path names.

GetPathRoot(ReadOnlySpan<Char>)

Ottiene la directory radice dal percorso contenuto nell'intervallo di caratteri specificato.Gets the root directory information from the path contained in the specified character span.

GetPathRoot(String)

Ottiene la directory radice del percorso specificato.Gets the root directory information of the specified path.

GetRandomFileName()

Restituisce un nome casuale di cartella o di file.Returns a random folder name or file name.

GetRelativePath(String, String)

Restituisce un percorso relativo da un percorso all'altro.Returns a relative path from one path to another.

GetTempFileName()

Crea un file temporaneo a zero byte con nome univoco sul disco e restituisce il percorso intero di quel file.Creates a uniquely named, zero-byte temporary file on disk and returns the full path of that file.

GetTempPath()

Restituisce il percorso della cartella temporanea dell'utente corrente.Returns the path of the current user's temporary folder.

HasExtension(ReadOnlySpan<Char>)

Determina se il percorso rappresentato dall'intervallo di caratteri specificato include un'estensione di file.Determines whether the path represented by the specified character span includes a file name extension.

HasExtension(String)

Determina se un percorso include un'estensione di nome di file.Determines whether a path includes a file name extension.

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.Returns a value that indicates whether the file path represented by the specified character span is fixed to a specific drive or UNC path.

IsPathFullyQualified(String)

Restituisce un valore che indica se il percorso di file specificato è fisso in un'unità specifica o in un percorso UNC.Returns a value that indicates whether the specified file path is fixed to a specific drive or UNC path.

IsPathRooted(ReadOnlySpan<Char>)

Restituisce un valore che indica se l'intervallo di caratteri specificato che rappresenta un percorso di file contiene una radice.Returns a value that indicates whether the specified character span that represents a file path contains a root.

IsPathRooted(String)

Restituisce un valore che indica se la stringa di percorso specificata contiene una radice.Returns a value indicating whether the specified path string contains a root.

Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatena due componenti del percorso in un unico percorso.Concatenates two path components into a single path.

Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatena tre componenti del percorso in un unico percorso.Concatenates three path components into a single path.

Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatena quattro componenti del percorso in un unico percorso.Concatenates four path components into a single path.

Join(String, String)

Concatena due percorsi in un unico percorso.Concatenates two paths into a single path.

Join(String, String, String)

Concatena tre percorsi in un unico percorso.Concatenates three paths into a single path.

Join(String, String, String, String)

Concatena quattro percorsi in un unico percorso.Concatenates four paths into a single path.

Join(String[])

Concatena una matrice di percorsi in un unico percorso.Concatenates an array of paths into a single path.

TrimEndingDirectorySeparator(ReadOnlySpan<Char>)

Taglia un separatore di directory finale oltre la radice del percorso specificato.Trims one trailing directory separator beyond the root of the specified path.

TrimEndingDirectorySeparator(String)

Taglia un separatore di directory finale oltre la radice del percorso specificato.Trims one trailing directory separator beyond the root of the specified path.

TryJoin(ReadOnlySpan<Char>, 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.Attempts to concatenate two path components to a single preallocated character span, and returns a value that indicates whether the operation succeeded.

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.Attempts to concatenate two path components to a single preallocated character span, and returns a value that indicates whether the operation succeeded.

Si applica a

Vedi anche