In today's digital era, document manipulation has become a core part of business and personal computing needs. Microsoft's OpenXML format offers a robust way to create, edit, and manage documents programmatically. This blog post will guide you through five essential OpenXML recipes to take your document manipulation skills to the next level. Whether you're a developer looking to automate document tasks or a curious tech enthusiast, these tips will help you harness the power of OpenXML for both productivity and creative purposes.
Understanding OpenXML
OpenXML, short for Office Open XML, is a standardized file format used by Microsoft Office and other applications. It's an XML-based format that allows for:
- Interoperability: Documents can be read and written by various applications.
- Programmatic manipulation: Easier to automate document creation and editing tasks.
- Customizability: Users can define their own custom XML schemas.
OpenXML files include .docx, .xlsx, .pptx, and many others, providing a wealth of possibilities for those who can tap into their internal structure.
Recipe 1: Extracting Text from a .docx File
To start your journey with OpenXML, extracting text from a .docx file is an excellent foundational skill:
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
using System.IO;
using System.Text;
public static string ExtractTextFromDocx(string filepath)
{
StringBuilder text = new StringBuilder();
using (WordprocessingDocument wordDoc = WordprocessingDocument.Open(filepath, false))
{
var body = wordDoc.MainDocumentPart.Document.Body;
foreach (var paragraph in body.Elements<Paragraph>())
{
foreach (var run in paragraph.Elements<Run>())
{
foreach (var textElement in run.Elements<Text>())
{
text.Append(textElement.Text);
}
}
text.AppendLine();
}
}
return text.ToString();
}
Recipe 2: Generating a Table in a Word Document
Creating and populating tables in Word documents can streamline reporting processes. Here's how you can do it:
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
public static void CreateTableInDocx(string filepath, int rows, int columns)
{
using (WordprocessingDocument wordDoc = WordprocessingDocument.Create(filepath, WordprocessingDocumentType.Document))
{
MainDocumentPart mainPart = wordDoc.AddMainDocumentPart();
Document document = new Document(new Body());
Table table = new Table();
// Add Table Properties
TableProperties tblProp = new TableProperties(
new TableBorders(
new TopBorder { Val = new EnumValue<BorderValues>(BorderValues.BasicBlackDotted), Size = 8 },
new BottomBorder { Val = new EnumValue<BorderValues>(BorderValues.BasicBlackDotted), Size = 8 },
new LeftBorder { Val = new EnumValue<BorderValues>(BorderValues.BasicBlackDotted), Size = 8 },
new RightBorder { Val = new EnumValue<BorderValues>(BorderValues.BasicBlackDotted), Size = 8 },
new InsideHorizontalBorder { Val = new EnumValue<BorderValues>(BorderValues.BasicBlackDotted), Size = 8 },
new InsideVerticalBorder { Val = new EnumValue<BorderValues>(BorderValues.BasicBlackDotted), Size = 8 }));
table.AppendChild(tblProp);
// Generate rows and cells
for (int i = 0; i < rows; i++)
{
TableRow tr = new TableRow();
for (int j = 0; j < columns; j++)
{
TableCell tc = new TableCell(new Paragraph(new Run(new Text($"Row {i + 1}, Column {j + 1}"))));
tr.Append(tc);
}
table.Append(tr);
}
document.Body.Append(table);
mainPart.Document = document;
}
}
💡 Note: Adjust table properties like border styles, widths, and cell padding for your specific needs.
Recipe 3: Inserting Images in a Word Document
Inserting images dynamically into documents can enhance reports, manuals, or any document where visual representation is vital:
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
using System.IO;
public static void InsertImageInDocx(string filepath, string imagePath, float width, float height)
{
using (WordprocessingDocument wordDoc = WordprocessingDocument.Open(filepath, true))
{
MainDocumentPart mainPart = wordDoc.MainDocumentPart;
ImagePart imagePart = mainPart.AddImagePart(ImagePartType.Jpeg);
using (FileStream stream = new FileStream(imagePath, FileMode.Open))
{
imagePart.FeedData(stream);
}
AddImageToBody(wordDoc, mainPart.GetIdOfPart(imagePart), width, height);
}
}
private static void AddImageToBody(WordprocessingDocument wordDoc, string relationshipId, float width, float height)
{
Body body = wordDoc.MainDocumentPart.Document.Body;
Paragraph para = body.AppendChild(new Paragraph());
Run run = para.AppendChild(new Run());
run.AppendChild(new Drawing(
new Inline(
new Extent { Cx = (long)(width * 914400), Cy = (long)(height * 914400) },
new EffectExtent { LeftEdge = 0L, TopEdge = 0L, RightEdge = 0L, BottomEdge = 0L },
new DocProperties { Id = (UInt32Value)1U, Name = "Image1" },
new NonVisualGraphicFrameDrawingProperties(
new GraphicFrameLocks { NoChangeAspect = true }),
new Graphic(
new GraphicData(
new Picture(
new NonVisualPictureProperties(
new NonVisualDrawingProperties { Id = (UInt32Value)0U, Name = "Image.jpg" },
new NonVisualPictureDrawingProperties()),
new BlipFill(
new Blip { Embed = relationshipId, CompressionState = BlipCompressionValues.Print, },
new Stretch(new FillRectangle())),
new ShapeProperties(
new Transform2D(
new Offset { X = 0L, Y = 0L },
new Extents { Cx = (long)(width * 914400), Cy = (long)(height * 914400) }
),
new PresetGeometry { Preset = ShapeTypeValues.Rectangle }
)
)
) { Uri = "http://schemas.openxmlformats.org/drawingml/2006/picture" }
)
) { DistanceFromTop = 0U, DistanceFromBottom = 0U, DistanceFromLeft = 0U, DistanceFromRight = 0U }
));
}
Recipe 4: Manipulating Styles in a Document
Manipulating styles can automate the formatting of documents for branding or presentation purposes:
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
public static void ChangeDocumentStyle(string filepath)
{
using (WordprocessingDocument wordDoc = WordprocessingDocument.Open(filepath, true))
{
var stylesPart = wordDoc.MainDocumentPart.StyleDefinitionsPart;
if (stylesPart == null)
{
stylesPart = wordDoc.MainDocumentPart.AddNewPart<StyleDefinitionsPart>();
stylesPart.Styles = new Styles();
}
Style style = new Style()
{
Type = StyleValues.Paragraph,
StyleId = "MyStyle"
};
// Define a style for headings
StyleRunProperties styleRunProperties = new StyleRunProperties();
styleRunProperties.Append(new Bold(), new FontSize() { Val = "28" });
style.Append(styleRunProperties);
stylesPart.Styles.Append(style);
stylesPart.Styles.Save();
// Apply the style to all paragraphs with a specific title
foreach (var paragraph in wordDoc.MainDocumentPart.Document.Body.Elements<Paragraph>())
{
if (paragraph.InnerText.Contains("Chapter"))
{
paragraph.ParagraphProperties = new ParagraphProperties(
new ParagraphStyleId { Val = "MyStyle" });
}
}
}
}
Recipe 5: Adding Custom XML Parts
Adding custom XML parts can allow for more advanced document interactions:
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml;
using System.Xml.Linq;
public static void AddCustomXmlPart(string filepath, string xmlString)
{
using (WordprocessingDocument wordDoc = WordprocessingDocument.Open(filepath, true))
{
CustomXmlPart customPart = wordDoc.MainDocumentPart.AddCustomXmlPart(CustomXmlPartType.CustomXml);
XElement xmlElement = XElement.Parse(xmlString);
using (Stream partStream = customPart.GetStream())
{
xmlElement.Save(partStream);
}
// Add the relationship from the main part to the custom XML part
wordDoc.MainDocumentPart.AddCustomXmlPartRelationshipTo(new[] { customPart });
}
}
These OpenXML recipes are just the beginning. With these skills, you can automate repetitive document tasks, build dynamic reports, and even create document templates for your organization. Remember that OpenXML can be complex due to its XML-based structure, but with practice, you'll find it an invaluable tool in your document manipulation arsenal.
What is the primary use of OpenXML?
+
OpenXML is primarily used for creating, editing, and manipulating documents programmatically, allowing for interoperability, automation, and custom XML schema creation.
Can OpenXML files be used with applications other than Microsoft Office?
+
Yes, OpenXML files are standardized formats, which means they can be read and written by many applications, including LibreOffice and Google Docs, ensuring document portability.
How can I start learning OpenXML programming?
+
Begin with understanding XML, then dive into the OpenXML SDK documentation. Practice with simple tasks like extracting text or modifying basic document properties using examples and tutorials available online.
What are some common errors when working with OpenXML?
+
Common errors include forgetting to open and close the document properly, mismatching XML tags, or not handling relationships between document parts correctly.
Are there any limitations to what can be done with OpenXML?
+
While versatile, OpenXML does not support all features of older Microsoft Word formats like .doc, especially when it comes to macros or certain complex document structures. However, for most modern document manipulation, it provides robust capabilities.
