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

Článek
10/04/2023

Členové mnoha typů v System.IO oboru názvů zahrnují path parametr, který 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ů Systému 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í od kořene 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 jednotky `C:`.
`C:Projects\apilibrary\apilibrary.sln`	Relativní cesta z aktuálního `C:` adresáře jednotky.

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, zda 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á, že adresář D:\FY2018\ existuje a že jste před spuštěním příkladu nenastavili žádný aktuální adresář z D:\ příkazového řádku.

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

public class Example
{
   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 Uri(Assembly.GetExecutingAssembly().GetName().CodeBase, UriKind.Absolute);
         string commandLine = $"/C cd D:\\FY2018 & \"{currentExe.LocalPath}\" stop";
         ProcessStartInfo psi = new ProcessStartInfo("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.Diagnostics
Imports System.IO
Imports System.Reflection

Public Module Example

    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ý je předzvědem \\. Název serveru může být název počítače NetBIOS nebo IP/plně kvalifikovaný název domény (podporuje se protokol IPv4 i v6).
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ář `C:` jednotky 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. Relativní cesty můžete použít pouze mapováním cesty 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 komponent:

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 po specifikátoru cesty zařízení identifikuje svazek nebo jednotku. (Například \\?\C:\ a \\.\BootPartition\.)

Existuje zvláštní odkaz pro uncs, který je volána, ne překvapením, UNC. Příklad:

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

U unc zařízení tvoří část server/sdílená složka svazek. Například v \\?\server1\utilities\\filecomparer\části server/sdílená složka je server1\utilities. To je důležité při volání metody, jako Path.GetFullPath(String, String) je například u relativních segmentů adresáře; nikdy není možné přejít přes svazek.

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

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",
            @"\\127.0.0.1\c$\temp\test-file.txt" };

        foreach (var filename in filenames)
        {
            FileInfo fi = new FileInfo(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
//      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",
                "\\127.0.0.1\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.
Canonicalizes component and directory separators.
Vyhodnotí relativní komponenty adresáře (. pro aktuální adresář a .. nadřazený adresář).
Oříznou se 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(). Funkci Windows GetFullPathName() můžete také volat přímo pomocí volání nespravovaného kódu.

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 otazníkem nebo tečkou (\\? 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 komponent (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í vzhledem k aktuálnímu adresáři zadané jednotky; to znamená, že začínají písmenem jednotky, oddělovačem svazků a bez oddělovače součástí (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.

Zpracování starších zařízení

Pokud je cesta starším zařízením DOS, například CON, COM1nebo LPT1, je převedena na cestu zařízení předem \\.\ a vrácena.

Cesta, která začíná názvem starší verze zařízení, se vždy interpretuje jako starší verze zařízení metodou Path.GetFullPath(String) . Například cesta zařízení DOS je CON.TXT a cesta zařízení DOS je COM1.TXT\file1.txt\\.\COM1.\\.\CON

Použití aktuálního adresáře

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

Pokud cesta začíná oddělovačem jedné součásti, použije se jednotka 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ů. Za předpokladu, že cesta začínající písmenem a dvojtečka není zřejmě relativní, není samozřejmě správná.

Pokud cesta začíná něčím jiným než oddělovačem, použije se aktuální jednotka 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), se kterou ji chcete přelož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í za prvními dvěma lomítky, jsou sbalené do jednoho lomítka.

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 odeberou jenom v případě, že nejsou v kořenovém adresáři cesty. Kořen cesty závisí na typu cesty. Jedná se o jednotku (C:\) pro cesty k systému DOS, server/sdílenou složku pro řadiče unc (\\Server\Share) a předponu cesty zařízení pro cesty zařízení (\\?\ nebo \\.\).

Oříznout znaky

Kromě spuštění oddělovačů a relativních segmentů odebraných 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říneboch
Pokud cesta nekončí oddělovačem, odeberou se všechna koncová tečka 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á začíná otazníkem místo tečky. 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.
Pokud chcete zvýšit výkon přeskočením normalizace, pokud jste už normalizovali.
Pouze v rozhraní .NET Framework přeskočte MAX_PATH kontrolu délky cesty, aby byly cesty větší 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 maximální kontroly cest je jediným rozdílem mezi syntaxí dvou cest zařízení; jsou jinak 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é cesty délky až do maximální velikosti řetězce, kterou může Systém Windows zpracovat.

Case and the Windows file system

Zvláštní vlastností systému souborů Windows, který uživatelé a vývojáři, kteří nejsou windows, je matoucí je, že názvy cest a adresářů nerozlišují malá a velká 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í. Napří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 Example
{
   static void Main()
   {
      var fi = new FileInfo(@".\test.txt");
      fi.MoveTo(@".\Test.txt");
   }
}

Imports System.IO

Module Example
    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šují malá a velká písmena. 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".