Create a Well-Formatted Word Document in C# on macOS from JSON

Dynamic Word Document Generation from JSON Data

Using a template-based approach with placeholders, implemented in C# for macOS in .NET 8

// Import necessary libraries
using System;
using System.IO;
using Newtonsoft.Json;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
// Define the data model for employees
public class Employee
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string DateOfBirth { get; set; }
}
// Main program
class Program
{
    static void Main(string[] args)
    {
        // Load JSON data
        string jsonFilePath = "employees.json";
        var employees = JsonConvert.DeserializeObject<List<Employee>>(File.ReadAllText(jsonFilePath));
        // Define template path and output path
        string templatePath = "template.docx";
        string outputPath = "output.docx";
        // Open the Word template
        using (var wordDoc = WordprocessingDocument.Open(templatePath, true))
        {
            var body = wordDoc.MainDocumentPart.Document.Body;
            // Replace placeholders
            foreach (var employee in employees)
            {
                foreach (var text in body.Descendants<Text>())
                {
                    text.Text = text.Text.Replace("{FirstName}", employee.FirstName)
                                          .Replace("{LastName}", employee.LastName)
                                          .Replace("{DateOfBirth}", employee.DateOfBirth);
                }
            }
        }
        // Save as a new file
        File.Copy(templatePath, outputPath, true);
        Console.WriteLine("Document generated successfully!");
    }
}

Generate Word Documents Programmatically Without Templates

Using a pure code-based approach with Open XML SDK in C#

// Import necessary libraries
using System;
using System.IO;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
using Newtonsoft.Json;
// Define the data model for employees
public class Employee
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string DateOfBirth { get; set; }
}
// Main program
class Program
{
    static void Main(string[] args)
    {
        // Load JSON data
        string jsonFilePath = "employees.json";
        var employees = JsonConvert.DeserializeObject<List<Employee>>(File.ReadAllText(jsonFilePath));
        // Define output path
        string outputPath = "output_from_code.docx";
        // Create Word document
        using (var wordDoc = WordprocessingDocument.Create(outputPath, DocumentFormat.OpenXml.WordprocessingDocumentType.Document))
        {
            // Add a main document part
            var mainPart = wordDoc.AddMainDocumentPart();
            mainPart.Document = new Document();
            var body = mainPart.Document.AppendChild(new Body());
            // Add content for each employee
            foreach (var employee in employees)
            {
                var para = body.AppendChild(new Paragraph());
                var run = para.AppendChild(new Run());
                run.AppendChild(new Text($"Name: {employee.FirstName} {employee.LastName}, DOB: {employee.DateOfBirth}"));
            }
        }
        Console.WriteLine("Document generated successfully!");
    }
}

Common Questions About Automating Word Documents

1. What is the best library for working with Word documents in C#?
2. The Open XML SDK is widely regarded as the most robust option for manipulating Word documents programmatically.
3. How do I replace placeholders in a Word template?
4. You can use Text.Replace to locate and replace placeholders such as {FirstName} with dynamic content.
5. What happens if my JSON file contains unexpected data?
6. Using JsonConvert.DeserializeObject with validation ensures that your JSON data is processed correctly, even if it includes unexpected fields.
7. Can I add images to my Word document programmatically?
8. Yes, you can embed images using ImagePart in the Open XML SDK to add logos or photos dynamically.
9. How can I ensure my document matches corporate branding?
10. Prepare a preformatted template that includes custom styles, fonts, and colors, which your script can use for generating documents.
11. Is it possible to handle nested JSON data?
12. You can preprocess the JSON to flatten nested objects or use loops to dynamically populate multiple placeholders in the Word document.
13. Which approach is better for complex documents: templates or code-based?
14. Templates are generally better for complex designs, while code-based approaches are ideal for simpler structures or high customization.
15. How do I prevent overwriting the original template?
16. Use File.Copy to save the output as a new file, preserving your original template.
17. Can I generate multiple Word documents at once?
18. Yes, you can iterate over your JSON data, creating a new document for each entry using a loop in your script.
19. What’s the best IDE for this workflow?
20. While you can use Visual Studio or Visual Studio Code, the latter is lightweight and works well with macOS.

Crafting Dynamic Word Documents with JSON and C#

The template-based approach stands out for its flexibility and ease of use, particularly for creating well-designed, professional documents. By combining manual formatting and automated data insertion, you can save time while maintaining quality and consistency. 📝

Alternatively, programmatically generating a Word document from scratch offers greater customization but requires more effort for detailed formatting. With tools like Open XML SDK, this method is excellent for straightforward or repetitive documents with minimal style adjustments. Choose the method that aligns with your workflow. 🚀