Comparar identificadores de versión

Question

Aquí está mi código, que toma dos identificadores de versión en el formato "1, 5, 0, 4" o "1.5.0.4" y determina cuál es la versión más nueva.

Sugerencias o mejoras, por favor!

/// <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); 
     } 
    } 

---

@Darren Kopp:

La clase versión no maneja versiones del formato 1.0.0.5.

Answer 1

La clase System.Version no es compatible con versiones comas, por lo que la solución presentada por Darren Kopp no es suficiente .

Aquí hay una versión que es lo más simple posible (pero no más simple).

Utiliza System.Version pero logra la compatibilidad con los números de versión como "1, 2, 3, 4" al hacer una búsqueda-reemplazar antes de comparar.

/// <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); 
    } 

El código ha sido probado con:

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.")); 
    } 

Answer 2

Bueno, como solo tiene una matriz de cuatro elementos, es posible que desee desenrollar la recursión para ahorrar tiempo. Pasar las matrices como argumentos consumirá la memoria y dejará un desorden para que el GC lo limpie más tarde.

Answer 3

Usa la clase Version.

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 4

Si se puede asumir que cada lugar en la cadena de versión sólo será un número (o por lo menos el último 3, puede simplemente eliminar las comas o los períodos y comparar ... lo cual sería mucho más rápido ... no es tan robusto, pero no siempre es necesario que.

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 
} 

Y sí, también estoy asumiendo 4 lugares versión aquí ...