Formáty cest k souborům v systémech Windows

Členové mnoha typů v System.IO oboru názvů zahrnují path parametr, který vám umožňuje zadat absolutní nebo relativní cestu k prostředku systému souborů. Tato cesta se pak předá rozhraním API systému souborů Windows. Toto téma popisuje formáty cest k souborům, které můžete použít v systémech Windows.

Tradiční cesty k DOS

Standardní cesta k systému DOS se může skládat ze tří komponent:

Písmeno svazku nebo jednotky následované oddělovačem svazku (:).
Název adresáře. Znak oddělovače adresáře odděluje podadresáře v hierarchii vnořených adresářů.
Volitelný název souboru. Znak oddělovače adresářů odděluje cestu k souboru a název souboru.

Pokud jsou k dispozici všechny tři komponenty, cesta je absolutní. Pokud není zadán žádný svazek nebo písmeno jednotky a název adresáře začíná znakem oddělovače adresáře, cesta je relativní vůči kořenu aktuální jednotky. Jinak je cesta relativní k aktuálnímu adresáři. Následující tabulka uvádí některé možné cesty k adresáři a souborům.

Cesta	Popis
`C:\Documents\Newsletters\Summer2018.pdf`	Absolutní cesta k souboru z kořenového adresáře jednotky `C:`.
`\Program Files\Custom Utilities\StringFinder.exe`	Relativní cesta z kořenového adresáře aktuální jednotky.
`2018\January.xlsx`	Relativní cesta k souboru v podadresáři aktuálního adresáře.
`..\Publications\TravelBrochure.pdf`	Relativní cesta k souboru v adresáři počínaje aktuálním adresářem.
`C:\Projects\apilibrary\apilibrary.sln`	Absolutní cesta k souboru z kořenového adresáře disku `C:`.
`C:Projects\apilibrary\apilibrary.sln`	Relativní cesta z aktuálního adresáře jednotky `C:`.

Důležité

Všimněte si rozdílu mezi posledními dvěma cestami. Oba určují volitelný specifikátor svazku (C: v obou případech), ale první začíná kořenem zadaného svazku, zatímco druhý není. Výsledkem je první absolutní cesta z kořenového adresáře jednotky C:, zatímco druhá je relativní cesta z aktuálního adresáře jednotky C:. Použití druhého formuláře, pokud je první zamýšlený, je běžným zdrojem chyb, které zahrnují cesty k souborům Systému Windows.

Můžete určit, jestli je cesta k souboru plně kvalifikovaná (tj. pokud je cesta nezávislá na aktuálním adresáři a nemění se, když se aktuální adresář změní) voláním Path.IsPathFullyQualified metody. Mějte na paměti, že taková cesta může obsahovat relativní segmenty adresáře (. a ..) a přesto být plně kvalifikovaná, pokud přeložená cesta vždy odkazuje na stejné umístění.

Následující příklad znázorňuje rozdíl mezi absolutními a relativními cestami. Předpokládá se, že adresář D:\FY2018\ existuje a že jste před spuštěním tohoto příkladu nenastavili žádný aktuální adresář pomocí příkazového řádku D:\.

using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;

public class Example2
{
    public static void Main(string[] args)
    {
        Console.WriteLine($"Current directory is '{Environment.CurrentDirectory}'");
        Console.WriteLine("Setting current directory to 'C:\\'");

        Directory.SetCurrentDirectory(@"C:\");
        string path = Path.GetFullPath(@"D:\FY2018");
        Console.WriteLine($"'D:\\FY2018' resolves to {path}");
        path = Path.GetFullPath(@"D:FY2018");
        Console.WriteLine($"'D:FY2018' resolves to {path}");

        Console.WriteLine("Setting current directory to 'D:\\Docs'");
        Directory.SetCurrentDirectory(@"D:\Docs");

        path = Path.GetFullPath(@"D:\FY2018");
        Console.WriteLine($"'D:\\FY2018' resolves to {path}");
        path = Path.GetFullPath(@"D:FY2018");

        // This will be "D:\Docs\FY2018" as it happens to match the drive of the current directory
        Console.WriteLine($"'D:FY2018' resolves to {path}");

        Console.WriteLine("Setting current directory to 'C:\\'");
        Directory.SetCurrentDirectory(@"C:\");

        path = Path.GetFullPath(@"D:\FY2018");
        Console.WriteLine($"'D:\\FY2018' resolves to {path}");

        // This will be either "D:\FY2018" or "D:\FY2018\FY2018" in the subprocess. In the sub process,
        // the command prompt set the current directory before launch of our application, which
        // sets a hidden environment variable that is considered.
        path = Path.GetFullPath(@"D:FY2018");
        Console.WriteLine($"'D:FY2018' resolves to {path}");

        if (args.Length < 1)
        {
            Console.WriteLine(@"Launching again, after setting current directory to D:\FY2018");
            Uri currentExe = new(Assembly.GetExecutingAssembly().Location, UriKind.Absolute);
            string commandLine = $"/C cd D:\\FY2018 & \"{currentExe.LocalPath}\" stop";
            ProcessStartInfo psi = new("cmd", commandLine); ;
            Process.Start(psi).WaitForExit();

            Console.WriteLine("Sub process returned:");
            path = Path.GetFullPath(@"D:\FY2018");
            Console.WriteLine($"'D:\\FY2018' resolves to {path}");
            path = Path.GetFullPath(@"D:FY2018");
            Console.WriteLine($"'D:FY2018' resolves to {path}");
        }
        Console.WriteLine("Press any key to continue... ");
        Console.ReadKey();
    }
}
// The example displays the following output:
//      Current directory is 'C:\Programs\file-paths'
//      Setting current directory to 'C:\'
//      'D:\FY2018' resolves to D:\FY2018
//      'D:FY2018' resolves to d:\FY2018
//      Setting current directory to 'D:\Docs'
//      'D:\FY2018' resolves to D:\FY2018
//      'D:FY2018' resolves to D:\Docs\FY2018
//      Setting current directory to 'C:\'
//      'D:\FY2018' resolves to D:\FY2018
//      'D:FY2018' resolves to d:\FY2018
//      Launching again, after setting current directory to D:\FY2018
//      Sub process returned:
//      'D:\FY2018' resolves to D:\FY2018
//      'D:FY2018' resolves to d:\FY2018
// The subprocess displays the following output:
//      Current directory is 'C:\'
//      Setting current directory to 'C:\'
//      'D:\FY2018' resolves to D:\FY2018
//      'D:FY2018' resolves to D:\FY2018\FY2018
//      Setting current directory to 'D:\Docs'
//      'D:\FY2018' resolves to D:\FY2018
//      'D:FY2018' resolves to D:\Docs\FY2018
//      Setting current directory to 'C:\'
//      'D:\FY2018' resolves to D:\FY2018
//      'D:FY2018' resolves to D:\FY2018\FY2018

Imports System.IO
Imports System.Reflection

Public Module Example2

    Public Sub Main(args() As String)
        Console.WriteLine($"Current directory is '{Environment.CurrentDirectory}'")
        Console.WriteLine("Setting current directory to 'C:\'")
        Directory.SetCurrentDirectory("C:\")

        Dim filePath As String = Path.GetFullPath("D:\FY2018")
        Console.WriteLine($"'D:\\FY2018' resolves to {filePath}")
        filePath = Path.GetFullPath("D:FY2018")
        Console.WriteLine($"'D:FY2018' resolves to {filePath}")

        Console.WriteLine("Setting current directory to 'D:\\Docs'")
        Directory.SetCurrentDirectory("D:\Docs")

        filePath = Path.GetFullPath("D:\FY2018")
        Console.WriteLine($"'D:\\FY2018' resolves to {filePath}")
        filePath = Path.GetFullPath("D:FY2018")

        ' This will be "D:\Docs\FY2018" as it happens to match the drive of the current directory
        Console.WriteLine($"'D:FY2018' resolves to {filePath}")

        Console.WriteLine("Setting current directory to 'C:\\'")
        Directory.SetCurrentDirectory("C:\")

        filePath = Path.GetFullPath("D:\FY2018")
        Console.WriteLine($"'D:\\FY2018' resolves to {filePath}")

        ' This will be either "D:\FY2018" or "D:\FY2018\FY2018" in the subprocess. In the sub process,
        ' the command prompt set the current directory before launch of our application, which
        ' sets a hidden environment variable that is considered.
        filePath = Path.GetFullPath("D:FY2018")
        Console.WriteLine($"'D:FY2018' resolves to {filePath}")

        If args.Length < 1 Then
            Console.WriteLine("Launching again, after setting current directory to D:\FY2018")
            Dim currentExe As New Uri(Assembly.GetExecutingAssembly().GetName().CodeBase, UriKind.Absolute)
            Dim commandLine As String = $"/C cd D:\FY2018 & ""{currentExe.LocalPath}"" stop"
            Dim psi As New ProcessStartInfo("cmd", commandLine)
            Process.Start(psi).WaitForExit()

            Console.WriteLine("Sub process returned:")
            filePath = Path.GetFullPath("D:\FY2018")
            Console.WriteLine($"'D:\\FY2018' resolves to {filePath}")
            filePath = Path.GetFullPath("D:FY2018")
            Console.WriteLine($"'D:FY2018' resolves to {filePath}")
        End If
        Console.WriteLine("Press any key to continue... ")
        Console.ReadKey()
    End Sub
End Module
' The example displays the following output:
'      Current directory is 'C:\Programs\file-paths'
'      Setting current directory to 'C:\'
'      'D:\FY2018' resolves to D:\FY2018
'      'D:FY2018' resolves to d:\FY2018
'      Setting current directory to 'D:\Docs'
'      'D:\FY2018' resolves to D:\FY2018
'      'D:FY2018' resolves to D:\Docs\FY2018
'      Setting current directory to 'C:\'
'      'D:\FY2018' resolves to D:\FY2018
'      'D:FY2018' resolves to d:\FY2018
'      Launching again, after setting current directory to D:\FY2018
'      Sub process returned:
'      'D:\FY2018' resolves to D:\FY2018
'      'D:FY2018' resolves to d:\FY2018
' The subprocess displays the following output:
'      Current directory is 'C:\'
'      Setting current directory to 'C:\'
'      'D:\FY2018' resolves to D:\FY2018
'      'D:FY2018' resolves to D:\FY2018\FY2018
'      Setting current directory to 'D:\Docs'
'      'D:\FY2018' resolves to D:\FY2018
'      'D:FY2018' resolves to D:\Docs\FY2018
'      Setting current directory to 'C:\'
'      'D:\FY2018' resolves to D:\FY2018
'      'D:FY2018' resolves to D:\FY2018\FY2018

Cesty UNC

Cesty UNC (Universal Naming Convention), které se používají pro přístup k síťovým prostředkům, mají následující formát:

Název serveru nebo hostitele, kterému předchází \\. Název serveru může být název počítače NetBIOS nebo IP/FQDN adresa (podporovány jsou jak IPv4, tak i IPv6).
Název sdílené složky, který je oddělený od názvu hostitele\. Název serveru a sdílené složky společně tvoří svazek.
Název adresáře. Znak oddělovače adresáře odděluje podadresáře v hierarchii vnořených adresářů.
Volitelný název souboru. Znak oddělovače adresářů odděluje cestu k souboru a název souboru.

Tady je několik příkladů cest UNC:

Cesta	Popis
`\\system07\C$\`	Kořenový adresář jednotky `C:` disku na `system07`.
`\\Server2\Share\Test\Foo.txt`	Soubor `Foo.txt` v adresáři Test svazku `\\Server2\Share` .

Cesty UNC musí být vždy plně kvalifikované. Mohou zahrnovat relativní segmenty adresáře (. a ..), ale musí být součástí plně kvalifikované cesty. Použít relativní cesty můžete pouze tak, že mapujete cestu UNC na písmeno jednotky.

Cesty zařízení DOS

Operační systém Windows má jednotný objektový model, který odkazuje na všechny prostředky včetně souborů. Tyto cesty k objektům jsou přístupné z okna konzoly a jsou přístupné vrstvě Win32 prostřednictvím speciální složky symbolických odkazů, na které jsou mapovány starší cesty DOS a UNC. K této speciální složce se přistupuje prostřednictvím syntaxe cesty zařízení DOS, což je jedna z těchto možností:

\\.\C:\Test\Foo.txt \\?\C:\Test\Foo.txt

Kromě identifikace jednotky písmenem jednotky můžete svazek identifikovat pomocí identifikátoru GUID svazku. To má podobu:

\\.\Volume{b75e2c83-0000-0000-0000-602f00000000}\Test\Foo.txt \\?\Volume{b75e2c83-0000-0000-0000-602f00000000}\Test\Foo.txt

Poznámka:

Syntaxe cesty zařízení DOS je podporována u implementací .NET běžících ve Windows počínaje rozhraním .NET Core 1.1 a .NET Framework 4.6.2.

Cesta zařízení DOS se skládá z následujících součástí:

Specifikátor cesty zařízení (\\.\ nebo \\?\), který identifikuje cestu jako cestu zařízení DOS.

Poznámka:

Podporuje se \\?\ ve všech verzích .NET Core a .NET 5 a v rozhraní .NET Framework počínaje verzí 4.6.2.
Symbolický odkaz na „skutečný“ objekt zařízení (C: v případě názvu jednotky nebo svazku {b75e2c83-0000-0000-0000-602f00000000} v případě identifikátoru GUID svazku).

První segment cesty zařízení DOS, který následuje za specifikátorem cesty zařízení, identifikuje svazek nebo disk. (Například \\?\C:\ a \\.\BootPartition\.)

Existuje zvláštní odkaz pro UNCs, který je, nepřekvapivě, nazýván UNC. Například:

\\.\UNC\Server\Share\Test\Foo.txt \\?\UNC\Server\Share\Test\Foo.txt

U zařízení UNC tvoří část serveru/sdílení svazek. Například v \\?\server1\utilities\\filecomparer\ je část server/sdílená složka server1\utilities. To je významné při volání metody s použitím relativních segmentů adresáře, jako je Path.GetFullPath(String, String); není nikdy možné navigovat za svazek.

Cesty zařízení DOS jsou plně kvalifikované definicí a nemůžou začínat relativním segmentem adresáře (. nebo ..). Aktuální adresáře se nikdy nepoužívají.

Příklad: Způsoby, jak odkazovat na stejný soubor

Následující příklad ukazuje některé ze způsobů, jak můžete odkazovat na soubor při použití rozhraní API v System.IO oboru názvů. Příklad vytvoří instanci objektu FileInfo a použije jeho Name a Length vlastnosti k zobrazení názvu souboru a délky souboru.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string[] filenames = {
            @"c:\temp\test-file.txt",
            @"\\127.0.0.1\c$\temp\test-file.txt",
            @"\\LOCALHOST\c$\temp\test-file.txt",
            @"\\.\c:\temp\test-file.txt",
            @"\\?\c:\temp\test-file.txt",
            @"\\.\UNC\LOCALHOST\c$\temp\test-file.txt" };

        foreach (string filename in filenames)
        {
            FileInfo fi = new(filename);
            Console.WriteLine($"file {fi.Name}: {fi.Length:N0} bytes");
        }
    }
}
// The example displays output like the following:
//      file test-file.txt: 22 bytes
//      file test-file.txt: 22 bytes
//      file test-file.txt: 22 bytes
//      file test-file.txt: 22 bytes
//      file test-file.txt: 22 bytes
//      file test-file.txt: 22 bytes

Imports System.IO

Module Program
    Sub Main()
        Dim filenames() As String = {
                "c:\temp\test-file.txt",
                "\\127.0.0.1\c$\temp\test-file.txt",
                "\\LOCALHOST\c$\temp\test-file.txt",
                "\\.\c:\temp\test-file.txt",
                "\\?\c:\temp\test-file.txt",
                "\\.\UNC\LOCALHOST\c$\temp\test-file.txt"}

        For Each filename In filenames
            Dim fi As New FileInfo(filename)
            Console.WriteLine($"file {fi.Name}: {fi.Length:N0} bytes")
        Next
    End Sub
End Module

Normalizace cest

Téměř všechny cesty předávané rozhraním API systému Windows jsou normalizovány. Během normalizace systém Windows provádí následující kroky:

Identifikuje cestu.
Použije aktuální adresář na částečně kvalifikované (relativní) cesty.
Normalizuje komponenty a oddělovače adresářů.
Vyhodnotí relativní komponenty adresáře (. pro aktuální adresář a .. pro rodičovský adresář).
Ořízne určité znaky.

Tato normalizace se provádí implicitně, ale můžete to udělat explicitně voláním Path.GetFullPath metody, která zabalí volání funkce GetFullPathName(). Pomocí P/Invoke můžete také přímo volat funkci Windows GetFullPathName().

Identifikace cesty

Prvním krokem normalizace cesty je identifikace typu cesty. Cesty spadají do jedné z několika kategorií:

Jedná se o cesty zařízení; to znamená, že začínají dvěma oddělovači a poté otazníkem nebo tečkou (např. \\? nebo \\.).
Jsou to cesty UNC; to znamená, že začínají dvěma oddělovači bez otazníku nebo tečky.
Jedná se o plně kvalifikované cesty DOS; to znamená, že začínají písmenem jednotky, oddělovačem svazku a oddělovačem složek (C:\).
Označí starší zařízení (CON, LPT1).
Jsou relativní ke kořenu aktuální jednotky; to znamená, že začínají oddělovačem jedné komponenty (\).
Jsou relativní vůči aktuálnímu adresáři specifikované jednotky; to znamená, že začínají písmenem jednotky, oddělovačem svazku a nemají oddělovač komponent (C:).
Jsou relativní vzhledem k aktuálnímu adresáři; to znamená, že začínají čímkoli jiným (temp\testfile.txt).

Typ cesty určuje, zda je aktuální adresář použit nějakým způsobem. Určuje také, co je "kořenem" cesty.

Řešení zastaralých zařízení

Pokud je cesta původním zařízením DOS, například CON, COM1 nebo LPT1, je převedena na cestu zařízení přidáním \\.\ na začátek a vrácena.

Před Windows 11 se cesta, která začíná názvem starší verze zařízení, vždy interpretuje jako starší verze zařízení metodou Path.GetFullPath(String) . Například cesta zařízení DOS pro CON.TXT je \\.\CON, a cesta zařízení DOS pro COM1.TXT\file1.txt je \\.\COM1. Vzhledem k tomu, že tento postup už neplatí pro Windows 11, zadejte úplnou cestu ke staršímu zařízení SYSTÉMU DOS, například \\.\CON.

Použij aktuální adresář

Pokud cesta není plně kvalifikovaná, windows na něj použije aktuální adresář. UNC cesty a cesty zařízení nepoužívají aktuální adresář. Ani jeden z nich nemá plnou jednotku s oddělovačem C:\.

Pokud cesta začíná oddělovačem složek, použije se disk z aktuálního adresáře. Pokud je \utilities například cesta k souboru a aktuální adresář je C:\temp\, normalizace vytvoří C:\utilities.

Pokud cesta začíná písmenem jednotky, oddělovačem svazků a bez oddělovače součástí, použije se poslední aktuální adresář nastavený z příkazového prostředí pro zadanou jednotku. Pokud nebyl nastaven poslední aktuální adresář, použije se samotná jednotka. Pokud je D:sourcesnapříklad cesta k souboru , aktuální adresář je C:\Documents\a poslední aktuální adresář na jednotce D: byl D:\sources\, výsledek je D:\sources\sources. Tyto cesty "relativní jednotky" jsou běžným zdrojem chyb logiky programů a skriptů. Předpokládat, že cesta začínající písmenem a dvojtečkou není relativní, není zjevně správné.

Pokud cesta nezačíná oddělovačem, použije se aktuální disk a aktuální adresář. Například pokud je filecompare cesta a aktuální adresář je C:\utilities\, výsledek je C:\utilities\filecompare\.

Důležité

Relativní cesty jsou nebezpečné ve vícevláknových aplikacích (tj. většina aplikací), protože aktuální adresář je nastavení pro jednotlivé procesy. Jakékoli vlákno může kdykoli změnit aktuální adresář. Počínaje rozhraním .NET Core 2.1 můžete volat metodu Path.GetFullPath(String, String), která získá absolutní cestu z relativní cesty a základní cesty (aktuálního adresáře), vůči které ji chcete vyřešit.

Kanonické oddělovače

Všechna lomítka (/) se převedou na standardní oddělovač Windows, zpětné lomítko (\). Pokud jsou přítomny, řada lomítek, které následují po prvních dvou lomítkách, jsou sloučena do jednoho lomítka.

Poznámka:

Počínaje .NET 8 na operačních systémech založených na Unixu už modul runtime nepřevádí zpětné lomítko (\) na oddělovače adresářů (lomítka dopředu /). Další informace naleznete v tématu Mapování zpětného lomítka v cestách souborů Unix.

Vyhodnocení relativních komponent

Při zpracování cesty se vyhodnocují všechny komponenty nebo segmenty, které se skládají z jednoho nebo dvojitého období (. nebo ..) :

Pro jedno období se aktuální segment odebere, protože odkazuje na aktuální adresář.
U dvojité tečky se odebere aktuální segment a nadřazený segment, protože dvojité období odkazuje na nadřazený adresář.

Nadřazené adresáře se odstraní pouze v případě, že nepřesahují kořen cesty. Kořen cesty závisí na typu cesty. Jedná se o jednotku (disk) (C:\) pro cesty systému DOS, server/sdílenou složku pro UNC (\\Server\Share) a předponu cesty zařízení pro cesty zařízení (\\?\ nebo \\.\).

Oříznout znaky

Kromě sérií oddělovačů a relativních segmentů, které byly odstraněny dříve, se během normalizace odeberou některé další znaky:

Pokud segment končí v jednom období, odebere se toto období. (Segment jednoho nebo dvojitého období se normalizuje v předchozím kroku. Segment tří nebo více období není normalizován a ve skutečnosti je platným názvem souboru nebo adresáře.)
Pokud cesta nekončí oddělovačem, jsou odstraněny všechny koncové tečky a mezery (U+0020). Pokud je poslední segment jednoduše jedno nebo dvojité období, spadá pod výše uvedené pravidlo relativních součástí.

Toto pravidlo znamená, že můžete vytvořit název adresáře s koncovou mezerou přidáním koncového oddělovače za mezeru.

Důležité

Nikdy byste neměli vytvářet adresář ani název souboru s koncovou mezerou. Koncové mezery můžou znesnadnit nebo znemožnit přístup k adresáři a při pokusu o zpracování adresářů nebo souborů, jejichž názvy zahrnují koncové mezery, často selžou.

Přeskočení normalizace

Za normálních okolností se jakákoli cesta předaná do rozhraní API systému Windows (efektivně) předá funkci GetFullPathName a normalizuje se. Existuje jedna důležitá výjimka: cesta zařízení, která místo tečky začíná otazníkem. Pokud cesta nezačíná přesně \\?\ (všimněte si použití kanonického zpětného lomítka), je normalizována.

Proč byste chtěli normalizaci přeskočit? Existují tři hlavní důvody:

Pokud chcete získat přístup k cestám, které jsou normálně nedostupné, ale jsou legální. Soubor nebo adresář volaný hidden.například není možné získat přístup jiným způsobem.
Zvýšit výkon přeskočením normalizace, pokud jste ji už provedli.
Pouze v rozhraní .NET Framework přeskočte kontrolu délky cesty MAX_PATH, aby umožnila cesty delší než 259 znaků. Většina rozhraní API to umožňuje s některými výjimkami.

Poznámka:

.NET Core a .NET 5+ zpracovávají dlouhé cesty implicitně a neprovádí MAX_PATH kontrolu. Kontrola MAX_PATH platí pouze pro rozhraní .NET Framework.

Přeskočení normalizace a kontroly maximální délky cesty je jediným rozdílem mezi syntaxí dvou cest zařízení; jinak jsou identické. Při přeskakování normalizace buďte opatrní, protože můžete snadno vytvářet cesty, které jsou pro "normální" aplikace obtížné řešit.

Cesty, které začínají \\?\, se stále normalizují, pokud je explicitně předáte funkci GetFullPathName.

Cesty s více než MAX_PATH znaky lze předat getFullPathName bez \\?\. Podporuje libovolné délky cest až do maximálně možné velikosti řetězce, kterou může systém Windows zpracovat.

Případy a souborový systém Windows

Zvláštní vlastností systému souborů Windows, která mate uživatele a vývojáře nepoužívající Windows, je, že názvy cest a adresářů nerozlišují velká a malá písmena. To znamená, že názvy adresářů a souborů odrážejí velikost písmen řetězců použitých při jejich vytvoření. Příklad volání metody

Directory.Create("TeStDiReCtOrY");

Directory.Create("TeStDiReCtOrY")

vytvoří adresář s názvem TeStDiReCtOrY. Pokud přejmenujete adresář nebo soubor a změníte jeho velikost, bude název adresáře nebo souboru odpovídat velikosti řetězce použitého při jeho přejmenování. Například následující kód přejmenuje soubor s názvem test.txt na Test.txt:

using System.IO;

class Example3
{
    static void Main()
    {
        var fi = new FileInfo(@".\test.txt");
        fi.MoveTo(@".\Test.txt");
    }
}

Imports System.IO

Module Example3
    Public Sub Main()
        Dim fi As New FileInfo(".\test.txt")
        fi.MoveTo(".\Test.txt")
    End Sub
End Module

Porovnání názvů adresářů a souborů ale nerozlišuje mezi malými a velkými písmeny. Pokud hledáte soubor s názvem "test.txt", rozhraní API systému souborů .NET v porovnání ignorují velká a malá písmena. "Test.txt", "TEST.TXT", "test.TXT" a jakákoli jiná kombinace velkých a malých písmen bude odpovídat "test.txt".

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-10-22

Sdílet prostřednictvím

Formáty cest k souborům v systémech Windows

Tradiční cesty k DOS

Cesty UNC

Cesty zařízení DOS

Příklad: Způsoby, jak odkazovat na stejný soubor

Normalizace cest

Identifikace cesty

Řešení zastaralých zařízení

Použij aktuální adresář

Kanonické oddělovače

Vyhodnocení relativních komponent

Oříznout znaky

Přeskočení normalizace

Případy a souborový systém Windows

Váš názor

Další materiály