clean up docs\spreadsheet\how-to-retrieve-the-values-of-cells-in-a-spreadsheet.md

mikeebowen · mikeebowen · commit 93c4e5c06b62 · 2025-01-10T15:51:26.000-08:00
diff --git a/docs/spreadsheet/how-to-retrieve-the-values-of-cells-in-a-spreadsheet.md b/docs/spreadsheet/how-to-retrieve-the-values-of-cells-in-a-spreadsheet.md
@@ -10,22 +10,22 @@ ms.suite: office
 ms.author: o365devx
 author: o365devx
 ms.topic: conceptual
-ms.date: 11/20/2023
+ms.date: 01/10/2025
 ms.localizationpriority: high
 ---
 
 # Retrieve the values of cells in a spreadsheet document
 
 This topic shows how to use the classes in the Open XML SDK for
 Office to programmatically retrieve the values of cells in a spreadsheet
-document. It contains an example **GetCellValue** method to illustrate
+document. It contains an example `GetCellValue` method to illustrate
 this task.
 
 
 
 ## GetCellValue Method
 
-You can use the **GetCellValue** method to
+You can use the `GetCellValue` method to
 retrieve the value of a cell in a workbook. The method requires the
 following three parameters:
 
@@ -62,7 +62,7 @@ initializes it to null.
 ## Accessing the Cell
 
 Next, the code opens the document by using the <xref:DocumentFormat.OpenXml.Packaging.SpreadsheetDocument.Open*> method, indicating that the document
-should be open for read-only access (the final **false** parameter). Next, the code retrieves a
+should be open for read-only access (the final `false` parameter). Next, the code retrieves a
 reference to the workbook part by using the <xref:DocumentFormat.OpenXml.Packaging.SpreadsheetDocument.WorkbookPart*> property of the document.
 
 ### [C#](#tab/cs-3)
@@ -111,8 +111,8 @@ the corresponding <xref:DocumentFormat.OpenXml.Spreadsheet.Worksheet.WorksheetPa
 Just as when locating the named sheet, when locating the named cell, the
 code uses the <xref:DocumentFormat.OpenXml.OpenXmlElement.Descendants*> method, searching for the first
 match in which the <xref:DocumentFormat.OpenXml.Spreadsheet.CellType.CellReference*> property equals the specified
-**addressName**
-parameter. After this method call, the variable named **theCell** will either contain a reference to the cell,
+`addressName`
+parameter. After this method call, the variable named `theCell` will either contain a reference to the cell,
 or will contain a null reference.
 
 ### [C#](#tab/cs-6)
@@ -125,9 +125,9 @@ or will contain a null reference.
 
 ## Retrieving the Value
 
-At this point, the variable named **theCell**
+At this point, the variable named `theCell`
 contains either a null reference, or a reference to the cell that you
-requested. If you examine the Open XML content (that is, **theCell.OuterXml**) for the cell, you will find XML
+requested. If you examine the Open XML content (that is, `theCell.OuterXml`) for the cell, you will find XML
 such as the following.
 
 ```xml
@@ -151,9 +151,9 @@ Now, the sample method must interpret the value. As it is, the code
 handles numeric and date, string, and Boolean values. You can extend the
 sample as necessary. The <xref:DocumentFormat.OpenXml.Spreadsheet.Cell> type provides a
 <xref:DocumentFormat.OpenXml.Spreadsheet.CellType.DataType*> property that indicates the type
-of the data within the cell. The value of the **DataType** property is null for numeric and date
-types. It contains the value **CellValues.SharedString** for strings, and **CellValues.Boolean** for Boolean values. If the
-**DataType** property is null, the code returns
+of the data within the cell. The value of the `DataType` property is null for numeric and date
+types. It contains the value `CellValues.SharedString` for strings, and `CellValues.Boolean` for Boolean values. If the
+`DataType` property is null, the code returns
 the value of the cell (it is a numeric value). Otherwise, the code
 continues by branching based on the data type.
 
@@ -165,7 +165,7 @@ continues by branching based on the data type.
 ***
 
 
-If the **DataType** property contains **CellValues.SharedString**, the code must retrieve a
+If the `DataType` property contains `CellValues.SharedString`, the code must retrieve a
 reference to the single <xref:DocumentFormat.OpenXml.Packaging.WorkbookPart.SharedStringTablePart*>.
 
 ### [C#](#tab/cs-9)
@@ -178,7 +178,7 @@ reference to the single <xref:DocumentFormat.OpenXml.Packaging.WorkbookPart.Shar
 
 Next, if the string table exists (and if it does not, the workbook is
 damaged and the sample code returns the index into the string table
-instead of the string itself) the code returns the **InnerText** property of the element it finds at the
+instead of the string itself) the code returns the `InnerText` property of the element it finds at the
 specified index (first converting the value property to an integer).
 
 ### [C#](#tab/cs-10)
@@ -189,7 +189,7 @@ specified index (first converting the value property to an integer).
 ***
 
 
-If the **DataType** property contains **CellValues.Boolean**, the code converts the 0 or 1
+If the `DataType` property contains `CellValues.Boolean`, the code converts the 0 or 1
 it finds in the cell value into the appropriate text string.
 
 ### [C#](#tab/cs-11)
@@ -200,17 +200,18 @@ it finds in the cell value into the appropriate text string.
 ***
 
 
-Finally, the procedure returns the variable **value**, which contains the requested information.
+Finally, the procedure returns the variable `value`, which contains the requested information.
 
 ## Sample Code
 
-The following is the complete **GetCellValue** code sample in C\# and Visual Basic.
+The following is the complete `GetCellValue` code sample in C\# and Visual Basic.
 
 ### [C#](#tab/cs)
 [!code-csharp[](../../samples/spreadsheet/retrieve_the_values_of_cells/cs/Program.cs#snippet0)]
 
 ### [Visual Basic](#tab/vb)
 [!code-vb[](../../samples/spreadsheet/retrieve_the_values_of_cells/vb/Program.vb#snippet0)]
+***
 
 ## See also
 
diff --git a/samples/spreadsheet/retrieve_the_values_of_cells/cs/Program.cs b/samples/spreadsheet/retrieve_the_values_of_cells/cs/Program.cs
@@ -1,4 +1,3 @@
-// <Snippet0>
 using DocumentFormat.OpenXml.Packaging;
 using DocumentFormat.OpenXml.Spreadsheet;
 using System;
@@ -7,6 +6,7 @@
 Console.WriteLine(GetCellValue(args[0], args[1], args[2]));
 // Retrieve the value of a cell, given a file name, sheet name, 
 // and address name.
+// <Snippet0>
 // <Snippet1>
 static string GetCellValue(string fileName, string sheetName, string addressName)
 // </Snippet1>
@@ -88,9 +88,9 @@ static string GetCellValue(string fileName, string sheetName, string addressName
                         break;
                     default:
                         value = "TRUE";
-                        // </Snippet11>
                         break;
                 }
+                // </Snippet11>
             }
         }
     }
diff --git a/samples/spreadsheet/retrieve_the_values_of_cells/vb/Program.vb b/samples/spreadsheet/retrieve_the_values_of_cells/vb/Program.vb
@@ -1,92 +1,91 @@
-' <Snippet0>
 Imports DocumentFormat.OpenXml.Packaging
 Imports DocumentFormat.OpenXml.Spreadsheet
 
 Module Program
     Sub Main(args As String())
+        Console.WriteLine(GetCellValue(args(0), args(1), args(2)))
     End Sub
 
-
+    ' Retrieve the value of a cell, given a file name, sheet name, 
+    ' and address name.
+    ' <Snippet0>
     ' <Snippet1>
-    Public Function GetCellValue(ByVal fileName As String, ByVal sheetName As String, ByVal addressName As String) As String
+    Function GetCellValue(fileName As String, sheetName As String, addressName As String) As String
         ' </Snippet1>
         ' <Snippet2>
         Dim value As String = Nothing
         ' </Snippet2>
         ' <Snippet3>
         ' Open the spreadsheet document for read-only access.
         Using document As SpreadsheetDocument = SpreadsheetDocument.Open(fileName, False)
-
             ' Retrieve a reference to the workbook part.
             Dim wbPart As WorkbookPart = document.WorkbookPart
             ' </Snippet3>
             ' <Snippet4>
-            ' Find the sheet with the supplied name, and then use that Sheet object
-            ' to retrieve a reference to the appropriate worksheet.
-            Dim theSheet As Sheet = wbPart.Workbook.Descendants(Of Sheet)().
-                Where(Function(s) s.Name = sheetName).FirstOrDefault()
+            ' Find the sheet with the supplied name, and then use that 
+            ' Sheet object to retrieve a reference to the first worksheet.
+            Dim theSheet As Sheet = wbPart?.Workbook.Descendants(Of Sheet)().Where(Function(s) s.Name = sheetName).FirstOrDefault()
 
             ' Throw an exception if there is no sheet.
-            If theSheet Is Nothing Then
+            If theSheet Is Nothing OrElse theSheet.Id Is Nothing Then
                 Throw New ArgumentException("sheetName")
             End If
             ' </Snippet4>
-            ' Retrieve a reference to the worksheet part.
             ' <Snippet5>
+            ' Retrieve a reference to the worksheet part.
             Dim wsPart As WorksheetPart = CType(wbPart.GetPartById(theSheet.Id), WorksheetPart)
             ' </Snippet5>
             ' <Snippet6>
             ' Use its Worksheet property to get a reference to the cell 
             ' whose address matches the address you supplied.
-            Dim theCell As Cell = wsPart.Worksheet.Descendants(Of Cell).
-                Where(Function(c) c.CellReference = addressName).FirstOrDefault
+            Dim theCell As Cell = wsPart.Worksheet?.Descendants(Of Cell)().Where(Function(c) c.CellReference = addressName).FirstOrDefault()
             ' </Snippet6>
             ' <Snippet7>
             ' If the cell does not exist, return an empty string.
-            If theCell IsNot Nothing Then
-                value = theCell.InnerText
-                ' </Snippet7>
-                ' <Snippet8>
-                ' If the cell represents an numeric value, you are done. 
-                ' For dates, this code returns the serialized value that 
-                ' represents the date. The code handles strings and 
-                ' Booleans individually. For shared strings, the code 
-                ' looks up the corresponding value in the shared string 
-                ' table. For Booleans, the code converts the value into 
-                ' the words TRUE or FALSE.
-                If theCell.DataType IsNot Nothing Then
-                    Select Case theCell.DataType.Value
-                        ' </Snippet8>
-                        Case CellValues.SharedString
-                            ' <Snippet9>
-                            ' For shared strings, look up the value in the 
-                            ' shared strings table.
-                            Dim stringTable = wbPart.GetPartsOfType(Of SharedStringTablePart).FirstOrDefault()
-                            ' </Snippet9>
-                            ' <Snippet10>
-                            ' If the shared string table is missing, something
-                            ' is wrong. Return the index that is in 
-                            ' the cell. Otherwise, look up the correct text in 
-                            ' the table.
-                            If stringTable IsNot Nothing Then
-                                value = stringTable.SharedStringTable.
-                                ElementAt(Integer.Parse(value)).InnerText
-                            End If
-                            ' </Snippet10>
-                            ' <Snippet11>
-                        Case CellValues.Boolean
-                            Select Case value
-                                Case "0"
-                                    value = "FALSE"
-                                Case Else
-                                    value = "TRUE"
-                            End Select
-                            ' </Snippet11>
+            If theCell Is Nothing OrElse theCell.InnerText.Length < 0 Then
+                Return String.Empty
+            End If
+            value = theCell.InnerText
+            ' </Snippet7>
+            ' <Snippet8>
+            ' If the cell represents an integer number, you are done. 
+            ' For dates, this code returns the serialized value that 
+            ' represents the date. The code handles strings and 
+            ' Booleans individually. For shared strings, the code 
+            ' looks up the corresponding value in the shared string 
+            ' table. For Booleans, the code converts the value into 
+            ' the words TRUE or FALSE.
+            If theCell.DataType IsNot Nothing Then
+                If theCell.DataType.Value = CellValues.SharedString Then
+                    ' </Snippet8>
+                    ' <Snippet9>
+                    ' For shared strings, look up the value in the
+                    ' shared strings table.
+                    Dim stringTable = wbPart.GetPartsOfType(Of SharedStringTablePart)().FirstOrDefault()
+                    ' </Snippet9>
+                    ' <Snippet10>
+                    ' If the shared string table is missing, something 
+                    ' is wrong. Return the index that is in
+                    ' the cell. Otherwise, look up the correct text in 
+                    ' the table.
+                    If stringTable IsNot Nothing Then
+                        value = stringTable.SharedStringTable.ElementAt(Integer.Parse(value)).InnerText
+                    End If
+                    ' </Snippet10>
+                ElseIf theCell.DataType.Value = CellValues.Boolean Then
+                    ' <Snippet11>
+                    Select Case value
+                        Case "0"
+                            value = "FALSE"
+                        Case Else
+                            value = "TRUE"
                     End Select
+                    ' </Snippet11>
                 End If
             End If
         End Using
+
         Return value
     End Function
+    ' </Snippet0>
 End Module
-' </Snippet0>

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,3 @@`
`1`		`-// <Snippet0>`
`2`	`1`	`using DocumentFormat.OpenXml.Packaging;`
`3`	`2`	`using DocumentFormat.OpenXml.Spreadsheet;`
`4`	`3`	`using System;`
`@@ -7,6 +6,7 @@`
`7`	`6`	`Console.WriteLine(GetCellValue(args[0], args[1], args[2]));`
`8`	`7`	`// Retrieve the value of a cell, given a file name, sheet name,`
`9`	`8`	`// and address name.`
	`9`	`+// <Snippet0>`
`10`	`10`	`// <Snippet1>`
`11`	`11`	`static string GetCellValue(string fileName, string sheetName, string addressName)`
`12`	`12`	`// </Snippet1>`
`@@ -88,9 +88,9 @@ static string GetCellValue(string fileName, string sheetName, string addressName`
`88`	`88`	`break;`
`89`	`89`	`default:`
`90`	`90`	`value = "TRUE";`
`91`		`- // </Snippet11>`
`92`	`91`	`break;`
`93`	`92`	`}`
	`93`	`+ // </Snippet11>`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`	`}`