精华内容
下载资源
问答
  • 真正十六进制编辑器-精品源代码 真正十六进制编辑器-精品源代码
  • 支持十六进制/二进制编辑 支持文件内查找/十六进制输出 允许文字大小/类型/颜色/背景的设置
  • - 修改了经典的HexEdit源码 - 支持Unicode编译 - 增加了剪切的功能 - 修改了粘贴的功能,支持覆盖粘贴 - 修改了如果数据长度为0是可能错误的BUG。
  • WinHex_17.8, 超好用,功能强大的十六进制文件编辑器,可以编辑磁盘,U盘,闪存等的分区表,文件分配表等,也可编辑游戏的存档文件等等。
  • TTHexEdit 是一个十六进制文件编辑器,你可以编辑、剪切、复制、粘贴、插入或删除文件数据,可以边编辑边查看各种数据类型,可以跳转到某个地址处,可以查找并替换文件数据等待,界面美观,一切易于操作。...
  • 十六进制编辑器可以用来检查和修复各种文件、恢复删除文件、硬盘损坏造成的数据丢失等。它一直是计算机专业人员非常喜欢的工具。 其实,如果将它用在一个恰当的环境中,十六进制编辑器能够发现Windows以及一些应用...
  • FC专用16进制编辑器.zip
  • 任务二:掌握进制编辑器 拓展:修改游戏存档 自测 任务一:用『0』和『1』绘图 在code.org上注册账号,完成与计算机像素相关的系列任务(https://studio.code.org/s/pixelation) 通过二进制的 0 和 1 『画』...

    目录

    任务一:用『0』和『1』绘图

    任务二:掌握进制编辑器

    拓展:修改游戏存档

    自测


    任务一:用『0』和『1』绘图

    • 通过二进制的 0 和 1 『画』图:这里设置的像素位数为1,也就是每1位数代表着一个颜色值,1表示黑色,0表示白色。

    • 计算机二进制存储图片文件的原理:
    图像文件存储的都是每一个像素对应的颜色值。
    
    1、位图文件有两种存储像素数据的格式。16777216色(真彩色)的图像,一个像素的颜色可以用24位数据表示。256色的图像可以用调色板对颜色的信息进行编码,一个像素的值对应的是调色板的索引,而不是直接对应一个像素的颜色,调色板的索引映射为像素的颜色。
    
    2、以一百万个像素,256种颜色的BMP文件在电脑上的存储为例。这个文件包括一个十四字节的文件首部,一个四十字节的信息首部,一个1024字节的颜色表,一兆字节的位图数据。文件首部的前两个字节由字符BM组成,还包括了文件长度和位图数据在文件中的起始位置。
    
    3、文件的信息首部包含了图像的高、宽、颜色数等非图形数据。这个图像共有一百万个像素,一个像素需要八位的颜色信息,文件的这一部分的长度是一百万个字节,字节排放的顺序是自左到右从图像的最下面那行开始,这个文件的总大小是1001078字节。
    
    作者:Alone
    链接:https://www.zhihu.com/question/65771363/answer/391740385
    来源:知乎
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

    任务二:掌握进制编辑器

    • 使用进制编辑器修改文本内容
    • 工具:Hex Editor Neo

    首先用Windows自带的记事本新建一个文本,里面输入想要输入的内容,如图(输入中文字符的话会麻烦很多,这里暂时先用英文字符举例(其实是我还没搞懂中文字符怎么改,如果有大佬知道的话还望不吝赐教。◕ᴗ◕。))

    再把它拖入进制编辑器中;拖入后现在看起来好像还不是很明白这些数字到底是什么意思,我们将数据的显示方式改成十进制再看(路径:View->Display As),

    ↓↓↓↓

    到了现在就一目了然了,这些数字不就是字符的 ASCII码 嘛,将其稍作修改,编辑器右侧会实时显示修改的内容,在记事本中打开也如此:

    拓展:修改游戏存档

    • 修改 植物大战僵尸 的存档,(修改游戏关卡、金币,通过修改解锁『迷你游戏』和『生存模式』)

    首先进入游戏创建一个角色玩几局,然后进入游戏的存档路径 C:\ProgramData\PopCap Games\PlantsVsZombies\userdata (其中 ProgramData 这个文件夹默认是隐藏的,需要开启显示影藏项目才可以看到),发现其中有两个文件:users.dat、user1.dat。其中 users 保存的是刚刚创建的角色信息, user1 保存的才是该角色的游戏存档(由于版本原因,也有可能信息是全保存在一个文件里),废话不多说直接进入正题。

    每通过一关再重新打开存档文件就可以发现,文件中 04 列的数值一直在发生变化,进行到第二关的时候数值为 02,第三关的时候数值为 03,

    在这里插入图片描述

    想必这就是关卡的存档数据,直接对其进行修改,因为当前选择的数据显示方式为十六进制,所以修改时需要注意进制的转换,将其修改为 29,关卡成功来到 5-1.

    发现了规律后,剩下也就简单了,经过研究后发现,修改 08 09 0a 0b 列的数值会使金币发生变化,但是最大好像只能修改到 255 255 255 88 ,0b 列再改大的话,金币就会变成负数。

    将 0c列的数值修改为 01,全部内容就会解锁:

    自测

    • 110101010001转十六进制是多少?有什么最快的计算方法能得到结果?

    答:使用 8421 方法,得出结果为 d51.

    8421法:
    1、如果是整数,从它的低位到高位每4位数为一组,不足四位则往左侧补0,将每组对应的数用十六进制表示出来即可:
     8 4 2 1   8 4 2 1   8 4 2 1
    (1 1 0 1) (0 1 0 1) (0 0 0 1)
       |||       |||       |||
        d         5         1
    2、如果有小数部分,则从小数点开始,分别向左右两边,左侧不足4位,在左侧补0;右侧不足4位,在右侧补0:
    (0 1 0 1).(0 1 1 0) (1 1 0 0)
       |||       |||       |||
        5         6         c
    二进制 101.011011 转换成十六进制为:5.6c
    • 101011.101011对应的十进制是多少?
    (2^5 * 1 + 2^4 * 0 + 2^3 * 1 + 2^2 * 0 + 2^1 * 1 + 2^0 * 1) 
    + (2^-1 * 1 + 2^-2 * 0 + 2^-3 * 1 + 2^-4 * 0 + 2^-5 * 1 + 2^-6 * 1) 
    = 43.671875
    • 常见的音频编码格式有哪些?
    音频编码格式总共有以下10种,生活中最常见的非 MP3 莫属
    1、CDA
    2、WAV
    3、MP3/MP3 Pro
    4、WMA
    5、RA
    6、MIDI
    7、OGG
    8、APE
    9、FLAC
    10、AAC
    • 常见的视频编码格式有哪些?
    视频编码格式总共有以下 7 种,常见的有:AVI、MOV、MP4
    1、AVI
    2、MOV
    3、RMVB
    4、RM
    5、FLV
    6、MP4
    7、3GP
    • 一个尺寸8*8大小的png全黑图片前四个字节的十六进制值是什么?
    尝试后结果为:89 50 4e 47,原理等弄清楚再更新
    • UTF8三字节的编码方式为:1110xxxx 10xxxxxx 10xxxxxx,汉字【中】的Unicode编码十六进制值是0x4e2d,Unicode编码按三字节编码转换到十六进制的UTF8编码的计算过程是什么?
    先将 4e2d 转换成二进制 -> 100111000101101
    然后把得到的二进制数从低位到高位,依次从右至左填入1110xxxx 10xxxxxx 10xxxxxx
    得到 11101001 10111000 10101101
    再将得到的二进制数转换到十六进制,得到的 e4b8ad 即为结果
    • 如果要提供一个实时的流媒体服务器,除了ffmpeg,还需要使用哪个组件?
    还需要 ffserver
    
    参考文档:https://www.cnblogs.com/lidabo/p/3701071.html

    展开全文
  • UltraEdit、WinHex之类16进制编辑器在程序设计和文件修改的过程中作用很大——比如你可能会用编辑器来修改游戏的存档……我个人比较习惯使用的编辑器是HxD,但它依然需要你下载一个小小的安装包。而如果你在网吧、在...

    107039563_1

    UltraEdit、WinHex之类16进制编辑器在程序设计和文件修改的过程中作用很大——比如你可能会用编辑器来修改游戏的存档……

    我个人比较习惯使用的编辑器是HxD,但它依然需要你下载一个小小的安装包。而如果你在网吧、在酒店、在老家,或是在所有不适合往本地硬盘上写入东西的情况下,你就需要一款在线的16进制编辑器了。Hexed.it可能正是你想要的!

    107039563_2

    Flash已经死而未僵,替代者正齐头并进。这款使用HTML5和JavaScript的编辑器为我们提供了一个非常舒适的在线编辑环境。据编辑使用来看,其编辑过程非常流畅,不存在卡顿的现象。它可以按照你的设定格式来显示十六进制和ASCII的数据。它还可以将内容以特定的格式进行整理显示,如8位整数,32位整数,日期和时间等。它甚至可以调整数据的大端和小端。

    107039563_3

    对于文件格式,该工具可以扫描文件以将它与近7000种文件类型进行自动识别和匹配,并应用语法方案。你可以将设定导出到本地硬盘驱动器。根据网站的陈述来看,这个程序不会将任何数据发送到他们的网络服务器,同时它也不使用内存来缓存整个文件,因此同一时间,一台机器上可以进行大量的文件编辑。这个在线程序的缺点可能是它不能将读取和写入成一些特定的格式(如Intel hex或Motorola S-record文件)。虽然我们可以使用srec_cat这样的工具将这些文件转换为特定格式的二进制文件,不过与其这样,还不如下载一个专门的本地编辑器呢!

    展开全文
  • 如何将字节数组转换为十六进制字符串,反之亦然?

    如何将字节数组转换为十六进制字符串,反之亦然?


    #1楼

    在此不谈很多答案,但我发现十六进制字符串解析器的实现相当理想(比公认的要好约4.5倍),直接实现。 首先,我的测试输出(第一批是我的实现):

    Give me that string:
    04c63f7842740c77e545bb0b2ade90b384f119f6ab57b680b7aa575a2f40939f
    
    Time to parse 100,000 times: 50.4192 ms
    Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58=
    BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5
    7-B6-80-B7-AA-57-5A-2F-40-93-9F
    
    Accepted answer: (StringToByteArray)
    Time to parse 100000 times: 233.1264ms
    Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58=
    BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5
    7-B6-80-B7-AA-57-5A-2F-40-93-9F
    
    With Mono's implementation:
    Time to parse 100000 times: 777.2544ms
    Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58=
    BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5
    7-B6-80-B7-AA-57-5A-2F-40-93-9F
    
    With SoapHexBinary:
    Time to parse 100000 times: 845.1456ms
    Result as base64: BMY/eEJ0DHflRbsLKt6Qs4TxGfarV7aAt6pXWi9Ak58=
    BitConverter'd: 04-C6-3F-78-42-74-0C-77-E5-45-BB-0B-2A-DE-90-B3-84-F1-19-F6-AB-5
    7-B6-80-B7-AA-57-5A-2F-40-93-9F
    

    base64和'BitConverter'd'行在那里测试正确性。 请注意,它们是相等的。

    实现:

    public static byte[] ToByteArrayFromHex(string hexString)
    {
      if (hexString.Length % 2 != 0) throw new ArgumentException("String must have an even length");
      var array = new byte[hexString.Length / 2];
      for (int i = 0; i < hexString.Length; i += 2)
      {
        array[i/2] = ByteFromTwoChars(hexString[i], hexString[i + 1]);
      }
      return array;
    }
    
    private static byte ByteFromTwoChars(char p, char p_2)
    {
      byte ret;
      if (p <= '9' && p >= '0')
      {
        ret = (byte) ((p - '0') << 4);
      }
      else if (p <= 'f' && p >= 'a')
      {
        ret = (byte) ((p - 'a' + 10) << 4);
      }
      else if (p <= 'F' && p >= 'A')
      {
        ret = (byte) ((p - 'A' + 10) << 4);
      } else throw new ArgumentException("Char is not a hex digit: " + p,"p");
    
      if (p_2 <= '9' && p_2 >= '0')
      {
        ret |= (byte) ((p_2 - '0'));
      }
      else if (p_2 <= 'f' && p_2 >= 'a')
      {
        ret |= (byte) ((p_2 - 'a' + 10));
      }
      else if (p_2 <= 'F' && p_2 >= 'A')
      {
        ret |= (byte) ((p_2 - 'A' + 10));
      } else throw new ArgumentException("Char is not a hex digit: " + p_2, "p_2");
    
      return ret;
    }
    

    我尝试了一些东西与unsafe和移动(显然是多余)字符到四位if序列的另一种方法,但这是它得到了最快的。

    (我承认这回答了一半的问题。我认为string-> byte []转换的代表性不足,而byte []-> string的角度似乎已被很好地涵盖了。因此,此答案。)


    #2楼

    并用于插入SQL字符串(如果您不使用命令参数):

    public static String ByteArrayToSQLHexString(byte[] Source)
    {
        return = "0x" + BitConverter.ToString(Source).Replace("-", "");
    }
    

    #3楼

    编写加密代码时,通常要避免依赖数据的分支和表查找,以确保运行时不依赖数据,因为依赖数据的时序会导致边信道攻击。

    它也非常快。

    static string ByteToHexBitFiddle(byte[] bytes)
    {
        char[] c = new char[bytes.Length * 2];
        int b;
        for (int i = 0; i < bytes.Length; i++) {
            b = bytes[i] >> 4;
            c[i * 2] = (char)(55 + b + (((b-10)>>31)&-7));
            b = bytes[i] & 0xF;
            c[i * 2 + 1] = (char)(55 + b + (((b-10)>>31)&-7));
        }
        return new string(c);
    }
    

    Ph'nglui mglw'nafh Cthulhu R'lyeh wgah'nagl fhtagn


    放弃所有希望,进入这里的你们

    奇怪的摆弄的解释:

    1. bytes[i] >> 4提取一个字节的高半字节
      bytes[i] & 0xF提取字节的低半字节
    2. b - 10
      对于b < 10< 0 ,它将成为一个十进制数字
      对于值b > 10等于>= 0 ,这将成为从AF的字母。
    3. 由于符号扩展,对有符号的32位整数使用i >> 31提取符号。 这将是-1i < 00i >= 0
    4. 组合2)和3),表明(b-10)>>31对于字母将为0 ,对于数字为-1
    5. 查看字母的大小写,最后一个被加数变为0 ,并且b在10到15的范围内。我们想将其映射到A (65)到F (70),这意味着添加55( 'A'-10 ) 。
    6. 考虑数字的大小写,我们要调整最后一个被加数,以便将b从0到9的范围映射到0 (48)到9 (57)的范围。 这意味着它需要变为-7( '0' - 55 )。
      现在我们可以乘以7。但是由于-1表示所有位均为1,因此我们可以使用& -7因为(0 & -7) == 0(-1 & -7) == -7

    一些进一步的考虑:

    • 我没有使用第二个循环变量来索引c ,因为测量表明从i计算更便宜。
    • 精确地使用i < bytes.Length作为循环的上限允许JITter消除对bytes[i]边界检查,因此我选择了该变体。
    • b为int允许从字节到字节的不必要转换。

    #4楼

    两个混搭将两个半字节操作折叠为一个。

    可能是非常有效的版本:

    public static string ByteArrayToString2(byte[] ba)
    {
        char[] c = new char[ba.Length * 2];
        for( int i = 0; i < ba.Length * 2; ++i)
        {
            byte b = (byte)((ba[i>>1] >> 4*((i&1)^1)) & 0xF);
            c[i] = (char)(55 + b + (((b-10)>>31)&-7));
        }
        return new string( c );
    }
    

    a废linq-with-bit-hacking版本:

    public static string ByteArrayToString(byte[] ba)
    {
        return string.Concat( ba.SelectMany( b => new int[] { b >> 4, b & 0xF }).Select( b => (char)(55 + b + (((b-10)>>31)&-7))) );
    }
    

    反过来:

    public static byte[] HexStringToByteArray( string s )
    {
        byte[] ab = new byte[s.Length>>1];
        for( int i = 0; i < s.Length; i++ )
        {
            int b = s[i];
            b = (b - '0') + ((('9' - b)>>31)&-7);
            ab[i>>1] |= (byte)(b << 4*((i&1)^1));
        }
        return ab;
    }
    

    #5楼

    这是我的照片。 我创建了一对扩展类来扩展字符串和字节。 在大文件测试中,性能可与Byte Manipulation 2媲美。

    下面的ToHexString代码是查找和移位算法的优化实现。 它几乎与Behrooz的相同,但是事实证明,使用foreach进行迭代,并且计数器比的显式索引for快。

    它在我的机器上的字节操作2之后排在第二位,并且代码可读性强。 以下测试结果也很有趣:

    ToHexStringCharArrayWithCharArrayLookup:41,589.69平均滴答声(超过1000次运行),1.5X ToHexStringCharArrayWithStringLookup:50,764.06平均滴答声(超过1000次运行),1.2X ToHexStringStringBuilderWithCharArrayLookup:62,812.87平均滴答声(超过1000次运行),1.0X

    根据以上结果,可以得出结论:

    1. 在大型文件测试中,索引到字符串以执行查找与char数组相比要付出很大的代价。
    2. 使用已知容量的StringBuilder与已知大小的char数组来创建字符串的代价甚至更大。

    这是代码:

    using System;
    
    namespace ConversionExtensions
    {
        public static class ByteArrayExtensions
        {
            private readonly static char[] digits = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
    
            public static string ToHexString(this byte[] bytes)
            {
                char[] hex = new char[bytes.Length * 2];
                int index = 0;
    
                foreach (byte b in bytes)
                {
                    hex[index++] = digits[b >> 4];
                    hex[index++] = digits[b & 0x0F];
                }
    
                return new string(hex);
            }
        }
    }
    
    
    using System;
    using System.IO;
    
    namespace ConversionExtensions
    {
        public static class StringExtensions
        {
            public static byte[] ToBytes(this string hexString)
            {
                if (!string.IsNullOrEmpty(hexString) && hexString.Length % 2 != 0)
                {
                    throw new FormatException("Hexadecimal string must not be empty and must contain an even number of digits to be valid.");
                }
    
                hexString = hexString.ToUpperInvariant();
                byte[] data = new byte[hexString.Length / 2];
    
                for (int index = 0; index < hexString.Length; index += 2)
                {
                    int highDigitValue = hexString[index] <= '9' ? hexString[index] - '0' : hexString[index] - 'A' + 10;
                    int lowDigitValue = hexString[index + 1] <= '9' ? hexString[index + 1] - '0' : hexString[index + 1] - 'A' + 10;
    
                    if (highDigitValue < 0 || lowDigitValue < 0 || highDigitValue > 15 || lowDigitValue > 15)
                    {
                        throw new FormatException("An invalid digit was encountered. Valid hexadecimal digits are 0-9 and A-F.");
                    }
                    else
                    {
                        byte value = (byte)((highDigitValue << 4) | (lowDigitValue & 0x0F));
                        data[index / 2] = value;
                    }
                }
    
                return data;
            }
        }
    }
    

    以下是将代码放入计算机上@patridge的测试项目中时得到的测试结果。 我还添加了一个从十六进制转换为字节数组的测试。 行使我的代码的测试运行是ByteArrayToHexViaOptimizedLookupAndShift和HexToByteArrayViaByteManipulation。 HexToByteArrayViaConvertToByte来自XXXX。 HexToByteArrayViaSoapHexBinary是@Mykroft的答案之一。

    英特尔奔腾III至强处理器

      Cores: 4 <br/> Current Clock Speed: 1576 <br/> Max Clock Speed: 3092 <br/> 

    将字节数组转换为十六进制字符串表示形式


    ByteArrayToHexViaByteManipulation2:39,366.64个平均滴答声(超过1000次运行),22.4X

    ByteArrayToHexViaOptimizedLookupAndShift:平均滴答声41588.64(运行1000多次),21.2X

    ByteArrayToHexViaLookup:55,509.56平均滴答声(超过1000次运行),15.9X

    ByteArrayToHexViaByteManipulation:65,349.12平均滴答声(超过1000次运行),13.5X

    ByteArrayToHexViaLookupAndShift:平均滴答声86,926.87(运行1000多次),10.2倍

    ByteArrayToHexStringViaBitConverter:139,353.73平均滴答声(运行1000多次),6.3X

    ByteArrayToHexViaSoapHexBinary:314,598.77平均滴答声(运行1000多次),2.8X

    ByteArrayToHexStringViaStringBuilderForEachByteToString:344,264.63平均滴答声(运行1000多次),2.6X

    ByteArrayToHexStringViaStringBuilderAggregateByteToString:382,623.44平均滴答声(运行1000多次),2.3倍

    ByteArrayToHexStringViaStringBuilderForEachAppendFormat:平均滴答声(超过1000次运行)为818,111.95,1.1X

    ByteArrayToHexStringViaStringConcatArrayConvertAll:839,244.84平均滴答声(运行1000多次),1.1X

    ByteArrayToHexStringViaStringBuilderAggregateAppendFormat:平均滴答声(超过1000次运行),1.0X

    ByteArrayToHexStringViaStringJoinArrayConvertAll:882,710.28平均滴答声(运行1000多次),1.0X



    #6楼

    通过@CodesInChaos回答的补充(反向方法)

    public static byte[] HexToByteUsingByteManipulation(string s)
    {
        byte[] bytes = new byte[s.Length / 2];
        for (int i = 0; i < bytes.Length; i++)
        {
            int hi = s[i*2] - 65;
            hi = hi + 10 + ((hi >> 31) & 7);
    
            int lo = s[i*2 + 1] - 65;
            lo = lo + 10 + ((lo >> 31) & 7) & 0x0f;
    
            bytes[i] = (byte) (lo | hi << 4);
        }
        return bytes;
    }
    

    说明:

    & 0x0f也支持小写字母

    hi = hi + 10 + ((hi >> 31) & 7); 是相同的:

    hi = ch-65 + 10 + (((ch-65) >> 31) & 7);

    对于“ 0” ..“ 9”,它与hi = ch - 65 + 10 + 7; hi = ch - 48 (这是因为0xffffffff & 7 )。

    对于“ A” ..“ F”,它是hi = ch - 65 + 10; (这是因为0x00000000 & 7 )。

    对于'a'..'f',我们必须使用大数字,因此必须通过使用& 0x0f将一些位设置为0 ,从而从默认版本中减去32。

    65是'A'代码

    48是代码'0'

    7是ASCII表中'9''A'之间的字母数( ...456789:;<=>?@ABCD... )。


    #7楼

    此版本的ByteArrayToHexViaByteManipulation可能会更快。

    从我的报告中:

    • ByteArrayToHexViaByteManipulation3:1,68个平均滴答声(运行1000次以上),17.5X
    • ByteArrayToHexViaByteManipulation2:1,73个平均滴答声(超过1000次运行),16,9X
    • ByteArrayToHexViaByteManipulation:2,90平均滴答声(超过1000次运行),10,1X
    • ByteArrayToHexViaLookupAndShift:3,22个平均滴答声(超过1000次运行),9,1X
    • ...

       static private readonly char[] hexAlphabet = new char[] {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; static string ByteArrayToHexViaByteManipulation3(byte[] bytes) { char[] c = new char[bytes.Length * 2]; byte b; for (int i = 0; i < bytes.Length; i++) { b = ((byte)(bytes[i] >> 4)); c[i * 2] = hexAlphabet[b]; b = ((byte)(bytes[i] & 0xF)); c[i * 2 + 1] = hexAlphabet[b]; } return new string(c); } 

    我认为这是一种优化:

        static private readonly char[] hexAlphabet = new char[]
            {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
        static string ByteArrayToHexViaByteManipulation4(byte[] bytes)
        {
            char[] c = new char[bytes.Length * 2];
            for (int i = 0, ptr = 0; i < bytes.Length; i++, ptr += 2)
            {
                byte b = bytes[i];
                c[ptr] = hexAlphabet[b >> 4];
                c[ptr + 1] = hexAlphabet[b & 0xF];
            }
            return new string(c);
        }
    

    #8楼

    尚未针对速度进行优化,但是比大多数答案(.NET 4.0)更多的LINQy:

    <Extension()>
    Public Function FromHexToByteArray(hex As String) As Byte()
        hex = If(hex, String.Empty)
        If hex.Length Mod 2 = 1 Then hex = "0" & hex
        Return Enumerable.Range(0, hex.Length \ 2).Select(Function(i) Convert.ToByte(hex.Substring(i * 2, 2), 16)).ToArray
    End Function
    
    <Extension()>
    Public Function ToHexString(bytes As IEnumerable(Of Byte)) As String
        Return String.Concat(bytes.Select(Function(b) b.ToString("X2")))
    End Function
    

    #9楼

    另一个快速功能...

    private static readonly byte[] HexNibble = new byte[] {
        0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
        0x8, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
        0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF, 0x0,
        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
        0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF
    };
    
    public static byte[] HexStringToByteArray( string str )
    {
        int byteCount = str.Length >> 1;
        byte[] result = new byte[byteCount + (str.Length & 1)];
        for( int i = 0; i < byteCount; i++ )
            result[i] = (byte) (HexNibble[str[i << 1] - 48] << 4 | HexNibble[str[(i << 1) + 1] - 48]);
        if( (str.Length & 1) != 0 )
            result[byteCount] = (byte) HexNibble[str[str.Length - 1] - 48];
        return result;
    }
    

    #10楼

    这是一个很棒的帖子。 我喜欢Waleed的解决方案。 我还没有通过patridge的测试来运行它,但是它似乎很快。 我还需要反向过程,将十六进制字符串转换为字节数组,因此我将其编写为与Waleed解决方案相反。 不知道它是否比Tomalak的原始解决方案更快。 同样,我也没有通过patridge的测试进行相反的过程。

    private byte[] HexStringToByteArray(string hexString)
    {
        int hexStringLength = hexString.Length;
        byte[] b = new byte[hexStringLength / 2];
        for (int i = 0; i < hexStringLength; i += 2)
        {
            int topChar = (hexString[i] > 0x40 ? hexString[i] - 0x37 : hexString[i] - 0x30) << 4;
            int bottomChar = hexString[i + 1] > 0x40 ? hexString[i + 1] - 0x37 : hexString[i + 1] - 0x30;
            b[i / 2] = Convert.ToByte(topChar + bottomChar);
        }
        return b;
    }
    

    #11楼

    安全版本:

    public static class HexHelper
    {
        [System.Diagnostics.Contracts.Pure]
        public static string ToHex(this byte[] value)
        {
            if (value == null)
                throw new ArgumentNullException("value");
    
            const string hexAlphabet = @"0123456789ABCDEF";
    
            var chars = new char[checked(value.Length * 2)];
            unchecked
            {
                for (int i = 0; i < value.Length; i++)
                {
                    chars[i * 2] = hexAlphabet[value[i] >> 4];
                    chars[i * 2 + 1] = hexAlphabet[value[i] & 0xF];
                }
            }
            return new string(chars);
        }
    
        [System.Diagnostics.Contracts.Pure]
        public static byte[] FromHex(this string value)
        {
            if (value == null)
                throw new ArgumentNullException("value");
            if (value.Length % 2 != 0)
                throw new ArgumentException("Hexadecimal value length must be even.", "value");
    
            unchecked
            {
                byte[] result = new byte[value.Length / 2];
                for (int i = 0; i < result.Length; i++)
                {
                    // 0(48) - 9(57) -> 0 - 9
                    // A(65) - F(70) -> 10 - 15
                    int b = value[i * 2]; // High 4 bits.
                    int val = ((b - '0') + ((('9' - b) >> 31) & -7)) << 4;
                    b = value[i * 2 + 1]; // Low 4 bits.
                    val += (b - '0') + ((('9' - b) >> 31) & -7);
                    result[i] = checked((byte)val);
                }
                return result;
            }
        }
    }
    

    不安全版本适用于喜欢性能且不怕不安全的人。 ToHex快大约35%,FromHex快10%。

    public static class HexUnsafeHelper
    {
        [System.Diagnostics.Contracts.Pure]
        public static unsafe string ToHex(this byte[] value)
        {
            if (value == null)
                throw new ArgumentNullException("value");
    
            const string alphabet = @"0123456789ABCDEF";
    
            string result = new string(' ', checked(value.Length * 2));
            fixed (char* alphabetPtr = alphabet)
            fixed (char* resultPtr = result)
            {
                char* ptr = resultPtr;
                unchecked
                {
                    for (int i = 0; i < value.Length; i++)
                    {
                        *ptr++ = *(alphabetPtr + (value[i] >> 4));
                        *ptr++ = *(alphabetPtr + (value[i] & 0xF));
                    }
                }
            }
            return result;
        }
    
        [System.Diagnostics.Contracts.Pure]
        public static unsafe byte[] FromHex(this string value)
        {
            if (value == null)
                throw new ArgumentNullException("value");
            if (value.Length % 2 != 0)
                throw new ArgumentException("Hexadecimal value length must be even.", "value");
    
            unchecked
            {
                byte[] result = new byte[value.Length / 2];
                fixed (char* valuePtr = value)
                {
                    char* valPtr = valuePtr;
                    for (int i = 0; i < result.Length; i++)
                    {
                        // 0(48) - 9(57) -> 0 - 9
                        // A(65) - F(70) -> 10 - 15
                        int b = *valPtr++; // High 4 bits.
                        int val = ((b - '0') + ((('9' - b) >> 31) & -7)) << 4;
                        b = *valPtr++; // Low 4 bits.
                        val += (b - '0') + ((('9' - b) >> 31) & -7);
                        result[i] = checked((byte)val);
                    }
                }
                return result;
            }
        }
    }
    

    BTW为了进行基准测试,每次调用的转换函数错误时初始化字母,字母必须为const(对于字符串)或静态只读(对于char [])。 然后,基于字母的byte []到字符串的转换变得和字节操作版本一样快。

    当然,测试必须在Release(带有优化)中进行编译,并且调试选项“抑制JIT优化”处于关闭状态(如果代码必须是可调试的,则与“ Enable Just My Code”相同)。


    #12楼

    我将参加这个有点挑剔的比赛,因为我有一个答案,该答案也使用了点缀十六进制进行解码 。 请注意,使用字符数组可能更快,因为调用StringBuilder方法也将花费时间。

    public static String ToHex (byte[] data)
    {
        int dataLength = data.Length;
        // pre-create the stringbuilder using the length of the data * 2, precisely enough
        StringBuilder sb = new StringBuilder (dataLength * 2);
        for (int i = 0; i < dataLength; i++) {
            int b = data [i];
    
            // check using calculation over bits to see if first tuple is a letter
            // isLetter is zero if it is a digit, 1 if it is a letter
            int isLetter = (b >> 7) & ((b >> 6) | (b >> 5)) & 1;
    
            // calculate the code using a multiplication to make up the difference between
            // a digit character and an alphanumerical character
            int code = '0' + ((b >> 4) & 0xF) + isLetter * ('A' - '9' - 1);
            // now append the result, after casting the code point to a character
            sb.Append ((Char)code);
    
            // do the same with the lower (less significant) tuple
            isLetter = (b >> 3) & ((b >> 2) | (b >> 1)) & 1;
            code = '0' + (b & 0xF) + isLetter * ('A' - '9' - 1);
            sb.Append ((Char)code);
        }
        return sb.ToString ();
    }
    
    public static byte[] FromHex (String hex)
    {
    
        // pre-create the array
        int resultLength = hex.Length / 2;
        byte[] result = new byte[resultLength];
        // set validity = 0 (0 = valid, anything else is not valid)
        int validity = 0;
        int c, isLetter, value, validDigitStruct, validDigit, validLetterStruct, validLetter;
        for (int i = 0, hexOffset = 0; i < resultLength; i++, hexOffset += 2) {
            c = hex [hexOffset];
    
            // check using calculation over bits to see if first char is a letter
            // isLetter is zero if it is a digit, 1 if it is a letter (upper & lowercase)
            isLetter = (c >> 6) & 1;
    
            // calculate the tuple value using a multiplication to make up the difference between
            // a digit character and an alphanumerical character
            // minus 1 for the fact that the letters are not zero based
            value = ((c & 0xF) + isLetter * (-1 + 10)) << 4;
    
            // check validity of all the other bits
            validity |= c >> 7; // changed to >>, maybe not OK, use UInt?
    
            validDigitStruct = (c & 0x30) ^ 0x30;
            validDigit = ((c & 0x8) >> 3) * (c & 0x6);
            validity |= (isLetter ^ 1) * (validDigitStruct | validDigit);
    
            validLetterStruct = c & 0x18;
            validLetter = (((c - 1) & 0x4) >> 2) * ((c - 1) & 0x2);
            validity |= isLetter * (validLetterStruct | validLetter);
    
            // do the same with the lower (less significant) tuple
            c = hex [hexOffset + 1];
            isLetter = (c >> 6) & 1;
            value ^= (c & 0xF) + isLetter * (-1 + 10);
            result [i] = (byte)value;
    
            // check validity of all the other bits
            validity |= c >> 7; // changed to >>, maybe not OK, use UInt?
    
            validDigitStruct = (c & 0x30) ^ 0x30;
            validDigit = ((c & 0x8) >> 3) * (c & 0x6);
            validity |= (isLetter ^ 1) * (validDigitStruct | validDigit);
    
            validLetterStruct = c & 0x18;
            validLetter = (((c - 1) & 0x4) >> 2) * ((c - 1) & 0x2);
            validity |= isLetter * (validLetterStruct | validLetter);
        }
    
        if (validity != 0) {
            throw new ArgumentException ("Hexadecimal encoding incorrect for input " + hex);
        }
    
        return result;
    }
    

    从Java代码转换而成。


    #13楼

    另一种基于查找表的方法。 这个每个字节只使用一个查询表,而不是每个半字节使用一个查询表。

    private static readonly uint[] _lookup32 = CreateLookup32();
    
    private static uint[] CreateLookup32()
    {
        var result = new uint[256];
        for (int i = 0; i < 256; i++)
        {
            string s=i.ToString("X2");
            result[i] = ((uint)s[0]) + ((uint)s[1] << 16);
        }
        return result;
    }
    
    private static string ByteArrayToHexViaLookup32(byte[] bytes)
    {
        var lookup32 = _lookup32;
        var result = new char[bytes.Length * 2];
        for (int i = 0; i < bytes.Length; i++)
        {
            var val = lookup32[bytes[i]];
            result[2*i] = (char)val;
            result[2*i + 1] = (char) (val >> 16);
        }
        return new string(result);
    }
    

    我还使用查找表中的ushortstruct{char X1, X2}struct{byte X1, X2}测试了它的变体。

    根据编译目标(x86,X64),它们的性能大致相同,或者比此变体稍慢。


    为了获得更高的性能,它的unsafe同级产品:

    private static readonly uint[] _lookup32Unsafe = CreateLookup32Unsafe();
    private static readonly uint* _lookup32UnsafeP = (uint*)GCHandle.Alloc(_lookup32Unsafe,GCHandleType.Pinned).AddrOfPinnedObject();
    
    private static uint[] CreateLookup32Unsafe()
    {
        var result = new uint[256];
        for (int i = 0; i < 256; i++)
        {
            string s=i.ToString("X2");
            if(BitConverter.IsLittleEndian)
                result[i] = ((uint)s[0]) + ((uint)s[1] << 16);
            else
                result[i] = ((uint)s[1]) + ((uint)s[0] << 16);
        }
        return result;
    }
    
    public static string ByteArrayToHexViaLookup32Unsafe(byte[] bytes)
    {
        var lookupP = _lookup32UnsafeP;
        var result = new char[bytes.Length * 2];
        fixed(byte* bytesP = bytes)
        fixed (char* resultP = result)
        {
            uint* resultP2 = (uint*)resultP;
            for (int i = 0; i < bytes.Length; i++)
            {
                resultP2[i] = lookupP[bytesP[i]];
            }
        }
        return new string(result);
    }
    

    或者,如果您认为直接写入字符串是可以接受的:

    public static string ByteArrayToHexViaLookup32UnsafeDirect(byte[] bytes)
    {
        var lookupP = _lookup32UnsafeP;
        var result = new string((char)0, bytes.Length * 2);
        fixed (byte* bytesP = bytes)
        fixed (char* resultP = result)
        {
            uint* resultP2 = (uint*)resultP;
            for (int i = 0; i < bytes.Length; i++)
            {
                resultP2[i] = lookupP[bytesP[i]];
            }
        }
        return result;
    }
    

    #14楼

    有一个名为SoapHexBinary的类可以完全满足您的需求。

    using System.Runtime.Remoting.Metadata.W3cXsd2001;
    
    public static byte[] GetStringToBytes(string value)
    {
        SoapHexBinary shb = SoapHexBinary.Parse(value);
        return shb.Value;
    }
    
    public static string GetBytesToString(byte[] value)
    {
        SoapHexBinary shb = new SoapHexBinary(value);
        return shb.ToString();
    }
    

    #15楼

    这是对Tomalak最受欢迎的答案 (及其后续编辑)的修订版4回答

    我将以为这种编辑是错误的,并解释为什么可以将其还原。 在此过程中,您可能会学到一些关于内部原理的东西,然后再看一个示例,该示例实际上是什么过早的优化及其如何对您造成伤害。

    tl; dr:如果需要的话,只需使用Convert.ToByteString.Substring (下面的“原始代码”),如果您不想重新实现Convert.ToByte ,这是最好的组合。 如果需要性能,请使用不使用Convert.ToByte更高级的功能(请参阅其他答案)。 不要使用任何东西比其他String.Substring结合Convert.ToByte ,除非有人些有趣的说这个在这个答案的评论。

    警告: 如果在框架中实现了Convert.ToByte(char[], Int32)重载,则此答案可能已过时。 这不太可能很快发生。

    通常,我不太喜欢说“不要过早优化”,因为没人知道“过早”的时间。 在决定是否进行优化时,您必须考虑的唯一事情是:“我是否有时间和资源来正确研究优化方法?”。 如果不这样做,那么它的太早,等到项目比较成熟,或者直到你所需要的性能(如果有实际需要,那么你会的时间)。 同时,请执行可能可行的最简单的操作。

    原始代码:

        public static byte[] HexadecimalStringToByteArray_Original(string input)
        {
            var outputLength = input.Length / 2;
            var output = new byte[outputLength];
            for (var i = 0; i < outputLength; i++)
                output[i] = Convert.ToByte(input.Substring(i * 2, 2), 16);
            return output;
        }
    

    修订4:

        public static byte[] HexadecimalStringToByteArray_Rev4(string input)
        {
            var outputLength = input.Length / 2;
            var output = new byte[outputLength];
            using (var sr = new StringReader(input))
            {
                for (var i = 0; i < outputLength; i++)
                    output[i] = Convert.ToByte(new string(new char[2] { (char)sr.Read(), (char)sr.Read() }), 16);
            }
            return output;
        }
    

    该修订版避免使用String.Substring ,而是使用StringReader 。 给定的原因是:

    编辑:您可以使用单遍解析器来提高长字符串的性能,如下所示:

    好吧,看一下String.Substring参考代码 ,它显然已经是“单次通过”了; 为什么不呢? 它以字节级别运行,而不是在代理对上运行。

    但是,它确实分配了一个新字符串,但是无论如何,您都需要分配一个字符串以传递给Convert.ToByte 。 此外,修订版中提供的解决方案在每次迭代中分配了另一个对象(两字符数组)。 您可以安全地将该分配放到循环之外,并重新使用该数组来避免这种情况。

        public static byte[] HexadecimalStringToByteArray(string input)
        {
            var outputLength = input.Length / 2;
            var output = new byte[outputLength];
            var numeral = new char[2];
            using (var sr = new StringReader(input))
            {
                for (var i = 0; i < outputLength; i++)
                {
                    numeral[0] = (char)sr.Read();
                    numeral[1] = (char)sr.Read();
                    output[i] = Convert.ToByte(new string(numeral), 16);
                }
            }
            return output;
        }
    

    每个十六进制numeral使用两个数字(符号)表示一个八位字节。

    但是,为什么StringReader.Read调用StringReader.Read两次呢? 只需调用它的第二个重载,并要求它一次读取2个字符的数组中的两个字符即可; 并将通话量减少两个。

        public static byte[] HexadecimalStringToByteArray(string input)
        {
            var outputLength = input.Length / 2;
            var output = new byte[outputLength];
            var numeral = new char[2];
            using (var sr = new StringReader(input))
            {
                for (var i = 0; i < outputLength; i++)
                {
                    var read = sr.Read(numeral, 0, 2);
                    Debug.Assert(read == 2);
                    output[i] = Convert.ToByte(new string(numeral), 16);
                }
            }
            return output;
        }
    

    剩下的是一个字符串读取器,其唯一添加的“值”是您可以声明自己的并行索引(内部_pos ,例如j ),冗余长度变量(内部_length )和冗余引用到输入字符串(内部_s )。 换句话说,它是没有用的。

    如果您想了解Read是如何“读取”的,只需看一下代码 ,它所做的就是在输入字符串上调用String.CopyTo 。 剩下的只是簿记管理费用,以维持我们不需要的价值。

    因此,已经删除了字符串阅读器,然后调用CopyTo自己; 更简单,更清晰,更高效。

        public static byte[] HexadecimalStringToByteArray(string input)
        {
            var outputLength = input.Length / 2;
            var output = new byte[outputLength];
            var numeral = new char[2];
            for (int i = 0, j = 0; i < outputLength; i++, j += 2)
            {
                input.CopyTo(j, numeral, 0, 2);
                output[i] = Convert.ToByte(new string(numeral), 16);
            }
            return output;
        }
    

    您是否真的需要一个j索引,它以与i平行的两个步长递增? 当然,不可以,只需将i乘以2(编译器应该可以将其优化为加法)。

        public static byte[] HexadecimalStringToByteArray_BestEffort(string input)
        {
            var outputLength = input.Length / 2;
            var output = new byte[outputLength];
            var numeral = new char[2];
            for (int i = 0; i < outputLength; i++)
            {
                input.CopyTo(i * 2, numeral, 0, 2);
                output[i] = Convert.ToByte(new string(numeral), 16);
            }
            return output;
        }
    

    现在的解决方案是什么样的? 就像刚开始时一样,只是使用中间数组,而不是使用String.Substring分配字符串并将数据复制到其中,而是将十六进制数字复制到该中间数组,然后自己分配字符串并复制再次将数据从数组传入字符串(当您在字符串构造函数中传递数据时)。 如果该字符串已经在内部缓冲池中,则第二个副本可能已被优化,但是在这种情况下, String.Substring也可以避免使用它。

    实际上,如果再次查看String.Substring ,您会发现它使用了一些底层的内部知识,即如何构造字符串以比通常更快的速度分配字符串,并且它内联了直接由CopyTo使用的代码在那里避免通话开销。

    String.Substring

    • 最坏的情况:一种快速分配,一种快速复制。
    • 最佳情况:无分配,无副本。

    手动方式

    • 最坏的情况:两个普通分配,一个普通副本,一个快速副本。
    • 最佳情况:一份普通分配,一份普通副本。

    结论? 如果您要使用Convert.ToByte(String, Int32) (因为您不想自己重新实现该功能),似乎没有办法击败String.Substring ; 您要做的只是绕圈运行,重新发明轮子(仅适用于次优材料)。

    请注意,如果您不需要极端的性能,则使用Convert.ToByteString.Substring是一个完全有效的选择。 切记:只有在您有时间和资源调查其工作方式的情况下,才选择其他方法。

    如果有一个Convert.ToByte(char[], Int32) ,那么事情当然会有所不同(可以做我上面描述的事情,完全避免使用String )。

    我怀疑通过“避免使用String.Substring ”报告更好的性能的人也避免使用Convert.ToByte(String, Int32) ,如果仍然需要性能,则应该这样做。 查看无数其他答案,以发现实现此目的的所有不同方法。

    免责声明:我尚未反编译该框架的最新版本,以确认参考源是最新的(我认为是最新的)。

    现在,这一切听起来不错且合乎逻辑,如果您已经走到了这一步,希望甚至显而易见。 但这是真的吗?

    Intel(R) Core(TM) i7-3720QM CPU @ 2.60GHz
        Cores: 8
        Current Clock Speed: 2600
        Max Clock Speed: 2600
    --------------------
    Parsing hexadecimal string into an array of bytes
    --------------------
    HexadecimalStringToByteArray_Original: 7,777.09 average ticks (over 10000 runs), 1.2X
    HexadecimalStringToByteArray_BestEffort: 8,550.82 average ticks (over 10000 runs), 1.1X
    HexadecimalStringToByteArray_Rev4: 9,218.03 average ticks (over 10000 runs), 1.0X
    

    是!

    为Benchridge的Partridge提供支持,很容易被黑客入侵。 所使用的输入是以下SHA-1哈希,重复进行了5000次,以生成100,000个字节长的字符串。

    209113288F93A9AB8E474EA78D899AFDBB874355
    

    玩得开心! (但要适度优化。)


    #16楼

    我没有收到您建议使用的代码,Olipro。 hex[i] + hex[i+1]显然返回了一个int

    但是,通过从Waleeds代码中获得一些提示并将其整合在一起,我确实取得了一些成功。 根据我的测试(使用色标测试机制),它看起来像地狱一样丑陋,但它似乎可以工作并且比其他时间的性能高出1/3。 取决于输入大小。 先切换?:s来分开0-9可能会产生更快的结果,因为数字多于字母。

    public static byte[] StringToByteArray2(string hex)
    {
        byte[] bytes = new byte[hex.Length/2];
        int bl = bytes.Length;
        for (int i = 0; i < bl; ++i)
        {
            bytes[i] = (byte)((hex[2 * i] > 'F' ? hex[2 * i] - 0x57 : hex[2 * i] > '9' ? hex[2 * i] - 0x37 : hex[2 * i] - 0x30) << 4);
            bytes[i] |= (byte)(hex[2 * i + 1] > 'F' ? hex[2 * i + 1] - 0x57 : hex[2 * i + 1] > '9' ? hex[2 * i + 1] - 0x37 : hex[2 * i + 1] - 0x30);
        }
        return bytes;
    }
    

    #17楼

    在速度方面,这似乎比这里的任何东西都要好:

      public static string ToHexString(byte[] data) {
        byte b;
        int i, j, k;
        int l = data.Length;
        char[] r = new char[l * 2];
        for (i = 0, j = 0; i < l; ++i) {
          b = data[i];
          k = b >> 4;
          r[j++] = (char)(k > 9 ? k + 0x37 : k + 0x30);
          k = b & 15;
          r[j++] = (char)(k > 9 ? k + 0x37 : k + 0x30);
        }
        return new string(r);
      }
    

    #18楼

    要么:

    public static string ByteArrayToString(byte[] ba)
    {
      StringBuilder hex = new StringBuilder(ba.Length * 2);
      foreach (byte b in ba)
        hex.AppendFormat("{0:x2}", b);
      return hex.ToString();
    }
    

    要么:

    public static string ByteArrayToString(byte[] ba)
    {
      return BitConverter.ToString(ba).Replace("-","");
    }
    

    例如, 这里还有更多的变体。

    反向转换将如下所示:

    public static byte[] StringToByteArray(String hex)
    {
      int NumberChars = hex.Length;
      byte[] bytes = new byte[NumberChars / 2];
      for (int i = 0; i < NumberChars; i += 2)
        bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
      return bytes;
    }
    

    Convert.ToByte结合使用Substring是最好的选择。 有关更多信息,请参见此答案 。 如果需要更好的性能,则在删除SubString之前必须避免Convert.ToByte


    #19楼

    扩展方法 (免责声明:完全未经测试的代码,BTW ...):

    public static class ByteExtensions
    {
        public static string ToHexString(this byte[] ba)
        {
            StringBuilder hex = new StringBuilder(ba.Length * 2);
    
            foreach (byte b in ba)
            {
                hex.AppendFormat("{0:x2}", b);
            }
            return hex.ToString();
        }
    }
    

    等。使用Tomalak的三种解决方案之一 (最后一种是对字符串的扩展方法)。


    #20楼

    您可以使用BitConverter.ToString方法:

    byte[] bytes = {0, 1, 2, 4, 8, 16, 32, 64, 128, 256}
    Console.WriteLine( BitConverter.ToString(bytes));
    

    输出:

    00-01-02-04-08-10-20-40-80-FF

    详细信息: BitConverter.ToString方法(字节[])


    #21楼

    如果您想要比BitConverter更大的灵活性,但又不想那些笨拙的1990年代风格的显式循环,则可以执行以下操作:

    String.Join(String.Empty, Array.ConvertAll(bytes, x => x.ToString("X2")));
    

    或者,如果您使用的是.NET 4.0:

    String.Concat(Array.ConvertAll(bytes, x => x.ToString("X2")));
    

    (后者来自对原始帖子的评论。)


    #22楼

    Waleed Eissa代码的反函数(十六进制字符串到字节数组):

        public static byte[] HexToBytes(this string hexString)        
        {
            byte[] b = new byte[hexString.Length / 2];            
            char c;
            for (int i = 0; i < hexString.Length / 2; i++)
            {
                c = hexString[i * 2];
                b[i] = (byte)((c < 0x40 ? c - 0x30 : (c < 0x47 ? c - 0x37 : c - 0x57)) << 4);
                c = hexString[i * 2 + 1];
                b[i] += (byte)(c < 0x40 ? c - 0x30 : (c < 0x47 ? c - 0x37 : c - 0x57));
            }
    
            return b;
        }
    

    Waleed Eissa函数具有小写字母支持:

        public static string BytesToHex(this byte[] barray, bool toLowerCase = true)
        {
            byte addByte = 0x37;
            if (toLowerCase) addByte = 0x57;
            char[] c = new char[barray.Length * 2];
            byte b;
            for (int i = 0; i < barray.Length; ++i)
            {
                b = ((byte)(barray[i] >> 4));
                c[i * 2] = (char)(b > 9 ? b + addByte : b + 0x30);
                b = ((byte)(barray[i] & 0xF));
                c[i * 2 + 1] = (char)(b > 9 ? b + addByte : b + 0x30);
            }
    
            return new string(c);
        }
    

    #23楼

    另一种方法是使用stackalloc降低GC内存压力:

    static string ByteToHexBitFiddle(byte[] bytes)
    {
            var c = stackalloc char[bytes.Length * 2 + 1];
            int b; 
            for (int i = 0; i < bytes.Length; ++i)
            {
                b = bytes[i] >> 4;
                c[i * 2] = (char)(55 + b + (((b - 10) >> 31) & -7));
                b = bytes[i] & 0xF;
                c[i * 2 + 1] = (char)(55 + b + (((b - 10) >> 31) & -7));
            }
            c[bytes.Length * 2 ] = '\0';
            return new string(c);
    }
    

    #24楼

    从微软的开发人员那里,一个很好的,简单的转换:

    public static string ByteArrayToString(byte[] ba) 
    {
        // Concatenate the bytes into one long string
        return ba.Aggregate(new StringBuilder(32),
                                (sb, b) => sb.Append(b.ToString("X2"))
                                ).ToString();
    }
    

    尽管上面的内容干净紧凑,但是性能迷们会使用枚举器大喊大叫。 您可以使用Tomalak原始答案的改进版本获得最佳性能:

    public static string ByteArrayToString(byte[] ba)   
    {   
       StringBuilder hex = new StringBuilder(ba.Length * 2);   
    
       for(int i=0; i < ba.Length; i++)       // <-- Use for loop is faster than foreach   
           hex.Append(ba[i].ToString("X2"));   // <-- ToString is faster than AppendFormat   
    
       return hex.ToString();   
    } 
    

    到目前为止,这是我在此处看到的所有例程中最快的。 不要只是相信我的话...对每个例程进行性能测试,并亲自检查其CIL代码。


    #25楼

    为什么要使其复杂? 在Visual Studio 2008中,这很简单:

    C#:

    string hex = BitConverter.ToString(YourByteArray).Replace("-", "");
    

    VB:

    Dim hex As String = BitConverter.ToString(YourByteArray).Replace("-", "")
    

    #26楼

    绩效分析

    注意:截至2015年8月20日的新领导者。

    我通过一些简单的Stopwatch性能测试运行了每种转换方法,使用随机语句运行(n = 61,1000次迭代),使用Project Gutenburg文本运行(n = 1,238,957,150次迭代)。 结果如下,大致从最快到最慢。 所有度量单位均为滴答声( 10,000 ticks = 1 ms ),并将所有相关注释与[最慢] StringBuilder实现进行比较。 有关使用的代码,请参见下文或测试框架库 ,我现在在其中维护用于运行该代码的代码。

    免责声明

    警告:不要依赖这些统计信息来获取任何具体信息; 它们只是样本数据的样本运行。 如果您确实需要一流的性能,请在代表您的生产需求的环境中测试这些方法,并使用代表您将要使用的数据。

    结果

    查找表已领先于字节操作。 基本上,有某种形式的预计算什么给定的半字节或字节。 然后,当您翻阅数据时,您只需查找下一部分即可看到它是十六进制字符串。 然后将该值以某种方式添加到结果字符串输出中。 长期以来,性能最佳的方法是字节操作,某些开发人员可能更难以阅读。

    您最好的选择仍然是找到一些具有代表性的数据,然后在类似于生产的环境中进行尝试。 如果您有不同的内存限制,则您可能更喜欢分配较少的方法,而不是分配更快但消耗更多内存的方法。

    测试代码

    随意使用我使用的测试代码。 这里包含一个版本,但可以随时克隆存储并添加自己的方法。 如果您发现任何有趣的东西或想要帮助改进它使用的测试框架,请提交请求请求。

    1. 将新的静态方法( Func<byte[], string> )添加到/Tests/ConvertByteArrayToHexString/Test.cs。
    2. 将该方法的名称添加到同一类的TestCandidates返回值中。
    3. 通过在同一类的GenerateTestInput中切换注释,确保正在运行所需的输入版本,句子或文本。
    4. F5键并等待输出(/ bin文件夹中还将生成HTML转储)。
    static string ByteArrayToHexStringViaStringJoinArrayConvertAll(byte[] bytes) {
        return string.Join(string.Empty, Array.ConvertAll(bytes, b => b.ToString("X2")));
    }
    static string ByteArrayToHexStringViaStringConcatArrayConvertAll(byte[] bytes) {
        return string.Concat(Array.ConvertAll(bytes, b => b.ToString("X2")));
    }
    static string ByteArrayToHexStringViaBitConverter(byte[] bytes) {
        string hex = BitConverter.ToString(bytes);
        return hex.Replace("-", "");
    }
    static string ByteArrayToHexStringViaStringBuilderAggregateByteToString(byte[] bytes) {
        return bytes.Aggregate(new StringBuilder(bytes.Length * 2), (sb, b) => sb.Append(b.ToString("X2"))).ToString();
    }
    static string ByteArrayToHexStringViaStringBuilderForEachByteToString(byte[] bytes) {
        StringBuilder hex = new StringBuilder(bytes.Length * 2);
        foreach (byte b in bytes)
            hex.Append(b.ToString("X2"));
        return hex.ToString();
    }
    static string ByteArrayToHexStringViaStringBuilderAggregateAppendFormat(byte[] bytes) {
        return bytes.Aggregate(new StringBuilder(bytes.Length * 2), (sb, b) => sb.AppendFormat("{0:X2}", b)).ToString();
    }
    static string ByteArrayToHexStringViaStringBuilderForEachAppendFormat(byte[] bytes) {
        StringBuilder hex = new StringBuilder(bytes.Length * 2);
        foreach (byte b in bytes)
            hex.AppendFormat("{0:X2}", b);
        return hex.ToString();
    }
    static string ByteArrayToHexViaByteManipulation(byte[] bytes) {
        char[] c = new char[bytes.Length * 2];
        byte b;
        for (int i = 0; i < bytes.Length; i++) {
            b = ((byte)(bytes[i] >> 4));
            c[i * 2] = (char)(b > 9 ? b + 0x37 : b + 0x30);
            b = ((byte)(bytes[i] & 0xF));
            c[i * 2 + 1] = (char)(b > 9 ? b + 0x37 : b + 0x30);
        }
        return new string(c);
    }
    static string ByteArrayToHexViaByteManipulation2(byte[] bytes) {
        char[] c = new char[bytes.Length * 2];
        int b;
        for (int i = 0; i < bytes.Length; i++) {
            b = bytes[i] >> 4;
            c[i * 2] = (char)(55 + b + (((b - 10) >> 31) & -7));
            b = bytes[i] & 0xF;
            c[i * 2 + 1] = (char)(55 + b + (((b - 10) >> 31) & -7));
        }
        return new string(c);
    }
    static string ByteArrayToHexViaSoapHexBinary(byte[] bytes) {
        SoapHexBinary soapHexBinary = new SoapHexBinary(bytes);
        return soapHexBinary.ToString();
    }
    static string ByteArrayToHexViaLookupAndShift(byte[] bytes) {
        StringBuilder result = new StringBuilder(bytes.Length * 2);
        string hexAlphabet = "0123456789ABCDEF";
        foreach (byte b in bytes) {
            result.Append(hexAlphabet[(int)(b >> 4)]);
            result.Append(hexAlphabet[(int)(b & 0xF)]);
        }
        return result.ToString();
    }
    static readonly uint* _lookup32UnsafeP = (uint*)GCHandle.Alloc(_Lookup32, GCHandleType.Pinned).AddrOfPinnedObject();
    static string ByteArrayToHexViaLookup32UnsafeDirect(byte[] bytes) {
        var lookupP = _lookup32UnsafeP;
        var result = new string((char)0, bytes.Length * 2);
        fixed (byte* bytesP = bytes)
        fixed (char* resultP = result) {
            uint* resultP2 = (uint*)resultP;
            for (int i = 0; i < bytes.Length; i++) {
                resultP2[i] = lookupP[bytesP[i]];
            }
        }
        return result;
    }
    static uint[] _Lookup32 = Enumerable.Range(0, 255).Select(i => {
        string s = i.ToString("X2");
        return ((uint)s[0]) + ((uint)s[1] << 16);
    }).ToArray();
    static string ByteArrayToHexViaLookupPerByte(byte[] bytes) {
        var result = new char[bytes.Length * 2];
        for (int i = 0; i < bytes.Length; i++)
        {
            var val = _Lookup32[bytes[i]];
            result[2*i] = (char)val;
            result[2*i + 1] = (char) (val >> 16);
        }
        return new string(result);
    }
    static string ByteArrayToHexViaLookup(byte[] bytes) {
        string[] hexStringTable = new string[] {
            "00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "0A", "0B", "0C", "0D", "0E", "0F",
            "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "1A", "1B", "1C", "1D", "1E", "1F",
            "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "2A", "2B", "2C", "2D", "2E", "2F",
            "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "3A", "3B", "3C", "3D", "3E", "3F",
            "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "4A", "4B", "4C", "4D", "4E", "4F",
            "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "5A", "5B", "5C", "5D", "5E", "5F",
            "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "6A", "6B", "6C", "6D", "6E", "6F",
            "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "7A", "7B", "7C", "7D", "7E", "7F",
            "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "8A", "8B", "8C", "8D", "8E", "8F",
            "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "9A", "9B", "9C", "9D", "9E", "9F",
            "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9", "AA", "AB", "AC", "AD", "AE", "AF",
            "B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9", "BA", "BB", "BC", "BD", "BE", "BF",
            "C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9", "CA", "CB", "CC", "CD", "CE", "CF",
            "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9", "DA", "DB", "DC", "DD", "DE", "DF",
            "E0", "E1", "E2", "E3", "E4", "E5", "E6", "E7", "E8", "E9", "EA", "EB", "EC", "ED", "EE", "EF",
            "F0", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "FA", "FB", "FC", "FD", "FE", "FF",
        };
        StringBuilder result = new StringBuilder(bytes.Length * 2);
        foreach (byte b in bytes) {
            result.Append(hexStringTable[b]);
        }
        return result.ToString();
    }
    

    更新(2010-01-13)

    在分析中添加了Waleed的答案。 蛮快。

    更新(2011-10-05)

    添加了string.Concat Array.ConvertAll变体,以实现完整性(需要.NET 4.0)。 与string.Join版本同等。

    更新(2012-02-05)

    测试库包含更多变体,例如StringBuilder.Append(b.ToString("X2")) 。 没有人会破坏结果。 foreach{IEnumerable}.Aggregate ,例如,但BitConverter仍然获胜。

    更新(2012-04-03)

    在分析中添加了Mykroft的SoapHexBinary答案,该答案排在第三位。

    更新(2013-01-15)

    添加了CodesInChaos的字节操作答案,该答案占据了第一位(在大块文本上占据了很大的空间)。

    更新(2013-05-23)

    添加了内森·莫因瓦济里(Nathan Moinvaziri)的查找答案以及布莱恩·兰伯特(Brian Lambert)博客的变体。 两者都相当快,但是在我使用的测试机器(AMD Phenom 9750)上却没有领先。

    更新(2014-07-31)

    添加了@CodesInChaos的新的基于字节的查找答案。 它似乎在句子测试和全文测试上都处于领先地位。

    更新(2015-08-20)

    向此答案的repo添加了airbreather的优化和unsafe变体。 如果您想玩这种不安全的游戏,无论是短字符串还是大文本,您都可以比以前的任何顶级赢家都获得巨大的性能提升。


    #27楼

    使用查找表也可以解决此问题。 对于编码器和解码器,这将需要少量的静态存储器。 但是,此方法将很快:

    • 编码器表512字节或1024字节(如果需要大小写,则为两倍)
    • 解码器表256字节或64 KiB(单字符查找或双字符查找)

    我的解决方案将1024字节用于编码表,将256字节用于解码。

    解码

    private static readonly byte[] LookupTable = new byte[] {
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    };
    
    private static byte Lookup(char c)
    {
      var b = LookupTable[c];
      if (b == 255)
        throw new IOException("Expected a hex character, got " + c);
      return b;
    }
    
    public static byte ToByte(char[] chars, int offset)
    {
      return (byte)(Lookup(chars[offset]) << 4 | Lookup(chars[offset + 1]));
    }
    

    编码方式

    private static readonly char[][] LookupTableUpper;
    private static readonly char[][] LookupTableLower;
    
    static Hex()
    {
      LookupTableLower = new char[256][];
      LookupTableUpper = new char[256][];
      for (var i = 0; i < 256; i++)
      {
        LookupTableLower[i] = i.ToString("x2").ToCharArray();
        LookupTableUpper[i] = i.ToString("X2").ToCharArray();
      }
    }
    
    public static char[] ToCharLower(byte[] b, int bOffset)
    {
      return LookupTableLower[b[bOffset]];
    }
    
    public static char[] ToCharUpper(byte[] b, int bOffset)
    {
      return LookupTableUpper[b[bOffset]];
    }
    

    比较方式

    StringBuilderToStringFromBytes:   106148
    BitConverterToStringFromBytes:     15783
    ArrayConvertAllToStringFromBytes:  54290
    ByteManipulationToCharArray:        8444
    TableBasedToCharArray:              5651 *
    

    *此解决方案

    注意

    在解码期间,可能会发生IOException和IndexOutOfRangeException(如果字符的值太高,大于256)。 应该实现对流或数组进行解码/编码的方法,这只是概念上的证明。


    #28楼

    为了性能,我会选择drphrozens解决方案。 解码器的一个微小优化可能是使用一个表作为char来摆脱“ << 4”。

    显然,这两种方法调用的成本很高。 如果对输入或输出数据进行某种类型的检查(可能是CRC,校验和或其他), if (b == 255)...可以跳过if (b == 255)... ,因此该方法也将完全调用。

    使用offset++offset而不是offsetoffset + 1可能会提供一些理论上的好处,但是我怀疑编译器会比我更好地处理此问题。

    private static readonly byte[] LookupTableLow = new byte[] {
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    };
    
    private static readonly byte[] LookupTableHigh = new byte[] {
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
      0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    };
    
    private static byte LookupLow(char c)
    {
      var b = LookupTableLow[c];
      if (b == 255)
        throw new IOException("Expected a hex character, got " + c);
      return b;
    }
    
    private static byte LookupHigh(char c)
    {
      var b = LookupTableHigh[c];
      if (b == 255)
        throw new IOException("Expected a hex character, got " + c);
      return b;
    }
    
    public static byte ToByte(char[] chars, int offset)
    {
      return (byte)(LookupHigh(chars[offset++]) | LookupLow(chars[offset]));
    }
    

    这只是我的脑袋,尚未经过测试或基准测试。


    #29楼

    我今天遇到了同样的问题,遇到了以下代码:

    private static string ByteArrayToHex(byte[] barray)
    {
        char[] c = new char[barray.Length * 2];
        byte b;
        for (int i = 0; i < barray.Length; ++i)
        {
            b = ((byte)(barray[i] >> 4));
            c[i * 2] = (char)(b > 9 ? b + 0x37 : b + 0x30);
            b = ((byte)(barray[i] & 0xF));
            c[i * 2 + 1] = (char)(b > 9 ? b + 0x37 : b + 0x30);
        }
        return new string(c);
    }
    

    来源:论坛帖子byte []数组到十六进制字符串 (请参阅PZahra的帖子)。 我对代码做了一些修改以删除0x前缀。

    我对代码进行了性能测试,它几乎比使用BitConverter.ToString()快八倍(根据patridge的帖子,最快)。


    #30楼

    多样性的另一种变化:

    public static byte[] FromHexString(string src)
    {
        if (String.IsNullOrEmpty(src))
            return null;
    
        int index = src.Length;
        int sz = index / 2;
        if (sz <= 0)
            return null;
    
        byte[] rc = new byte[sz];
    
        while (--sz >= 0)
        {
            char lo = src[--index];
            char hi = src[--index];
    
            rc[sz] = (byte)(
                (
                    (hi >= '0' && hi <= '9') ? hi - '0' :
                    (hi >= 'a' && hi <= 'f') ? hi - 'a' + 10 :
                    (hi >= 'A' && hi <= 'F') ? hi - 'A' + 10 :
                    0
                )
                << 4 | 
                (
                    (lo >= '0' && lo <= '9') ? lo - '0' :
                    (lo >= 'a' && lo <= 'f') ? lo - 'a' + 10 :
                    (lo >= 'A' && lo <= 'F') ? lo - 'A' + 10 :
                    0
                )
            );
        }
    
        return rc;          
    }
    
    展开全文
  • 手机使用的16进制编辑器中文版,和电脑版没有多大区别。
  • 能直接编辑硬盘扇区数据,打开内存修改运行中的游戏,创建磁盘镜像文件,各种强大的搜索,查找文本及十六进制数值,替换文本及十六进制数值,支持组合搜索同步搜索,还能转换格式填充文件数据,在专业人员手中它就是...
  • java对文件的十六进制读取和操作

    千次阅读 2011-10-12 11:42:39
    大家可以参考一下源代码的相关部分注释,然后写出自己的16进制处理程序。 有几个重点地方: 16进制字符串-》10进制数  int input = Integer.parseInt("Str", 16) 10进制整数-》16进制字符串
    大家可以参考一下源代码的相关部分注释,然后写出自己的16进制处理程序。
    
    有几个重点地方:
    • 16进制字符串-》10进制数
             int input = Integer.parseInt("Str", 16)
    • 10进制整数-》16进制字符串
             String hex = Integer.toHexString(int)
    • 文件读取方法
             作为2进制文件直接读取,一个byte为单位的读取。

    将来我还将在此基础上制作Java版本的16进制编辑器,请大家多多支持。谢谢。

    /**
    * RO Utility
    * Mainly used for:
    * 1.Double Open client
    * 2.Open Unlimited View
    *  这是个样本程序,是我针对游戏修改写的。主要作用是将游戏文件用16进制打开,然后
    * 修改相关的部分,然后保存。
    *
    * @author Ciro Deng(cdtdx@sohu.com)
    * @version 1.0
    */
    package cn.edu.uestc.rotool;

    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.StringWriter;

    /**
    * RO Utility Mainly used for: 1.Double Open client 2.Open Unlimited View
    *
    * @author Ciro Deng(cdtdx@sohu.com)
    * @version 1.0
    *
    */
    public class MainTool {

        private final String RO_HOME = "D://Games//RO//"; //修改文件的路径

        private final String FILE = "Ragexe"; //修改文件的主文件名

        private final String BAK_FILE = FILE + "_BAK.sp2"; //修改文件的备份扩展名

        private final String PATCH_FILE = FILE + ".sp2"; //修改文件的扩展名

        /**
         * 进行16进制替换的规则定义
         * Pattern Array Example: pattern[0][0] = "Original Hex String"; 原16进制字符串
         * pattern[0][1] = "New Hex String"; 要替换的16进制字符串
         */
        private final String[][] pattern = {
                { "85C074095F5E33C05B8BE55DC3", "85C0EB095F5E33C05B8BE55DC3" },
                { "85C0740E5F5EB801000000", "85C0EB0E5F5EB801000000" }, // Double
                // Open
                { "000066430000C843", "0000004300008644" } // Umlimited View

        };

        /**
         * 备份文件恢复
         * ture the backup file into real file
         *
         */
        public void restore() {
            if (isExistBackup()) {
                new File(RO_HOME + PATCH_FILE).delete();
                new File(RO_HOME + BAK_FILE)
                        .renameTo(new File(RO_HOME + PATCH_FILE));
                System.out.println("[----------------Restore file OK!--------------------]");
            } else {
                System.out.println("Backup file does not exist!");
                System.exit(0);

            }
        }

        public void init() { //初始化操作
            if (new File(RO_HOME + PATCH_FILE).exists()) {
                System.out
                        .println("[-------------Initialize original file OK!-----------]");
            } else {
                System.out.println("File is not Existed! Please restore it first!");
            }

            // backup original file
            if (!isExistBackup()) {
                new File(RO_HOME + PATCH_FILE)
                        .renameTo(new File(RO_HOME + BAK_FILE));
            }

            System.out
                    .println("[---------------Please choose your action------------]");
            System.out.println("1:Modify double open and unlimited view mode!");
            System.out.println("2:Restore original mode!");
            System.out.println("Please input 1 or 2 and Enter:");

        }

        public void success() { //成功操作提示
            System.out.println();
            System.out
                    .println("[-------------Patch file OK! Have fun with RO!-------]");
        }

        /**
         * 进行16进制替换
         * replace input Hex String with defined pattern
         *
         * @param original
         * @return
         */
        public String replace(String original) {
            for (int i = 0; i < pattern.length; i++) {
                original = original.replaceAll(pattern[i][0].toLowerCase(),
                        pattern[i][1].toLowerCase());
            }

            return original;

        }

        /**
         * 将文件读取为16进制String
         * Read original File and transfer it into Hex String
         *
         * @return
         * @throws IOException
         */
        public String readOriginal2Hex() throws IOException {
            FileInputStream fin = new FileInputStream(new File(RO_HOME + BAK_FILE));
            StringWriter sw = new StringWriter();

            int len = 1;
            byte[] temp = new byte[len];

           /*16进制转化模块*/
            for (; (fin.read(temp, 0, len)) != -1;) {
                if (temp[0] > 0xf && temp[0] <= 0xff) {
                    sw.write(Integer.toHexString(temp[0]));
                } else if (temp[0] >= 0x0 && temp[0] <= 0xf) {//对于只有1位的16进制数前边补“0”
                    sw.write("0" + Integer.toHexString(temp[0]));
                } else { //对于int<0的位转化为16进制的特殊处理,因为Java没有Unsigned int,所以这个int可能为负数
                    sw.write(Integer.toHexString(temp[0]).substring(6));
                }
            }

            return sw.toString();
        }

        /**
         * 将替换后的16进制字符串写回文件
         * write replaced original String to file
         *
         * @param replaced
         * @throws NumberFormatException
         * @throws IOException
         */
        public void writeNew2Binary(String replaced) throws NumberFormatException,
                IOException {
            FileOutputStream fout = new FileOutputStream(RO_HOME + PATCH_FILE);

            for (int i = 0; i < replaced.length(); i = i + 2) {
                fout.write(Integer.parseInt(replaced.substring(i, i + 2), 16));
            }

        }

        /**
         * test direct output string to file
         *
         * @param temp
         * @throws IOException
         */
        public void writeTest(String temp) throws IOException {
            FileOutputStream fout = new FileOutputStream(RO_HOME + "test.txt");
            for (int i = 0; i < temp.length(); i++) {
                fout.write(temp.charAt(i));
            }
        }

        /**
         * check if the backup file exists
         *
         * @return
         */
        public boolean isExistBackup() {
            return new File(RO_HOME + BAK_FILE).exists();
        }

        /**
         * 主要操作方法,组织工作流程
         * Main process method
         *
         * @throws IOException
         */
        public void patch() throws IOException {
            // init
            init();
           //输入参数:
           //1:进行查找替换
           //2:将备份文件恢复
            String input = new BufferedReader(new InputStreamReader(System.in))
                    .readLine();
            if (input.equals("1")) {
                String temp = null;
                temp = readOriginal2Hex();
                temp = replace(temp);
                writeNew2Binary(temp);
                success();
            } else if (input.equals("2")) {
                restore();
            } else {
                System.out.println("Bad input parameter!");
                System.exit(0);
            }

        }

        /**
         * Main方法
         * main
         *
         * @param args
         * @throws IOException
         */
        public static void main(String[] args) throws IOException {
            MainTool tool = new MainTool();
            tool.patch();

        }

    }
    展开全文
  • 可以很方便的用来修改文件哦 包括马等,事实上我用它修改了explorer使得2K系统的任务栏变为真彩
  • 我的第一个原创FC工具,在HEX工具的基础上,加入6502指令的输入方式.可以直接写汇编呀...对于修改很有用的.
  • 并且我已经成功开通了流量主同时会赚一点点广告费,我打算每个月把这部分钱拿出来给大家买点...私活接单qq群:716817407最近在 GitHub 上最火的项目是一个对视力友好的十六进制编辑器,它上线仅 5 天就收获了 2500 ...
  • Hex Editor Neo(二进制、十六进制文件编辑查看) 提取码:ayyh 学习过程 理清思路 首先,植物大战僵尸是一个单机游戏,那它的存档必然是保存在本地,具体路径在网上搜一下就知道,是保存在 C:\ProgramData\...
  •  变量窗口支持将变量(例如,解密的字节数组)保存到磁盘或在十六进制编辑器(内存窗口)中查看它们  .NET调试器对象IDq2315702359  可以同时调试多个进程  打破模块负载  .NET调试器跟踪点和条件断点  .NET...
  • 下载一个进制编辑器(此处下载的是EmEditor编辑器) 找到存档位置 X:\ProgramData\PopCap Games\PlantsVsZombies\userdata11 二、进行修改 首先打开存档文件User1.data,此时为初始状态 图下为进行一段时间游戏...
  • 专业文本/十六进制编辑利器IDM UltraEdit现已更新至v23.10.0.3,这次修复了上版一些问题,绿色特别版已跟进!UltraEdit是性价比全球一流的文本、十六进制,HTML、PHP、Java 和 JavaScript程序文本编辑器
  • C1-1 进制与信息编码

    千次阅读 2021-05-14 10:13:27
    任务一:用(0)和(1)绘图 任务二:掌握进制编辑器 进制 十进制,二进制,十六进制,八进制
  • 修改植物大战僵尸游戏存档及二进制绘制字符或图形 目录 ...打开注册表编辑器, 路径:计算机\HKEY_CURRENT_USER\SOFTWARE\PopCap\PlantsVsZombies, 找到ScreenMode(屏面方式),将数值数据为0
  • 如何修改游戏金币总结 前言 任务C1:要求修改植物大战僵尸的关卡并且修改金币10万 一、任务分析 要想修改植物大战僵尸的关卡首先要下载,然后~嗯(其实我没玩过这款游戏),然后才能修改(感觉是废话) 二、修改...
  • C1任务01-修改游戏存档

    千次阅读 多人点赞 2021-04-03 14:31:58
    文章目录挑战说明内容一、任务实现工具:游戏:植物大战僵尸中文版十六进制编辑器:Hex Editor Neo二、任务实现过程:1、修改关卡2、修改金币3、修改用户名4、修改局内文字信息总结 挑战 有的玩家在玩游戏时,可能...
  • GG修改Unity 3D加密游戏

    千次阅读 2020-03-22 20:57:47
    在set上鼠标右键“在十六进制编辑器中显示方法体”,高亮部分就是hex代码,复制出来,对照il指令,查Opcode就可以直接代码了。如Mathf.Clamp(value,0,this.maximumAmmo);中的0中间语言为ldc.i4....
  • 1.要想修改《植物大战僵尸》中的存档文件,需要一个十六进制编辑器(因为用户的存档数据是通过十六进制文件保存的),这里我所使用的是Ultra Edit。 2.通过网上阅览资料得知《植物大战僵尸》储存用户
  • 二、加入了十六进制文件编辑功能 三、数值的查找和修改支持单精度和双精度 四、提供无限撤消 五、线程暂停(当然只能在win2000以上) 六、加快了一些对话框的弹出速度。当有软件在频繁地占用CPU时PL的有些对话框弹出...
  • 0x01 安装植物大战僵尸 ...找到 userdata\xxxxx\3590\remote 文件夹(xxxx是一串数字,似乎是 Steam ID),可以看到里面有一个 user1.dat,用 HxD 这个十六进制编辑器打开 0x03 确定关卡存储位 打开后找到
  • 十六进制是进制中的一种,是我们在进行编辑的时候将要碰到的最多的问题,你接触修改,就不可避免的会遇到进制上的换算,简单的说来,十六进制就是满十六就进一位,同十进制的满十进一是一样的道理,我在这里要求大家记住最...
  • 任务:使用二进制编辑器修改单机版植物大战僵尸的游戏存档,实现跳关卡(如5-1),修改金币数量(如100000金币) 二进制编辑器:win推荐hex editor neo,Linux或Mac使用vim的二进制编辑模式 二、实践过程 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,021
精华内容 1,608
关键字:

十六进制编辑器改游戏