Path Classe

Definição

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

Herança

Object

Path

Atributos

ComVisibleAttribute

Exemplos

O exemplo a seguir demonstra alguns dos principais membros da 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

Comentários

Um caminho é uma cadeia de caracteres que fornece o local de um arquivo ou diretório. Um caminho não necessariamente aponta para um local no disco; por exemplo, um caminho pode ser mapeado para um local na memória ou em um dispositivo. O formato exato de um caminho é determinado pela plataforma atual. Por exemplo, em alguns sistemas, um caminho pode começar com uma unidade ou letra de volume, enquanto esse elemento não está presente em outros sistemas. Em alguns sistemas, os caminhos de arquivo podem conter extensões, que indicam o tipo de informação armazenada no arquivo. O formato de uma extensão de nome de arquivo depende da plataforma; por exemplo, alguns sistemas limitam extensões a três caracteres (como FAT16 comumente usado em armazenamento flash menor e versões mais antigas do ISO 9660 usadas em mídia óptica), e outros não. A plataforma atual também determina o conjunto de caracteres usado para separar os elementos de um caminho e o conjunto de caracteres que não podem ser usados ao especificar caminhos. Devido a essas diferenças, os campos da classe Path, bem como o comportamento exato de alguns membros da classe Path são dependentes da plataforma.

Um caminho pode conter informações de localização absolutas ou relativas. Caminhos absolutos especificam totalmente um local: o arquivo ou diretório pode ser identificado exclusivamente independentemente do local atual. Caminhos relativos especificam um local parcial: o local atual é usado como ponto de partida ao localizar um arquivo especificado com um caminho relativo. Para determinar o diretório atual, chame Directory.GetCurrentDirectory.

O .NET Core 1.1 e versões posteriores e o .NET Framework 4.6.2 e versões posteriores também dão suporte ao acesso a objetos do sistema de arquivos que são nomes de dispositivo, como "\\?\C:\".

Para obter mais informações sobre formatos de caminho de arquivo no Windows, consulte Formatos de caminho de arquivo em sistemas Windows.

A maioria dos membros da classe Path não interage com o sistema de arquivos e não verifica a existência do arquivo especificado por uma cadeia de caracteres de caminho. Path membros de classe que modificam uma cadeia de caracteres de caminho, como ChangeExtension, não têm efeito sobre os nomes dos arquivos no sistema de arquivos.

Alguns membros Path validam o conteúdo de uma cadeia de caracteres de caminho especificada e lançam um ArgumentException se a cadeia de caracteres contiver caracteres que não são válidos em cadeias de caracteres de caminho, conforme definido nos caracteres retornados do método GetInvalidPathChars. Por exemplo, em plataformas de área de trabalho baseadas no Windows, caracteres de caminho inválidos podem incluir aspas ("), menor que (<), maior que (>), pipe (|), backspace (\b), nulo (\0) e caracteres Unicode de 16 a 18 e 20 a 25. Esse comportamento de validação varia entre as versões do .NET:

• Em versões do .NET Framework e do .NET Core anteriores à 2.1: todos os membros Path que tomam um caminho como argumento geram um ArgumentException se detectarem caracteres de caminho inválidos.

• No .NET Core 2.1 e versões posteriores: GetFullPath é o único membro que lança um ArgumentException se a cadeia de caracteres contiver caracteres de caminho inválidos.

Os membros da classe Path permitem executar operações comuns de forma rápida e fácil, como determinar se uma extensão de nome de arquivo faz parte de um caminho e combinar duas cadeias de caracteres em um nome de caminho.

Todos os membros da classe Path são estáticos e, portanto, podem ser chamados sem ter uma instância de um caminho.

Em membros que aceitam um caminho, o caminho pode se referir a um arquivo ou apenas a um diretório. O caminho especificado também pode se referir a um caminho relativo ou a um caminho UNC (Convenção Universal de Nomenclatura) para um servidor e um nome de compartilhamento. Por exemplo, todos os seguintes são caminhos aceitáveis:

• "c:\\MyDir\\MyFile.txt" em C#ou "c:\MyDir\MyFile.txt" no Visual Basic.

• "c:\\MyDir" em C#ou "c:\MyDir" no Visual Basic.

• "MyDir\\MySubdir" em C#ou "MyDir\MySubDir" no Visual Basic.

• "\\\\MyServer\\MyShare" em C#ou "\\MyServer\MyShare" no Visual Basic.

Como todas essas operações são executadas em cadeias de caracteres, é impossível verificar se os resultados são válidos em todos os cenários. Por exemplo, o método GetExtension analisa uma cadeia de caracteres que você passa para ela e retorna a extensão dessa cadeia de caracteres. No entanto, isso não significa que exista um arquivo com essa extensão no disco.

Para obter uma lista de tarefas comuns de E/S, consulte Tarefas comuns de E/S.

Campos

Métodos

Aplica-se a

Confira também

• de E/S de Fluxo e Arquivo
• Como ler texto de um arquivo
• Como gravar texto em um arquivo
• Como ler e gravar em um arquivo de dados recém-criado
• formatos de caminho de arquivo em sistemas Windows