Path Třída

  • Reference

Definice

Obor názvů:
System.IO
Sestavení:
System.Runtime.Extensions.dll
Sestavení:
System.Runtime.dll
Sestavení:
mscorlib.dll
Sestavení:
netstandard.dll
Zdroj:
Path.cs
Zdroj:
Path.cs
Zdroj:
Path.cs

Provádí operace s String instancemi, které obsahují informace o cestě k souboru nebo adresáři. Tyto operace se provádějí multiplatformně.

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
Dědičnost
Object
Path
Atributy
ComVisibleAttribute

Příklady

Následující příklad ukazuje některé z hlavních členů Path třídy.

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

Poznámky

Cesta je řetězec, který poskytuje umístění souboru nebo adresáře. Cesta nemusí nutně odkazovat na umístění na disku; Cesta se může například namapovat na umístění v paměti nebo na zařízení. Přesný formát cesty určuje aktuální platforma. Například v některých systémech může cesta začínat jednotkou nebo písmenem svazku, zatímco tento prvek není v jiných systémech k dispozici. V některých systémech můžou cesty k souborům obsahovat přípony, které označují typ informací uložených v souboru. Formát přípony názvu souboru je závislý na platformě. Některé systémy například omezují rozšíření na tři znaky (například FAT16 běžně používané v menším úložišti flash a starší verze ISO 9660 používané na optických médiích) a jiné ne. Aktuální platforma také určuje sadu znaků sloužících k oddělení prvků cesty a sadu znaků, které nelze použít při zadávání cest. Vzhledem k těmto rozdílům jsou pole Path třídy a přesné chování některých členů třídy závislé na Path platformě.

Cesta může obsahovat absolutní nebo relativní informace o poloze. Absolutní cesty plně určují umístění: soubor nebo adresář lze jednoznačně identifikovat bez ohledu na aktuální umístění. Relativní cesty určují částečné umístění: aktuální umístění se použije jako výchozí bod při umístění souboru zadaného s relativní cestou. Pokud chcete zjistit aktuální adresář, zavolejte .Directory.GetCurrentDirectory

.NET Core 1.1 a novější verze a .NET Framework 4.6.2 a novější verze také podporují přístup k objektům systému souborů, které jsou názvy zařízení, například \\?\C:\.

Další informace o formátech cest k souborům ve Windows najdete v tématu Formáty cest k souborům v systémech Windows.

Většina členů Path třídy neinteraguje se systémem souborů a neověřuje existenci souboru určeného řetězcem cesty. Path členy tříd, které upravují řetězec cesty, například ChangeExtension, nemají žádný vliv na názvy souborů v systému souborů.

Někteří Path členové ověřují obsah zadaného řetězce cesty a vyvolá, ArgumentException pokud řetězec obsahuje znaky, které nejsou platné v řetězcích cesty, jak jsou definovány ve znacích vrácených metodou GetInvalidPathChars . Například na desktopových platformách s Windows můžou neplatné znaky cesty obsahovat uvozovky ("), menší než (<), větší než (>), svislé znaky (|), backspace (\b), null (\0) a znaky Unicode 16 až 18 a 20 až 25. Toto chování ověřování se v jednotlivých verzích .NET liší:

  • Ve verzích .NET Framework a .NET Core starších než 2.1: Všichni Path členové, kteří používají cestu jako argument, vyvolá chybu ArgumentException , pokud zjistí neplatné znaky cesty.

  • V .NET Core 2.1 a novějších verzích: GetFullPath je jediným členem, který vyvolá výjimku ArgumentException , pokud řetězec obsahuje neplatné znaky cesty.

Členové Path třídy umožňují rychle a snadno provádět běžné operace, jako je určení, zda je přípona názvu souboru součástí cesty, a kombinování dvou řetězců do jednoho názvu cesty.

Všechny členy Path třídy jsou statické, a proto je možné je volat bez instance cesty.

Poznámka

Ve členech, které přijímají cestu jako vstupní řetězec, musí být tato cesta správně vytvořena nebo je vyvolána výjimka. Pokud je například cesta plně kvalifikovaná, ale začíná mezerou, cesta není oříznuta v metodách třídy. Proto je cesta poškozena a vyvolána výjimka. Podobně cesta nebo kombinace cest nemůže být plně kvalifikovaná dvakrát. Například c:\temp c:\windows ve většině případů také vyvolá výjimku. Ujistěte se, že vaše cesty jsou správně vytvořené při použití metod, které přijímají řetězec cesty.

Ve členech, kteří přijímají cestu, může cesta odkazovat na soubor nebo jenom adresář. Zadaná cesta může také odkazovat na relativní cestu nebo cestu UNC (Universal Naming Convention) pro název serveru a sdílené složky. Přijatelné jsou například všechny následující cesty:

  • "c:\\MyDir\\MyFile.txt" v jazyce C# nebo "c:\MyDir\MyFile.txt" v jazyce Visual Basic.

  • "c:\\MyDir" v jazyce C# nebo "c:\MyDir" v jazyce Visual Basic.

  • "MyDir\\MySubdir" v jazyce C# nebo "MyDir\MySubDir" v jazyce Visual Basic.

  • "\\\MyServer\\MyShare" v jazyce C# nebo "\\MyServer\MyShare" v jazyce Visual Basic.

Vzhledem k tomu, že všechny tyto operace se provádějí s řetězci, není možné ověřit, zda jsou výsledky platné ve všech scénářích. Metoda například analyzuje řetězec, GetExtension který jí předáte, a vrátí rozšíření z daného řetězce. To ale neznamená, že na disku existuje soubor s touto příponou.

Seznam běžných vstupně-výstupních úloh najdete v tématu Běžné vstupně-výstupní úlohy.

Pole

AltDirectorySeparatorChar

Poskytuje alternativní znak specifický pro platformu, který slouží k oddělení úrovní adresářů v řetězci cesty, který odráží hierarchickou organizaci systému souborů.
DirectorySeparatorChar

Poskytuje znak specifický pro platformu, který slouží k oddělení úrovní adresářů v řetězci cesty, který odráží hierarchickou organizaci systému souborů.
InvalidPathChars
Zastaralé.
Zastaralé.

Poskytuje pole znaků specifické pro platformu, které nelze zadat v argumentech řetězce cesty předaných členům Path třídy.
PathSeparator

Znak oddělovače specifické pro platformu, který slouží k oddělení řetězců cesty v proměnných prostředí.
VolumeSeparatorChar

Poskytuje znak oddělovače svazku specifického pro platformu.

Metody

ChangeExtension(String, String)

Změní rozšíření řetězce cesty.
Combine(String, String)

Zkombinuje dva řetězce do cesty.
Combine(String, String, String)

Kombinuje tři řetězce do cesty.
Combine(String, String, String, String)

Kombinuje čtyři řetězce do cesty.
Combine(String[])

Kombinuje pole řetězců do cesty.
EndsInDirectorySeparator(ReadOnlySpan<Char>)

Vrátí hodnotu, která označuje, zda cesta zadaná jako rozsah jen pro čtení končí oddělovačem adresáře.
EndsInDirectorySeparator(String)

Vrátí hodnotu, která označuje, zda zadaná cesta končí oddělovačem adresáře.
Exists(String)

Určuje, zda zadaný soubor nebo adresář existuje.
GetDirectoryName(ReadOnlySpan<Char>)

Vrátí informace o adresáři pro zadanou cestu reprezentovanou rozsahem znaků.
GetDirectoryName(String)

Vrátí informace o adresáři pro zadanou cestu.
GetExtension(ReadOnlySpan<Char>)

Vrátí příponu cesty k souboru, která je reprezentována znakovým rozsahem jen pro čtení.
GetExtension(String)

Vrátí příponu (včetně tečky .) zadaného řetězce cesty.
GetFileName(ReadOnlySpan<Char>)

Vrátí název souboru a příponu cesty k souboru, která je reprezentována znakovým rozsahem jen pro čtení.
GetFileName(String)

Vrátí název souboru a příponu zadaného řetězce cesty.
GetFileNameWithoutExtension(ReadOnlySpan<Char>)

Vrátí název souboru bez přípony cesty k souboru, která je reprezentována znakovým rozsahem jen pro čtení.
GetFileNameWithoutExtension(String)

Vrátí název souboru zadaného řetězce cesty bez přípony.
GetFullPath(String)

Vrátí absolutní cestu pro zadaný řetězec cesty.
GetFullPath(String, String)

Vrátí absolutní cestu z relativní cesty a plně kvalifikovanou základní cestu.
GetInvalidFileNameChars()

Získá pole obsahující znaky, které nejsou povoleny v názvech souborů.
GetInvalidPathChars()

Získá pole obsahující znaky, které nejsou povoleny v názvech cest.
GetPathRoot(ReadOnlySpan<Char>)

Získá informace o kořenovém adresáři z cesty obsažené v zadaném rozsahu znaků.
GetPathRoot(String)

Získá informace o kořenovém adresáři z cesty obsažené v zadaném řetězci.
GetRandomFileName()

Vrátí náhodný název složky nebo souboru.
GetRelativePath(String, String)

Vrátí relativní cestu z jedné cesty do druhé.
GetTempFileName()

Vytvoří na disku jedinečně pojmenovaný dočasný soubor s nulovými bajty a vrátí úplnou cestu k ho souboru.
GetTempPath()

Vrátí cestu k dočasné složce aktuálního uživatele.
HasExtension(ReadOnlySpan<Char>)

Určuje, zda cesta reprezentovaná zadaným rozsahem znaků obsahuje příponu názvu souboru.
HasExtension(String)

Určuje, zda cesta obsahuje příponu názvu souboru.
IsPathFullyQualified(ReadOnlySpan<Char>)

Vrátí hodnotu, která označuje, zda cesta k souboru reprezentovaná zadaným rozsahem znaků je pevně nastavena na konkrétní jednotku nebo cestu UNC.
IsPathFullyQualified(String)

Vrátí hodnotu, která označuje, zda je zadaná cesta k souboru pevná na konkrétní jednotku nebo cestu UNC.
IsPathRooted(ReadOnlySpan<Char>)

Vrátí hodnotu, která označuje, zda zadaný znak rozsah, který představuje cestu k souboru obsahuje kořen.
IsPathRooted(String)

Vrátí hodnotu označující, zda zadaný řetězec cesty obsahuje kořen.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Zřetězí dvě komponenty cesty do jedné cesty.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Zřetězí tři komponenty cesty do jedné cesty.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Zřetězí čtyři komponenty cesty do jedné cesty.
Join(String, String)

Zřetězí dvě cesty do jedné cesty.
Join(String, String, String)

Zřetězí tři cesty do jedné cesty.
Join(String, String, String, String)

Zřetězí čtyři cesty do jedné cesty.
Join(String[])

Zřetězí pole cest do jedné cesty.
TrimEndingDirectorySeparator(ReadOnlySpan<Char>)

Oříznou jeden koncový oddělovač adresáře za kořenem zadané cesty.
TrimEndingDirectorySeparator(String)

Oříznou jeden koncový oddělovač adresáře za kořenem zadané cesty.
TryJoin(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, Span<Char>, Int32)

Pokusí se zřetězení tří komponent cesty do jednoho předem přiděleného rozsahu znaků a vrátí hodnotu, která označuje, zda operace byla úspěšná.
TryJoin(ReadOnlySpan<Char>, ReadOnlySpan<Char>, Span<Char>, Int32)

Pokusí se zřetězení dvou komponent cesty s jedním předem přiděleným rozsahem znaků a vrátí hodnotu, která označuje, zda byla operace úspěšná.

Platí pro

Viz také