缺少使用 OpenXml 解析 Excel 文件的列

Question

我发现使用 OpenXml 我的列并不总是对齐。例如看这个例子

这是标题行 第 37 列 = “仅限交换” 第 38 列 = “现有数量” 第 39 栏 = “成本法” 第 40 列 = “成本法金额”

现在，在下一行 - 在 37 和 38 中都有实际数据的行是空白的，但它省略了第 38 列。所以我的数据看起来像这样。

第 37 列 = ""（应为空白） 第 38 列 = “设置金额”（应为空白，因为它应与“现有数量”对齐） 第 39 列 = 0

请注意，它删除了真正的列/单元格 38，现在我的解析器不再排队。 37 和 38 都是空白，但不会丢失 37。

这里有一些代码展示了我是如何得到字符串数组的——它实际上只是一个来自 MSDN 的修改示例。

public InventoryItemLoadProxy CreateInventoryItemFromSpreadsheetRow(Row row, SharedStringTable sharedStrings)
     {
         var invItem = new InventoryItemLoadProxy();
         var theCells = row.Descendants<Cell>();

         var textValues =
             from cell in row.Descendants<Cell>()
             select(cell.CellValue == null ? string.Empty : ((cell.DataType != null
                             && cell.DataType.HasValue
                              && cell.DataType == CellValues.SharedString) ? sharedStrings.ChildElements[int.Parse(cell.CellValue.InnerText)].InnerText : cell.CellValue.InnerText));

          if(textValues.Any(x => x != string.Empty))
          {
             var textArray = textValues.ToArray();


             invItem.PartNumber = textArray[0].ToStrippedPartNumber();
             invItem.DisplayPartNumber = textArray[0];
             //More parsing...
         }
    }

你可以看到我是说如果它是 null 就让它 string.empty （是的 - 那个疯狂的 linq 语句会在某个时候被重构）。

Answer 1

事实证明，其他人已经回答了这个问题。见reading Excel Open XML is ignoring blank cells。我使用了更多的“蛮力和无知”方法，尽管一旦我有机会对来自其他答案的代码进行单元测试，我可能会进行重构。不过，这可以满足我目前的需求。

private int GetIndexFromCellRef(Cell cell)
        {
            var colname = cell.CellReference.Value;
            colname = Regex.Replace(colname, "[0-9]", "");
            var indexList = new Dictionary<string, int>
                {
                    {"A", 0},
                    {"B", 1},
                    {"C", 2},
                    {"D", 3},
                    {"E", 4},
                    {"F", 5},
                    {"G", 6},
                    {"H", 7},
                    {"I", 8},
                    {"J", 9},
                    {"K", 10},
                    {"L", 11},
                    {"M", 12},
                    {"N", 13},
                    {"O", 14},
                    {"P", 15},
                    {"Q", 16},
                    {"R", 17},
                    {"S", 18},
                    {"T", 19},
                    {"U", 20},
                    {"V", 21},
                    {"W", 22},
                    {"X", 23},
                    {"Y", 24},
                    {"Z", 25},
                    {"AA", 26},
                    {"AB", 27},
                    {"AC", 28},
                    {"AD", 29},
                    {"AE", 30},
                    {"AF", 31},
                    {"AG", 32},
                    {"AH", 33},
                    {"AI", 34},
                    {"AJ", 35},
                    {"AK", 36},
                    {"AL", 37},
                    {"AM", 38},
                    {"AN", 39},
                    {"AO", 40},
                    {"AP", 41},
                    {"AQ", 42},
                    {"AR", 43},
                    {"AS", 44},
                    {"AT", 45},
                    {"AU", 46},
                    {"AV", 47},
                    {"AW", 48},
                    {"AX", 49},
                    {"AY", 50},
                    {"AZ", 51},
                    {"BA", 52},
                    {"BB", 53},
                    {"BC", 54},
                    {"BD", 55},
                    {"BE", 56},
                    {"BF", 57},
                    {"BG", 58},
                    {"BH", 59},
                    {"BI", 60},
                    {"BJ", 61},
                    {"BK", 62},
                    {"BL", 63},
                    {"BM", 64},
                    {"BN", 65},
                    {"BO", 66},
                    {"BP", 67},
                    {"BQ", 68}
                };

            if (indexList.ContainsKey(colname))
                return indexList.First(x => x.Key.Equals(colname)).Value;
            return -1;
        }