Q: How to sort a list / array of string version number? I have a list of strings of version (see photo), and I'd like to sort them in descending order. 

I've seen a few solutions using Version class to compare them, but I can't think of any solution that sort a whole list like this. What is the least complicated way to achieve this? 

A: you can use IComparable
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
              List<string> data = new List<string>{
                "3.5.0.1", "3.4.1.9", "3.4.1.56", "3.4.1.55", "3.4.1.46",
                "3.4.1.45", "3.4.1.44", "3.4.1.30", "3.4.1.3", "3.4.1.22",
                "3.4.1.2", "3.4.1.11", "3.4.1.0", "3.4.0.7", "3.4.0.3",
                "3.4.0.1", "3.3.0.8", "3.3.0.4", "3.3.0.0", "3.2.0.9",
                "3.2.0.6", "3.2.0.3", "3.2.0.27", "3.2.0.20", "3.2.0.15",
                "3.2.0.1", "3.2.0.0", "3.1.0.7", "3.1.0.15", "3.1.0.14"
              };
              List<SortPara> sortPara = data.Select(x => new SortPara(x)).ToList();
              data = sortPara.OrderBy(x => x).Select(x => x.strNumbers).ToList();
              data = sortPara.OrderByDescending(x => x).Select(x => x.strNumbers).ToList();
        }

    }
    public class SortPara : IComparable<SortPara>
    {
        public List<int> numbers { get; set; }
        public string strNumbers { get; set; }
        public SortPara(string strNumbers)
        {
            this.strNumbers = strNumbers;
            numbers = strNumbers.Split(new char[] { '.' }).Select(x => int.Parse(x)).ToList();

        }
        public int CompareTo(SortPara other)
        {
            int shortest = this.numbers.Count < other.numbers.Count ? this.numbers.Count : other.numbers.Count;
            int results = 0;
            for (int i = 0; i < shortest; i++)
            {
                if (this.numbers[i] != other.numbers[i])
                {
                    results = this.numbers[i].CompareTo(other.numbers[i]);
                    break;
                }
            }
            return results;
        }
    }
}


A: know its an old thread but the easiest way is:
//list with some version numbers as strings
var versionList = new List<string>()
{
   "1.1.0",
   "1.10.0",
   "1.112.0",
}     
versionList.OrderByDescending(x => Version.Parse(x));

output: 
1.112.0 
1.10.0
1.1.0

A: what is wrong with this simple implementation?
using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var ver = new List<Version>();

            ver.Add(new Version("3.5"));
            ver.Add(new Version("3.15"));
            ver.Add(new Version("3.10"));
            ver.Add(new Version("3.1"));

            ver.Sort();
            ver.Reverse();
        }
    }
}


A: You should use IComparable as jdweng, just edit a bit to compare versions like "2.1.0.4" and "2.1":
public int CompareTo(SortPara other)
    {
        int shortest = this.numbers.Count < other.numbers.Count ? this.numbers.Count : other.numbers.Count;
        int results = 0;
        for (int i = 0; i < shortest; i++)
        {
            if (this.numbers[i] != other.numbers[i])
            {
                results = this.numbers[i].CompareTo(other.numbers[i]);
                break;
            }
        }
        if (results != 0)
            return results;
        if (this.numbers.Count > other.numbers.Count)
            return 1;
        else if (this.numbers.Count < other.numbers.Count)
            return -1;
        else
            return 0;
    }


A: Here's a solution that will sort Semantic Versioning (https://semver.org). Nuget.Core offers a SemanticVersion class that operates very similarly to the standard Version class in .net.  It will parse your string into an IComparable and IEquatable object so you can compare multiple versions or sort them within a collection, etc.
Nuget.Core:  https://www.nuget.org/packages/nuget.core/  (you can pull this library via nuget)
https://github.com/NuGet/NuGet2/blob/2.13/src/Core/SemanticVersion.cs
var rawVersions = new [] {"v1.4.0", "v1.4.0-patch10", "v1.4.0-patch2"};
var versions = rawVersions.Select(v => new SemanticVersion(v));
var sorted = versions.ToList().Sort();


A: Sorry for late answer. we can sort version number this way too. here is a small example.
var ver = new List<string>();
ver.Add("3.5");
ver.Add("3.15");
ver.Add("3.10");
ver.Add("3.1");

var OrderData = ver.Select(x => new
{
    version = x.ToString(),
    vorder = x.ToString().Replace(".", "")
}).OrderByDescending(y => Convert.ToInt32(y.vorder)).ToList();

