Did you notice how Explorer in XP is intelligent enough to sort the files in a natural order?
If you have 10 files on your hard disk, they will show in this order:
However, if you try in under DOS, they will appear this way:
The reason for that is that DOS uses a simple alphabetical search.
The aim of this article is to show how I think Explorer does this better than DOS and provide to the CodeProject readers a class to reproduce this in their .NET programs.
The .NET framework uses the
IComparer interface a lot. This interface is very simple to implement; it contains a single member:
Public Function Compare(ByVal x As Object, ByVal y As Object) As Integer
int IComparer.Compare(object x, object y)
The function you must provide returns an integer which must be:
- less than zero when
x is less than
- zero when
- more than zero when
x is greater than
null reference (
Nothing in Visual Basic) with any reference type is allowed, and does not generate an exception. A
null reference is considered to be less than any reference that is not
Using the code
NaturalComparer can be used anywhere the .NET framework requires an
IComparer. That is about every operation which involves sorting data. The most common is probably
In the demo program, for example, I use:
Array.Sort(lines, New NaturalComparer())
This will sort the lines using the natural order I have briefly described above.
How does this work
NaturalComparer class uses a couple of
StringParser classes to compare each item.
StringParser is a pretty straightforward character parser. It eats the characters of the string, and returns through its member
NextToken a series of tokens. Each token is either numerical or string.
public void NextToken()
if (mCurChar == '\0')
mTokenType = NaturalComparer.TokenType.Nothing;
mStringValue = null;
else if (char.IsDigit(mCurChar))
mTokenType = NaturalComparer.TokenType.Numerical;
else if (char.IsLetter(mCurChar))
mTokenType = NaturalComparer.TokenType.String;
} while (true);
StringParser ignores the punctuations and spaces.
NaturalComparer has very little to do. It will get the first token from each string and compares their numerical values if both are numerical, if not compares the string values.
int System.Collections.Generic.IComparer<string>.Compare(string string1,
if (mParser1.TokenType == TokenType.Numerical &
mParser2.TokenType == TokenType.Numerical)
result = decimal.Compare(mParser1.NumericalValue, mParser2.NumericalValue);
result = string.Compare(mParser1.StringValue, mParser2.StringValue);
if (result != 0) return result;
} while (!(mParser1.TokenType == TokenType.Nothing &
mParser2.TokenType == TokenType.Nothing));
return 0; }
Points of interest
As an option, you can ask the
NaturalComparer to detect and parse Roman numerals.
The problem is that sometimes the comparer could mix a valid English name for a Roman number. This is okay if the other side of the comparison is a string, but it can mess your sort order if the other side is a number or another false Roman numeral positive.
So, use this option if you believe the likelihood of having Roman numerals is worth messing the order.
- 2008 Jan 17: First release.