Filsökvägsformat i Windows-system

Artikel
08/31/2024

Medlemmar av många av typerna System.IO i namnområdet innehåller en path parameter som gör att du kan ange en absolut eller relativ sökväg till en filsystemresurs. Den här sökvägen skickas sedan till Windows-filsystem-API:er. I det här avsnittet beskrivs format för filsökvägar som du kan använda i Windows-system.

Traditionella DOS-sökvägar

En DOS-standardsökväg kan bestå av tre komponenter:

En volym- eller enhetsbeteckning följt av volymavgränsaren (:).
Ett katalognamn. Katalogavgränsartecknet separerar underkataloger i den kapslade kataloghierarkin.
Ett valfritt filnamn. Katalogavgränsartecknet separerar filsökvägen och filnamnet.

Om alla tre komponenterna finns är sökvägen absolut. Om ingen volym eller enhetsbeteckning har angetts och katalognamnet börjar med katalogavgränsartecknet är sökvägen relativ från roten på den aktuella enheten. Annars är sökvägen relativ till den aktuella katalogen. I följande tabell visas några möjliga katalog- och filsökvägar.

Sökväg	beskrivning
`C:\Documents\Newsletters\Summer2018.pdf`	En absolut filsökväg från roten på enheten `C:`.
`\Program Files\Custom Utilities\StringFinder.exe`	En relativ sökväg från roten på den aktuella enheten.
`2018\January.xlsx`	En relativ sökväg till en fil i en underkatalog till den aktuella katalogen.
`..\Publications\TravelBrochure.pdf`	En relativ sökväg till en fil i en katalog som börjar från den aktuella katalogen.
`C:\Projects\apilibrary\apilibrary.sln`	En absolut sökväg till en fil från roten på enheten `C:`.
`C:Projects\apilibrary\apilibrary.sln`	En relativ sökväg från enhetens `C:` aktuella katalog.

Viktigt!

Observera skillnaden mellan de två sista sökvägarna. Båda anger den valfria volymspecificeraren (C: i båda fallen), men den första börjar med roten på den angivna volymen, medan den andra inte gör det. Därför är den första en absolut sökväg från rotkatalogen på enheten C:, medan den andra är en relativ sökväg från den aktuella katalogen på enheten C:. Användning av det andra formuläret när det första är avsett är en vanlig källa till buggar som omfattar Windows-filsökvägar.

Du kan avgöra om en filsökväg är fullständigt kvalificerad (dvs. om sökvägen är oberoende av den aktuella katalogen och inte ändras när den aktuella katalogen ändras) genom att anropa Path.IsPathFullyQualified metoden. Observera att en sådan sökväg kan innehålla relativa katalogsegment (. och ..) och fortfarande vara fullständigt kvalificerade om den lösta sökvägen alltid pekar på samma plats.

I följande exempel visas skillnaden mellan absoluta och relativa sökvägar. Det förutsätter att katalogen D:\FY2018\ finns och att du inte har angett någon aktuell katalog för D:\ från kommandotolken innan du kör exemplet.

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-sökvägar

UNC-sökvägar (Universal Naming Convention), som används för att komma åt nätverksresurser, har följande format:

Ett server- eller värdnamn som föregås av \\. Servernamnet kan vara ett NetBIOS-datornamn eller en IP/FQDN-adress (IPv4 samt v6 stöds).
Ett resursnamn som avgränsas från värdnamnet med \. Tillsammans utgör server- och resursnamnet volymen.
Ett katalognamn. Katalogavgränsartecknet separerar underkataloger i den kapslade kataloghierarkin.
Ett valfritt filnamn. Katalogavgränsartecknet separerar filsökvägen och filnamnet.

Följande är några exempel på UNC-sökvägar:

Sökväg	beskrivning
`\\system07\C$\`	Rotkatalogen för `C:` enheten på `system07`.
`\\Server2\Share\Test\Foo.txt`	Filen `Foo.txt` i volymens `\\Server2\Share` testkatalog.

UNC-sökvägar måste alltid vara fullständigt kvalificerade. De kan innehålla relativa katalogsegment (. och ..), men dessa måste ingå i en fullständigt kvalificerad sökväg. Du kan endast använda relativa sökvägar genom att mappa en UNC-sökväg till en enhetsbeteckning.

DOS-enhetssökvägar

Windows-operativsystemet har en enhetlig objektmodell som pekar på alla resurser, inklusive filer. Dessa objektsökvägar är tillgängliga från konsolfönstret och exponeras för Win32-lagret via en särskild mapp med symboliska länkar som äldre DOS- och UNC-sökvägar mappas till. Den här särskilda mappen nås via syntaxen för DOS-enhetens sökväg, som är en av:

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

Förutom att identifiera en enhet med dess enhetsbeteckning kan du identifiera en volym med hjälp av dess volym-GUID. Detta tar formuläret:

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

Kommentar

SYNTAX för DOS-enhetssökväg stöds för .NET-implementeringar som körs i Windows från och med .NET Core 1.1 och .NET Framework 4.6.2.

DOS-enhetssökvägen består av följande komponenter:

Enhetssökvägsspecificeraren (\\.\ eller \\?\), som identifierar sökvägen som en DOS-enhetssökväg.

Kommentar

\\?\ stöds i alla versioner av .NET Core och .NET 5+ och i .NET Framework från och med version 4.6.2.
En symbolisk länk till det "riktiga" enhetsobjektet (C: om det gäller ett enhetsnamn eller Volym{b75e2c83-0000-0000-0000-602f00000000} om det gäller ett volym-GUID).

Det första segmentet av DOS-enhetssökvägen efter enhetssökvägsspecificeraren identifierar volymen eller enheten. (Till exempel \\?\C:\ och \\.\BootPartition\.)

Det finns en specifik länk för UNCs som kallas, inte överraskande, UNC. Till exempel:

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

För enhets-UNC:er utgör server-/resursdelen volymen. I \\?\server1\utilities\\filecomparer\är server1\utilitiestill exempel server-/resursdelen . Detta är viktigt när du anropar en metod, till exempel Path.GetFullPath(String, String) med relativa katalogsegment. Det går aldrig att navigera förbi volymen.

DOS-enhetssökvägar är fullständigt kvalificerade per definition och kan inte börja med ett relativt katalogsegment (. eller ..). Aktuella kataloger används aldrig.

Exempel: Sätt att referera till samma fil

I följande exempel visas några av de sätt på vilka du kan referera till en fil när du använder API:erna i System.IO namnområdet. Exemplet instansierar ett FileInfo objekt och använder dess Name egenskaper och Length för att visa filnamnet och filens längd.

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

Sökvägsnormalisering

Nästan alla sökvägar som skickas till Windows-API:er normaliseras. Under normaliseringen utför Windows följande steg:

Identifierar sökvägen.
Tillämpar den aktuella katalogen på delvis kvalificerade (relativa) sökvägar.
Kanoniserar komponent- och katalogavgränsare.
Utvärderar relativa katalogkomponenter (. för den aktuella katalogen och .. för den överordnade katalogen).
Trimmar vissa tecken.

Den här normaliseringen sker implicit, men du kan göra det explicit genom att anropa Path.GetFullPath metoden, som omsluter ett anrop till funktionen GetFullPathName(). Du kan också anropa funktionen Windows GetFullPathName() direkt med hjälp av P/Invoke.

Identifiera sökvägen

Det första steget i sökvägsnormalisering är att identifiera typen av sökväg. Sökvägarna delas in i någon av följande kategorier:

De är enhetssökvägar. det vill: de börjar med två avgränsare och ett frågetecken eller en punkt (\\? eller \\.).
De är UNC-sökvägar. De börjar alltså med två avgränsare utan frågetecken eller punkt.
De är fullständigt kvalificerade DOS-sökvägar; De börjar alltså med en enhetsbeteckning, en volymavgränsare och en komponentavgränsare (C:\).
De anger en äldre enhet (CON, LPT1).
De är relativa till roten för den aktuella enheten. det vill: de börjar med en enskild komponentavgränsare (\).
De är relativa till den aktuella katalogen för en angiven enhet. det vill: de börjar med en enhetsbeteckning, en volymavgränsare och ingen komponentavgränsare (C:).
De är relativa till den aktuella katalogen. det vill: de börjar med något annat (temp\testfile.txt).

Typen av sökväg avgör om en aktuell katalog tillämpas på något sätt. Den avgör också vad "roten" för sökvägen är.

Hantera äldre enheter

Om sökvägen är en äldre DOS-enhet som CON, COM1eller LPT1, konverteras den till en enhetssökväg genom att vänta \\.\ och returneras.

Innan Windows 11 tolkas alltid en sökväg som börjar med ett äldre enhetsnamn som en äldre enhet med Path.GetFullPath(String) metoden . Till exempel är \\.\CONDOS-enhetssökvägen för CON.TXT , och DOS-enhetssökvägen för COM1.TXT\file1.txt är \\.\COM1. Eftersom detta inte längre gäller för Windows 11 anger du den fullständiga sökvägen till den äldre DOS-enheten, till exempel \\.\CON.

Tillämpa den aktuella katalogen

Om en sökväg inte är fullständigt kvalificerad tillämpar Windows den aktuella katalogen på den. Uncs och enhetssökvägar har inte den aktuella katalogen tillämpad. Inte heller en fullständig enhet med avgränsare C:\.

Om sökvägen börjar med en enskild komponentavgränsare tillämpas enheten från den aktuella katalogen. Om filsökvägen till exempel är \utilities och den aktuella katalogen är C:\temp\genererar C:\utilitiesnormaliseringen .

Om sökvägen börjar med en enhetsbeteckning, volymavgränsare och ingen komponentavgränsare tillämpas den senaste aktuella kataloguppsättningen från kommandogränssnittet för den angivna enheten. Om den senaste aktuella katalogen inte har angetts tillämpas enbart enheten. Om filsökvägen till exempel är D:sources, är C:\Documents\den aktuella katalogen , och den senaste aktuella katalogen på enhet D: var D:\sources\, är D:\sources\sourcesresultatet . Dessa "enhetsrelativa" sökvägar är en vanlig källa till program- och skriptlogikfel. Att anta att en sökväg som börjar med en bokstav och ett kolon inte är relativ är uppenbarligen inte korrekt.

Om sökvägen börjar med något annat än en avgränsare tillämpas den aktuella enheten och den aktuella katalogen. Om sökvägen till exempel är filecompare och den aktuella katalogen är C:\utilities\blir C:\utilities\filecompare\resultatet .

Viktigt!

Relativa sökvägar är farliga i flertrådade program (dvs. de flesta program) eftersom den aktuella katalogen är en inställning per process. Alla trådar kan när som helst ändra den aktuella katalogen. Från och med .NET Core 2.1 kan du anropa Path.GetFullPath(String, String) metoden för att hämta en absolut sökväg från en relativ sökväg och den bassökväg (den aktuella katalogen) som du vill matcha den mot.

Kanoniska avgränsare

Alla snedstreck (/) konverteras till Windows-standardavgränsaren, snedstrecket (\). Om de finns komprimeras en serie snedstreck som följer de två första snedstrecken till ett enda snedstreck.

Kommentar

Från och med .NET 8 på Unix-baserade operativsystem konverterar körningen inte längre snedstreckstecken (\) till katalogavgränsare (snedstreck /). Mer information finns i Omvänt snedstrecksmappning i Unix-filsökvägar.

Utvärdera relativa komponenter

När sökvägen bearbetas utvärderas alla komponenter eller segment som består av en enskild eller dubbel period (. eller ..) :

Under en enskild period tas det aktuella segmentet bort, eftersom det refererar till den aktuella katalogen.
För en dubbel period tas det aktuella segmentet och det överordnade segmentet bort, eftersom den dubbla perioden refererar till den överordnade katalogen.

Överordnade kataloger tas bara bort om de inte är förbi sökvägens rot. Sökvägens rot beror på typen av sökväg. Det är enheten (C:\) för DOS-sökvägar, servern/resursen för UNCs (\\Server\Share) och enhetssökvägsprefixet för enhetssökvägar (\\?\ eller \\.\).

Trimma tecken

Tillsammans med körningar av avgränsare och relativa segment som tagits bort tidigare tas några ytterligare tecken bort under normaliseringen:

Om ett segment slutar i en enskild period tas den perioden bort. (Ett segment av en enskild eller dubbel period normaliseras i föregående steg. Ett segment med tre eller flera perioder normaliseras inte och är faktiskt ett giltigt fil-/katalognamn.)
Om sökvägen inte slutar i en avgränsare tas alla avslutande punkter och blanksteg (U+0020) bort. Om det sista segmentet bara är en enda eller dubbel period faller det under regeln för relativa komponenter ovan.

Den här regeln innebär att du kan skapa ett katalognamn med ett avslutande blanksteg genom att lägga till en avslutande avgränsare efter utrymmet.

Viktigt!

Du bör aldrig skapa en katalog eller ett filnamn med ett avslutande utrymme. Avslutande blanksteg kan göra det svårt eller omöjligt att komma åt en katalog, och program misslyckas ofta vid försök att hantera kataloger eller filer vars namn inkluderar avslutande blanksteg.

Hoppa över normalisering

Normalt skickas alla sökvägar som skickas till ett Windows-API (i praktiken) till funktionen GetFullPathName och normaliseras. Det finns ett viktigt undantag: en enhetssökväg som börjar med ett frågetecken i stället för en punkt. Om sökvägen inte börjar exakt med \\?\ (observera användningen av det kanoniska omvänt snedstrecket) normaliseras den.

Varför skulle du vilja hoppa över normaliseringen? Det finns tre huvudsakliga orsaker:

För att få åtkomst till sökvägar som normalt inte är tillgängliga men som är lagliga. En fil eller katalog med namnet hidden., till exempel, är omöjlig att komma åt på något annat sätt.
För att förbättra prestanda genom att hoppa över normaliseringen om du redan har normaliserats.
Endast på .NET Framework hoppar du över MAX_PATH sökvägens längd för att tillåta sökvägar som är större än 259 tecken. De flesta API:er tillåter detta, med vissa undantag.

Kommentar

.NET Core och .NET 5+ hanterar långa sökvägar implicit och utför MAX_PATH ingen kontroll. Kontrollen MAX_PATH gäller endast för .NET Framework.

Att hoppa över normaliserings- och maxsökvägskontroller är den enda skillnaden mellan de två syntaxerna för enhetssökväg. de är i övrigt identiska. Var försiktig med att hoppa över normalisering, eftersom du enkelt kan skapa sökvägar som är svåra för "normala" program att hantera.

Sökvägar som börjar med \\?\ normaliseras fortfarande om du uttryckligen skickar dem till funktionen GetFullPathName.

Du kan skicka sökvägar med fler än MAX_PATH tecken till GetFullPathName utan \\?\. Den stöder godtyckliga längdsökvägar upp till den maximala strängstorlek som Windows kan hantera.

Case och Windows-filsystemet

En egenhet i Windows-filsystemet som användare och utvecklare som inte är Windows-användare och utvecklare tycker är förvirrande är att sökvägen och katalognamnen är skiftlägeskänsliga. Katalog- och filnamn återspeglar alltså höljet för de strängar som används när de skapas. Metoden anropar till exempel

Directory.Create("TeStDiReCtOrY");

Directory.Create("TeStDiReCtOrY")

skapar en katalog med namnet TeStDiReCtOrY. Om du byter namn på en katalog eller fil för att ändra dess skiftläge återspeglar katalog- eller filnamnet fallet med strängen som användes när du byter namn på den. Följande kod byter till exempel namn på en fil med namnet test.txt till 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

Katalog- och filnamnsjämförelser är dock skiftlägesokänsliga. Om du söker efter en fil med namnet "test.txt" ignorerar .NET-filsystemets API:er skiftläge i jämförelsen. "Test.txt", "TEST.TXT", "test.TXT" och alla andra kombinationer av versaler och gemener matchar "test.txt".

Dela via

Filsökvägsformat i Windows-system

Traditionella DOS-sökvägar

UNC-sökvägar

DOS-enhetssökvägar

Exempel: Sätt att referera till samma fil

Sökvägsnormalisering

Identifiera sökvägen

Hantera äldre enheter

Tillämpa den aktuella katalogen

Kanoniska avgränsare

Utvärdera relativa komponenter

Trimma tecken

Hoppa över normalisering

Case och Windows-filsystemet

Ytterligare resurser