Path Classe

Definizione

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 classe Path.

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 su 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 file dipende dalla piattaforma; Ad esempio, alcuni sistemi limitano le estensioni a tre caratteri (ad esempio FAT16 comunemente usati 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 classe Path e il comportamento esatto di alcuni membri della classe Path 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 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 file nei sistemi Windows.

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

Alcuni membri Path convalidano il contenuto di una stringa di percorso specificata e generano un ArgumentException se la stringa contiene caratteri non validi nelle stringhe di percorso, come definito nei caratteri restituiti dal metodo GetInvalidPathChars. Ad esempio, nelle piattaforme desktop basate su Windows, 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. Questo comportamento di convalida varia tra le versioni di .NET:

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

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

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

Tutti i membri della classe Path sono statici e possono quindi essere chiamati senza avere un'istanza di un 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.

• "MyDir\\MySubdir" in C#, o "MyDir\MySubDir" in Visual Basic.

• "\\\MyServer\\MyShare" in C#, o "\\MyServer\MyShare" 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 metodo GetExtension analizza una stringa passata e restituisce l'estensione da tale stringa. Tuttavia, questo non significa che un file con tale estensione esista sul disco.

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

Campi

Metodi

Si applica a

Vedi anche

• di I/O di flusso e file
• Procedura: Leggere testo da un file
• Procedura: Scrivere testo in un di file
• Procedura: Leggere e scrivere in un file di dati appena creato
• formati di percorso file nei sistemi Windows