Compare of version number as Extention

VersionExtention.cs

using System;
using System.Collections.Generic;


/* Sample

class MainClass
{
    public static void Main(string[] args)
    {
        if ("2.3.4".AsVersion().IsGreater("1.2"))
            Console.WriteLine("Greater");
        else
            Console.WriteLine("not Greater");
	
        List<string> Versions = new List<string>() { "10.10.2.3", "10.10.2", "10.10.3", "10.10.2.2", "10.10.2.4", "10.10" };

        foreach (string itemA in Versions)
            foreach (string itemB in Versions)
                {
                    Console.WriteLine("\"{0}\".AsVersion().IsGreater(\"{1}\")={2}", itemA, itemB, itemA.AsVersion().IsGreater(itemB));
                    Console.WriteLine("\"{0}\".AsVersion().IsLess(\"{1}\")={2}", itemA, itemB, itemA.AsVersion().IsLess(itemB));
                    Console.WriteLine("\"{0}\".AsVersion().IsEqual(\"{1}\")={2}", itemA, itemB, itemA.AsVersion().IsEqual(itemB));
                }
    }
}
*/

namespace EifelMono.Core
{
    public enum VersionFormat
    {
        Default,
        BuildAsTime,
        PatchAsDateAndBuildAsTime
    }

    public static class VersionExtentions
    {
        #region Helper class VersionPipe

        public class VersionPipe
        {
            #region CompareDigits == how many digits used to compare!

            private int mCompareDigits = -1;

            public int CompareDigits
            {
                get
                {
                    return mCompareDigits;
                }
                set
                {
                    mCompareDigits = value;
                }
            }

            #endregion

            #region CompareFromValue

            string mCompareFromValue = "";

            public string CompareFromValue
            {
                get
                {
                    return mCompareFromValue;
                }
                set
                {
                    mCompareFromValue = value;
                    ValueToList(mCompareFromValue, CompareFromList);
                }
            }

            public List<int> CompareFromList = new List<int>();

            #endregion

            #region CompareToValue

            string mCompareToValue = "";

            public string CompareToValue
            {
                get
                {
                    return mCompareToValue;
                }
                set
                {
                    mCompareToValue = value;
                    ValueToList(mCompareToValue, CompareToList);
                }
            }

            public List<int> CompareToList = new List<int>();

            #endregion

            #region Helper functions

            internal void ValueToList(string value, List<int> list)
            {
                string[] sList = value.Split('.');
                list.Clear();
                foreach (string item in sList)
                    list.Add(Convert.ToInt16(item));
            }

            public int CompareTo()
            {
                int result = 0;
                while (CompareFromList.Count < CompareToList.Count)
                    CompareFromList.Add(0);
                while (CompareToList.Count < CompareFromList.Count)
                    CompareToList.Add(0);

                for (int index = 0; index < CompareFromList.Count; index++)
                {
                    result = CompareFromList[index].CompareTo(CompareToList[index]);
                    if (result != 0)
                        break;
                    if (CompareDigits != -1)
                        if (index == CompareDigits - 1)
                            break;
                }
                return result;
            }

            #endregion
        }

        #endregion

        public static bool IsVersion(this string value)
        {
            try
            {
                value.AsVersion();
                return true;
            }
            catch
            {
                return false;
            }
        }

        public static VersionPipe AsVersion(this string compareFromValue, int compareDigits = -1)
        {
            return new VersionPipe()
            {
                CompareFromValue = compareFromValue,
                CompareDigits = compareDigits
            };
        }

        public static string AsString(this VersionPipe pipe, VersionFormat format = VersionFormat.Default)
        {
            string result = pipe.CompareFromValue;
            switch (format)
            {
                case VersionFormat.BuildAsTime:
                    {
                        if (pipe.CompareFromList.Count > 3)
                        {
                            DateTime dt = new DateTime();
                            dt= dt.AddSeconds(2 * pipe.CompareFromList[3]);
                            result = string.Format("{0}.{1}.{2}  {3}",
                                pipe.CompareFromList[0],
                                pipe.CompareFromList[1],
                                pipe.CompareFromList[3],
                                dt.ToString("dddd, MMMM dd, yyyy"));
                        }
                        break;
                    }
                case VersionFormat.PatchAsDateAndBuildAsTime:
                    {
                        if (pipe.CompareFromList.Count > 2)
                        {
                            DateTime dt = new DateTime(2000, 1, 1);
                            dt = dt.AddDays(pipe.CompareFromList[2]);
                            dt = dt.AddSeconds(2 * pipe.CompareFromList[3]);
                            result = string.Format("{0}.{1} {2}",
                                pipe.CompareFromList[0],
                                pipe.CompareFromList[1],
                                dt.ToString("dddd, MMMM dd, yyyy HH:mm:ss"));
                        }
                        break;
                    }
            }
            return result;
        }

        public static int DaysFromPatch(this VersionPipe pipe)
        {
            if (pipe.CompareFromList.Count > 1)
                return pipe.CompareFromList[2];
            else
                return -1;
        }

        public static int SecondsFromBuild(this VersionPipe pipe)
        {
            if (pipe.CompareFromList.Count > 2)
                return pipe.CompareFromList[3];
            else
                return -1;
        }

        #region Comapre functions

        public static bool IsEqual(this VersionPipe pipe, string compareToValue)
        {
            pipe.CompareToValue = compareToValue;
            return pipe.CompareTo() == 0;
        }

        public static bool IsGreater(this VersionPipe pipe, string compareToValue)
        {
            pipe.CompareToValue = compareToValue;
            return pipe.CompareTo() > 0;
        }

        public static bool IsGreaterOrEqual(this VersionPipe pipe, string compareToValue)
        {
            pipe.CompareToValue = compareToValue;
            return pipe.CompareTo() >= 0;
        }

        public static bool IsLess(this VersionPipe pipe, string compareToValue)
        {
            pipe.CompareToValue = compareToValue;
            return pipe.CompareTo() < 0;
        }

        public static bool IsLessOrEqual(this VersionPipe pipe, string compareToValue)
        {
            pipe.CompareToValue = compareToValue;
            return pipe.CompareTo() <= 0;
        }

        #endregion
    }
}