十进制转Hex报错：输入格式不正确，求最优转换方案

Hey there! Let's break down your problem and the best solutions step by step.

This error almost always means your input string isn't a valid decimal number—either it contains non-digit characters (like letters, symbols, or spaces), is empty, or the value is too large for the integer type you're using (e.g., trying to parse a 20-digit number with int.Parse). Start by validating your input before conversion, and use error-safe parsing methods to avoid crashes.

Chances are you're using a basic approach like int.Parse(input).ToString("X"). This works for small, guaranteed-valid integers, but it's not the best choice for all scenarios. Below are better alternatives tailored to different use cases:

1. Best for Regular Integer Ranges (int/long): Error-Safe Parsing #

If you're dealing with numbers within standard integer limits, swap Parse with TryParse to handle invalid inputs gracefully—this is far more robust than letting exceptions crash your code:

string input = "1234";
if (int.TryParse(input, out int decimalNum))
{
    string hexValue = decimalNum.ToString("X"); // Use "x" for lowercase hex
    Console.WriteLine(hexValue); // Outputs: 4D2
}
else
{
    Console.WriteLine("Invalid decimal input—check for non-digit characters or out-of-range values");
}

This method is clean, maintainable, and avoids unnecessary exceptions—perfect for most everyday scenarios.

2. Best for Extra-Large Numbers (Beyond long.MaxValue): Use BigInteger #

If your decimal number is massive (e.g., a 30-digit ID), standard integer types can't handle it. Use BigInteger to convert arbitrarily large decimals to hex:

using System.Numerics;

string input = "123456789012345678901234567890";
if (BigInteger.TryParse(input, out BigInteger bigDecimal))
{
    string hexValue = bigDecimal.ToString("X");
    Console.WriteLine(hexValue);
}
else
{
    Console.WriteLine("Invalid large decimal input");
}

This handles any size of decimal number (as long as you have enough memory) without breaking a sweat.

3. Best for Custom Formatting: Control Prefixes & Length #

If you need hex values with a 0x prefix or fixed length (e.g., 8 digits with leading zeros), skip manual string concatenation and use format parameters directly:

int num = 1234;
string fixedLengthHex = num.ToString("X8"); // Outputs: 000004D2
string hexWithPrefix = $"0x{num.ToString("X")}"; // Outputs: 0x4D2

This is more elegant than building strings manually and keeps your code concise.

4. Best for Extreme Performance: Manual Conversion (Rarely Needed) #

Only use this if you're doing millions of conversions per second and need to squeeze out every bit of performance. Manual conversion avoids framework method overhead but is complex and error-prone:

using System.Numerics;
using System.Text;

public static string DecimalToHexManual(string decimalStr)
{
    if (!BigInteger.TryParse(decimalStr, out BigInteger num))
        throw new ArgumentException("Invalid decimal string");
    
    if (num == 0) return "0";
    
    char[] hexChars = "0123456789ABCDEF".ToCharArray();
    StringBuilder sb = new();
    bool isNegative = num < 0;
    
    if (isNegative) num = -num;
    
    while (num > 0)
    {
        sb.Append(hexChars[(int)(num % 16)]);
        num /= 16;
    }
    
    if (isNegative) sb.Append('-');
    
    char[] result = sb.ToString().ToCharArray();
    Array.Reverse(result);
    return new string(result);
}

Only opt for this if profiling proves your current method is a bottleneck—otherwise, stick to the simpler framework methods.

If you're using Parse + ToString("X"), it's only optimal if you're 100% sure inputs are valid and fit within small integer ranges. For all other cases, the TryParse, BigInteger, or custom formatting methods are better choices.

内容的提问来源于stack exchange，提问作者GerN