Compare Version Identifiers

Question

Here is my code, which takes two version identifiers in the form "1, 5, 0, 4" or "1.5.0.4" and determines which is the newer version.

Suggestions or improvements, please!

    /// <summary>
    /// Compares two specified version strings and returns an integer that 
    /// indicates their relationship to one another in the sort order.
    /// </summary>
    /// <param name="strA">the first version</param>
    /// <param name="strB">the second version</param>
    /// <returns>less than zero if strA is less than strB, equal to zero if
    /// strA equals strB, and greater than zero if strA is greater than strB</returns>
    public static int CompareVersions(string strA, string strB)
    {
        char[] splitTokens = new char[] {'.', ','};
        string[] strAsplit = strA.Split(splitTokens, StringSplitOptions.RemoveEmptyEntries);
        string[] strBsplit = strB.Split(splitTokens, StringSplitOptions.RemoveEmptyEntries);
        int[] versionA = new int[4];
        int[] versionB = new int[4];

        for (int i = 0; i < 4; i++)
        {
            versionA[i] = Convert.ToInt32(strAsplit[i]);
            versionB[i] = Convert.ToInt32(strBsplit[i]);
        }

        // now that we have parsed the input strings, compare them
        return RecursiveCompareArrays(versionA, versionB, 0);
    }

    /// <summary>
    /// Recursive function for comparing arrays, 0-index is highest priority
    /// </summary>
    private static int RecursiveCompareArrays(int[] versionA, int[] versionB, int idx)
    {
        if (versionA[idx] < versionB[idx])
            return -1;
        else if (versionA[idx] > versionB[idx])
            return 1;
        else
        {
            Debug.Assert(versionA[idx] == versionB[idx]);
            if (idx == versionA.Length - 1)
                return 0;
            else
                return RecursiveCompareArrays(versionA, versionB, idx + 1);
        }
    }

Answer 1

Well, since you only have a four element array you may just want ot unroll the recursion to save time. Passing arrays as arguments will eat up memory and leave a mess for the GC to clean up later.

Answer 2

Use the Version class.

Version a = new Version("1.0.0.0");
Version b = new Version("2.0.0.0");

Console.WriteLine(string.Format("Newer: {0}", (a > b) ? "a" : "b"));
// prints b

Answer 3

If you can assume that each place in the version string will only be one number (or at least the last 3, you can just remove the commas or periods and compare...which would be a lot faster...not as robust, but you don't always need that.

public static int CompareVersions(string strA, string strB)
{
    char[] splitTokens = new char[] {'.', ','};
    string[] strAsplit = strA.Split(splitTokens, StringSplitOptions.RemoveEmptyEntries);
    string[] strBsplit = strB.Split(splitTokens, StringSplitOptions.RemoveEmptyEntries);
    int versionA = 0;
    int versionB = 0;
    string vA = string.Empty;
    string vB = string.Empty;

    for (int i = 0; i < 4; i++)
    {
        vA += strAsplit[i];
        vB += strBsplit[i];
        versionA[i] = Convert.ToInt32(strAsplit[i]);
        versionB[i] = Convert.ToInt32(strBsplit[i]);
    }

    versionA = Convert.ToInt32(vA);
    versionB = Convert.ToInt32(vB);

    if(vA > vB)
       return 1;
    else if(vA < vB)
       return -1;
    else
       return 0;  //they are equal
}

And yes, I'm also assuming 4 version places here...

Answer 4

@ Darren Kopp:

The version class does not handle versions of the format 1.0.0.5.

Answer 5

The System.Version class does not support versions with commas in it, so the solution presented by Darren Kopp is not sufficient.

Here is a version that is as simple as possible (but no simpler).

It uses System.Version but achieves compatibility with version numbers like "1, 2, 3, 4" by doing a search-replace before comparing.

    /// <summary>
    /// Compare versions of form "1,2,3,4" or "1.2.3.4". Throws FormatException
    /// in case of invalid version.
    /// </summary>
    /// <param name="strA">the first version</param>
    /// <param name="strB">the second version</param>
    /// <returns>less than zero if strA is less than strB, equal to zero if
    /// strA equals strB, and greater than zero if strA is greater than strB</returns>
    public static int CompareVersions(String strA, String strB)
    {
        Version vA = new Version(strA.Replace(",", "."));
        Version vB = new Version(strB.Replace(",", "."));

        return vA.CompareTo(vB);
    }

The code has been tested with:

    static void Main(string[] args)
    {
        Test("1.0.0.0", "1.0.0.1", -1);
        Test("1.0.0.1", "1.0.0.0", 1);
        Test("1.0.0.0", "1.0.0.0", 0);
        Test("1, 0.0.0", "1.0.0.0", 0);
        Test("9, 5, 1, 44", "3.4.5.6", 1);
        Test("1, 5, 1, 44", "3.4.5.6", -1);
        Test("6,5,4,3", "6.5.4.3", 0);

        try
        {
            CompareVersions("2, 3, 4 - 4", "1,2,3,4");
            Console.WriteLine("Exception should have been thrown");
        }
        catch (FormatException e)
        {
            Console.WriteLine("Got exception as expected.");
        }

        Console.ReadLine();
    }

    private static void Test(string lhs, string rhs, int expected)
    {
        int result = CompareVersions(lhs, rhs);
        Console.WriteLine("Test(\"" + lhs + "\", \"" + rhs + "\", " + expected +
            (result.Equals(expected) ? " succeeded." : " failed."));
    }