Versionsbezeichner vergleichen

Question

Hier ist mein Code, der zwei Versionsbezeichner in der Form "1, 5, 0, 4" oder "1.5.0.4" benötigt und bestimmt, welche die neuere Version ist.

Vorschläge oder Verbesserungen, bitte!

/// <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:

Die Version Klasse behandelt nicht Versionen des Formats 1.0.0.5.

Answer 1

Die System.Version Klasse unterstützt keine Versionen mit Kommas darin, so dass die von Darren Kopp vorgestellte Lösung nicht ausreicht .

Hier ist eine Version, die so einfach wie möglich ist (aber nicht einfacher).

Es verwendet System.Version aber erreicht Kompatibilität mit Versionsnummern wie "1, 2, 3, 4", indem Sie eine Suche ersetzen vor dem Vergleich.

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

Der Code wurde getestet mit:

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

Nun, da Sie nur ein Array mit vier Elementen haben, möchten Sie vielleicht nur die Rekursion ausrollen, um Zeit zu sparen. Das Übergeben von Arrays als Argumente wird Speicher auffressen und dem GC eine Unordnung zum späteren Aufräumen bereiten.

Answer 3

Verwenden Sie die Klasse 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

Wenn Sie davon ausgehen, dass jeder Platz in der Versionszeichenfolge nur eine Nummer sein (oder zumindest die letzten 3, können Sie einfach die Kommas oder Punkte entfernen und vergleichen ... was viel schneller sein würde, ... nicht so robust, aber Sie nicht immer brauchen.

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 
} 

Und ja, ich bin auch davon 4 Version Orte hier ...