C# BigInteger到十六进制/十进制/八进制/二进制字符串？

在Java中，我可以

BigInteger b = new BigInteger(500);

然后按照我的意愿格式化它

b.toString(2); //binary
b.toString(8); //octal
b.toString(10); //decimal
b.toString(16); //hexadecimal

在C#中，我能做到

int num = int.Parse(b.ToString());
Convert.ToString(num,2) //binary
Convert.ToString(num,8) //octal

等等。 但是我只能用

长的
值和更小的值来做。是否有某种方法可以打印具有指定基数的BigInteger？我昨天发布了这篇文章，并收到了如何将基本上所有字符串转换为BigInteger值的解决方案，但尚未成功输出。
将
BigInteger
转换为十进制、十六进制、二进制、八进制字符串：
让我们从一个
biginger
值开始：

BigInteger bigint = BigInteger.Parse("123456789012345678901234567890");

var bytes = bigint.ToByteArray();

基数10和基数16
内置的10进制（十进制）和16进制（十六进制）转换非常简单：

// Convert to base 10 (decimal):
string base10 = bigint.ToString();

// Convert to base 16 (hexadecimal):
string base16 = bigint.ToString("X");

前导零（正与负双整数值）
请注意，
ToString（“X”）
确保了当
BigInteger
的值为正数时，十六进制字符串具有前导零。这与从前导零被抑制的其他值类型转换时的
ToString（“X”）
的通常行为不同

例如：

var positiveBigInt = new BigInteger(128);
var negativeBigInt = new BigInteger(-128);
Console.WriteLine(positiveBigInt.ToString("X"));
Console.WriteLine(negativeBigInt.ToString("X"));

结果:

080
80

这种行为是有目的的，因为前导零表示
biginger
是一个正值——本质上，前导零提供符号。这是必要的（与其他值类型转换相反），因为
biginger
没有固定的大小；因此，没有指定的符号位。前导零表示正值，而不是负值。这允许通过
ToString（）
将值“往返”
biginger
输出，并通过
Parse（）
返回。MSDN页面上讨论了此行为

扩展方法：BigInteger到二进制、十六进制和八进制
下面是一个包含扩展方法的类，用于将
biginger
实例转换为二进制、十六进制和八进制字符串：

using System;
using System.Numerics;
using System.Text;

/// <summary>
/// Extension methods to convert <see cref="System.Numerics.BigInteger"/>
/// instances to hexadecimal, octal, and binary strings.
/// </summary>
public static class BigIntegerExtensions
{
  /// <summary>
  /// Converts a <see cref="BigInteger"/> to a binary string.
  /// </summary>
  /// <param name="bigint">A <see cref="BigInteger"/>.</param>
  /// <returns>
  /// A <see cref="System.String"/> containing a binary
  /// representation of the supplied <see cref="BigInteger"/>.
  /// </returns>
  public static string ToBinaryString(this BigInteger bigint)
  {
    var bytes = bigint.ToByteArray();
    var idx = bytes.Length - 1;

    // Create a StringBuilder having appropriate capacity.
    var base2 = new StringBuilder(bytes.Length * 8);

    // Convert first byte to binary.
    var binary = Convert.ToString(bytes[idx], 2);

    // Ensure leading zero exists if value is positive.
    if (binary[0] != '0' && bigint.Sign == 1)
    {
      base2.Append('0');
    }

    // Append binary string to StringBuilder.
    base2.Append(binary);

    // Convert remaining bytes adding leading zeros.
    for (idx--; idx >= 0; idx--)
    {
      base2.Append(Convert.ToString(bytes[idx], 2).PadLeft(8, '0'));
    }

    return base2.ToString();
  }

  /// <summary>
  /// Converts a <see cref="BigInteger"/> to a hexadecimal string.
  /// </summary>
  /// <param name="bigint">A <see cref="BigInteger"/>.</param>
  /// <returns>
  /// A <see cref="System.String"/> containing a hexadecimal
  /// representation of the supplied <see cref="BigInteger"/>.
  /// </returns>
  public static string ToHexadecimalString(this BigInteger bigint)
  {
    return bigint.ToString("X");
  }

  /// <summary>
  /// Converts a <see cref="BigInteger"/> to a octal string.
  /// </summary>
  /// <param name="bigint">A <see cref="BigInteger"/>.</param>
  /// <returns>
  /// A <see cref="System.String"/> containing an octal
  /// representation of the supplied <see cref="BigInteger"/>.
  /// </returns>
  public static string ToOctalString(this BigInteger bigint)
  {
    var bytes = bigint.ToByteArray();
    var idx = bytes.Length - 1;

    // Create a StringBuilder having appropriate capacity.
    var base8 = new StringBuilder(((bytes.Length / 3) + 1) * 8);

    // Calculate how many bytes are extra when byte array is split
    // into three-byte (24-bit) chunks.
    var extra = bytes.Length % 3;

    // If no bytes are extra, use three bytes for first chunk.
    if (extra == 0)
    {
      extra = 3;
    }

    // Convert first chunk (24-bits) to integer value.
    int int24 = 0;
    for (; extra != 0; extra--)
    {
      int24 <<= 8;
      int24 += bytes[idx--];
    }

    // Convert 24-bit integer to octal without adding leading zeros.
    var octal = Convert.ToString(int24, 8);

    // Ensure leading zero exists if value is positive.
    if (octal[0] != '0' && bigint.Sign == 1)
    {
      base8.Append('0');
    }

    // Append first converted chunk to StringBuilder.
    base8.Append(octal);

    // Convert remaining 24-bit chunks, adding leading zeros.
    for (; idx >= 0; idx -= 3)
    {
      int24 = (bytes[idx] << 16) + (bytes[idx - 1] << 8) + bytes[idx - 2];
      base8.Append(Convert.ToString(int24, 8).PadLeft(8, '0'));
    }

    return base8.ToString();
  }
}

这些扩展方法的基本核心是
biginger.ToByteArray（）
方法。此方法将
biginger
转换为字节数组，这就是我们如何获得
biginger
值的二进制表示：

BigInteger bigint = BigInteger.Parse("123456789012345678901234567890");

var bytes = bigint.ToByteArray();

不过，请注意，返回的字节数组是以小尾数顺序排列的，因此第一个数组元素是
biginger
的最低有效字节（LSB）。由于使用
StringBuilder
构建输出字符串（从最高有效位（MSB）开始）必须反向迭代字节数组，以便首先转换最高有效位字节

因此，索引指针设置为字节数组中的最高有效位（最后一个元素）：

var idx = bytes.Length - 1;

要捕获转换后的字节，将创建
StringBuilder
：

var base2 = new StringBuilder(bytes.Length * 8);

StringBuilder
构造函数接受
StringBuilder
的容量。
StringBuilder
所需的容量通过将要转换的字节数乘以八（每个转换的字节产生八个二进制数字）来计算

然后将第一个字节转换为二进制字符串：

// Convert BigInteger to binary string.
bigint.ToBinaryString();

var binary = Convert.ToString(bytes[idx], 2);

此时，如果
BigInteger
为正值，则必须确保前导零存在（请参见上面的讨论）。如果第一个转换的数字不是零，并且
bigint
为正，则
'0'
将附加到
StringBuilder
：

// Ensure leading zero exists if value is positive.
if (binary[0] != '0' && bigint.Sign == 1)
{
  base2.Append('0');
}

base2.Append(binary);

base8.Append(octal);

接下来，将转换后的字节附加到
StringBuilder
：

// Ensure leading zero exists if value is positive.
if (binary[0] != '0' && bigint.Sign == 1)
{
  base2.Append('0');
}

base2.Append(binary);

base8.Append(octal);

要转换剩余字节，循环将按相反顺序迭代字节数组的剩余部分：

for (idx--; idx >= 0; idx--)
{
  base16.Append(Convert.ToString(bytes[idx], 2).PadLeft(8, '0'));
}

请注意，根据需要，每个转换的字节在左侧用零（'0'）填充，因此转换的字符串是八个二进制字符。这是非常重要的。如果没有此填充，十六进制值“101”将转换为二进制值“11”。前导零确保转换为“100000000001”

转换所有字节后，
StringBuilder
包含完整的二进制字符串，该字符串由扩展方法返回：

return base2.ToString();

BigInteger.ToOctalString
将
biginger
转换为八进制（以8为基数）字符串更为复杂。问题是，八进制数字表示三位，而这三位不是由
biginger.ToByteArray（）
创建的字节数组的每个元素中的八位的偶数倍。为了解决这个问题，数组中的三个字节被组合成24位的块。每个24位块平均转换为八个八进制字符

第一个24位块需要一些模运算：

var extra = bytes.Length % 3;

此计算确定将整个字节数组拆分为三个字节（24位）块时“额外”的字节数。第一次转换为八进制（最高有效位）将获得“额外”字节，因此所有剩余的转换将分别获得三个字节

如果没有“额外”字节，则第一个块将获得完整的三个字节：

if (extra == 0)
{
  extra = 3;
}

第一个块加载到一个名为
int24
的整数变量中，该变量最多可容纳24位。块的每个字节都被加载。加载额外字节时，
int24
中先前的位左移8位以腾出空间：

int int24 = 0;
for (; extra != 0; extra--)
{
  int24 <<= 8;
  int24 += bytes[idx--];
}

同样，如果
BigInteger
是正值，则第一个数字必须是前导零：

// Ensure leading zero exists if value is positive.
if (octal[0] != '0' && bigint.Sign == 1)
{
  base8.Append('0');
}

第一个转换的块被附加到
StringBuilder
：

// Ensure leading zero exists if value is positive.
if (binary[0] != '0' && bigint.Sign == 1)
{
  base2.Append('0');
}

base2.Append(binary);

base8.Append(octal);

剩余的24位块在循环中转换：

for (; idx >= 0; idx -= 3)
{
  int24 = (bytes[idx] << 16) + (bytes[idx -1] << 8) + bytes[idx - 2];
  base8.Append(Convert.ToString(int24, 8).PadLeft(8, '0'));
}

（；idx>=0；idx-=3）的

{
int24=（bytes[idx]这是一种将
biginger
转换为任意基的简单方法：

public static string ToNBase(BigInteger a, int n)
        {
            StringBuilder sb = new StringBuilder();
            while (a > 0)
            {
                sb.Insert(0,a % n);
                a /= n;
            }
            return sb.ToString();
        }

它适用于基数2-10。如果您希望它生成十六进制或其他更高的基数字符串，则必须在插入它之前根据基数修改
a%b
的形式。
在使用BigInteger一整天之后，我找到了一种更好的方法来以二进制输出字符串，试试这个！（适用于负数）

产出：1111

@格雷格-他们说如何用十六进制来做，其他什么都没有。我已经看了很多次了，希望我