Bestandspadindelingen op Windows-systemen

Leden van veel van de typen in de System.IO naamruimte bevatten een path parameter waarmee u een absoluut of relatief pad naar een bestandssysteemresource kunt opgeven. Dit pad wordt vervolgens doorgegeven aan Windows-bestandssysteem-API's. In dit onderwerp worden de indelingen voor bestandspaden besproken die u op Windows-systemen kunt gebruiken.

Traditionele DOS-paden

Een standaard DOS-pad kan bestaan uit drie onderdelen:

• Een volume- of stationsletter gevolgd door het volumescheidingsteken (:).
• Een mapnaam. Het directoryscheidingsteken scheidt submappen binnen de geneste directoryhiërarchie.
• Een optionele bestandsnaam. Het mapscheidingsteken scheidt het bestandspad en de bestandsnaam.

Als alle drie de onderdelen aanwezig zijn, is het pad absoluut. Als er geen volume- of stationsletter is opgegeven en de mapnaam begint met het mapscheidingsteken, is het pad relatief ten opzichte van de hoofdmap van de huidige schijf. Anderszins is het pad relatief ten opzichte van de huidige directory. In de volgende tabel ziet u enkele mogelijke map- en bestandspaden.

U kunt bepalen of een bestandspad volledig is gekwalificeerd (als het pad onafhankelijk is van de huidige map en niet verandert wanneer de huidige map wordt gewijzigd) door de Path.IsPathFullyQualified methode aan te roepen. Houd er rekening mee dat een dergelijk pad relatieve mapsegmenten (. en ..) kan bevatten en nog steeds volledig kan worden gekwalificeerd als het opgeloste pad altijd naar dezelfde locatie verwijst.

In het volgende voorbeeld ziet u het verschil tussen absolute en relatieve paden. Hierbij wordt ervan uitgegaan dat de map D:\FY2018\ bestaat en dat u geen huidige map D:\ hebt ingesteld vanaf de opdrachtprompt voordat u het voorbeeld uitvoert.

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

UNC-paden

UNC-paden (Universal Naming Convention), die worden gebruikt voor toegang tot netwerkbronnen, hebben de volgende indeling:

• Een server- of hostnaam, die voorafgegaan wordt door \\. De servernaam kan een NetBIOS-computernaam zijn of een IP-/FQDN-adres (IPv4 en v6 worden ondersteund).
• Een sharenaam, die is gescheiden van de hostnaam door \. Samen vormen de server en de sharenaam het volume.
• Een mapnaam. Het directoryscheidingsteken scheidt submappen binnen de geneste directoryhiërarchie.
• Een optionele bestandsnaam. Het mapscheidingsteken scheidt het bestandspad en de bestandsnaam.

Hier volgen enkele voorbeelden van UNC-paden:

UNC-paden moeten altijd volledig gekwalificeerd zijn. Ze kunnen relatieve mapsegmenten (. en ..) bevatten, maar deze moeten deel uitmaken van een volledig gekwalificeerd pad. U kunt relatieve paden alleen gebruiken door een UNC-pad aan een stationsletter te koppelen.

DOS-apparaatpaden

Het Windows-besturingssysteem heeft een geïntegreerd objectmodel dat verwijst naar alle resources, inclusief bestanden. Deze objectpaden zijn toegankelijk vanuit het consolevenster en worden blootgesteld aan de Win32-laag via een speciale map met symbolische koppelingen waaraan verouderde DOS- en UNC-paden zijn toegewezen. Deze speciale map wordt geopend via de syntaxis van het DOS-apparaatpad. Dit is een van de volgende:

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

Naast dat u een station kunt identificeren aan de hand van de stationsletter, kunt u een volume identificeren d.m.v. de volume-GUID. Dit heeft de volgende vorm:

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

Het DOS-apparaatpad bestaat uit de volgende onderdelen:

• De apparaatpadaanduiding (\\.\ of \\?\), waarmee het pad wordt geïdentificeerd als een DOS-apparaatpad.

  Opmerking

  De \\?\ wordt ondersteund in alle versies van .NET Core en .NET 5+ en in .NET Framework vanaf versie 4.6.2.

• Een symbolische koppeling naar het 'echte' apparaatobject (C: in het geval van een stationsnaam of Volume{b75e2c83-0000-0000-0000-602f00000000} in het geval van een volume-GUID).

  Het eerste segment van het DOS-apparaatpad nadat de aanduiding voor het apparaatpad het volume of station identificeert. (Bijvoorbeeld \\?\C:\ , en \\.\BootPartition\.)

  Er is een specifieke koppeling voor UNC's die, niet verrassend, UNC wordt genoemd. Voorbeeld:

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

  Voor apparaat-UNC's vormt het server-/sharegedeelte het volume. Bijvoorbeeld, in \\?\server1\utilities\\filecomparer\ is het gedeelte server/share server1\utilities. Dit is belangrijk wanneer u een methode aanroept, zoals Path.GetFullPath(String, String) met relatieve adreslijstsegmenten. Het is nooit mogelijk om voorbij het volume te navigeren.

DOS-apparaatpaden zijn per definitie volledig gekwalificeerd en kunnen niet beginnen met een relatief mapsegment (. of ..). Huidige directory's voeren nooit hun gebruik in.

Voorbeeld: Manieren om naar hetzelfde bestand te verwijzen

In het volgende voorbeeld ziet u een aantal manieren waarop u naar een bestand kunt verwijzen wanneer u de API's in de System.IO naamruimte gebruikt. In het voorbeeld wordt een FileInfo-object geïnstantieerd en worden de eigenschappen Name en Length gebruikt om de bestandsnaam en de lengte van het bestand weer te geven.

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

Padnormalisatie

Bijna alle paden die worden doorgegeven aan Windows-API's, worden genormaliseerd. Tijdens normalisatie voert Windows de volgende stappen uit:

• Identificeert het pad.
• Hiermee past u de huidige map toe op gedeeltelijk gekwalificeerde (relatieve) paden.
• Canonicaliseert onderdelen en mapscheidingstekens.
• Evalueert relatieve maponderdelen (. voor de huidige map en .. voor de bovenliggende map).
• Hiermee worden bepaalde tekens geknipt.

Deze normalisatie gebeurt impliciet, maar u kunt dit expliciet doen door de Path.GetFullPath methode aan te roepen, waarmee een aanroep naar de functie GetFullPathName() wordt verpakt. U kunt de Functie Windows GetFullPathName() ook rechtstreeks aanroepen met behulp van P/Invoke.

Het pad identificeren

De eerste stap in padnormalisatie is het identificeren van het type pad. Paden vallen in een van de volgende categorieën:

• Het zijn apparaatpaden; dat wil zeggen: ze beginnen met twee scheidingstekens en een vraagteken of een punt (\\? of \\.).
• Het zijn UNC-paden; Dat wil gezegd: ze beginnen met twee scheidingstekens zonder vraagteken of punt.
• Ze zijn volledig gekwalificeerde DOS-paden, dat wil zeggen: ze beginnen met een stationsletter, een volumescheidingsteken en een onderdeelscheidingsteken (C:\).
• Ze wijzen een verouderd apparaat (CON, LPT1) aan.
• Ze zijn relatief ten opzichte van de hoofdmap van het huidige station; dat wil zeggen dat ze beginnen met namelijk één onderdeelscheidingsteken (\).
• Ze zijn relatief ten opzichte van de huidige map van een opgegeven station; Dat wil gezegd: ze beginnen met een stationsletter, een volumescheidingsteken en geen onderdeelscheidingsteken (C:).
• Ze zijn relatief ten opzichte van de huidige map; Dat wil zeggen, ze beginnen met iets anders (temp\testfile.txt).

Het type van het pad bepaalt of de huidige map op een of andere manier wordt toegepast. Het bepaalt ook wat de 'root' van het pad is.

Verouderde apparaten verwerken

Als het pad een verouderd DOS-apparaat is, zoals CON, COM1 of LPT1, wordt het geconverteerd naar een apparaatpad door \\.\ eraan toe te voegen en dan te retourneren.

Vóór Windows 11 wordt een pad dat begint met een verouderde apparaatnaam altijd geïnterpreteerd als een verouderd apparaat door de Path.GetFullPath(String) methode. Het DOS-apparaatpad voor CON.TXT is \\.\CON, en het DOS-apparaatpad voor COM1.TXT\file1.txt is \\.\COM1. Omdat dit niet meer van toepassing is met Windows 11, geeft u het volledige pad op naar het verouderde DOS-apparaat, zoals \\.\CON.

De huidige map toepassen

Als een pad niet volledig is gekwalificeerd, past Windows de huidige map hierop toe. UNC's en apparaatpaden hebben de huidige map niet toegepast. Ook een volle schijf met scheidingsteken C:\ niet.

Als het pad begint met een scheidingsteken van één component, wordt de schijf van de huidige map toegepast. Als het bestandspad bijvoorbeeld is \utilities en de huidige map is C:\temp\, produceert C:\utilitiesnormalisatie .

Als het pad begint met een stationsletter, volumescheidingsteken en geen onderdeelscheidingsteken, wordt de laatste huidige mapset van de opdrachtshell voor het opgegeven station toegepast. Als de laatste huidige werkmap niet is ingesteld, wordt alleen de schijf gebruikt. Als het bestandspad bijvoorbeeld D:sources is, de huidige map C:\Documents\ is, en de laatste huidige map op station D: D:\sources\ was, dan is het resultaat D:\sources\sources. Deze 'schijf-relatieve paden' zijn een veelvoorkomende bron van fouten in de logica van programma's en scripts. Ervan uitgaan dat een pad dat begint met een letter en een dubbele punt niet relatief is, is uiteraard onjuist.

Als het pad begint met iets anders dan een scheidingsteken, worden de huidige schijf en map gebruikt. Als het pad bijvoorbeeld is filecompare en de huidige map is C:\utilities\, is C:\utilities\filecompare\het resultaat .

Canonicaliseren van scheidingstekens

Alle schuine strepen (/) worden omgezet naar het standaardscheidingsteken voor Windows, de backslash (\). Als ze aanwezig zijn, wordt een reeks slashes die volgen op de eerste twee slashes samengevouwen tot één enkele slash.

Relatieve onderdelen evalueren

Wanneer het pad wordt verwerkt, worden alle onderdelen of segmenten die bestaan uit één of twee perioden (. of ..) geëvalueerd:

• Voor één periode wordt het huidige segment verwijderd, omdat het verwijst naar de huidige map.

• Voor een dubbele periode worden het huidige segment en het bovenliggende segment verwijderd, aangezien de dubbele periode verwijst naar de bovenliggende directory.

  Bovenliggende mappen worden alleen verwijderd als ze niet achter de hoofdmap van het pad liggen. De basis van het pad is afhankelijk van het type pad. Het is het station (C:\) voor DOS-paden, de server/share voor UNC's (\\Server\Share) en het voorvoegsel van het apparaatpad voor apparaatpaden (\\?\ of \\.\).

Tekens knippen

Naast de reeksen scheidingstekens en relatieve segmenten die eerder zijn verwijderd, worden tijdens normalisatie extra tekens verwijderd.

• Als een segment in één punt eindigt, wordt die periode verwijderd. (Een segment van een enkele of dubbele periode wordt genormaliseerd in de vorige stap. Een segment van drie of meer perioden wordt niet genormaliseerd en is in feite een geldige bestandsnaam/mapnaam.)

• Als het pad niet eindigt op een scheidingsteken, worden alle volgperioden en spaties (U+0020) verwijderd. Als het laatste segment slechts één of twee punten is, valt het onder de bovenstaande regel voor relatieve componenten.

  Deze regel betekent dat u een mapnaam met een volgruimte kunt maken door een volgscheidingsteken toe te voegen na de spatie.

  Belangrijk

  Maak nooit een map of bestandsnaam met een volgruimte. Volgspaties kunnen het moeilijk of onmogelijk maken om toegang te krijgen tot een map en toepassingen mislukken meestal bij het verwerken van mappen of bestanden waarvan de namen volgspaties bevatten.

Normalisatie overslaan

Normaal gesproken wordt elk pad dat wordt doorgegeven aan een Windows-API (effectief) doorgegeven aan de functie GetFullPathName en genormaliseerd. Er is een belangrijke uitzondering: een apparaatpad dat begint met een vraagteken in plaats van een punt. Tenzij het pad precies met \\?\ begint (let op het gebruik van de canonieke backslash), wordt het genormaliseerd.

Waarom wilt u normalisatie overslaan? Er zijn drie belangrijke redenen:

1. Toegang krijgen tot paden die normaal gesproken niet beschikbaar zijn, maar legaal zijn. Een bestand of map met de naam hidden., bijvoorbeeld, is onmogelijk om op een andere manier toegang te krijgen.

2. Om de prestaties te verbeteren door normalisatie over te slaan als u al genormaliseerd bent.

3. Alleen in .NET Framework kunt u de controle op padlengte MAX_PATH overslaan om paden met meer dan 259 tekens toe te staan. De meeste API's staan dit toe, met enkele uitzonderingen.

Normalisatie- en maximumpadcontroles overslaan is het enige verschil tussen de twee apparaatpadsyntaxis; verder zijn ze identiek. Wees voorzichtig met het overslaan van normalisatie, omdat u eenvoudig paden kunt maken die moeilijk zijn voor 'normale' toepassingen om mee te gaan.

Paden die beginnen met \\?\ worden nog steeds genormaliseerd als u ze expliciet doorgeeft aan de functie GetFullPathName.

U kunt paden van meer dan MAX_PATH tekens doorgeven aan GetFullPathName zonder \\?\. Het ondersteunt willekeurige lengtepaden tot de maximale tekenreeksgrootte die Door Windows kan worden verwerkt.

Case en het Windows-bestandssysteem

Een eigenaardigheid van het Windows-bestandssysteem dat niet-Windows-gebruikers en ontwikkelaars verwarrend vinden, is dat pad- en mapnamen niet hoofdlettergevoelig zijn. Met andere woorden, map- en bestandsnamen weerspiegelen het hoofdlettergebruik van de tekenreeksen die worden gebruikt wanneer ze worden aangemaakt. Bijvoorbeeld de methode-aanroep

Directory.Create("TeStDiReCtOrY");

Directory.Create("TeStDiReCtOrY")

maakt een map met de naam TeStDiReCtOrY. Als u de naam van een map of bestand wijzigt om het hoofdlettergebruik te wijzigen, geeft de map of bestandsnaam het geval weer van de tekenreeks die wordt gebruikt wanneer u de naam ervan wijzigt. Met de volgende code wordt bijvoorbeeld de naam van een bestand met de naam test.txt gewijzigd in 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

Vergelijkingen van map- en bestandsnaam zijn echter niet hoofdlettergevoelig. Als u zoekt naar een bestand met de naam 'test.txt', negeren .NET-bestandssysteem-API's het geval in de vergelijking. "Test.txt", "TEST.TXT", "test.TXT" en een andere combinatie van hoofdletters en kleine letters komt overeen met "test.txt".