Silverlight上的BigInteger解析

我实际上正在研究一个IBAN密钥验证功能

要获得钥匙，我需要执行以下操作：

string theKey = (98 - ((int64.Parse(value)) % 97)).ToString();

问题是我的值比19长。所以我需要使用System.Numerics中的BigInteger

此引用不包括Parse（）方法

---

我需要一个解决方案，允许我在Silverlight上使用23char整数。

是的，我认为Silverlight中没有

biginger.Parse（）

您可以使用不带小数点的

Decimal

，因为十进制值可以高达79228162514264337593543950335

如果我数对的话

---

*编辑-我选择

decimal

而不是

double

的原因是

decimal

有更多的有效数字，因此可以更精确。

MSDN上的某个人给了我一个带有Parse/TryParse的类，它工作得非常好，我希望它能有所帮助。感谢您提供的十进制解决方案，但我似乎还需要使用30位int，因此biginteger是必须具备的：

public static class BigIntegerHelper
    {
        public static BigInteger Parse(string s)
        {
            return Parse(s, CultureInfo.CurrentCulture);
        }

        public static BigInteger Parse(string s, IFormatProvider provider)
        {
            return Parse(s, NumberStyles.Integer, provider);
        }

        public static BigInteger Parse(string s, NumberStyles style)
        {
            return Parse(s, style, CultureInfo.CurrentCulture);
        }

        public static BigInteger Parse(string s, NumberStyles style, IFormatProvider provider)
        {
            BigInteger result;
            if (TryParse(s, style, provider, out result))
            {
                return result;
            }
            throw new FormatException();
        }

        public static bool TryParse(string s, out BigInteger b)
        {
            return TryParse(s, NumberStyles.Integer, CultureInfo.CurrentCulture, out b);
        }

        public static bool TryParse(string s, NumberStyles style, IFormatProvider formatProvider, out BigInteger value)
        {
            if (formatProvider == null)
            {
                formatProvider = CultureInfo.CurrentCulture;
            }
            if ((style & ~(NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite | NumberStyles.AllowLeadingSign | NumberStyles.AllowHexSpecifier)) != NumberStyles.None)
            {
                throw new NotSupportedException();
            }
            NumberFormatInfo numberFormatInfo = (NumberFormatInfo)formatProvider.GetFormat(typeof(NumberFormatInfo));
            uint num = ((style & NumberStyles.AllowHexSpecifier) != NumberStyles.None) ? 16u : 10u;
            int num2 = 0;
            bool flag = false;
            if ((style & NumberStyles.AllowLeadingWhite) != NumberStyles.None)
            {
                while (num2 < s.Length && IsWhiteSpace(s[num2]))
                {
                    num2++;
                }
            }
            if ((style & NumberStyles.AllowLeadingSign) != NumberStyles.None)
            {
                int length = numberFormatInfo.NegativeSign.Length;
                if (length + num2 < s.Length && string.Compare(s, num2, numberFormatInfo.NegativeSign, 0, length, CultureInfo.CurrentCulture, CompareOptions.None) == 0)
                {
                    flag = true;
                    num2 += numberFormatInfo.NegativeSign.Length;
                }
            }
            value = BigInteger.Zero;
            BigInteger bigInteger = BigInteger.One;
            if (num2 == s.Length)
            {
                return false;
            }
            for (int i = s.Length - 1; i >= num2; i--)
            {
                if ((style & NumberStyles.AllowTrailingWhite) != NumberStyles.None && IsWhiteSpace(s[i]))
                {
                    int num3 = i;
                    while (num3 >= num2 && IsWhiteSpace(s[num3]))
                    {
                        num3--;
                    }
                    if (num3 < num2)
                    {
                        return false;
                    }
                    i = num3;
                }
                uint num4;
                if (!ParseSingleDigit(s[i], (ulong)num, out num4))
                {
                    return false;
                }
                if (num4 != 0u)
                {
                    value += num4 * bigInteger;
                }
                bigInteger *= num;
            }
            if (value.Sign == 1 && flag)
            {
                value = -value;
            }
            return true;
        }

        private static bool IsWhiteSpace(char ch)
        {
            return ch == ' ' || (ch >= '\t' && ch <= '\r');
        }

        private static bool ParseSingleDigit(char c, ulong radix, out uint result)
        {
            result = 0;
            if (c >= '0' && c <= '9')
            {
                result = (uint)(c - '0');
                return true;
            }
            if (radix == 16uL)
            {
                c = (char)((int)c & -33);
                if (c >= 'A' && c <= 'F')
                {
                    result = (uint)(c - 'A' + '\n');
                    return true;
                }
            }
            return false;
        }

    }

公共静态类BigIntegerHelper
{
公共静态BigInteger解析（字符串s）
{
返回解析（s，CultureInfo.CurrentCulture）；
}
公共静态BigInteger解析（字符串s，IFormatProvider）
{
返回解析（s，NumberStyles.Integer，provider）；
}
公共静态BigInteger解析（字符串s，NumberStyles样式）
{
返回解析（s、样式、CultureInfo.CurrentCulture）；
}
公共静态BigInteger解析（字符串s、NumberStyles样式、IFormatProvider）
{
大整数结果；
if（TryParse（s、样式、提供程序、输出结果））
{
返回结果；
}
抛出新的FormatException（）；
}
公共静态bool TryParse（字符串s，out big整数b）
{
返回TryParse（s，NumberStyles.Integer，CultureInfo.CurrentCulture，out b）；
}
公共静态bool TryParse（字符串s、NumberStyles样式、IFormatProvider formatProvider、out BigInteger值）
{
if（formatProvider==null）
{
formatProvider=CultureInfo.CurrentCulture；
}
if（（style&~（NumberStyles.allowreadingwhite | NumberStyles.AllowTrailingWhite | NumberStyles.allowreadingsign | NumberStyles.allowwhexspecifier））！=NumberStyles.None）
{
抛出新的NotSupportedException（）；
}
NumberFormatInfo NumberFormatInfo=（NumberFormatInfo）formatProvider.GetFormat（typeof（NumberFormatInfo））；
uint num=（（样式和数字样式.AllowHexSpecifier）！=数字样式.无）？16u:10u；
int num2=0；
布尔标志=假；
if（（style&NumberStyles.allowreadingwhite）！=NumberStyles.None）
{
while（num2=num2；i--）
{
if（（style&NumberStyles.AllowTrailingWhite）！=NumberStyles.None&&IsWhiteSpace（s[i]））
{
int num3=i；
while（num3>=num2&&IsWhiteSpace（s[num3]））
{
num3--；
}
如果（num3返回ch=''| |（ch>='\t'&&ch='0'&&c='A'&&c哦，对了，以前没有遇到过-我很高兴你找到了解决方案！