在文本文件中查找数据行

Question

我有一个文本文件（实际上是一个Intel Hex文件，但数据是ASCII文本），但我一直想不出一种方法来查找零数据的开始和结束行。

该文件将从数据行开始，然后可能有几行为零，然后再为数据。 我正在尝试做的是找到最后一组零的位置。

例如，文件可能包含以下内容：

:1234567890
:0987654321
:0000000000
:0000000000
:ABCDEFABCD
:DCBAFEDCBA
:0000000000
:0000000000
:0000000000
:9999999999

对于此文件，我想将第7行作为起始行，将第9行作为结束行。

我目前正在使用StreamReader和ReadLine像这样：

StreamReader srHexFile = File.OpenText(m_pathHexFile);
while ((readData = srHexFile.ReadLine()) != null)
....

但是，我对遍历和设置/重置起始行和结束行的最佳方法有一个想法。

在此先感谢您的帮助！

根据@ user993533的建议，我正在使用以下函数，但对于firstZeroRow返回2881，应为2883。

这是新的代码：

 private int FindEndofFlashData()
    {
        int lineNumber = 0;
        String readData;
        String zeroRowData = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
        int firstZeroRow = -1; // Will hold the location that starts the zero data
        //int lastZeroRow = m_numberOfFlashRows - 2;  // We know where to stop looking from m_numberOfFlashRows
        int lastZeroRow = -1;
        bool groupEnded = true;
        StreamReader srHexFile = File.OpenText(m_pathHexFile);

        /* Loop till the main flash row data ends, which will be used to calculate the number of lines in hex file for
         * flash rows.  Each line of hex file will have data for 1/2 th of a Flash row (64 bytes)*/
        while (((readData = srHexFile.ReadLine()) != null) && (lineNumber < (m_numberOfFlashRows*4 - 4)))
        {

            if ((readData[HEX_FILE_RECORD_TYPE_CHAR_0_INDEX] == HEX_FILE_DATA_RECORD_CHAR_0) && (readData[HEX_FILE_RECORD_TYPE_CHAR_1_INDEX] == HEX_FILE_DATA_RECORD_CHAR_1))
            {
                lineNumber++;

                if (readData.Substring(9, 128) == zeroRowData)
                {
                    if(groupEnded)
                    {
                        firstZeroRow = lineNumber;
                        groupEnded = false;
                    }

                    lastZeroRow = lineNumber;
                }
                else
                {
                    groupEnded = true;
                }
            }
            else
            {

                if ((readData[HEX_FILE_RECORD_TYPE_CHAR_0_INDEX] == HEX_FILE_EXTEND_LINEAR_RECORD_CHAR_0) &&
                    (readData[HEX_FILE_RECORD_TYPE_CHAR_1_INDEX] == HEX_FILE_EXTEND_LINEAR_RECORD_CHAR_1))
                {
                    if (readData[HEX_FILE_EXTENDED_ADDR_CHAR_1_INDEX] >= HEX_FILE_EXTENDED_ADDR_NON_FLASH_REGION)
                    {
                        break;
                    }
                }
            }

        }
        Console.WriteLine("First Zero Row is: {0}", firstZeroRow);
        Console.WriteLine("Last Zero Row is: {0}", lastZeroRow);
        return (firstZeroRow);
    }

Answer 1

    long firstZeroRow = -1;
    long lastZeroRow = -1;
    long rowNum = 0;

    StreamReader srHexFile = File.OpenText(m_pathHexFile);
    while ((readData = srHexFile.ReadLine()) != null){
       rowNum++;
       if (readData.equals(":0000000000" /*or ":0000000000\n"*/)){
           if (firstZeroRow == -1){
               firstZeroRow = rowNum;
           }
           lastZeroRow = rowNum;
       }
    }

    if (firstZeroRow == -1){
        System.out.println("firstZeroRow: " + firstZeroRow);
        System.out.println("lastZeroRow: " + lastZeroRow);
    }

Answer 2

由于不清楚总体目标是什么...我使用了另一种方法。 在读取数据时，我没有尝试摆弄最后的零起始行和结束行，而是简单地列出了全为零的那些行。 然后，只需按从高到低的顺序对列表进行排序即可获得最后一行的零位索引。 然后使用相同的列表，从列表的顶部开始，获取最后一个零组的第一个/起始索引，进行检查以查看相邻索引是否连续。 如果索引是连续的，那么我们只是继续进行下去，直到下一个元素索引不连续为止，此时我们将知道最后一组的起始位置。 如果我们到达列表的末尾，那么您会知道列表以零行开始，在这种情况下索引为0。我知道我的索引与您的帖子偏离了1，因为我以a开头零（0）索引而不是1。

private static void GetStartEndOfLastGroupOfZeros() {
  string readData = "";
  int rowNum = 0;
  List<int> rowsOfZero = new List<int>();
  StreamReader srHexFile = File.OpenText(m_pathHexFile);
  while ((readData = srHexFile.ReadLine()) != null) {
    if (readData.Equals(":0000000000")) {
      rowsOfZero.Add(rowNum);
    }
    rowNum++;
  }
  rowsOfZero.Reverse();
  PrintIndexes(rowsOfZero);
  if (rowsOfZero.Count < 1) {
    Console.WriteLine("There are NO rows that are :0000000000");
  }
  else {
    Console.WriteLine("\n\rStart line number of Last Zero Group: " + GetFirstIndexOfLastGroupOfZeroRows(rowsOfZero));
    Console.WriteLine("End line number of Last Zero Group: " + GetLastIndexOfLastGroupOfZeroRows(rowsOfZero));
  }
}

private static int GetFirstIndexOfLastGroupOfZeroRows(List<int> rowsOfZero) {
  if (rowsOfZero.Count < 1)  // <- if there are not any int in the list then there are no zero rows return -1;
    return -1;
  if (rowsOfZero.Count < 2)  // <- if there is only one row then it starts and ends on that single row
      return rowsOfZero[0];
  if (rowsOfZero[1] + 1 != rowsOfZero[0])  // <-- if the second element(1) is not contiguous, then the last row is a single zero row,
    return rowsOfZero[0];                  // <-- so the start line of the last group will be the same as the end line index 
  int startOfThisGroup = 0;
  for (int i = 2; i < rowsOfZero.Count; i++) {
    if (rowsOfZero[i] + 1 == rowsOfZero[i - 1]) {  // <-- if they are contiguous then we have a new startOfThisGroup row, if not we are done checking
      startOfThisGroup = rowsOfZero[i];
    }
    else {
      break;
    }
  }
  return startOfThisGroup;
}

private static int GetLastIndexOfLastGroupOfZeroRows(List<int> rowsOfZero) {
  if (rowsOfZero.Count < 1)
    return 0;
  return rowsOfZero[0];
}

private static void PrintIndexes(List<int> rowsOfZero) {
  if (rowsOfZero.Count < 1) {
    Console.WriteLine("No zero rows");
  }
  else {
    Console.Write("Sorted (high to low) row indexes that are ':0000000000' -> ");
    foreach (int curInt in rowsOfZero)
      Console.Write(curInt + " ");
  }
  Console.WriteLine("");
}

希望这可以帮助。