Read word Document using C# Interop and populate it into the DataGrid?

3 min read 07-10-2024

Read word Document using C# Interop and populate it into the DataGrid?

Reading Word Documents and Populating a DataGrid with C# Interop

This article will guide you through the process of reading data from a Word document using C# Interop and populating a DataGrid with the extracted information. This is a common task in various applications where you need to import data from existing Word documents into a structured format for further processing or display.

Scenario: Extracting Data from a Word Document

Imagine you have a Word document containing a list of products, each with details like name, description, price, and quantity. You want to display this information in a user-friendly DataGrid within your C# application.

Here's a simplified example of how the Word document might look:

**Product Name	Description	Price	Quantity**
Product A	This is a sample product	$10.00	10
Product B	Another product description	$15.00	5
Product C	A third product	$20.00	8

The Code: Reading Data and Populating the DataGrid

using Microsoft.Office.Interop.Word;
using System;
using System.Collections.Generic;
using System.Data;
using System.Windows.Forms;

namespace WordToDataGrid
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void btnReadWord_Click(object sender, EventArgs e)
        {
            // Open file dialog to select the Word document
            OpenFileDialog openFileDialog = new OpenFileDialog();
            openFileDialog.Filter = "Word Documents (*.docx;*.doc)|*.docx;*.doc";
            if (openFileDialog.ShowDialog() == DialogResult.OK)
            {
                string filePath = openFileDialog.FileName;
                ReadWordData(filePath);
            }
        }

        private void ReadWordData(string filePath)
        {
            // Create a Word application object
            Application wordApp = new Application();
            Document wordDoc = wordApp.Documents.Open(filePath);

            // Define the table data structure
            DataTable dt = new DataTable();
            dt.Columns.Add("ProductName", typeof(string));
            dt.Columns.Add("Description", typeof(string));
            dt.Columns.Add("Price", typeof(double));
            dt.Columns.Add("Quantity", typeof(int));

            // Iterate through the tables in the document
            foreach (Table table in wordDoc.Tables)
            {
                // Iterate through rows in the table (starting from the second row, skipping the header)
                for (int i = 2; i <= table.Rows.Count; i++)
                {
                    DataRow row = dt.NewRow();

                    // Extract data from each cell in the row
                    row["ProductName"] = table.Cell(i, 1).Range.Text.Trim();
                    row["Description"] = table.Cell(i, 2).Range.Text.Trim();
                    row["Price"] = Convert.ToDouble(table.Cell(i, 3).Range.Text.Trim().Replace("{{content}}quot;, "").Trim());
                    row["Quantity"] = Convert.ToInt32(table.Cell(i, 4).Range.Text.Trim());

                    dt.Rows.Add(row);
                }
            }

            // Populate the DataGrid
            dataGridView1.DataSource = dt;

            // Clean up Word objects
            wordDoc.Close();
            wordApp.Quit();
        }
    }
}

Explanation of the Code

Import necessary namespaces: This code imports the Microsoft.Office.Interop.Word namespace for working with Word documents, along with other essential namespaces for DataTables and UI elements.
Open the Word document: The code uses an OpenFileDialog to allow the user to select the Word document to read.
Create Word objects: It creates a Application object (wordApp) and opens the document (wordDoc).
Define the data table: It creates a DataTable to store the extracted data, defining columns for each data field.
Iterate through tables and rows: The code iterates through all tables in the document, then iterates through each row in the table, skipping the header row.
Extract data: For each row, the code retrieves the text content of each cell, trims any leading/trailing spaces, and converts the values to the appropriate data types (string, double, int).
Populate the DataGrid: Finally, the code sets the DataGrid's DataSource to the populated DataTable, displaying the data in a structured table format.
Clean up: It closes the document and quits the Word application to release resources.

Additional Considerations and Best Practices

Error Handling: Implement error handling to gracefully handle situations like missing or invalid data in the Word document.
Advanced Data Extraction: For more complex scenarios, you can explore using Word's API to extract more specific information, such as table formatting, images, and other document properties.
Security: Be mindful of security implications when working with external files. Validate user input and sanitize data to prevent vulnerabilities.
Data Validation: Implement validation rules on the extracted data to ensure data integrity.
Alternative Methods: While Interop is a common method, consider exploring other options like the Open XML SDK, which can provide more flexibility and performance in certain situations.

Conclusion

By using C# Interop, you can effectively read data from Word documents and populate a DataGrid for visualization and further processing within your application. This article provides a foundational understanding of the process and highlights some key aspects for successful implementation. Remember to adapt this code to your specific requirements and always prioritize security and data integrity.