Windows sistemlerinde dosya yolu biçimleri

Ad alanı içindeki System.IO türlerin birçoğunun üyeleri, bir path dosya sistemi kaynağının mutlak veya göreli yolunu belirtmenize olanak tanıyan bir parametre içerir. Bu yol daha sonra Windows dosya sistemi API'lerine geçirilir. Bu konuda, Windows sistemlerinde kullanabileceğiniz dosya yollarının biçimleri açıklanmaktadır.

Geleneksel DOS yolları

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

• Birim veya sürücü harfi ve ardından birim ayırıcısı (: ).
• Dizin adı. Dizin ayırıcı karakteri , iç içe 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şen de varsa, yol mutlaktır. 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österilmektedir.

Yöntemini çağırarak Path.IsPathFullyQualified bir dosya yolunun tam olarak nitelenip nitelenmediğini (yani, yolun geçerli dizinden bağımsız olup olmadığını ve geçerli dizin değiştiğinde değişmediğini) belirleyebilirsiniz. Bu tür bir yolun göreli dizin kesimlerini (. ve ) içerebileceğini ve ..çözümlenen yol her zaman aynı konumu işaret ediyorsa tam olarak nitelenebilir.

Aşağıdaki örnekte mutlak ve göreli yollar arasındaki fark gösterilmektedir. Dizinin D:\FY2018\ mevcut olduğu ve örneği çalıştırmadan önce komut isteminden için D:\ herhangi bir geçerli dizin ayarlamadığınız varsayılır.

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 yolları

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

• tarafından önceden oluşturulmuş \\bir sunucu veya ana bilgisayar adı. Sunucu adı bir NetBIOS makine adı veya IP/FQDN adresi olabilir (IPv4 ve v6 desteklenir).
• Ana bilgisayar adından ile \ayrılmış bir paylaşım adı. Birlikte, sunucu ve paylaşım adı birimi oluşturur.
• Dizin adı. Dizin ayırıcı karakteri , iç içe 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ına bazı örnekler aşağıda verilmiştir:

UNC yolları her zaman tam olmalıdır. Göreli dizin kesimlerini (. ve ..) içerebilirler, ancak bunlar tam yolun parçası olmalıdır. Göreli yolları yalnızca unc yolunu bir sürücü harfine eşleyerek kullanabilirsiniz.

DOS cihaz yolları

Windows işletim sistemi, dosyalar da dahil olmak üzere tüm kaynakları işaret eden birleşik bir nesne modeline sahiptir. Bu nesne yollarına konsol penceresinden erişilebilir ve eski DOS ve UNC yollarının eşlendiği özel bir sembolik bağlantı klasörü aracılığıyla Win32 katmanına sunulur. Bu özel klasöre AŞAĞıDAKIlerden 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ımlamanın yanı sıra 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 DOS cihaz yolu olarak tanımlayan cihaz yolu tanımlayıcısı (\\.\ veya \\?\).

  Not

  \\?\, .NET Core ve .NET 5+ sürümlerinin tüm sürümlerinde ve 4.6.2 sürümünden itibaren .NET Framework'te desteklenir.

• "Gerçek" cihaz nesnesine sembolik bağlantı (C: sürücü adı söz konusu olduğunda veya birim GUID'si söz konusu olduğunda Volume{b75e2c83-0000-0000-0000-602f00000000} ).

  DoS cihaz yolunun, cihaz yolu tanımlayıcısı birimi veya sürücüyü tanımladıktan sonraki ilk kesimi. (Örneğin, \\?\C:\ ve \\.\BootPartition\.)

  UNC'ler için şaşırtıcı değil UNColarak adlandırılan belirli bir bağlantı vardır. Örneğin:

  \\.\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\utilities\\filecomparer\sunucu/paylaşım bölümü şeklindedir server1\utilities. Göreli dizin kesimleri gibi Path.GetFullPath(String, String) bir yöntemi çağırırken bu önemlidir; birimden geçmek asla mümkün değildir.

DOS cihaz yolları tanım gereği tam olarak nitelenir ve göreli dizin kesimiyle (. veya ..) başlayamaz. Geçerli dizinler kullanımlarına hiçbir zaman girmez.

Örnek: Aynı dosyaya başvurmanın yolları

Aşağıdaki örnekte, ad alanında API'leri System.IO kullanırken bir dosyaya başvurmanın bazı yolları gösterilmektedir. Örnek bir FileInfo nesnenin örneğini oluşturur ve dosya adını ve dosyanın uzunluğunu görüntülemek için ve Length özelliklerini kullanırName.

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

Yol normalleştirme

Windows API'lerine geçirilen neredeyse tüm yollar normalleştirilir. Normalleştirme sırasında Windows aşağıdaki adımları gerçekleştirir:

• Yolu tanımlar.
• Geçerli dizini kısmen nitelenmiş (göreli) yollara uygular.
• Bileşen ve dizin ayırıcılarını kurallı hale getirme.
• 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 getFullPathName() işlevine bir çağrı sarmalayan yöntemini çağırarak Path.GetFullPath bunu açıkça yapabilirsiniz. Windows GetFullPathName() işlevini doğrudan P/Invoke kullanarak da çağırabilirsiniz.

Yolu tanımlama

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

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

Yolun türü, geçerli bir dizinin bir şekilde uygulanıp uygulanmayacağını belirler. Ayrıca yolun "kökünün" ne olduğunu da belirler.

Eski cihazları işleme

Yol , COM1veya LPT1gibi CONeski bir DOS cihazıysa, önceden bağlama \\.\ yoluyla bir cihaz yoluna dönüştürülür ve döndürülür.

Windows 11'in öncesinde, eski cihaz adıyla başlayan bir yol her zaman yöntemiyle Path.GetFullPath(String) eski bir cihaz olarak yorumlanır. Örneğin, için CON.TXT DOS cihaz yolu , \\.\CONiçin DOS cihaz yolu COM1.TXT\file1.txt ise şeklindedir \\.\COM1. Bu artık Windows 11 için geçerli olmadığından, gibi \\.\CONeski DOS cihazının tam yolunu belirtin.

Geçerli dizini uygulama

Bir yol tam olarak nitelenmemişse, Windows geçerli dizini buna uygular. UNC'lerde ve cihaz yollarında geçerli dizin uygulanmaz. Ayırıcısı C:\olan tam sürücü de yoktur.

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ı ile başlıyorsa ve bileşen ayırıcısı yoksa, belirtilen sürücü için komut kabuğundan ayarlanan son geçerli dizin uygulanır. Son geçerli dizin ayarlanmadıysa, tek başına sürücü uygulanır. Örneğin, dosya yolu D:sourcesise geçerli dizin olur C:\Documents\ve D: D:\sources\sürücüsündeki son geçerli dizin olur, sonuç olur D:\sources\sources. Bu "sürücü göreli" yolları, ortak bir program ve betik mantığı hataları kaynağıdır. Harf ve iki nokta üst üste ile başlayan bir yolun göreli olmadığını varsayarsak, açıkça doğru değildir.

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\.

Kurallı ayırıcılar

Tüm eğik çizgiler (/) standart Windows ayırıcısına( ters eğik çizgiye (\ ) dönüştürülür. Varsa, ilk iki eğik çizgiyi izleyen bir dizi eğik çizgi tek bir eğik çizgiye daraltılır.

Göreli bileşenleri değerlendirme

Yol işlenirken, tek veya çift bir dönemden (. veya ) oluşan tüm bileşenler veya ..segmentler değerlendirilir:

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

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

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

Karakterleri kırpma

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

• Bir segment tek bir dönemde biterse, bu dönem kaldırılır. (Önceki adımda tek veya çift dönemli bir kesim normalleştirilir. Üç veya daha fazla dönemlik bir kesim normalleştirilmemiştir ve aslında geçerli bir dosya/dizin adıdır.)

• Yol bir ayırıcıyla bitmezse, sondaki tüm nokta ve boşluklar (U+0020) kaldırılır. Son segment yalnızca tek veya çift dönemse, yukarıdaki göreli bileşenler kuralına girer.

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

  Önemli

  Hiçbir zaman sonunda boşluk olan bir dizin veya dosya adı oluşturmamalısınız. Sondaki boşluklar bir dizine erişimi zorlaştırabilir veya imkansız hale getirir ve adları sondaki boşlukları içeren dizinleri veya dosyaları işlemeye çalışırken uygulamalar genellikle başarısız olur.

Normalleştirmeyi atla

Normalde, Bir Windows API'sine geçirilen tüm yollar (etkili bir şekilde) GetFullPathName işlevine geçirilir ve normalleştirilir. Önemli bir istisna vardır: nokta yerine soru işaretiyle başlayan cihaz yolu. Yol tam olarak ile \\?\ başlamadığı sürece (kurallı ters eğik çizgi kullanımına dikkat edin), normalleştirilir.

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

1. Normalde kullanılamayan ancak yasal olan yollara erişim elde etmek için. Örneğin, adlı hidden.bir dosyaya veya dizine başka bir şekilde erişmek mümkün değildir.

2. Zaten normalleştirdiyseniz normalleştirmeyi atlayarak performansı geliştirmek için.

3. Yalnızca .NET Framework'te, 259 karakterden büyük yollara izin vermek üzere yol uzunluğunu denetlemeyi atlamak MAX_PATH için. Çoğu API, bazı özel durumlar dışında buna izin verir.

normalleştirme ve maksimum yol denetimlerinin atlanması, iki cihaz yolu söz dizimi arasındaki tek farktır; aksi takdirde aynı olur. Normalleştirmeyi atlarken dikkatli olun, çünkü "normal" uygulamaların ilgilenmesi zor olan yolları kolayca oluşturabilirsiniz.

Ile \\?\ başlayan yollar, bunları GetFullPathName işlevine açıkça geçirirseniz yine de normalleştirilir.

Olmadan \\?\GetFullPathName'e birden fazla karakterden oluşan MAX_PATH yollar geçirebilirsiniz. Windows'un işleyebileceği en büyük dize boyutuna kadar rastgele uzunluk yollarını destekler.

Servis talebi ve Windows dosya sistemi

Windows olmayan kullanıcıların ve geliştiricilerin kafa karıştırıcı bulduğu Windows dosya sisteminin bir özelliği, yol ve dizin adlarının büyük/küçük harfe duyarsız olmasıdır. Diğer bir ifadeyle, dizin ve dosya adları oluşturulurken 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ı büyük/küçük harflerini değiştirmek için yeniden adlandırırsanız, dizin veya dosya adı, yeniden adlandırdığınızda kullanılan dizenin durumunu yansıtır. Örneğin, aşağıdaki kod test.txt adlı dosyayı Test.txt olarak yeniden adlandırır:

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

Ancak, dizin ve dosya adı karşılaştırmaları büyük/küçük harfe duyarlı değildir. "test.txt" adlı bir dosya ararsanız, .NET dosya sistemi API'leri karşılaştırmada büyük/küçük harf durumunu yoksayar. "Test.txt", "TEST.TXT", "test.TXT" ve büyük ve küçük harflerin diğer bileşimleri "test.txt" ile eşleşir.