C# Worksheet.GetFirstChild方法代码示例

 internal OpenXmlExcelRandomWriter(OpenXmlExcelConnection connection, string worksheetName, bool createSheetIfNotExists)
 {
     WorksheetName = worksheetName;
     this.connection = connection;
     this.worksheet = connection.GetSheet(worksheetName, createSheetIfNotExists);
     this.sheetData = worksheet.GetFirstChild<SheetData>();
 }

        public void AddRow(Worksheet worksheet, bool isHeader, params object[] values)
        {
            var row = new Row();
            var sheetData = worksheet.GetFirstChild<SheetData>();
            var styleIndex = StyleConst.CellFormat.CellFormatStyle.CELL_REGULAR;

            if (isHeader)
                styleIndex = StyleConst.CellFormat.CellFormatStyle.CELL_HEADER;

            foreach (var value in values)
            {
                var cell = GetCell(value, styleIndex);
                row.AppendChild(cell);
            }

            sheetData.Append(row);
            worksheet.Save();
        }

        // Given a worksheet, a column name, and a row index, gets the cell at the specified column and row.
        private static Cell GetSpreadsheetCell(Worksheet worksheet, string columnName, uint rowIndex)
        {
            IEnumerable<Row> rows = worksheet.GetFirstChild<SheetData>().Elements<Row>().Where(r => r.RowIndex == rowIndex);
            if (rows.Count() == 0)
            {
                // A cell does not exist at the specified row.
                return null;
            }

            IEnumerable<Cell> cells = rows.First().Elements<Cell>().Where(c => string.Compare(c.CellReference.Value, columnName + rowIndex, true) == 0);
            if (cells.Count() == 0)
            {
                // A cell does not exist at the specified column, in the specified row.
                return null;
            }

            return cells.First();
        }

        // Given a Worksheet and an address (like "AZ254"), either return a cell reference, or
        // create the cell reference and return it.
        private static Cell RetrieveCellReference(Worksheet ws, string addressName)
        {
            // Use regular expressions to get the row number and column name.
            // If the parameter wasn't well formed, this code
            // will fail:
            Regex rx = new Regex("^(?<col>\\D+)(?<row>\\d+)");
            Match m = rx.Match(addressName);
            uint rowNumber = uint.Parse(m.Result("${row}"));
            string colName = m.Result("${col}");

            // Retrieve reference to the sheet's data.
            SheetData sheetData = ws.GetFirstChild<SheetData>();

            // If the worksheet does not contain a row
            // with the specified row index, insert one.
            var rows = sheetData.Elements<Row>();
            var theRow = rows.FirstOrDefault(r => r.RowIndex.Value == rowNumber);
            if (theRow == null)
            {
                theRow = new Row();
                theRow.RowIndex = rowNumber;

                Row refRow = null;
                foreach (Row row in rows)
                {
                    if (row.RowIndex > rowNumber)
                    {
                        refRow = row;
                        break;
                    }
                }
                // If refRow is null, InsertBefore appends.
                sheetData.InsertBefore(theRow, refRow);
            }
            // At this point, theRow refers to the row to contain the cell value.
            // The cell may or may not exist.

            // If the cell you need already exists, return it.
            // If there is not a cell with the specified address name, insert one.
            var cells = theRow.Elements<Cell>();

            Cell theCell = cells.FirstOrDefault(c => c.CellReference.Value == addressName);
            if (theCell == null)
            {
                // Cell doesn't exist, so create one.
                theCell = new Cell();
                theCell.CellReference = addressName;
                // Must insert cell in the appropriate location.
                Cell refCell = null;
                foreach (Cell cell in cells)
                {
                    if (string.Compare(cell.CellReference.Value, addressName, true) > 0)
                    {
                        refCell = cell;
                        break;
                    }
                }
                // If refCell is null, InsertBefore appends.
                theRow.InsertBefore(theCell, refCell);
            }
            return theCell;
        }

 // Given a worksheet and a row index, return the row.
 private Row GetRow(Worksheet worksheet, uint rowIndex)
 {
     return worksheet.GetFirstChild<SheetData>().
       Elements<Row>().Where(r => r.RowIndex == rowIndex).First();
 }

        // Given a Worksheet and an address (like "AZ254"), either return a 
        // cell reference, or create the cell reference and return it.
        private static DocumentFormat.OpenXml.Spreadsheet.Cell InsertCellInWorksheet(Worksheet ws,
            string addressName)
        {
            SheetData sheetData = ws.GetFirstChild<SheetData>();
            DocumentFormat.OpenXml.Spreadsheet.Cell cell = null;

            UInt32 rowNumber = GetRowIndex(addressName);
            Row row = GetRow(sheetData, rowNumber);

            // If the cell you need already exists, return it.
            // If there is not a cell with the specified column name, insert one.  
            DocumentFormat.OpenXml.Spreadsheet.Cell refCell = row.Elements<DocumentFormat.OpenXml.Spreadsheet.Cell>().
                Where(c => c.CellReference.Value == addressName).FirstOrDefault();
            if (refCell != null)
            {
                cell = refCell;
            }
            else
            {
                cell = CreateCell(row, addressName);
            }
            return cell;
        }

        // 创建一个 Row。不负责查重
        // row 的 cell 创建完成后，记得 ws.Save()
        public static Row CreateRow(
            Worksheet ws,
            // string addressName,
            UInt32 rowNumber)
        {
            SheetData sheetData = ws.GetFirstChild<SheetData>();

            // UInt32 rowNumber = GetRowIndex(addressName);
            Row row = new Row();
            row.RowIndex = rowNumber;
            sheetData.Append(row);

            return row;
        }

        public static MergeCell InsertMergeCell(Worksheet ws,
    string addressName1,
    string addressName2)
        {
            SheetData sheetData = ws.GetFirstChild<SheetData>();
            MergeCells cells = ws.GetFirstChild<MergeCells>();
            if (cells == null)
            {
                cells = new MergeCells();
                ws.InsertAfter<MergeCells>(cells, sheetData);
            }

            string s = addressName1 + ":" + addressName2;

            MergeCell cell = cells.Elements<MergeCell>().Where(c => c.Reference == s).FirstOrDefault();
            if (cell == null)
            {
                cell = new MergeCell();
                cell.Reference = s;
                cells.AppendChild<MergeCell>(cell);
            }

            return cell;
        }

 //
 //  Insert a new cell into the Worksheet at the given address
 //
 private Cell insertCellInWorkSheet(Worksheet ws, string addr)
 {
     //  Select the sheet data
     SheetData sheetData = ws.GetFirstChild<SheetData>();
     Cell cell = null;
     //  Get the row
     UInt32 rowNum = getRowIndex(addr);
     Row row = getRow(sheetData, rowNum);
     //
     //  If the selected cell already exists return it else create a new one
     //
     Cell refCell = row.Elements<Cell>().Where(c => c.CellReference.Value == addr).FirstOrDefault();
     if (refCell != null)
     {
         cell = refCell;
     }
     else
     {
         cell = createCell(row, addr);
     }
     return cell;
 }

        private bool SelectSheet(string nomeAba)
        {
            Sheet aba = _wbPart.Workbook.Descendants<Sheet>().ToList().FirstOrDefault(s => s.Name == nomeAba);

            if (aba != null)
            {
                _activeWorksheet = ((WorksheetPart)(_wbPart.GetPartById(aba.Id))).Worksheet;
                _controlesFolhaAtual = _activeWorksheet.GetFirstChild<Controls>();

                return true;
            }

            return false;
        }

        private Cell InsertCellInWorksheet(Worksheet ws, string addressName)
        {
            var sheetData = ws.GetFirstChild<SheetData>();
            Cell cell = null;

            var rowNumber = GetRowIndex(addressName);
            var row = GetRow(sheetData, rowNumber);

            var refCell = row.Elements<Cell>().FirstOrDefault(c => c.CellReference.Value == addressName);
            cell = refCell ?? CreateCell(row, addressName);
            return cell;
        }

 // Given a worksheet and a row index, return the row.
 private static Row GetRow(Worksheet worksheet, uint rowIndex)
 {
     var rows = worksheet.GetFirstChild<SheetData>().Elements<Row>().ToArray();
     return rows.FirstOrDefault(r => r.RowIndex == rowIndex);
 }

 // Given a worksheet and a row index, return the row.
 public static Row GetRow(Worksheet worksheet, uint rowIndex)
 {
     Row row = worksheet.GetFirstChild<SheetData>().Elements<Row>().ElementAtOrDefault((int)rowIndex - 1);
     return row;
 }

 public static Row CreateRow(Worksheet worksheet, uint rowIndex)
 {
     Row row = worksheet.GetFirstChild<SheetData>().AppendChild(new Row());
     row.RowIndex = rowIndex;
     return row;
     
 }

 // Given a worksheet and a row index, return the row.
 private static Row GetRow(Worksheet worksheet, uint rowIndex)
 {
     Row row;
     SheetData sheetData = worksheet.GetFirstChild<SheetData>();
     if (sheetData.Elements<Row>().Where(item => item.RowIndex == rowIndex).Count() != 0)
     {
         row = sheetData.Elements<Row>().Where(item => item.RowIndex == rowIndex).First();
     }
     else
     {
         Row previousRow = null;
         row = new Row() { RowIndex = rowIndex };
         for (uint counter = rowIndex - 1; counter > 0; counter--)
         {
             previousRow = sheetData.Elements<Row>().Where(item => item.RowIndex == counter).FirstOrDefault();
             if (previousRow != null)
             {
                 break;
             }
         }
         sheetData.InsertAfter(row, previousRow);
     }
     return row;
 }