private string GetDateTimeSortKey(IConvertible value)
        {
            long   ticks      = value.ToDateTime(null).Ticks;
            string scientific = string.Format(CultureInfo.InvariantCulture, "{0:e20}", ticks);

            return(StringKeyGenerator.GetNumericSortKey(scientific, ticks == 0));
        }
        private string GetDecimalSortKey(IConvertible value)
        {
            decimal d          = value.ToDecimal(null);
            string  scientific = string.Format(CultureInfo.InvariantCulture, "{0:e28}", value);

            return(StringKeyGenerator.GetNumericSortKey(scientific, d == 0m));
        }
        private string GetIntSortKey(IConvertible value)
        {
            long   num        = value.ToInt64(null);
            string scientific = string.Format(CultureInfo.InvariantCulture, "{0:e20}", value);

            return(StringKeyGenerator.GetNumericSortKey(scientific, num == 0));
        }
        private static string GetNumericSortKey(string scientific, bool isZero)
        {
            if (isZero)
            {
                return("D");
            }
            char[] array = new char[scientific.Length];
            bool   flag  = scientific[0] == '-';
            bool   flag2 = scientific[scientific.Length - 4] == '-';
            char   c     = (char)((!flag) ? (flag2 ? 69 : 70) : ((!flag2) ? 66 : 67));

            array[0] = c;
            array[1] = StringKeyGenerator.ReverseIfNegative(scientific[scientific.Length - 3], flag2 ^ flag);
            array[2] = StringKeyGenerator.ReverseIfNegative(scientific[scientific.Length - 2], flag2 ^ flag);
            array[3] = StringKeyGenerator.ReverseIfNegative(scientific[scientific.Length - 1], flag2 ^ flag);
            int num  = 4;
            int num2 = 0;
            int num3 = 4;

            if (scientific[num2] == '-')
            {
                num2++;
            }
            char c2 = scientific[num2++];

            while (true)
            {
                switch (c2)
                {
                default:
                    array[num++] = StringKeyGenerator.ReverseIfNegative(c2, flag);
                    if (c2 != '0')
                    {
                        num3 = num;
                    }
                    break;

                case '.':
                    break;

                case 'e':
                    if (flag && num3 < array.Length)
                    {
                        array[num3++] = 'A';
                    }
                    return(new string(array, 0, num3));
                }
                c2 = scientific[num2++];
            }
        }
        private string GetStringSortKey(IConvertible value)
        {
            string text = value.ToString(null);

            if (this._compareOptions.HasFlag(CompareOptions.Ordinal))
            {
                return(text);
            }
            if (this._compareOptions.HasFlag(CompareOptions.OrdinalIgnoreCase))
            {
                return(text.ToUpperInvariant());
            }
            SortKey sortKey = this._compareInfo.GetSortKey(text, this._compareOptions);

            return(StringKeyGenerator.ToComparableBase64String(sortKey.KeyData));
        }
        private string GetDoubleSortKey(IConvertible value)
        {
            double num = value.ToDouble(null);

            if (double.IsNegativeInfinity(num))
            {
                return("A");
            }
            if (double.IsPositiveInfinity(num))
            {
                return("G");
            }
            if (double.IsNaN(num))
            {
                return("H");
            }
            string scientific = string.Format(CultureInfo.InvariantCulture, "{0:e28}", value);

            return(StringKeyGenerator.GetNumericSortKey(scientific, num == 0.0));
        }