Windows sistemlerinde dosya yolu biçimleri

Ad alanı içinde türlerin birçoğu üyeleri, bir dosya sistemi kaynağı için mutlak veya göreli bir System.IO path yol belirtmenize olanak sağlayan bir parametre içerir. Bu yol daha sonra dosya Windows API'lere geçirildi. Bu konu, sistemlerde kullanabileceğiniz dosya yollarının biçimlerini Windows ele almaktadır.

Geleneksel DOS yolları

Standart bir DOS yolu üç bileşenden oluşur:

• Bir birim veya sürücü harfi ve ardından birim ayırıcısı ( : ).
• Dizin adı. Dizin ayırıcı karakteri, iç içe geçmiş dizin hiyerarşisi içindeki alt dizinleri ayırır.
• İsteğe bağlı bir dosya adı. Dizin ayırıcı karakteri, dosya yolunu ve dosya adını ayırır.

Üç bileşenin de mevcut olduğu yol mutlaktır. Hiçbir birim veya sürücü harfi belirtilmezse ve dizin adı dizin ayırıcı karakteriyle başlıyorsa, yol geçerli sürücünün kökünden görelidir. Aksi takdirde, yol geçerli dizine göredir. Aşağıdaki tabloda bazı olası dizin ve dosya yolları gösterir.

yöntemini çağırarak bir dosya yolunun tam olup olmadığını (yani yol, geçerli dizinden bağımsızdır ve geçerli dizin değiştiklerde değişmez) Path.IsPathFullyQualified belirlersiniz. Bu tür bir yolun göreli dizin kesimleri ( ve ) içerebilir ve çözümlenen yol her zaman aynı konuma yol alıyorsa hala tam . .. olarak nitelenmiş olabilir.

Aşağıdaki örnek, mutlak ve göreli yollar arasındaki farkı göstermektedir. Dizinin mevcut olduğunu ve örneği çalıştırmadan önce komut isteminden için geçerli D:\FY2018\ D:\ bir dizin ayarlamamanız varsayılacaktır.

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

Ingilizce dışındaki dillere çevrilmiş kod açıklamalarını görmek isterseniz, Bu GitHub tartışma sorununubize tanıyın.

UNC yolları

Ağ kaynaklarına erişmek için kullanılan evrensel adlandırma kuralı (UNC) yolları aşağıdaki biçime sahip olur:

• Başında olan bir sunucu veya ana bilgisayar \\ adı. Sunucu adı bir NetBIOS makine adı veya BIR IP/FQDN adresi olabilir (IPv4 ve v6 de desteklemiştir).
• Ana bilgisayar adı ile ayrılmış bir paylaşım \ adı. Sunucu ve paylaşım adı birlikte birimini gösterir.
• Dizin adı. Dizin ayırıcı karakteri, iç içe geçmiş dizin hiyerarşisi içindeki alt dizinleri ayırır.
• İsteğe bağlı bir dosya adı. Dizin ayırıcı karakteri, dosya yolunu ve dosya adını ayırır.

Unc yollarının bazı örnekleri aşağıda verilmiştir:

UNC yollarının her zaman tam olması gerekir. Göreli dizin kesimlerini ( ve ) . .. içerebilir, ancak bunlar tam yolun parçası olmalıdır. Göreli yolları yalnızca bir UNC yolunu bir sürücü harfiyle eşlerken kullanabilirsiniz.

DOS cihaz yolları

İşletim Windows sistemi, dosyalar da dahil olmak üzere tüm kaynakları gösteren birleşik bir nesne modeline sahiptir. Bu nesne yollarına konsol penceresinden erişilebilir ve eski DOS ve UNC yollarının eşlenmiş olduğu özel bir sembolik bağlantılar klasörü aracılığıyla Win32 katmanına gösterilir. Bu özel klasöre, şu dosyalardan biri olan DOS cihaz yolu söz dizimi aracılığıyla erişilir:

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

Bir sürücüyü sürücü harfiyle tanımlamaya ek olarak birim GUID'sini kullanarak da bir birimi tanımlayabilirsiniz. Bu, şu biçimi alır:

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

DOS cihaz yolu aşağıdaki bileşenlerden oluşur:

• Yolu BIR DOS cihaz yolu olarak tanımlayan cihaz \\.\ yolu belirleyicisi ( \\?\ veya ).

  Not

  , .NET Core ve .NET 5+ sürümlerinin tüm sürümlerinde ve \\?\ 4.6.2 sürümünden .NET Framework sürümünde de kullanılabilir.

• Birim GUID'i söz konusu olduğu için "gerçek" cihaz nesnesine sembolik bir bağlantı (C: sürücü adı söz konusu veya Birim{b75e2c83-0000-0000-0000-602f00000000} ).

  Cihaz yolu belirleyicisi birimi veya sürücüyü tanımdikten sonra DOS cihaz yolunun ilk segmenti. (Örneğin, \\?\C:\ ve \\.\BootPartition\ .)

  UNC'ler için şaşırtıcı bir şekilde değil, olarak adlandırılan belirli bir bağlantı UNC var. Örnek:

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

  Cihaz UNC'leri için sunucu/paylaşım bölümü birimi oluşturur. Örneğin, içinde \\?\server1\e:\utilities\\filecomparer\ sunucu/paylaşım bölümü server1\utilities olur. Bu durum, göreli dizin kesimleri gibi bir yöntem çağrılırken Path.GetFullPath(String, String) önemlidir; birimin gerisine gitmek hiçbir zaman mümkün değildir.

DOS cihaz yolları tanım gereği tam niteliklidir. Göreli dizin segmentlerine ( . .. ve ) izin verilmez. Geçerli dizinler hiçbir zaman kullanımlarına girmez.

Örnek: Aynı dosyaya başvurmak için yollar

Aşağıdaki örnek, ad alanı içinde API'leri kullanırken bir dosyaya başvurabilirsiniz bazı yolları System.IO göstermektedir. Örnek, bir nesnesinin örneğini oluşturur ve dosya adını ve dosya uzunluğunu FileInfo görüntülemek için ve özelliklerini Name Length kullanır.

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

Yol normalleştirme

Api'lere geçirilen Windows yolların neredeyse hepsi normalleştirilmiştir. Normalleştirme sırasında Windows aşağıdaki adımları gerçekleştirir:

• Yolu tanımlar.
• Geçerli dizini kısmen niteli (göreli) yollara uygular.
• Canonicalizes component and directory separators.
• Göreli dizin bileşenlerini . (geçerli dizin ve üst .. dizin için) değerlendirir.
• Belirli karakterleri kırpıyor.

Bu normalleştirme örtük olarak gerçekleşir, ancak Path.GetFullPath getFullPathName()işlevine bir çağrı sarmalama yöntemini çağırarak bunu açıkça yapabiliriz. P/Invoke kullanarak Windows GetFullPathName() işlevini de çağırabilirsiniz.

Yolu tanımlama

Yol normalleştirmenin ilk adımı, yol türünü tanımlamaktır. Yollar birkaç kategoriye ayrılır:

• Bunlar cihaz yollarıdır; Diğer bir ifadeyle başlarlar: İki ayırıcı ve bir soru işareti veya nokta ( veya \\? \\. ).
• Bunlar UNC yollarıdır; Diğer bir ifadeyle, soru işareti veya nokta olmadan iki ayırıcı ile başlarlar.
• Bunlar tam DOS yollarıdır; Diğer bir ifadeyle başlarlar; sürücü harfi, birim ayırıcısı ve bileşen ayırıcısı C:\ ( ).
• Eski bir cihaz ( CON , ) LPT1 gösterir.
• Bunlar geçerli sürücünün köküne göredir; Diğer bir ifadeyle, tek bir bileşen ayırıcısı () ile \ başlarlar.
• Bunlar, belirtilen sürücünün geçerli dizinine göredir; Diğer bir ifadeyle başlarlar; sürücü harfi, birim ayırıcısı ve bileşen ayırıcısı () C: yoktur.
• Bunlar geçerli dizine göredir; diğer bir ifadeyle başlarlar ( temp\testfile.txt ).

Yolun türü, geçerli bir dizinin bir şekilde uygulanıp uygulanmay olmadığını belirler. Ayrıca yolun "kök" ifadesini de belirler.

Eski cihazları işleme

Yol , veya gibi eski bir DOS cihazı ise, ön uç tarafından bir cihaz yoluna dönüştürülür CON COM1 ve LPT1 \\.\ döndürülür.

Eski cihaz adıyla başlayan bir yol her zaman yöntemi tarafından eski cihaz olarak Path.GetFullPath(String) yorumlanır. Örneğin, için DOS cihaz yolu CON.TXT \\.\CON ve için DOS cihaz yolu COM1.TXT\file1.txt \\.\COM1 .

Geçerli dizini Uygula

bir yol tam olarak nitelenmemişse Windows geçerli dizini ona uygular. UNCs ve cihaz yollarına geçerli dizin uygulanmaz. Ayırıcı ile tam bir sürücü yapmaz C:\ .

Yol tek bir bileşen ayırıcısıyla başlıyorsa, geçerli dizindeki sürücü uygulanır. Örneğin, dosya yolu \utilities ve geçerli dizin ise, C:\temp\ normalleştirme üretir C:\utilities .

Yol bir sürücü harfi, birim ayırıcısı ve bileşen ayırıcısı ile başlıyorsa, belirtilen sürücü için komut kabuğundan ayarlanan son geçerli dizin uygulanır. Son geçerli dizin ayarlanmamışsa, tek başına sürücü uygulanır. Örneğin, dosya yolu, D:sources geçerli dizin C:\Documents\ ve D: sürücüsündeki son geçerli dizin ise, D:\sources\ sonuç olur D:\sources\sources . Bu "sürücü göreli" yolları, yaygın olarak kullanılan bir program ve betik mantığı hataları kaynağıdır. Bir harf ile başlayan bir yolun ve iki nokta üst üste doğru olmadığını varsayarsak

Yol, ayırıcı dışında bir şeyle başlıyorsa, geçerli sürücü ve geçerli dizin uygulanır. Örneğin, yol filecompare ve geçerli dizin ise, C:\utilities\ sonuç olur C:\utilities\filecompare\ .

Canonicalize ayırıcılar

tüm eğik çizgiler ( / ), ters eğik çizgi () ile standart Windows ayırıcıya dönüştürülür \ . Varsa, ilk iki eğik çizgiyi izleyen eğik çizgi serileri tek eğik çizgi olarak daraltılır.

Göreli bileşenleri değerlendir

Yol işlendiğinde, tek veya çift nokta (veya) tarafından oluşturulan bileşenler veya segmentler . .. değerlendirilir:

• Tek bir dönem için geçerli kesim, geçerli dizine başvurduğundan kaldırılır.

• Çift dönem için, çift nokta üst dizine başvurduğundan, geçerli segment ve üst kesim kaldırılır.

  Üst dizinler yalnızca yolun kökünü geçmemişse kaldırılır. Yolun kökü, yol türüne bağlıdır. DOS yolları için sürücü ( C:\ ), UNCs için sunucu/paylaşma ( \\Server\Share ) ve cihaz yolları için cihaz yolu ön eki ( \\?\ veya \\.\ ).

Kırpma karakterleri

Daha önce kaldırılan ayırıcıların ve göreli parçaların çalıştırılmalarının yanı sıra, normalleştirme sırasında bazı ek karakterler kaldırılır:

• Bir segment tek bir dönemde sona ererse bu süre kaldırılır. (Tek veya çift dönemin bir segmenti, önceki adımda normalleştirilmelidir. Üç veya daha fazla dönemin bir segmenti normalleştirilmez ve aslında geçerli bir dosya/dizin adıdır.)

• Yol bir ayırıcıda sonlanmazsa, tüm sondaki noktalar ve boşluklar (U + 0020) kaldırılır. Son segment yalnızca tek veya çift bir nokta ise, yukarıdaki ilgili bileşenler kuralının altına girer.

  Bu kural, boşluktan sonra sondaki bir ayırıcı ekleyerek sonunda boşluk olan bir dizin adı oluşturabileceğiniz anlamına gelir.

  Önemli

  Sonunda boşluk olan bir dizin veya dosya adı oluşturmanız gerekir . Sondaki boşluklar, bir dizine erişmek zor veya olanaksız hale gelir ve uygulamalar genellikle boşluklar içeren dizinleri veya dosyaları işlemeye çalışırken başarısız olur.

Normalleştirme atlayın

normalde, bir Windows apı 'sine geçirilen tüm yol, getfullpathname işlevine ve normalleştirilmesine geçirilir. Önemli bir özel durum vardır: bir dönem yerine soru işaretiyle başlayan bir cihaz yolu. Yol tam olarak ile başlatılmadığı takdirde \\?\ (kurallı ters eğik çizginin kullanımını aklınızda), normalleştirilmelidir.

Neden normalleştirmeyi atlamak istiyorsunuz? Üç önemli neden vardır:

1. Normalde kullanılamayan ancak geçerli olan yollara erişim sağlamak için. Örneğin, adlı bir dosya veya dizin, hidden. başka bir şekilde erişim imkansızdır.

2. Zaten normalleştirdiyseniz normalleştirmeyi atlayarak performansı artırmak için.

3. yalnızca .NET Framework, MAX_PATH 259 karakterden büyük yollara izin vermek için yol uzunluğu denetimini atlamak için. Çoğu API, bazı özel durumlarla birlikte buna izin verir.

Normalleştirme atlama ve en yüksek yol denetimleri, iki cihaz yolu sözdizimleri arasındaki tek farktır; Aksi halde özdeş. "Normal" uygulamalar için zor olan yolları kolayca oluşturabildiklerinden, normalleştirmeyi atlama konusunda dikkatli olun.

Öğesini \\?\ GetFullPathName işlevineaçıkça geçirirseniz, ile başlayan yollar yine de normalleştirilmelidir.

Karakterden daha fazla karakter yolunu, MAX_PATH olmadan GetFullPathName 'e geçirebilirsiniz \\?\ . Windows işleyebileceği en büyük dize boyutuna kadar rastgele uzunluk yollarını destekler.

büyük/küçük harf ve Windows dosya sistemi

Windows dosya sisteminin, Windows olmayan kullanıcıların ve geliştiricilerin kafa karıştırıcı olduğunu fark eden, yol ve dizin adlarının büyük/küçük harfe duyarlı olduğunu belirtir. Diğer bir deyişle, dizin ve dosya adları, oluşturulduklarında kullanılan dizelerin büyük küçük harflerini yansıtır. Örneğin, yöntem çağrısı

Directory.Create("TeStDiReCtOrY");

Directory.Create("TeStDiReCtOrY")

TeStDiReCtOrY adlı bir dizin oluşturur. Bir dizini veya dosyayı durumunu değiştirmek için yeniden adlandırırsanız, dizin veya dosya adı, yeniden adlandırdığınızda kullanılan dize durumunu yansıtır. Örneğin, aşağıdaki kod, Test.txt test.txt adlı bir dosyayı yeniden adlandırır:

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

Bununla birlikte, dizin ve dosya adı karşılaştırmaları büyük/küçük harfe duyarlıdır. "test.txt" adlı bir dosyayı arıyorsanız, .NET dosya sistemi API 'Leri karşılaştırmayla ilgili büyük/küçük harf durumunu yoksayar. "Test.txt", "TEST.TXT", "test.TXT" ve büyük ve küçük harflerin diğer birleşimi "test.txt" ile eşleşir.