Here's a reproduction of a post I made many years ago:
People often ask how to sort alphanumeric
Strings logically. It is usually, although not exclusively, in the context of sorting file names. That's because Windows File Explorer does just that. As an example, Windows File Explorer would sort the following file names in the following order:
File1Test.txt
File2Test.txt
File3Test.txt
File4Test.txt
File5Test.txt
File10Test.txt
File20Test.txt
File30Test.txt
File40Test.txt
File50Test.txt
whereas a standard
String sort would yield the following order:
File1Test.txt
File10Test.txt
File2Test.txt
File20Test.txt
File3Test.txt
File30Test.txt
File4Test.txt
File40Test.txt
File5Test.txt
File50Test.txt
Windows File Explorer achieves this by using
the StrCmpLogicalW API function and you can do the same. The first step is to use Platform Invoke to declare this function in your .NET code so that you can invoke the unmanaged function:
Imports System.Runtime.InteropServices
Public Module NativeMethods
<DllImport("shlwapi.dll", CharSet:=CharSet.Unicode)>
Public Function StrCmpLogicalW(x As String, y As String) As Integer
End Function
End Module
Sorting is done in various specific ways but they all come down to comparing pairs of values and swapping them if required. You can provide the code to perform those comparisons yourself and use the API function above:
Public Class LogicalStringComparer
Implements IComparer, IComparer(Of String)
Private Function Compare(x As Object, y As Object) As Integer Implements IComparer.Compare
Return Compare(CStr(x), CStr(y))
End Function
Public Function Compare(x As String, y As String) As Integer Implements IComparer(Of String).Compare
Return NativeMethods.StrCmpLogicalW(x, y)
End Function
End Class
That class follows the convention of implementing both when there is a generic and non-generic version of an interface. As is done above, you should declare the non-generic method
Private and have it call the generic method. That way, those who use the class directly will only have access to the generic method but code that uses a reference of the non-generic interface type will still have access to the non-generic method. More on that later. Note that you may prefer to declare the API function inside that class if that's the only place you plan to use it:
Imports System.Runtime.InteropServices
Public Class LogicalStringComparer
Implements IComparer, IComparer(Of String)
<DllImport("shlwapi.dll", CharSet:=CharSet.Unicode)>
Private Shared Function StrCmpLogicalW(x As String, y As String) As Integer
End Function
Private Function Compare(x As Object, y As Object) As Integer Implements IComparer.Compare
Return Compare(CStr(x), CStr(y))
End Function
Public Function Compare(x As String, y As String) As Integer Implements IComparer(Of String).Compare
Return StrCmpLogicalW(x, y)
End Function
End Class
You can then use that class to perform the comparisons wherever an
IComparer or
IComparer(Of String) is expected. Here is some example code that uses it to sort a
String array, an
ArrayList, a
List(Of String) and a LINQ query producing an
IEnumerable(Of String):
Module Module1
Sub Main()
Dim fileNames = {"File1Test.txt",
"File2Test.txt",
"File3Test.txt",
"File4Test.txt",
"File5Test.txt",
"File10Test.txt",
"File20Test.txt",
"File30Test.txt",
"File40Test.txt",
"File50Test.txt"}
Dim rng As New Random
SortArray(fileNames.OrderBy(Function(s) rng.NextDouble()).ToArray())
SortArrayList(New ArrayList(fileNames.OrderBy(Function(s) rng.NextDouble()).ToArray()))
SortList(New List(Of String)(fileNames.OrderBy(Function(s) rng.NextDouble())))
SortQuery(fileNames.OrderBy(Function(s) rng.NextDouble()).ToArray())
Console.ReadLine()
End Sub
Private Sub SortArray(arr As String())
Console.WriteLine("Array before:")
For Each s In arr
Console.WriteLine(s)
Next
Console.WriteLine()
Array.Sort(arr, New LogicalStringComparer)
Console.WriteLine("Array after:")
For Each s In arr
Console.WriteLine(s)
Next
Console.WriteLine()
End Sub
Private Sub SortArrayList(al As ArrayList)
Console.WriteLine("ArrayList before:")
For Each s In al
Console.WriteLine(s)
Next
Console.WriteLine()
al.Sort(New LogicalStringComparer)
Console.WriteLine("ArrayList after:")
For Each s In al
Console.WriteLine(s)
Next
Console.WriteLine()
End Sub
Private Sub SortList(lst As List(Of String))
Console.WriteLine("List before:")
For Each s In lst
Console.WriteLine(s)
Next
Console.WriteLine()
lst.Sort(New LogicalStringComparer)
Console.WriteLine("List after:")
For Each s In lst
Console.WriteLine(s)
Next
Console.WriteLine()
End Sub
Private Sub SortQuery(arr As String())
Console.WriteLine("Query before:")
For Each s In arr
Console.WriteLine(s)
Next
Console.WriteLine()
Dim qry = arr.OrderBy(Function(s) s, New LogicalStringComparer)
Console.WriteLine("Query after:")
For Each s In qry
Console.WriteLine(s)
Next
Console.WriteLine()
End Sub
End Module
I've included the
ArrayList because it demonstrates that, even though the method that implements
IComparer.Compare is
Private, it is still accessible where a reference of type
IComparer is used. The parameter of the
ArrayList.Sort method is type
IComparer so, inside that method, it is actually that
Private overload of
LogicalStringComparer.Compare that is being invoked.
Note that the LINQ
OrderBy method that accepts an
IComparer(Of T) as an argument also requires you to specify a selector for the sort key of type
T. In the example above, we're sorting
Strings so the key is the item itself. In other cases, the sort key might be a property of the item, e.g. the
Name property of a
FileInfo object:
Dim folder As New DirectoryInfo(My.Computer.FileSystem.SpecialDirectories.MyDocuments)
Dim files = folder.EnumerateFiles("*.*", SearchOption.AllDirectories).
OrderBy(Function(fi) fi.Name,
New LogicalStringComparer).
ToArray()
