Compare los números de versión sin usar la función dividida

¿Cómo comparo los números de versión?

Por ejemplo:

x = 1.23.56.1487.5

y = 1.24.55.487.2

¿Puedes usar la clase Version?

http://msdn.microsoft.com/en-us/library/system.version.aspx

Tiene una interfaz IComparable. Tenga en cuenta que esto no funcionará con una cadena de versión de 5 partes como la que ha mostrado (¿es realmente su cadena de versión?). Suponiendo que sus entradas son cadenas, aquí hay una muestra de trabajo con la cadena de versión normal .NET de 4 partes:

static class Program
{
    static void Main()
    {
        string v1 = "1.23.56.1487";
        string v2 = "1.24.55.487";

        var version1 = new Version(v1);
        var version2 = new Version(v2);

        var result = version1.CompareTo(version2);
        if (result > 0)
            Console.WriteLine("version1 is greater");
        else if (result < 0)
            Console.WriteLine("version2 is greater");
        else
            Console.WriteLine("versions are equal");
        return;

    }
}

Si puede vivir con el esquema major.minor.build.revision, podría usar la clase .Net Version . De lo contrario, tendría que implementar algún tipo de análisis de izquierda a derecha y continuar hasta que tenga una diferencia o regrese que dos versiones son iguales.

Además de la respuesta de @JohnD, podría ser necesario comparar solo números de versión parciales sin usar Split ('.') U otra cadena <-> int bloat de conversión. Acabo de escribir un método de extensión CompareTo con 1 argumento adicional: número de partes significativas del número de versión para comparar (entre 1 y 4).

public static class VersionExtensions
{
    public static int CompareTo(this Version version, Version otherVersion, int significantParts)
    {
        if(version == null)
        {
            throw new ArgumentNullException("version");
        }
        if(otherVersion == null)
        {
            return 1;
        }

        if(version.Major != otherVersion.Major && significantParts >= 1)
            if(version.Major > otherVersion.Major)
                return 1;
            else
                return -1;

        if(version.Minor != otherVersion.Minor && significantParts >= 2)
            if(version.Minor > otherVersion.Minor)
                return 1;
            else
                return -1;

        if(version.Build != otherVersion.Build && significantParts >= 3)
            if(version.Build > otherVersion.Build)
                return 1;
            else
                return -1;

        if(version.Revision != otherVersion.Revision && significantParts >= 4)
            if(version.Revision > otherVersion.Revision)
                return 1;
            else
                return -1;

        return 0; 
    }
}

public int compareVersion(string Version1,string Version2)
    {
        System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(@"([\d]+)");
        System.Text.RegularExpressions.MatchCollection m1 = regex.Matches(Version1);
        System.Text.RegularExpressions.MatchCollection m2 = regex.Matches(Version2);
        int min = Math.Min(m1.Count,m2.Count);
        for(int i=0; i<min;i++)
        {
            if(Convert.ToInt32(m1[i].Value)>Convert.ToInt32(m2[i].Value))
            {
                return 1;
            }
            if(Convert.ToInt32(m1[i].Value)<Convert.ToInt32(m2[i].Value))
            {
                return -1;
            }               
        }
        return 0;
    }

Si por alguna razón no se le permite usar el método de comparación de la Versión directamente (por ejemplo, en un escenario cliente-servidor), otro enfoque es extraer un número largo de la versión y luego comparar los números entre sí. Sin embargo, el número debe tener el siguiente formato: dos dígitos para mayor, menor y revisión y cuatro para compilación.

Cómo extraer el número de versión:

var version = Assembly.GetExecutingAssembly().GetName().Version;

long newVersion = version.Major * 1000000000L + 
                   version.Minor * 1000000L + 
                   version.Build * 1000L + 
                   version.Revision;

Y luego, en otro lugar, puedes comparar:

if(newVersion > installedVersion)
{
  //update code
}

Nota: la versión instalada es un número largo previamente extraído