简介

十六进制（简写为hex或下标16）在数学中是一种逢16进1的进位制，一般用数字0到9和字母A到F表示（其中:AF即1015）。例如十进制数57，在二进制写作111001，在16进制写作39。

像c#,java,c这样的语言为了区分十六进制和十进制数值,会在十六进制数的前面加上 0x,比如0x20是十进制的32,而不是十进制的20。HexUtil就是将字符串或byte数组与16进制表示转换的工具类。

提供了一些常用的16进制处理方法，包括：

• HexToBytes：将16进制字符串转换为字节数组。
• BytesToHex：将字节数组转换为16进制字符串。
• HexEquals：比较两个16进制字符串是否相等。
• HexToInt：将16进制字符串转换为十进制数值。
• IntToHex：将十进制数值转换为16进制字符串。
• HexToUpper：将16进制字符串中的所有字符转换为大写。
• HexToLower：将16进制字符串中的所有字符转换为小写。
• GetHexChar：获取16进制字符串中指定位置的字符。
• ReplaceHexChar：将16进制字符串中指定位置的字符替换为新的字符。
• ReplaceHexChar：将16进制字符串中指定位置的字符替换为新的字符。
• ReplaceHexChar：将16进制字符串中指定位置的字符替换为新的字节。
• ReplaceHexChar：将16进制字符串中指定位置的字符替换为新的整数。
• InsertHexChar：在16进制字符串的指定位置插入新的字符。
• InsertHexChar：在16进制字符串的指定位置插入新的字符。
• InsertHexChar：在16进制字符串的指定位置插入新的字节。
• InsertHexChar：在16进制字符串的指定位置插入新的整数。
• RemoveHexChar：从16进制字符串中移除指定位置的字符。
• MoveHexChar：将16进制字符串中指定位置的字符移动到新的位置。
• ShiftHexChar：将16进制字符串中指定位置的字符移动指定的步长。
• ShiftHexCharLeft：将16进制字符串中指定位置的字符向左移动1位。
• ShiftHexCharRight：将16进制字符串中指定位置的字符向右移动1位。
• RotateHexCharLeft：将16进制字符串中指定位置的字符向左旋转1位。
• RotateHexCharRight：将16进制字符串中指定位置的字符向右旋转1位。

EasyTool.HexUtil 类

静态工具类 HexUtil，提供了许多常见的16进制字符串处理操作，例如转换为字节数组或十进制数值、比较两个16进制字符串是否相等、替换、插入、移除或移动指定位置的字符等。使用这些方法可以方便地进行16进制字符串的处理和操作。

HexToBytes-将16进制字符串转换为字节数组

/// <summary>
/// 将16进制字符串转换为字节数组
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <returns>字节数组</returns>
/// <exception cref="ArgumentException"></exception>
public static byte[] HexToBytes(string hex)

BytesToHex-将字节数组转换为16进制字符串

/// <summary>
/// 将字节数组转换为16进制字符串
/// </summary>
/// <param name="bytes">字节数组</param>
/// <returns>16进制字符串</returns>
public static string BytesToHex(byte[] bytes)

HexEquals-比较两个16进制字符串是否相等

/// <summary>
/// 比较两个16进制字符串是否相等
/// </summary>
/// <param name="hex1">16进制字符串</param>
/// <param name="hex2">16进制字符串</param>
/// <returns>是否相等</returns>
public static bool HexEquals(string hex1, string hex2)

HexToInt-将16进制字符串转换为十进制数值

/// <summary>
/// 将16进制字符串转换为十进制数值
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <returns>十进制数值</returns>
public static int HexToInt(string hex)

IntToHex-将十进制数值转换为16进制字符串

/// <summary>
/// 将十进制数值转换为16进制字符串
/// </summary>
/// <param name="number">十进制数值</param>
/// <returns>16进制字符串</returns>
public static string IntToHex(int number)

HexToUpper-将16进制字符串中的所有字符转换为大写

/// <summary>
/// 将16进制字符串中的所有字符转换为大写
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <returns>大写16进制字符串</returns>
public static string HexToUpper(string hex)

HexToLower-将16进制字符串中的所有字符转换为小写

/// <summary>
/// 将16进制字符串中的所有字符转换为小写
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <returns>小写16进制字符串</returns>
public static string HexToLower(string hex)

GetHexChar-获取16进制字符串中指定位置的字符

/// <summary>
/// 获取16进制字符串中指定位置的字符
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <param name="index">位置下标</param>
/// <returns>字符</returns>
/// <exception cref="IndexOutOfRangeException"></exception>
public static char GetHexChar(string hex, int index)

IsHexChar-判断一个字符是否是16进制字符

/// <summary>
/// 判断一个字符是否是16进制字符
/// </summary>
/// <param name="c">字符</param>
/// <returns></returns>
public static bool IsHexChar(char c)

ReplaceHexChar-将16进制字符串中指定位置的字符替换为新的字符

/// <summary>
/// 将16进制字符串中指定位置的字符替换为新的字符
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <param name="index">指定位置</param>
/// <param name="newChar">替换字符</param>
/// <returns>新16进制字符串</returns>
/// <exception cref="ArgumentException"></exception>
public static string ReplaceHexChar(string hex, int index, char newChar)

/// <summary>
/// 将16进制字符串中指定位置的字符替换为新的字符
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <param name="index">位置下标</param>
/// <param name="newHexChar">16进制字符</param>
/// <returns>新16进制字符串</returns>
/// <exception cref="ArgumentException"></exception>
public static string ReplaceHexChar(string hex, int index, string newHexChar)

/// <summary>
/// 将16进制字符串中指定位置的字符替换为新的字符
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <param name="index">位置下标</param>
/// <param name="newByte">字符</param>
/// <returns>新16进制字符串</returns>
public static string ReplaceHexChar(string hex, int index, byte newByte)

/// <summary>
/// 将16进制字符串中指定位置的字符替换为新的字符
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <param name="index">位置下标</param>
/// <param name="newInt">字符</param>
/// <returns>新16进制字符串</returns>
public static string ReplaceHexChar(string hex, int index, int newInt)

InsertHexChar-在16进制字符串的指定位置插入新的字符

/// <summary>
/// 在16进制字符串的指定位置插入新的字符
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <param name="index">位置下标</param>
/// <param name="newChar">字符</param>
/// <returns>新16进制字符串</returns>
/// <exception cref="ArgumentException"></exception>
public static string InsertHexChar(string hex, int index, char newChar)

/// <summary>
/// 在16进制字符串的指定位置插入新的字符
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <param name="index">位置下标</param>
/// <param name="newHexChar">字符</param>
/// <returns>新16进制字符串</returns>
/// <exception cref="ArgumentException"></exception>
public static string InsertHexChar(string hex, int index, string newHexChar)

/// <summary>
/// 在16进制字符串的指定位置插入新的字符
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <param name="index">位置下标</param>
/// <param name="newByte">字符</param>
/// <returns新16进制字符串></returns>
public static string InsertHexChar(string hex, int index, byte newByte)

/// <summary>
/// 在16进制字符串的指定位置插入新的字符
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <param name="index">位置下标</param>
/// <param name="newInt">字符</param>
/// <returns>新16进制字符串</returns>
public static string InsertHexChar(string hex, int index, int newInt)

RemoveHexChar-从16进制字符串中移除指定位置的字符

/// <summary>
/// 从16进制字符串中移除指定位置的字符
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <param name="index">位置下标</param>
/// <returns>新16进制字符串</returns>
/// <exception cref="IndexOutOfRangeException"></exception>
public static string RemoveHexChar(string hex, int index)

MoveHexChar-将16进制字符串中指定位置的字符移动到新的位置

/// <summary>
/// 将16进制字符串中指定位置的字符移动到新的位置
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <param name="fromIndex">移动前位置</param>
/// <param name="toIndex">移动后位置</param>
/// <returns>新16进制字符串</returns>
/// <exception cref="IndexOutOfRangeException"></exception>
public static string MoveHexChar(string hex, int fromIndex, int toIndex)

ShiftHexChar-将16进制字符串中指定位置的字符移动指定的步长

/// <summary>
/// 将16进制字符串中指定位置的字符移动指定的步长
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <param name="index">位置下标</param>
/// <param name="steps">步长</param>
/// <returns>新16进制字符串</returns>
/// <exception cref="IndexOutOfRangeException"></exception>
public static string ShiftHexChar(string hex, int index, int steps)

ShiftHexCharLeft-将16进制字符串中指定位置的字符向左移动1位

/// <summary>
/// 将16进制字符串中指定位置的字符向左移动1位
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <param name="index">位置下标</param>
/// <returns>新16进制字符串</returns>
public static string ShiftHexCharLeft(string hex, int index)

ShiftHexCharRight-将16进制字符串中指定位置的字符向右移动1位

/// <summary>
/// 将16进制字符串中指定位置的字符向右移动1位
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <param name="index">位置下标</param>
/// <returns></returns>
public static string ShiftHexCharRight(string hex, int index)

RotateHexCharLeft-将16进制字符串中指定位置的字符向左旋转1位

/// <summary>
/// 将16进制字符串中指定位置的字符向左旋转1位
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <param name="index">位置下标</param>
/// <returns>新16进制字符串</returns>
/// <exception cref="IndexOutOfRangeException"></exception>
public static string RotateHexCharLeft(string hex, int index)

RotateHexCharRight-将16进制字符串中指定位置的字符向右旋转1位

/// <summary>
/// 将16进制字符串中指定位置的字符向右旋转1位
/// </summary>
/// <param name="hex">16进制字符串</param>
/// <param name="index">位置下标</param>
/// <returns>新16进制字符串</returns>
/// <exception cref="IndexOutOfRangeException"></exception>
public static string RotateHexCharRight(string hex, int index)

使用示例

using System;
using HexUtil;

namespace HexUtilExample
{
    class Program
    {
        static void Main(string[] args)
        {
            string hex1 = "FF00";
            string hex2 = "FF01";
            byte[] bytes = HexUtil.HexToBytes(hex1);

            Console.WriteLine("Hex1: " + hex1);
            Console.WriteLine("Hex2: " + hex2);
            Console.WriteLine("Bytes: " + BitConverter.ToString(bytes));
            Console.WriteLine("Hex1 equals Hex2: " + HexUtil.HexEquals(hex1, hex2));
            Console.WriteLine("Hex1 as integer: " + HexUtil.HexToInt(hex1));
            Console.WriteLine("Integer 255 as hex: " + HexUtil.IntToHex(255));
            Console.WriteLine("Hex1 to upper case: " + HexUtil.HexToUpper(hex1));
            Console.WriteLine("Hex2 to lower case: " + HexUtil.HexToLower(hex2));
            Console.WriteLine("Character at position 2 in Hex1: " + HexUtil.GetHexChar(hex1, 2));
            Console.WriteLine("Replacing character at position 2 in Hex1 with 'A': " + HexUtil.ReplaceHexChar(hex1, 2, 'A'));
            Console.WriteLine("Inserting 'F' at position 3 in Hex1: " + HexUtil.InsertHexChar(hex1, 3, 'F'));
            Console.WriteLine("Removing character at position 1 in Hex1: " + HexUtil.RemoveHexChar(hex1, 1));
            Console.WriteLine("Moving character from position 0 to position 2 in Hex1: " + HexUtil.MoveHexChar(hex1, 0, 2));
            Console.WriteLine("Shifting character at position 1 in Hex1 to the left: " + HexUtil.ShiftHexCharLeft(hex1, 1));
            Console.WriteLine("Shifting character at position 2 in Hex1 to the right: " + HexUtil.ShiftHexCharRight(hex1, 2));
            Console.WriteLine("Rotating character at position 3 in Hex1 to the left: " + HexUtil.RotateHexCharLeft(hex1, 3));
            Console.WriteLine("Rotating character at position 0 in Hex1 to the right: " + HexUtil.RotateHexCharRight(hex1, 0));
        }
    }
}