Exemple #1
0
        static bool PerformParse(string s, NumberStyles style, IFormatProvider provider, out Decimal res, bool throwex)
        {
            var nfi = provider.ToNumberFormatInfo();

            try
            {
                int  decPos;
                bool isNegative;
                bool expFlag;
                int  exp;

                var stripped = StripStyles(s, style, nfi, out decPos, out isNegative, out expFlag, out exp, throwex);

                var b = new BigDecimal(stripped)
                        .MovePointLeft(stripped.Length - decPos)
                        .ScaleByPowerOfTen(exp);

                if (isNegative)
                {
                    b = b.Negate();
                }

                res = b;
                return(true);
            }
            catch (Exception)
            {
                if (throwex)
                {
                    throw;
                }
                res = default(decimal);
                return(false);
            }
        }
Exemple #2
0
        public string ToString(string format, IFormatProvider provider)
        {
            var ni = provider.ToNumberFormatInfo();

            string s;

            var val = Val.Abs();

            bool   group         = false;
            string decimalDigit  = ni.NumberDecimalSeparator;
            string groupingDigit = null;

            int[] groupingSize   = null;
            bool  covertEToLower = false;
            char  formatChar     = 'G';

            if (string.IsNullOrEmpty(format))
            {
                s = val.ToString();
            }
            else
            {
                formatChar     = format[0];
                covertEToLower = !char.IsUpper(formatChar);
                formatChar     = char.ToUpperInvariant(formatChar);

                int len;
                if (!int.TryParse(format.Substring(1), out len))
                {
                    len = -1;
                }

                switch (formatChar)
                {
                case 'E':
                    s = val.SetScale(len == -1 ? 6 : len, RoundingMode.HALF_UP)
                        .ToEngineeringString();
                    break;

                case 'C':
                    s = val.SetScale(len == -1 ? ni.CurrencyDecimalDigits : len, RoundingMode.HALF_UP)
                        .ToPlainString();
                    group         = true;
                    decimalDigit  = ni.CurrencyDecimalSeparator;
                    groupingDigit = ni.CurrencyGroupSeparator;
                    groupingSize  = ni.CurrencyGroupSizes;
                    break;

                case 'N':
                    s = val.SetScale(len == -1 ? ni.NumberDecimalDigits : len, RoundingMode.HALF_UP)
                        .ToPlainString();
                    group         = true;
                    decimalDigit  = ni.NumberDecimalSeparator;
                    groupingDigit = ni.NumberGroupSeparator;
                    groupingSize  = ni.NumberGroupSizes;
                    break;

                case 'F':
                    s = val.SetScale(len == -1 ? ni.NumberDecimalDigits : len, RoundingMode.HALF_UP)
                        .ToPlainString();
                    break;

                case 'G':
                    s = ((len == -1) ? val : val.SetScale(ni.NumberDecimalDigits, RoundingMode.HALF_UP))
                        .ToString();
                    break;

                case 'P':
                    s =
                        val.Multiply(new BigDecimal(100))
                        .SetScale(len == -1 ? ni.PercentDecimalDigits : len, RoundingMode.HALF_UP)
                        .ToString();
                    group         = true;
                    decimalDigit  = ni.PercentDecimalSeparator;
                    groupingDigit = ni.PercentGroupSeparator;
                    groupingSize  = ni.PercentGroupSizes;
                    break;

                default:
                    // TODO: support custom formats.
                    throw new NotImplementedException("format: " + format);
                }
            }

            StringBuilder b = new StringBuilder(s.Length + 10);

            if (this < Zero)
            {
                b.Append(ni.NegativeSign);
            }

            if (decimalDigit != ".")
            {
                s = s.Replace(".", decimalDigit);
            }

            if (group)
            {
                // todo: find the decimal separator, split the string and assemble everything again.
            }

            if (covertEToLower)
            {
                s = s.Replace('E', 'e');
            }

            b.Append(s);

            if (formatChar == 'P')
            {
                b.Append(" ");
                b.Append(ni.PercentSymbol);
            }
            else if (formatChar == 'C')
            {
                b.Append(" ");
                b.Append(ni.CurrencySymbol);
            }

            return(b.ToString());
        }