昨天，在文章：终于等到你：CYQ.Data V5系列 （ORM数据层，支持.NET Core）最新版本开源了 中，

不小心看到一条留言：

然后就去该地址看了一下，这一看，顺带折腾了一天。

今天，就和大伙分享下折腾的感觉。

在该开源地址中，代码有C++和C#两个版本，编码的整体风格倾向与于C++。

主要的时间，花了在对于检测无BOM的部分，顺带重温了各种编码的基础。

建议在看此文之前，先了解下编码、和BOM的概念。

对于一个文件，或者字节流，就是一堆二进制：

如果传输的过程，有指定BOM，就是前面两三个字节是固定的255,254之类的，那么解码起来就很简单了。

像之前IOHelper内部读文件的代码是这么写的：

  1.  /// <summary>
  2.         /// 先自动识别UTF8，否则归到Default编码读取
  3.         /// </summary>
  4.         /// <returns></returns>
  5.         public static string ReadAllText(string fileName)
  6.         {
  7.             return ReadAllText(fileName, DefaultEncoding);
  8.         }
  9.         public static string ReadAllText(string fileName, Encoding encoding)
  10.         {
  11.             try
  12.             {
  13.                 if (!File.Exists(fileName))
  14.                 {
  15.                     return string.Empty;
  16.                 }
  17.                 Byte[] buff = null;
  18.                 lock (GetLockObj(fileName.Length))
  19.                 {
  20.                     if (!File.Exists(fileName))//多线程情况处理
  21.                     {
  22.                         return string.Empty;
  23.                     }
  24.                     buff = File.ReadAllBytes(fileName);
  25.                 }
  26.                 if (buff.Length == 0) { return ""; }
  27.                 if (buff[0] == 239 && buff[1] == 187 && buff[2] == 191)
  28.                 {
  29.                     return Encoding.UTF8.GetString(buff, 3, buff.Length - 3);
  30.                 }
  31.                 else if (buff[0] == 255 && buff[1] == 254)
  32.                 {
  33.                     return Encoding.Unicode.GetString(buff, 2, buff.Length - 2);
  34.                 }
  35.                 else if (buff[0] == 254 && buff[1] == 255)
  36.                 {
  37.                     if (buff.Length > 3 && buff[2] == 0 && buff[3] == 0)
  38.                     {
  39.                         return Encoding.UTF32.GetString(buff, 4, buff.Length - 4);
  40.                     }
  41.                     return Encoding.BigEndianUnicode.GetString(buff, 2, buff.Length - 2);
  42.                 }
  43.                 return encoding.GetString(buff);
  44.             }
  45.             catch (Exception err)
  46.             {
  47.                 Log.WriteLogToTxt(err);
  48.             }
  49.             return string.Empty;
  50.         }

代码说白了，就是检测BOM头，然后识别编码，用对应的编码解码。

中文都能正确显示。

windows下文本的另存为只有：ANSI、UTF8､Unicode(UTF16LE)、BigEndianUnicode（UTF16BE）。

这四种有BOM的都是轻松检测了。

 那如果文件或字节没有BOM头呢？如果用默认的编码，由有一定概率会乱码。

如果一堆字节流，没有指定BOM，就要分析出编码类型，还是挺有难度的。

这需要对各种编码的规则有一定的熟悉度。

先看看网友给出的Github上的 原始源码：

  1. public Encoding DetectEncoding(byte[] buffer, int size)
  2.         {
  3.             // First check if we have a BOM and return that if so
  4.             Encoding encoding = CheckBom(buffer, size);
  5.             if (encoding != Encoding.None)
  6.             {
  7.                 return encoding;
  8.             }
  9.  
  10.             // Now check for valid UTF8
  11.             encoding = CheckUtf8(buffer, size);
  12.             if (encoding != Encoding.None)
  13.             {
  14.                 return encoding;
  15.             }
  16.  
  17.             // Now try UTF16 
  18.             encoding = CheckUtf16NewlineChars(buffer, size);
  19.             if (encoding != Encoding.None)
  20.             {
  21.                 return encoding;
  22.             }
  23.  
  24.             encoding = CheckUtf16Ascii(buffer, size);
  25.             if (encoding != Encoding.None)
  26.             {
  27.                 return encoding;
  28.             }
  29.  
  30.             // ANSI or None (binary) then
  31.             if (!DoesContainNulls(buffer, size))
  32.             {
  33.                 return Encoding.Ansi;
  34.             }
  35.  
  36.             // Found a null, return based on the preference in null_suggests_binary_
  37.             return _nullSuggestsBinary ? Encoding.None : Encoding.Ansi;
  38.         }

代码流程（和内涵）翻译下来是这样的：

  1. 1､检测BOM头，这个很Easy。
  2.  
  3. 2､检测UTF8编码（这个还是很有创意的），如果编码的规则完全符合UTF8,则认为是UTF8。
  4.  
  5. 3､检测字节中是否有换行符（根据换行符中的0的位置，区分是Utf16的BE大尾还是LE小尾）。
  6.  
  7. 这个概率要看字节抽样的长度，带不带换行符。
  8.  
  9. 4､检测字节中，单偶数出现的0的概率，设定了一个期望值来预判（对于中文而言，基本没用），大概是老外写的，只根据英文情况分析的概率。
  10.  
  11. 5､检测字节中，有没有出现0，如果没有，返回系统默认编码（不同系统环境编码是不同的）。

首先，不得不说，原作者还是有一定想法的。

虽然代码中除了UTF8按规则写的分析外，其它的都无法代入中文环境里通过。

但至少思路上，就能得到不少启发。

于是，坑了我大半天，进行重写，改造，代入中文环境测试。

改造后的代码流程是这样的：

  1. public Encoding DetectWithoutBom(byte[] buffer, int size)
  2.         {
  3.             // Now check for valid UTF8
  4.             Encoding encoding = CheckUtf8(buffer, size);
  5.             if (encoding != Encoding.None)
  6.             {
  7.                 return encoding;
  8.             }
  10.             // ANSI or None (binary) then 一个零都没有情况。
  11.             if (!ContainsZero(buffer, size))
  12.             {
  13.                 CheckChinese(buffer, size);
  14.                 return Encoding.Ansi;
  15.             }
  17.             // Now try UTF16  按寻找换行字符先进行判断
  18.             encoding = CheckByNewLineChar(buffer, size);
  19.             if (encoding != Encoding.None)
  20.             {
  21.                 return encoding;
  22.             }
  24.             // 没办法了，只能按0出现的次数比率，做大体的预判
  25.             encoding = CheckByZeroNumPercent(buffer, size);
  26.             if (encoding != Encoding.None)
  27.             {
  28.                 return encoding;
  29.             }
  31.             // Found a null, return based on the preference in null_suggests_binary_
  32.             return Encoding.None;
  33.         }

用中文解释流程是这样的：

  1. 1､UTF8编码的检测规则，这个是通用的有效，可以保留。
  3. 2､调整顺序：先检测字节有没有0字节，若无，补一个是否中文的编码的检测（GB2312､GBK、Big5)。
  5. 这个后续有点用。
  7. 3､检测换行符：增加UTF-32编码的检测（原来的思路只有UTF16)。
  9. 4､预判概率：改造成同时适应中文环境。

测试的结果是这样的：

A、纯中文的：

该测试下，对于BigEndianUnicode的会产生乱码。

B、非纯中文的

一切编码正常通用。

  1. using System;
  2. using System.Collections.Generic;
  3. using System.IO;
  4. using System.Text;
  6. namespace CYQ.Data.Tool
  7. {
  8.     internal static class IOHelper
  9.     {
  10.         internal static Encoding DefaultEncoding = Encoding.Default;
  12.         private static List<object> tenObj = new List<object>(10);
  13.         private static List<object> TenObj
  14.         {
  15.             get
  16.             {
  17.                 if (tenObj.Count == 0)
  18.                 {
  19.                     for (int i = 0; i < 10; i++)
  20.                     {
  21.                         tenObj.Add(new object());
  22.                     }
  23.                 }
  24.                 return tenObj;
  25.             }
  26.         }
  27.         private static object GetLockObj(int length)
  28.         {
  29.             int i = length % 9;
  30.             return TenObj[i];
  31.         }
  32.         /// <summary>
  33.         /// 先自动识别UTF8，否则归到Default编码读取
  34.         /// </summary>
  35.         /// <returns></returns>
  36.         public static string ReadAllText(string fileName)
  37.         {
  38.             return ReadAllText(fileName, DefaultEncoding);
  39.         }
  40.         public static string ReadAllText(string fileName, Encoding encoding)
  41.         {
  42.             try
  43.             {
  44.                 if (!File.Exists(fileName))
  45.                 {
  46.                     return string.Empty;
  47.                 }
  48.                 Byte[] buff = null;
  49.                 lock (GetLockObj(fileName.Length))
  50.                 {
  51.                     if (!File.Exists(fileName))//多线程情况处理
  52.                     {
  53.                         return string.Empty;
  54.                     }
  55.                     buff = File.ReadAllBytes(fileName);
  56.                     return BytesToText(buff, encoding);
  57.                 }
  59.             }
  60.             catch (Exception err)
  61.             {
  62.                 Log.WriteLogToTxt(err);
  63.             }
  64.             return string.Empty;
  65.         }
  66.         public static bool Write(string fileName, string text)
  67.         {
  68.             return Save(fileName, text, false, DefaultEncoding, true);
  69.         }
  70.         public static bool Write(string fileName, string text, Encoding encode)
  71.         {
  72.             return Save(fileName, text, false, encode, true);
  73.         }
  74.         public static bool Append(string fileName, string text)
  75.         {
  76.             return Save(fileName, text, true, true);
  77.         }
  79.         internal static bool Save(string fileName, string text, bool isAppend, bool writeLogOnError)
  80.         {
  81.             return Save(fileName, text, true, DefaultEncoding, writeLogOnError);
  82.         }
  83.         internal static bool Save(string fileName, string text, bool isAppend, Encoding encode, bool writeLogOnError)
  84.         {
  85.             try
  86.             {
  87.                 string folder = Path.GetDirectoryName(fileName);
  88.                 if (!Directory.Exists(folder))
  89.                 {
  90.                     Directory.CreateDirectory(folder);
  91.                 }
  93.                 lock (GetLockObj(fileName.Length))
  94.                 {
  95.                     using (StreamWriter writer = new StreamWriter(fileName, isAppend, encode))
  96.                     {
  97.                         writer.Write(text);
  98.                     }
  99.                 }
  100.                 return true;
  101.             }
  102.             catch (Exception err)
  103.             {
  104.                 if (writeLogOnError)
  105.                 {
  106.                     Log.WriteLogToTxt(err);
  107.                 }
  108.                 else
  109.                 {
  110.                     Error.Throw("IOHelper.Save() : " + err.Message);
  111.                 }
  112.             }
  113.             return false;
  114.         }
  116.         internal static bool Delete(string fileName)
  117.         {
  118.             try
  119.             {
  120.                 if (File.Exists(fileName))
  121.                 {
  122.                     lock (GetLockObj(fileName.Length))
  123.                     {
  124.                         if (File.Exists(fileName))
  125.                         {
  126.                             File.Delete(fileName);
  127.                             return true;
  128.                         }
  129.                     }
  130.                 }
  131.             }
  132.             catch
  133.             {
  135.             }
  136.             return false;
  137.         }
  139.         public static bool IsLastFileWriteTimeChanged(string fileName, ref DateTime compareTimeUtc)
  140.         {
  141.             bool isChanged = false;
  142.             IOInfo info = new IOInfo(fileName);
  143.             if (info.Exists && info.LastWriteTimeUtc != compareTimeUtc)
  144.             {
  145.                 isChanged = true;
  146.                 compareTimeUtc = info.LastWriteTimeUtc;
  147.             }
  148.             return isChanged;
  149.         }
  150.         public static string BytesToText(byte[] buff, Encoding encoding)
  151.         {
  152.             if (buff.Length == 0) { return ""; }
  153.             //if (buff[0] == 239 && buff[1] == 187 && buff[2] == 191)
  154.             //{
  155.             //    return Encoding.UTF8.GetString(buff, 3, buff.Length - 3);
  156.             //}
  157.             //else if (buff[0] == 255 && buff[1] == 254)
  158.             //{
  159.             //    return Encoding.Unicode.GetString(buff, 2, buff.Length - 2);
  160.             //}
  161.             //else if (buff[0] == 254 && buff[1] == 255)
  162.             //{
  163.             //    if (buff.Length > 3 && buff[2] == 0 && buff[3] == 0)
  164.             //    {
  165.             //        return Encoding.UTF32.GetString(buff, 4, buff.Length - 4);
  166.             //    }
  167.             //    return Encoding.BigEndianUnicode.GetString(buff, 2, buff.Length - 2);
  168.             //}
  169.             //else
  170.             //{
  171.             TextEncodingDetect detect = new TextEncodingDetect();
  173.             //检测Bom
  174.             switch (detect.DetectWithBom(buff))
  175.             {
  176.                 case TextEncodingDetect.Encoding.Utf8Bom:
  177.                     return Encoding.UTF8.GetString(buff, 3, buff.Length - 3);
  178.                 case TextEncodingDetect.Encoding.UnicodeBom:
  179.                     return Encoding.Unicode.GetString(buff, 2, buff.Length - 2);
  180.                 case TextEncodingDetect.Encoding.BigEndianUnicodeBom:
  181.                     return Encoding.BigEndianUnicode.GetString(buff, 2, buff.Length - 2);
  182.                 case TextEncodingDetect.Encoding.Utf32Bom:
  183.                     return Encoding.UTF32.GetString(buff, 4, buff.Length - 4);
  184.             }
  185.             if (encoding != DefaultEncoding && encoding != Encoding.ASCII)//自定义设置编码，优先处理。
  186.             {
  187.                 return encoding.GetString(buff);
  188.             }
  189.             switch (detect.DetectWithoutBom(buff, buff.Length > 1000 ? 1000 : buff.Length))//自动检测。
  190.             {
  192.                 case TextEncodingDetect.Encoding.Utf8Nobom:
  193.                     return Encoding.UTF8.GetString(buff);
  195.                 case TextEncodingDetect.Encoding.UnicodeNoBom:
  196.                     return Encoding.Unicode.GetString(buff);
  198.                 case TextEncodingDetect.Encoding.BigEndianUnicodeNoBom:
  199.                     return Encoding.BigEndianUnicode.GetString(buff);
  201.                 case TextEncodingDetect.Encoding.Utf32NoBom:
  202.                     return Encoding.UTF32.GetString(buff);
  204.                 case TextEncodingDetect.Encoding.Ansi:
  205.                     if (IsChineseEncoding(DefaultEncoding) && !IsChineseEncoding(encoding))
  206.                     {
  207.                         if (detect.IsChinese)
  208.                         {
  209.                             return Encoding.GetEncoding("gbk").GetString(buff);
  210.                         }
  211.                         else//非中文时，默认选一个。
  212.                         {
  213.                             return Encoding.Unicode.GetString(buff);
  214.                         }
  215.                     }
  216.                     else
  217.                     {
  218.                         return encoding.GetString(buff);
  219.                     }
  221.                 case TextEncodingDetect.Encoding.Ascii:
  222.                     return Encoding.ASCII.GetString(buff);
  224.                 default:
  225.                     return encoding.GetString(buff);
  226.             }
  227.             // }
  228.         }
  229.         private static bool IsChineseEncoding(Encoding encoding)
  230.         {
  231.             return encoding == Encoding.GetEncoding("gb2312") || encoding == Encoding.GetEncoding("gbk") || encoding == Encoding.GetEncoding("big5");
  232.         }
  233.     }
  234.     internal class IOInfo : FileSystemInfo
  235.     {
  236.         public IOInfo(string fileName)
  237.         {
  238.             base.FullPath = fileName;
  239.         }
  240.         public override void Delete()
  241.         {
  242.         }
  244.         public override bool Exists
  245.         {
  246.             get
  247.             {
  248.                 return File.Exists(base.FullPath);
  249.             }
  250.         }
  252.         public override string Name
  253.         {
  254.             get
  255.             {
  256.                 return null;
  257.             }
  258.         }
  259.     }
  260.     /// <summary>
  261.     /// 字节文本编码检测
  262.     /// </summary>
  263.     internal class TextEncodingDetect
  264.     {
  265.         private readonly byte[] _UTF8Bom =
  266.         {
  267.             0xEF,
  268.             0xBB,
  269.             0xBF
  270.         };
  271.         //utf16le _UnicodeBom
  272.         private readonly byte[] _UTF16LeBom =
  273.         {
  274.             0xFF,
  275.             0xFE
  276.         };
  278.         //utf16be _BigUnicodeBom
  279.         private readonly byte[] _UTF16BeBom =
  280.         {
  281.             0xFE,
  282.             0xFF
  283.         };
  285.         //utf-32le
  286.         private readonly byte[] _UTF32LeBom =
  287.         {
  288.             0xFF,
  289.             0xFE,
  290.             0x00,
  291.             0x00
  292.         };
  293.         //utf-32Be
  294.         //private readonly byte[] _UTF32BeBom =
  295.         //{
  296.         //    0x00,
  297.         //    0x00,
  298.         //    0xFE,
  299.         //    0xFF
  300.         //};
  301.         /// <summary>
  302.         /// 是否中文
  303.         /// </summary>
  304.         public bool IsChinese = false;
  306.         public enum Encoding
  307.         {
  308.             None, // Unknown or binary
  309.             Ansi, // 0-255
  310.             Ascii, // 0-127
  311.             Utf8Bom, // UTF8 with BOM
  312.             Utf8Nobom, // UTF8 without BOM
  313.             UnicodeBom, // UTF16 LE with BOM
  314.             UnicodeNoBom, // UTF16 LE without BOM
  315.             BigEndianUnicodeBom, // UTF16-BE with BOM
  316.             BigEndianUnicodeNoBom, // UTF16-BE without BOM
  318.             Utf32Bom,//UTF-32LE with BOM
  319.             Utf32NoBom //UTF-32 without BOM
  321.         }
  323.         public Encoding DetectWithBom(byte[] buffer)
  324.         {
  325.             if (buffer != null)
  326.             {
  327.                 int size = buffer.Length;
  328.                 // Check for BOM
  329.                 if (size >= 2 && buffer[0] == _UTF16LeBom[0] && buffer[1] == _UTF16LeBom[1])
  330.                 {
  331.                     return Encoding.UnicodeBom;
  332.                 }
  334.                 if (size >= 2 && buffer[0] == _UTF16BeBom[0] && buffer[1] == _UTF16BeBom[1])
  335.                 {
  336.                     if (size >= 4 && buffer[2] == _UTF32LeBom[2] && buffer[3] == _UTF32LeBom[3])
  337.                     {
  338.                         return Encoding.Utf32Bom;
  339.                     }
  340.                     return Encoding.BigEndianUnicodeBom;
  341.                 }
  343.                 if (size >= 3 && buffer[0] == _UTF8Bom[0] && buffer[1] == _UTF8Bom[1] && buffer[2] == _UTF8Bom[2])
  344.                 {
  345.                     return Encoding.Utf8Bom;
  346.                 }
  347.             }
  348.             return Encoding.None;
  349.         }
  351.         /// <summary>
  352.         ///     Automatically detects the Encoding type of a given byte buffer.
  353.         /// </summary>
  354.         /// <param name="buffer">The byte buffer.</param>
  355.         /// <param name="size">The size of the byte buffer.</param>
  356.         /// <returns>The Encoding type or Encoding.None if unknown.</returns>
  357.         public Encoding DetectWithoutBom(byte[] buffer, int size)
  358.         {
  359.             // Now check for valid UTF8
  360.             Encoding encoding = CheckUtf8(buffer, size);
  361.             if (encoding != Encoding.None)
  362.             {
  363.                 return encoding;
  364.             }
  366.             // ANSI or None (binary) then 一个零都没有情况。
  367.             if (!ContainsZero(buffer, size))
  368.             {
  369.                 CheckChinese(buffer, size);
  370.                 return Encoding.Ansi;
  371.             }
  373.             // Now try UTF16  按寻找换行字符先进行判断
  374.             encoding = CheckByNewLineChar(buffer, size);
  375.             if (encoding != Encoding.None)
  376.             {
  377.                 return encoding;
  378.             }
  380.             // 没办法了，只能按0出现的次数比率，做大体的预判
  381.             encoding = CheckByZeroNumPercent(buffer, size);
  382.             if (encoding != Encoding.None)
  383.             {
  384.                 return encoding;
  385.             }
  387.             // Found a null, return based on the preference in null_suggests_binary_
  388.             return Encoding.None;
  389.         }
  391.         /// <summary>
  392.         ///     Checks if a buffer contains text that looks like utf16 by scanning for
  393.         ///     newline chars that would be present even in non-english text.
  394.         ///     以检测换行符标识来判断。
  395.         /// </summary>
  396.         /// <param name="buffer">The byte buffer.</param>
  397.         /// <param name="size">The size of the byte buffer.</param>
  398.         /// <returns>Encoding.none, Encoding.Utf16LeNoBom or Encoding.Utf16BeNoBom.</returns>
  399.         private static Encoding CheckByNewLineChar(byte[] buffer, int size)
  400.         {
  401.             if (size < 2)
  402.             {
  403.                 return Encoding.None;
  404.             }
  406.             // Reduce size by 1 so we don't need to worry about bounds checking for pairs of bytes
  407.             size--;
  409.             int le16 = 0;
  410.             int be16 = 0;
  411.             int le32 = 0;//检测是否utf32le。
  412.             int zeroCount = 0;//utf32le 每4位后面多数是0
  413.             uint pos = 0;
  414.             while (pos < size)
  415.             {
  416.                 byte ch1 = buffer[pos++];
  417.                 byte ch2 = buffer[pos++];
  419.                 if (ch1 == 0)
  420.                 {
  421.                     if (ch2 == 0x0a || ch2 == 0x0d)//\r \t 换行检测。
  422.                     {
  423.                         ++be16;
  424.                     }
  425.                 }
  426.                 if (ch2 == 0)
  427.                 {
  428.                     zeroCount++;
  429.                     if (ch1 == 0x0a || ch1 == 0x0d)
  430.                     {
  431.                         ++le16;
  432.                         if (pos + 1 <= size && buffer[pos] == 0 && buffer[pos + 1] == 0)
  433.                         {
  434.                             ++le32;
  435.                         }
  437.                     }
  438.                 }
  440.                 // If we are getting both LE and BE control chars then this file is not utf16
  441.                 if (le16 > 0 && be16 > 0)
  442.                 {
  443.                     return Encoding.None;
  444.                 }
  445.             }
  447.             if (le16 > 0)
  448.             {
  449.                 if (le16 == le32 && buffer.Length % 4 == 0)
  450.                 {
  451.                     return Encoding.Utf32NoBom;
  452.                 }
  453.                 return Encoding.UnicodeNoBom;
  454.             }
  455.             else if (be16 > 0)
  456.             {
  457.                 return Encoding.BigEndianUnicodeNoBom;
  458.             }
  459.             else if (buffer.Length % 4 == 0 && zeroCount >= buffer.Length / 4)
  460.             {
  461.                 return Encoding.Utf32NoBom;
  462.             }
  463.             return Encoding.None;
  464.         }
  466.         /// <summary>
  467.         /// Checks if a buffer contains any nulls. Used to check for binary vs text data.
  468.         /// </summary>
  469.         /// <param name="buffer">The byte buffer.</param>
  470.         /// <param name="size">The size of the byte buffer.</param>
  471.         private static bool ContainsZero(byte[] buffer, int size)
  472.         {
  473.             uint pos = 0;
  474.             while (pos < size)
  475.             {
  476.                 if (buffer[pos++] == 0)
  477.                 {
  478.                     return true;
  479.                 }
  480.             }
  482.             return false;
  483.         }
  485.         /// <summary>
  486.         ///     Checks if a buffer contains text that looks like utf16. This is done based
  487.         ///     on the use of nulls which in ASCII/script like text can be useful to identify.
  488.         ///     按照一定的空0数的概率来预测。
  489.         /// </summary>
  490.         /// <param name="buffer">The byte buffer.</param>
  491.         /// <param name="size">The size of the byte buffer.</param>
  492.         /// <returns>Encoding.none, Encoding.Utf16LeNoBom or Encoding.Utf16BeNoBom.</returns>
  493.         private Encoding CheckByZeroNumPercent(byte[] buffer, int size)
  494.         {
  495.             //单数
  496.             int oddZeroCount = 0;
  497.             //双数
  498.             int evenZeroCount = 0;
  500.             // Get even nulls
  501.             uint pos = 0;
  502.             while (pos < size)
  503.             {
  504.                 if (buffer[pos] == 0)
  505.                 {
  506.                     evenZeroCount++;
  507.                 }
  509.                 pos += 2;
  510.             }
  512.             // Get odd nulls
  513.             pos = 1;
  514.             while (pos < size)
  515.             {
  516.                 if (buffer[pos] == 0)
  517.                 {
  518.                     oddZeroCount++;
  519.                 }
  521.                 pos += 2;
  522.             }
  524.             double evenZeroPercent = evenZeroCount * 2.0 / size;
  525.             double oddZeroPercent = oddZeroCount * 2.0 / size;
  527.             // Lots of odd nulls, low number of even nulls 这里的条件做了修改
  528.             if (evenZeroPercent < 0.1 && oddZeroPercent > 0)
  529.             {
  530.                 return Encoding.UnicodeNoBom;
  531.             }
  533.             // Lots of even nulls, low number of odd nulls 这里的条件也做了修改
  534.             if (oddZeroPercent < 0.1 && evenZeroPercent > 0)
  535.             {
  536.                 return Encoding.BigEndianUnicodeNoBom;
  537.             }
  539.             // Don't know
  540.             return Encoding.None;
  541.         }
  543.         /// <summary>
  544.         ///     Checks if a buffer contains valid utf8.
  545.         ///     以UTF8 的字节范围来检测。
  546.         /// </summary>
  547.         /// <param name="buffer">The byte buffer.</param>
  548.         /// <param name="size">The size of the byte buffer.</param>
  549.         /// <returns>
  550.         ///     Encoding type of Encoding.None (invalid UTF8), Encoding.Utf8NoBom (valid utf8 multibyte strings) or
  551.         ///     Encoding.ASCII (data in 0.127 range).
  552.         /// </returns>
  553.         /// <returns>2</returns>
  554.         private Encoding CheckUtf8(byte[] buffer, int size)
  555.         {
  556.             // UTF8 Valid sequences
  557.             // 0xxxxxxx  ASCII
  558.             // 110xxxxx 10xxxxxx  2-byte
  559.             // 1110xxxx 10xxxxxx 10xxxxxx  3-byte
  560.             // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx  4-byte
  561.             //
  562.             // Width in UTF8
  563.             // Decimal      Width
  564.             // 0-127        1 byte
  565.             // 194-223      2 bytes
  566.             // 224-239      3 bytes
  567.             // 240-244      4 bytes
  568.             //
  569.             // Subsequent chars are in the range 128-191
  570.             bool onlySawAsciiRange = true;
  571.             uint pos = 0;
  573.             while (pos < size)
  574.             {
  575.                 byte ch = buffer[pos++];
  577.                 if (ch == 0)
  578.                 {
  579.                     return Encoding.None;
  580.                 }
  582.                 int moreChars;
  583.                 if (ch <= 127)
  584.                 {
  585.                     // 1 byte
  586.                     moreChars = 0;
  587.                 }
  588.                 else if (ch >= 194 && ch <= 223)
  589.                 {
  590.                     // 2 Byte
  591.                     moreChars = 1;
  592.                 }
  593.                 else if (ch >= 224 && ch <= 239)
  594.                 {
  595.                     // 3 Byte
  596.                     moreChars = 2;
  597.                 }
  598.                 else if (ch >= 240 && ch <= 244)
  599.                 {
  600.                     // 4 Byte
  601.                     moreChars = 3;
  602.                 }
  603.                 else
  604.                 {
  605.                     return Encoding.None; // Not utf8
  606.                 }
  608.                 // Check secondary chars are in range if we are expecting any
  609.                 while (moreChars > 0 && pos < size)
  610.                 {
  611.                     onlySawAsciiRange = false; // Seen non-ascii chars now
  613.                     ch = buffer[pos++];
  614.                     if (ch < 128 || ch > 191)
  615.                     {
  616.                         return Encoding.None; // Not utf8
  617.                     }
  619.                     --moreChars;
  620.                 }
  621.             }
  623.             // If we get to here then only valid UTF-8 sequences have been processed
  625.             // If we only saw chars in the range 0-127 then we can't assume UTF8 (the caller will need to decide)
  626.             return onlySawAsciiRange ? Encoding.Ascii : Encoding.Utf8Nobom;
  627.         }
  628.         /// <summary>
  629.         /// 是否中文编码（GB2312、GBK、Big5）
  630.         /// </summary>
  631.         private void CheckChinese(byte[] buffer, int size)
  632.         {
  633.             IsChinese = false;
  634.             if (size < 2)
  635.             {
  636.                 return;
  637.             }
  639.             // Reduce size by 1 so we don't need to worry about bounds checking for pairs of bytes
  640.             size--;
  641.             uint pos = 0;
  642.             bool isCN = false;
  643.             while (pos < size)
  644.             {
  645.                 //GB2312
  646.                 //0xB0-0xF7(176-247)
  647.                 //0xA0-0xFE（160-254）
  649.                 //GBK
  650.                 //0x81-0xFE（129-254）
  651.                 //0x40-0xFE（64-254）
  653.                 //Big5
  654.                 //0x81-0xFE（129-255）
  655.                 //0x40-0x7E（64-126）  OR 0xA1－0xFE（161-254）
  656.                 byte ch1 = buffer[pos++];
  657.                 byte ch2 = buffer[pos++];
  658.                 isCN = (ch1 >= 176 && ch1 <= 247 && ch2 >= 160 && ch2 <= 254)
  659.                     || (ch1 >= 129 && ch1 <= 254 && ch2 >= 64 && ch2 <= 254)
  660.                     || (ch1 >= 129 && ((ch2 >= 64 && ch2 <= 126) || (ch2 >= 161 && ch2 <= 254)));
  661.                 if (!isCN)
  662.                 {
  663.                     return;
  664.                 }
  666.             }
  667.             IsChinese = true;
  668.         }
  669.     }
  670. }

后续更新地址：https://github.com/cyq1162/cyqdata/blob/master/Tool/IOHelper.cs

1、考虑到UTF7已经过时了，所以直接无视了。

2、对于纯中文情况，UTF16下是BE还是LE，暂时没有想到好的检测方法，所以默认返回了常用的LE，即Unicode。

3、其它一切都安好，全国公开的C#版本，应该就此一份了。

版权声明：本文为cyq1162原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/cyq1162/p/9183424.html