将BigInteger转换为十进制、十六进制、二进制、八进制字符串：
让我们从BigInteger 值开始：
BigInteger bigint = BigInteger.Parse("123456789012345678901234567890");
基数 10 和基数 16
内置的 Base 10（十进制）和 Base 16（十六进制）转换很简单：
// Convert to base 10 (decimal):
string base10 = bigint.ToString();
// Convert to base 16 (hexadecimal):
string base16 = bigint.ToString("X");
前导零（正与负 BigInteger 值）
请注意，当BigInteger 的值为正时，ToString("X") 确保十六进制字符串具有前导零。这与ToString("X") 在从其他前导零被抑制的值类型转换时的通常行为不同。
示例：
var positiveBigInt = new BigInteger(128);
var negativeBigInt = new BigInteger(-128);
Console.WriteLine(positiveBigInt.ToString("X"));
Console.WriteLine(negativeBigInt.ToString("X"));
结果：
080
80
这种行为是有目的的，因为前导零表示BigInteger 是一个正值——本质上，前导零提供了符号。这是必要的（与其他值类型转换相反），因为BigInteger 没有固定大小；因此，没有指定的符号位。前导零表示正值，而不是负值。这允许“往返”BigInteger 值通过ToString() 输出并通过Parse() 返回。此行为在 MSDN 上的 BigInteger Structure 页面上进行了讨论。
扩展方法：BigInteger 到二进制、十六进制和八进制
这是一个包含将BigInteger 实例转换为二进制、十六进制和八进制字符串的扩展方法的类：
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();
}
}
乍一看，这些方法似乎比必要的复杂。实际上，添加了一些额外的复杂性以确保正确的前导零出现在转换后的字符串中。
让我们检查每个扩展方法，看看它们是如何工作的：
BigInteger.ToBinaryString()
以下是如何使用此扩展方法将BigInteger 转换为二进制字符串：
// Convert BigInteger to binary string.
bigint.ToBinaryString();
这些扩展方法的基本核心是BigInteger.ToByteArray() 方法。此方法将BigInteger 转换为字节数组，这就是我们如何获得BigInteger 值的二进制表示：
var bytes = bigint.ToByteArray();
但请注意，返回的字节数组是小端顺序的，因此第一个数组元素是BigInteger 的最低有效字节 (LSB)。由于 StringBuilder 用于构建输出字符串——从最高有效位 (MSB) 开始——字节数组必须反向迭代，以便最高有效字节为首先转换。
因此，索引指针被设置为字节数组中的最高有效位（最后一个元素）：
var idx = bytes.Length - 1;
为了捕获转换后的字节，创建了一个StringBuilder：
var base2 = new StringBuilder(bytes.Length * 8);
StringBuilder 构造函数获取StringBuilder 的容量。 StringBuilder 所需的容量是通过将要转换的字节数乘以八（每个转换的字节产生八位二进制数字）来计算的。
然后将第一个字节转换为二进制字符串：
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');
}
接下来，将转换后的字节附加到StringBuilder：
base2.Append(binary);
为了转换剩余的字节，循环以相反的顺序迭代字节数组的剩余部分：
for (idx--; idx >= 0; idx--)
{
base16.Append(Convert.ToString(bytes[idx], 2).PadLeft(8, '0'));
}
请注意，每个转换后的字节都在左侧填充零（“0”），必要时，转换后的字符串是八个二进制字符。这是极其重要的。如果没有此填充，十六进制值“101”将转换为二进制值“11”。前导零确保转换为“100000001”。
当所有字节都转换后，StringBuilder 包含完整的二进制字符串，由扩展方法返回：
return base2.ToString();
BigInteger.ToOctalString
将BigInteger 转换为八进制（以8 为底）字符串更为复杂。问题是八进制数字表示三位，这不是由BigInteger.ToByteArray() 创建的字节数组的每个元素中保存的八位的偶数倍。为了解决这个问题，数组中的三个字节被组合成 24 位的块。每个 24 位块平均转换为 8 个八进制字符。
第一个 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--];
}
24 位块到八进制的转换通过以下方式完成：
var octal = Convert.ToString(int24, 8);
同样，如果BigInteger 为正值，则第一个数字必须是前导零：
// Ensure leading zero exists if value is positive.
if (octal[0] != '0' && bigint.Sign == 1)
{
base8.Append('0');
}
第一个转换的块被附加到StringBuilder:
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'));
}
与二进制转换一样，每个转换后的八进制字符串都用零填充，因此“7”变为“00000007”。这可确保不会从转换后的字符串中间删除零（即“17”而不是“100000007”）。
转换为基数 x？
将BigInteger 转换为其他数字基数可能要复杂得多。只要基数是 2 的幂（即 2、4、8、16），BigInteger.ToByteArray() 创建的字节数组就可以适当地拆分为位块并进行转换。
但是，如果基数不是 2 的幂，问题就会变得复杂得多，需要大量的循环和除法。由于这种基数转换很少见，我在这里只介绍了流行的计算基数。