C#: Conversión de números: binario/octal/decimal/hexadecimal

//Usings.
using System;
using System.Text;

/// <summary>
/// Convierte un número binario en octal.
/// </summary>
/// <param name="binaryNumber">El número binario a convertir representado como una cadena de caracteres.</param>
/// <returns>El número octal resultante como una cadena de caracteres.</returns>
public static string ConvertBinaryToOctal(string binaryNumber)
{
	if (!IsBinary(binaryNumber))
	{
		throw new ArgumentException("El número binario no es válido.");
	}

	int numDigits = binaryNumber.Length;
	int paddingZeros = (numDigits % 3 == 0) ? 0 : (3 - (numDigits % 3));
	binaryNumber = new string('0', paddingZeros) + binaryNumber;

	StringBuilder octalNumber = new StringBuilder();

	for (int i = 0; i < binaryNumber.Length; i += 3)
	{
		string binaryGroup = binaryNumber.Substring(i, 3);
		int decimalValue = ConvertBinaryToDecimal(binaryGroup);
		octalNumber.Append(ConvertDecimalToOctal(decimalValue));
	}

	return octalNumber.ToString().TrimStart('0');
}

/// <summary>
/// Convierte un número binario en decimal.
/// </summary>
/// <param name="binaryNumber">El número binario a convertir representado como una cadena de caracteres.</param>
/// <returns>El número decimal resultante.</returns>
public static int ConvertBinaryToDecimal(string binaryNumber)
{
	if (!IsBinary(binaryNumber))
	{
		throw new ArgumentException("El número binario no es válido.");
	}

	int decimalNumber = 0;
	int power = 0;

	for (int i = binaryNumber.Length - 1; i >= 0; i--)
	{
		if (binaryNumber[i] == '1')
		{
			decimalNumber += (int)Math.Pow(2, power);
		}
		power++;
	}

	return decimalNumber;
}

/// <summary>
/// Convierte un número binario en hexadecimal.
/// </summary>
/// <param name="binaryNumber">El número binario a convertir representado como una cadena de caracteres.</param>
/// <returns>El número hexadecimal resultante como una cadena de caracteres.</returns>
public static string ConvertBinaryToHexadecimal(string binaryNumber)
{
	if (!IsBinary(binaryNumber))
	{
		throw new ArgumentException("El número binario no es válido.");
	}

	int numDigits = binaryNumber.Length;
	int paddingZeros = (numDigits % 4 == 0) ? 0 : (4 - (numDigits % 4));
	binaryNumber = new string('0', paddingZeros) + binaryNumber;

	StringBuilder hexadecimalNumber = new StringBuilder();

	for (int i = 0; i < binaryNumber.Length; i += 4)
	{
		string binaryGroup = binaryNumber.Substring(i, 4);
		int decimalValue = ConvertBinaryToDecimal(binaryGroup);
		hexadecimalNumber.Append(ConvertDecimalToHexadecimal(decimalValue));
	}

	return hexadecimalNumber.ToString().TrimStart('0');
}

/// <summary>
/// Convierte un número octal en binario.
/// </summary>
/// <param name="octalNumber">El número octal a convertir representado como una cadena de caracteres.</param>
/// <returns>El número binario resultante como una cadena de caracteres.</returns>
public static string ConvertOctalToBinary(string octalNumber)
{
	if (!IsOctal(octalNumber))
	{
		throw new ArgumentException("El número octal no es válido.");
	}

	StringBuilder binaryNumber = new StringBuilder();

	for (int i = 0; i < octalNumber.Length; i++)
	{
		int digitValue = ConvertOctalToDecimal(octalNumber[i].ToString());
		string binaryGroup = ConvertDecimalToBinary(digitValue);
		binaryNumber.Append(binaryGroup.PadLeft(3, '0'));
	}

	return binaryNumber.ToString().TrimStart('0');
}

/// <summary>
/// Convierte un número octal en decimal.
/// </summary>
/// <param name="octalNumber">El número octal a convertir representado como una cadena de caracteres.</param>
/// <returns>El número decimal resultante.</returns>
public static int ConvertOctalToDecimal(string octalNumber)
{
	if (!IsOctal(octalNumber))
	{
		throw new ArgumentException("El número octal no es válido.");
	}

	int decimalNumber = 0;
	int power = 0;

	for (int i = octalNumber.Length - 1; i >= 0; i--)
	{
		int digit = int.Parse(octalNumber[i].ToString());
		decimalNumber += digit * (int)Math.Pow(8, power);
		power++;
	}

	return decimalNumber;
}     

/// <summary>
/// Convierte un número octal en hexadecimal.
/// </summary>
/// <param name="octalNumber">El número octal a convertir representado como una cadena de caracteres.</param>
/// <returns>El número hexadecimal resultante como una cadena de caracteres.</returns>
public static string ConvertOctalToHexadecimal(string octalNumber)
{
	if (!IsOctal(octalNumber))
	{
		throw new ArgumentException("El número octal no es válido.");
	}

	string binaryNumber = ConvertOctalToBinary(octalNumber);
	string hexadecimalNumber = ConvertBinaryToHexadecimal(binaryNumber);

	return hexadecimalNumber.TrimStart('0');
}

/// <summary>
/// Convierte un número decimal en binario.
/// </summary>
/// <param name="decimalNumber">El número decimal a convertir.</param>
/// <returns>El número binario resultante como una cadena de caracteres.</returns>
public static string ConvertDecimalToBinary(int decimalNumber)
{
	if (decimalNumber < 0)
	{
		throw new ArgumentException("El número decimal debe ser no negativo.");
	}

	string binaryNumber = string.Empty;

	if (decimalNumber == 0)
	{
		binaryNumber = "0";
	}
	else
	{
		while (decimalNumber > 0)
		{
			int remainder = decimalNumber % 2;
			binaryNumber = remainder.ToString() + binaryNumber;
			decimalNumber /= 2;
		}
	}

	return binaryNumber.TrimStart('0');
}

/// <summary>
/// Convierte un número decimal en octal.
/// </summary>
/// <param name="decimalNumber">El número decimal a convertir.</param>
/// <returns>El número octal resultante como una cadena de caracteres.</returns>
public static string ConvertDecimalToOctal(int decimalNumber)
{
	if (decimalNumber < 0)
	{
		throw new ArgumentException("El número decimal debe ser no negativo.");
	}

	string octalNumber = string.Empty;

	if (decimalNumber == 0)
	{
		octalNumber = "0";
	}
	else
	{
		while (decimalNumber > 0)
		{
			int remainder = decimalNumber % 8;
			octalNumber = remainder.ToString() + octalNumber;
			decimalNumber /= 8;
		}
	}

	return octalNumber.TrimStart('0');
}

/// <summary>
/// Convierte un número decimal en hexadecimal.
/// </summary>
/// <param name="decimalNumber">El número decimal a convertir.</param>
/// <returns>El número hexadecimal resultante como una cadena de caracteres.</returns>
public static string ConvertDecimalToHexadecimal(int decimalNumber)
{
	if (decimalNumber < 0)
	{
		throw new ArgumentException("El número decimal debe ser no negativo.");
	}

	string hexadecimalNumber = string.Empty;

	if (decimalNumber == 0)
	{
		hexadecimalNumber = "0";
	}
	else
	{
		while (decimalNumber > 0)
		{
			int remainder = decimalNumber % 16;
			hexadecimalNumber = GetHexDigit(remainder) + hexadecimalNumber;
			decimalNumber /= 16;
		}
	}

	return hexadecimalNumber.TrimStart('0');
}

/// <summary>
/// Convierte un número hexadecimal en binario.
/// </summary>
/// <param name="hexadecimalNumber">El número hexadecimal a convertir representado como una cadena de caracteres.</param>
/// <returns>El número binario resultante como una cadena de caracteres.</returns>
public static string CovnertHexadecimalToBinary(string hexadecimalNumber)
{
	if (!IsHexadecimal(hexadecimalNumber))
	{
		throw new ArgumentException("El número hexadecimal no es válido.");
	}

	StringBuilder binaryNumber = new StringBuilder();

	for (int i = 0; i < hexadecimalNumber.Length; i++)
	{
		int digitValue = ConvertHexadecimalToDecimal(hexadecimalNumber[i].ToString());
		string binaryGroup = ConvertDecimalToBinary(digitValue);
		binaryNumber.Append(binaryGroup.PadLeft(4, '0'));
	}

	return binaryNumber.ToString().TrimStart('0');
}

/// <summary>
/// Convierte un número hexadecimal en octal.
/// </summary>
/// <param name="hexadecimalNumber">El número hexadecimal a convertir representado como una cadena de caracteres.</param>
/// <returns>El número octal resultante como una cadena de caracteres.</returns>
public static string ConvertHexadecimalToOctal(string hexadecimalNumber)
{
	if (!IsHexadecimal(hexadecimalNumber))
	{
		throw new ArgumentException("El número hexadecimal no es válido.");
	}

	string binaryNumber = CovnertHexadecimalToBinary(hexadecimalNumber);
	string octalNumber = ConvertBinaryToOctal(binaryNumber);

	return octalNumber.TrimStart('0');
}

/// <summary>
/// Convierte un número hexadecimal en decimal.
/// </summary>
/// <param name="hexadecimalNumber">El número hexadecimal a convertir representado como una cadena de caracteres.</param>
/// <returns>El número decimal resultante.</returns>
public static int ConvertHexadecimalToDecimal(string hexadecimalNumber)
{
	if (!IsHexadecimal(hexadecimalNumber))
	{
		throw new ArgumentException("El número hexadecimal no es válido.");
	}

	int decimalNumber = 0;
	int power = 0;

	for (int i = hexadecimalNumber.Length - 1; i >= 0; i--)
	{
		int digitValue = GetHexDigitValue(hexadecimalNumber[i]);
		decimalNumber += digitValue * (int)Math.Pow(16, power);
		power++;
	}

	return decimalNumber;
}

/// <summary>
/// Verifica si un número binario es válido.
/// </summary>
/// <param name="binaryNumber">El número binario a verificar.</param>
/// <returns>True si el número binario es válido, False en caso contrario.</returns>
public static bool IsBinary(string binaryNumber)
{
	bool isBinary = true;

	foreach (char digit in binaryNumber)
	{
		if (digit != '0' && digit != '1')
		{
			isBinary = false;
		}
	}

	return isBinary;
}

/// <summary>
/// Verifica si un número octal es válido.
/// </summary>
/// <param name="octalNumber">El número octal a verificar.</param>
/// <returns>True si el número octal es válido, False en caso contrario.</returns>
public static bool IsOctal(string octalNumber)
{
	bool isOctal = true;

	foreach (char digit in octalNumber)
	{
		if (digit < '0' || digit > '7')
		{
			isOctal = false;
		}
	}

	return isOctal;
}

/// <summary>
/// Verifica si un número hexadecimal es válido.
/// </summary>
/// <param name="hexadecimalNumber">El número hexadecimal a verificar.</param>
/// <returns>True si el número hexadecimal es válido, False en caso contrario.</returns>
public static bool IsHexadecimal(string hexadecimalNumber)
{
	bool isHexadecimal = true;

	foreach (char digit in hexadecimalNumber)
	{
		if (!IsHexDigit(digit))
		{
			isHexadecimal = false;
		}
	}

	return isHexadecimal;
}

/// <summary>
/// Verifica si un carácter es un dígito hexadecimal válido.
/// </summary>
/// <param name="hexDigit">El carácter a verificar.</param>
/// <returns>True si el carácter es un dígito hexadecimal válido, False en caso contrario.</returns>
public static bool IsHexDigit(char hexDigit)
{
	bool isHexDigit = (hexDigit >= '0' && hexDigit <= '9') ||
					  (hexDigit >= 'A' && hexDigit <= 'F') ||
					  (hexDigit >= 'a' && hexDigit <= 'f');

	return isHexDigit;
}