Creeu un document de Word ben formatat en C# a macOS des de JSON

Creació de documents de Word dinàmics amb JSON i C#

Imagineu-vos que teniu l'encàrrec de transformar les dades JSON en brut en un document de Word polit, amb capçaleres, logotips i contingut dinàmic. 📝 Pot semblar un repte descoratjador, sobretot si no sabeu per on començar. Tanmateix, amb l'enfocament adequat, aquest procés pot ser alhora eficient i senzill.

Per als desenvolupadors que utilitzen macOS i .NET 8, la necessitat d'automatització sovint es creua amb el desig de personalització. En aquest escenari, us podríeu preguntar: heu de formatar manualment una plantilla i emplenar els marcadors de posició mitjançant programació, o hauríeu de crear el document completament mitjançant codi? Cada mètode té els seus avantatges i comprendre'ls us ajudarà a prendre la millor decisió.

Penseu-ho com si planegeu una presentació. Començaries amb una plataforma de diapositives predissenyada, intercanviant contingut segons sigui necessari o dissenyar totes les diapositives des de zero? El mateix principi s'aplica aquí. Un enfocament basat en plantilles us permet centrar-vos en el format per avançat alhora que minimitzeu la codificació repetitiva més endavant.

Aquest article explora com abordar aquest problema comú pas a pas. Tant si es tracta de registres d'empleats com de qualsevol dada estructurada, l'objectiu és que el vostre flux de treball sigui perfecte i es pugui mantenir. Aprofundim en els detalls i busquem la manera més eficaç de satisfer les vostres necessitats. 🚀

Optimització de la creació de documents de Word amb JSON i C#

El primer script demostra un enfocament basat en plantilles, que és especialment útil quan es tracta de documents preformatats. Aquest mètode comença amb un fitxer de Word que conté marcadors de posició, com ara {FirstName}, {LastName} i {DateOfBirth}. Utilitzant el Obre XML SDK, el programa llegeix el document i substitueix aquests marcadors de posició de manera dinàmica per dades dels empleats analitzades a partir d'un fitxer JSON. Aquest enfocament permet una personalització fàcil, com ara afegir un logotip d'empresa o capçaleres directament a la plantilla de Word. Per exemple, imagineu-vos que necessiteu crear centenars de contractes de treball: només cal que modifiqueu la plantilla una vegada i el programa s'encarrega de la resta. 📝

En canvi, el segon script utilitza un enfocament basat en codi per generar un document de Word des de zero. Aquest mètode crea tots els elements amb programació, com ara paràgrafs i nodes de text, mitjançant ordres Open XML com ara Body.AppendChild. Tot i que ofereix un control total sobre l'estructura del document, pot esdevenir tediós per a dissenys complexos. Per exemple, suposem que el vostre departament de recursos humans us demana que afegiu una marca d'aigua o una taula; aquests canvis requeririen actualitzacions importants de codi. Aquest mètode funciona millor per a documents amb un format mínim, però pot ser que no sigui ideal per a sortides de gran estil.

Els dos scripts utilitzen JsonConvert.DeserializeObject per analitzar el fitxer JSON en una llista d'objectes empleats. Aquest pas garanteix que les dades siguin fàcils de manipular dins del programa. L'ús de Fitxer.Copia en el primer enfocament destaca un altre avantatge: podeu conservar la plantilla original mentre genereu un fitxer de sortida independent. Aquesta funció és especialment útil en escenaris en què es requereixen múltiples iteracions o ajustos a la plantilla, com ara la creació de cartes personalitzades per a una campanya de correu de client. ✉️

En definitiva, l'elecció entre aquests enfocaments depèn de la complexitat del document i de la freqüència amb què canvia l'estructura. Si actualitzeu sovint el format o afegiu elements de disseny, l'enfocament basat en plantilles és més eficient. D'altra banda, si l'estructura del document es manté estàtica però el contingut canvia, el mètode basat en codi podria ser suficient. Tots dos enfocaments estan dissenyats per estalviar temps i millorar l'eficiència del flux de treball, especialment quan es tracten grans conjunts de dades com els registres dels empleats. Tant si esteu preparant invitacions a esdeveniments com informes financers, aquests scripts es poden adaptar a les vostres necessitats sense problemes. 🚀

// 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!");
    }
}

// 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!");
    }
}

Escollir les eines adequades per a l'automatització de documents de Word

Quan es generen documents de Word de manera dinàmica a partir de JSON en C#, un aspecte que sovint es passa per alt és gestionar la complexitat potencial de les estructures de dades. Per exemple, si el JSON conté objectes o matrius imbricats (com ara els projectes d'un empleat o les dades de contacte), necessiteu una estratègia per assignar aquests elements a formats compatibles amb Word. Una opció és aplanar les dades durant el preprocessament per garantir que tot el contingut dinàmic s'alinea perfectament amb l'estructura del document. Això és especialment útil quan s'utilitza un enfocament basat en plantilles, ja que les plantilles normalment es dissenyen tenint en compte una jerarquia plana. 📋

Una altra consideració crítica és el maneig i validació d'errors. Quan treballeu amb dades externes, com ara JSON generat per API, és possible que trobeu entrades incompletes o no vàlides. La implementació de comprovacions garanteix que les substitucions de marcadors de posició al document de Word no fallaran a causa de les dades que falten o estan malformades. Utilitzant biblioteques com Newtonsoft.Json, podeu validar estructures JSON amb un esquema o aplicar valors predeterminats per evitar errors en temps d'execució. Això no només augmenta la fiabilitat del vostre script, sinó que també facilita l'escala per a projectes més complexos, com ara l'automatització d'informes o contractes per a milers d'usuaris.

Finalment, no subestimeu el valor de l'estil i la marca. Si el vostre document de Word ha de reflectir una identitat corporativa específica, podeu inserir tipus de lletra personalitzats, colors i logotips directament a la plantilla. Això us permet combinar dades dinàmiques amb un disseny professional sense esforç. En integrar aquestes tècniques al vostre flux de treball, podeu crear documents polits per a usos com ara resums dels empleats o informes personalitzats. 🚀