C#轻量级骨架解析文件

Question

我有一个格式类似于

的文件

{1:[...]}{2:[X:11][Y:78][]...}{3:[...]}{4:[...]}{5:
[]
[]
...
[]}$
{1:[...]}{2:[X:43][Y:13][]...}{3:[...]}{4:[...]}{5:
[]
[]
...
[]}$
...

省略号表示许多重复结构或许多重复行。

因此文件由具有相同格式的段组成，并由管道字符分隔。

仅提取每个段的 X 值的最佳方法是什么？所以我们避免将整个文件加载到内存中。空间和时间上的最佳选择。这可能意味着避免将整个文件加载到内存中。可能我们可以读取每一行和正则表达式以匹配 {2:[X:nn][ 并提取 nn 但这只是行的一小部分。

但也许有更好的方法？

Answer 1

有很多方法可以解决这个问题，

给定

var lines = File.ReadLines(@"D:\Test.txt");

注意：File.ReadLines 返回一个Enumerbale，所以它会延迟加载每一行

---

选项 1：使用 Positive Look-behind 和模式 (?<=2:\[X:)\d+

的正则表达式

foreach (var line in lines)
{
   var match = Regex.Match(line,@"(?<=2:\[X:)\d+");
   if(match.Success)
      Console.WriteLine(match.Value);  
}

选项2：简单string.Split

foreach (var line in lines)
{
   var results = line.Split(new[] { "2:[X:", "][Y:" }, StringSplitOptions.RemoveEmptyEntries);

   if(results.Length>1)
      Console.WriteLine(results[1]);
}

选项 3：“可能”是一种性能更高的方法，使用 指针 fixed 和 unsafe

public static unsafe (bool found, int value) ParseLine(string line)
{
   const string prefix = "2:[X:"; 
   fixed (char* pLine = line,pPrefix = prefix)
   {
 
      var pLen = line.Length + pLine;
      var found = false;
      var result = 0;
      var i = 0;
      for (char* p = pLine ,pP = pPrefix; p < pLen; p++)
      {
         if (!found )
         {
            if( *p == *(pP+i)) i++;
            if( i ==prefix.Length) found = true;
            continue;
         }
         
         if (*p < '0' || *p > '9')
            break;

         result = result * 10 + *p - '0';

 
      }

      return (found, result);
   }
}
    
...

var results = File.ReadLines(@"D:\Test.txt")
                  .Select(ParseLine)
                  .Where(result => result.found)
                  .Select(result => result.value);

foreach (var result in results)
   Console.WriteLine(result);

---

注意：这不是关于正则表达式的抨击，只是不同的方法。

我没有对此进行基准测试，但我怀疑 Pointers 将是最快的，split 将紧随其后，Regex 可能是最慢的（即使使用编译的），但它是最易读、最易维护和最健壮的方法（这就是我把它放在第一位的原因）

基准测试

+----------+------------+-----------+-----------+
|  Method  |    Mean    |   Error   |  StdDev   |
+----------+------------+-----------+-----------+
| RegEx    | 3,358.3 us | 65.169 us | 66.923 us |
| Split    | 1,980.9 us | 38.440 us | 48.614 us |
| Pointers | 287.4 us   | 4.396 us  | 4.112 us  |
+----------+------------+-----------+-----------+

测试代码

public class Test
{
   private Regex _regex;

   private string[] data;

   [GlobalSetup]
   public void Setup()
   {
      _regex = new Regex(@"(?<=2:\[X:)\d+", RegexOptions.Compiled);

      data = File.ReadLines(@"D:\Test3.txt")
                 .ToArray();
   }

   [Benchmark]
   public List<int> RegEx()
   {
      return data.Select(line => _regex.Match(line))
                 .Where(x => x.Success)
                 .Select(match => int.Parse(match.Value))
                 .ToList();
   }

   [Benchmark]
   public List<int> Split()
   {
      return data.Select(line => line.Split(new[] { "2:[X:", "][Y:" }, StringSplitOptions.RemoveEmptyEntries))
                 .Where(results => results.Length > 1)
                 .Select(results => int.Parse(results[1]))
                 .ToList();
   }

   [Benchmark]
   public List<int> Pointers()
   {
      return data.Select(ParseLine)
                 .Where(result => result.found)
                 .Select(result => result.value)
                 .ToList();
   }

   public static unsafe (bool found, int value) ParseLine(string line)
   {
      const string prefix = "2:[X:"; 
      fixed (char* pLine = line,pPrefix = prefix)
      {
    
         var pLen = line.Length + pLine;
         var found = false;
         var result = 0;
         var i = 0;
         for (char* p = pLine ,pP = pPrefix; p < pLen; p++)
         {
            if (!found )
            {
               if( *p == *(pP+i)) i++;
               if( i ==prefix.Length) found = true;
               continue;
            }
            
            if (*p < '0' || *p > '9')
               break;

            result = result * 10 + *p - '0';

    
         }

         return (found, result);
      }
   }
}