C#实现2~36进制转换的完整代码_Asp.net

1. 引言：进制转换的重要性

进制转换是计算机科学中的基础技能，在编程开发、网络通信、数据加密等领域有着广泛应用。虽然c#提供了convert类等内置转换方法，但自定义进制转换工具类能提供更大的灵活性，特别是支持2~36进制的任意转换。本文将深入解析一个完整的进制转换工具类，逐行分析代码实现，并通过流程图直观展示算法原理。

进制转换的本质是将数字从一种表示系统转换为另一种表示系统。例如二进制使用0和1两个数字，十六进制使用0-9和a-f共16个字符。而36进制则使用0-9和a-z所有字符，能够更紧凑地表示大数字。

2. 进制转换工具类完整实现

以下是一个完整的c#进制转换工具类，支持2~36进制之间的相互转换：

using system;

/// <summary>
/// 进制转换工具类，支持2~36进制之间的转换
/// </summary>
public static class radixconverter
{
    // 字符集定义：0-9和a-z分别表示0~35
    [debuggerbrowsable(debuggerbrowsablestate.never)]
    private static readonly string _keys = "0123456789abcdefghijklmnopqrstuvwxyz";
    
    /// <summary>
    /// 将字符串转换为double类型
    /// </summary>
    /// <param name="v">要转换的字符串</param>
    /// <param name="radix">进制基数（2-36）</param>
    /// <returns>转换后的double值</returns>
    public static double todouble(string v, int radix) => bitconverter.int64bitstodouble(toint64(v, radix));
    
    /// <summary>
    /// 将字符串转换为long类型
    /// </summary>
    public static long toint64(string v, int radix) => (long)touint64(v, radix);
    
    /// <summary>
    /// 核心方法：将字符串转换为ulong（支持2~36进制）
    /// </summary>
    public static ulong touint64(string v, int radix)
    {
        // 处理空字符串或null值
        if (string.isnullorempty(v))
        {
            return 0;
        }
        
        // 进制参数验证与修正
        if (radix < 2)
        {
            radix = 10;  // 默认使用十进制
        }
        else if (radix > _keys.length)
        {
            radix = _keys.length;  // 最大不能超过字符集长度
        }
        
        ulong result = 0;     // 存储转换结果
        ulong basevalue = (ulong)radix;  // 进制基数
        ulong weight = 0;     // 当前位的权重（基数的幂次）
        
        // 从字符串末尾向前遍历（从低位到高位）
        for (int i = v.length - 1; i > -1; i--)
        {
            char ch = v[i];
            ulong digitvalue;
            
            // 字符到数字的映射转换
            if (ch >= '0' && ch <= '9')
            {
                digitvalue = (ulong)(ch - '0');  // 数字0-9直接转换
            }
            else if (ch >= 'a' && ch <= 'z')
            {
                digitvalue = 10 + (ulong)(ch - 'a');  // 大写字母a-z对应10-35
            }
            else if (ch >= 'a' && ch <= 'z')
            {
                digitvalue = 10 + (ulong)(ch - 'a');  // 小写字母a-z对应10-35
            }
            else
            {
                return 0;  // 非法字符返回0
            }
            
            // 检查数字是否有效（不能大于等于基数）
            if (digitvalue >= basevalue)
            {
                return 0;
            }
            
            // 计算当前位的贡献值
            if (i == v.length - 1)  // 最低位（权重为1）
            {
                result += digitvalue;
                weight = basevalue;  // 初始化权重
            }
            else  // 高位：权重递增
            {
                result += digitvalue * weight;
                weight = weight * basevalue;  // 权重乘以基数
            }
        }
        return result;
    }
    
    // 以下为数值转字符串的重载方法
    public static string tostring(long v, int radix) => tostring(v, radix, 0);
    public static string tostring(ulong v, int radix) => tostring(v, radix, 0);
    public static string tostring(double v, int radix) => tostring(v, radix, 0);
    public static string tostring(long v, int radix, int padding) => tostring(v, radix, padding, '0');
    public static string tostring(ulong v, int radix, int padding) => tostring(v, radix, padding, '0');
    public static string tostring(double v, int radix, int padding) => tostring(v, radix, padding, '0');
    
    /// <summary>
    /// 将double转换为字符串
    /// </summary>
    public static string tostring(double v, int radix, int padding, char paddingchar) 
        => tostring(bitconverter.doubletoint64bits(v), radix, padding, paddingchar);
    
    /// <summary>
    /// 将long转换为字符串
    /// </summary>
    public static string tostring(long v, int radix, int padding, char paddingchar) 
        => tostring((ulong)v, radix, padding, paddingchar);
    
    /// <summary>
    /// 核心方法：将ulong数值转换为指定进制的字符串
    /// </summary>
    public static string tostring(ulong v, int radix, int padding, char paddingchar)
    {
        // 进制参数验证
        if (radix < 2)
        {
            radix = 10;
        }
        else if (radix > _keys.length)
        {
            radix = _keys.length;
        }
        
        uint basevalue = (uint)radix;
        string result;
        
        // 处理零值特殊情况
        if (v == 0)
        {
            result = "0";
        }
        else
        {
            result = string.empty;
            // 使用除基取余法进行转换
            while (v > 0)
            {
                ulong remainder = v % basevalue;  // 计算当前余数
                result = _keys[(int)remainder] + result;  // 将余数映射为字符并拼接到结果前
                v /= basevalue;  // 更新商值
            }
        }
        
        // 填充处理：确保结果达到指定长度
        if (padding > result.length)
        {
            result = result.padleft(padding, paddingchar);
        }
        return result;
    }
}

3. 算法原理详解

3.1 字符串转数值算法（touint64）

此算法采用权重累加法，从字符串的最右字符（最低位）开始处理，每位数值乘以其权重（基数的幂次）后累加。

算法步骤解析：

参数验证：检查输入字符串是否为空，修正进制基数到有效范围（2-36）
字符映射：将每个字符转换为对应的数值（0-9对应0-9，a-z/a-z对应10-35）
权重计算：从最低位开始，每位权重是基数的递增幂次（基数的0次方、1次方、2次方…）
结果累加：将每位数值乘以其权重后累加到最终结果

示例：二进制"1101"转换为十进制

1×2³ + 1×2² + 0×2¹ + 1×2⁰ = 8 + 4 + 0 + 1 = 13

3.2 数值转字符串算法（tostring）

此算法采用除基取余法，通过反复除以基数并记录余数来实现转换。

算法步骤解析：

特殊情况处理：数值为0时直接返回"0"
除基取余：反复将数值除以基数，记录每次的余数
字符映射：将余数映射为字符集中的对应字符
结果构建：将映射的字符从后向前拼接（逆序）
填充处理：在结果前填充指定字符以达到最小长度要求

示例：十进制13转换为二进制

13 ÷ 2 = 6 余 1 → "1"
6 ÷ 2 = 3 余 0 → "01"
3 ÷ 2 = 1 余 1 → "101"
1 ÷ 2 = 0 余 1 → "1101"

4. 关键位置

4.1 字符映射机制

工具类使用_keys字符串作为字符映射表，其中0-9对应数字0-9，a-z对应数字10-35。这种设计支持最大36进制转换，且通过统一的映射表提高代码可维护性。

4.2 错误处理与边界条件

空值处理：空字符串或null值返回0，避免异常
进制范围：自动修正超出2-36范围的进制参数
非法字符：遇到非法字符时返回0，保证程序稳定性
数值越界：使用ulong类型支持更大数值范围

5. 使用示例与场景

5.1 基础转换示例

// 字符串转数值
console.writeline(radixconverter.toint64("1a", 16));  // 输出：26（16进制转10进制）
console.writeline(radixconverter.todouble("1010", 2)); // 输出：10（二进制转double）

// 数值转字符串
console.writeline(radixconverter.tostring(26, 16));    // 输出："1a"（10进制转16进制）
console.writeline(radixconverter.tostring(10, 2, 8));  // 输出："00001010"（填充至8位）

// 高进制转换（32进制）
console.writeline(radixconverter.tostring(100, 32));    // 输出："34"