Using word documents with

As part of the Microsoft Office Suite, MS Word is one of the most popular office productivity tools in the world.

In this guide, you’ll learn the basics of how to use Microsoft’s word processing software. Whether you’re just getting started with Word or have years of experience, you’ll find this guide helpful.

With Microsoft Word, you’ll be creating useful business documents in no time. Also, many other file formats can be converted to MS Word (.doc) format. And Word documents can be saved as .pdf files.

How to Use Microsoft Word to Create Professional Business Documents

One of the best and easiest ways to create an effective business document with Word is to use a template. There are hundreds of professional Word templates you can use available through Envato Elements and GraphicRiver. Here are just some of them:

• 

  25 Microsoft MS Word Business Proposal Templates to Make Deals in 2022

• 

  25 Free Creative Resume Templates (Word & PSD Downloads for 2022)

  

• 

  20 Best Free Microsoft Word Resume CV Cover Letter Templates 2022

  

How to Use This Tutorial Guide

Learn how to work with Word’s tools to make great business documents quickly. We’ll explore everything from formatting basic text styles to making awesome page layout designs to using headers and footers.

Note: Be sure to bookmark this Microsoft Word tutorial guide to start working through each tutorial at your own pace.

Whether you’re collaborating with your team on a Microsoft Word Document or you’ve ended up with two versions of your own work, you are now trying to find the best way to compare these two documents in a swift and easy manner.

Luckily, there are 4 different ways that you can compare Microsoft Word Documents. Each coming with some pretty huge positives and negatives, some are better suited to the individual and others to large businesses.

In this post, we will breakdown each option and leave you well equipt to decide which best suits your task or team.

1. Use a dedicated collaboration tool

With so many of us facing the same issues when trying to compare Microsoft Word Documents, dedicated collaboration tools such as Simul Docs were built with collaboration in mind.

With Simul, you can easily compare two documents. Upload the documents from your computer or from cloud storage services like Sharepoint, OneDrive, Dropbox, Box or Google Drive.

Simul will then highlight the differences between the documents, allowing you to accept or reject each change.

Once you have reviewed the documents, simple press ‘Merge’ and the two documents seamlessly become one new version.

The only downside in using a collaboration tool is the additional cost. Most tools charge a fee per month or per user and while often a small fee, this may not fit within all companies budgets.

On the plus side, these tools make collaborating and comparing Microsoft Documents as simple as a click of a button. They not only save you time but provide solutions to other common problems such as version control and collaboration. Simul Docs also allows you to share and compare documents with people outside of your company with ease.

2. Use a dedicated compare tool

Many professionals require a dedicated tool to compare word documents. Tools such as Workshare and ComparePro are tools that allow you to compare two or more Word Documents and more.

Workshare, for example, offers you the ability to compare two Powerpoint presentations, excel documents and PDF files. Workshare also has other functionality that comes as a part of your subscription, such as Metadata, a metadata management solution and more.

Similar to the dedicated collaboration tools such as Simul Docs, compare tools make comparing work documents easy and were built with this issue in mind.

The main difference between two two is the price and the additional functions, Workshare provides security functions while Simul provides a full set of functions that assist you with seamless collaboration.

The Con of a comparison tool such as Workshare or ComparePro is the price. They offer subscriptions per user, not per document so you pay the full $300/annum to access the tool. This doesn’t provide much value for the occasional user.

Did we mention that the $300/annum only gives you access to the compare function as well, you pay for each tool separately which can add up quickly for any business!

The Pros of a comparison tool are that they were purpose build to help you compare documents and offer comparisons on more than just Word. They also offer other tools such as security and transaction assistance if your company required it.

3. Use Microsoft Word’s default ‘Compare’ feature

Because this is a problem so many of us face, Microsoft created a built in feature that allows you to compare two-word documents, ‘Compare’.

By opening a blank word document, then clicking through the Tool bar > Review > Compare > Compare. Word will place both documents side by side within Word and allow you to review any differences or changes.

Work picks up on all changes, highlights them and lets you know how many ‘differences’ there are between the documents.

The challenging parts of using Word Compare is its clunky and doesn’t provide a very user-friendly experience. When you have the two documents open next to each other, Word shows this on a split screen and creates a Master document in the centre – there is a lot going on in front of you and changes aren’t easy to see and accept.

The positive is its free and already inbuilt into Microsoft Word.

4. Manually compare documents

Stripping it right back, you may opt to compare the documents manually. Open the two documents, place them side by side and review each line or sentence one at a time and manually highlight the differences or make changes.

The Cons of this approach is time and user error. Depending on how many changes were made between the two documents you are comparing this could take hours. Manually comparing the two documents without the assistance of a tool can also result in changes being missed or overlooked. This option works best when you know there are only a few changes and are very familiar with the document yourself.

The Pros of a manual comparison is its free!

To Sum it up…

There are some fantastic tools and options available to you when trying to diff two Microsoft Word Documents. What’s best for your team will come down to how often you are trying to compare documents, the size of your team and your budget.

Dedicated comparison tools such as Simul Docs offer a free document trial, so it’s worth trying at least once to help you make the right decision. With Microsoft Compare already built into your Microsoft Word and the old fashion manual comparison free, you can try 3 of the 4 options above at no cost.

Regardless of how often you find yourself needing to diff two Word Documents, this doesn’t have to be a time consuming, frustrating issue anymore. Take your time, try the WordCompare tool and give the free trial at Simul Docs a go, as a starting point.

• Download source — 698.6 KB
• Download OpenXMLPractice EXE

Introduction

Are you looking for a way to use Word automation? Want to deal with Word documents programmatically? Go through this tip, it will help you to deal with Word Automation without Interop using C# and OpenXML.

After going through this tip, you can tell:

1. What is Open XML
2. Why to use Open XML
3. How to use OpenXML to create Word documents using C# and OpenXML API
4. Create Word table using OpenXML and C#

Background

I have seen many developers struggling to deal with Word documents programmatically, There are couple of ways to deal with Word documents:

1. Using COM interop object (Winword instance) (For interop sample code, check this article)
2. Using OpenXML API (Do not have to install Word on machine)

Using the Code

Things We Need

Before starting with the OpenXML cooking, we need the following things to be ready with us:

1. C# Visual Studio (2005+ version)
2. OpenXML API (can be downloaded from here Open XML SDK 2.5 for Microsoft Office)

That’s it. (Wow!!! No word installation needed)

Getting Started with OpenXML

Now a days, DOCX files are getting popular day by day, due to them being very light and faster in processing, DOCX is the magical result of ZIP and XML combination. So it is clear that if we able to manage XMLs, we will be able to manage DOCX too. For managing WordXML, we need some API and that API is known as Open XML SDK for Microsoft Office, MSDN Says «API simplifies the task of manipulating Open XML packages and the underlying Open XML schema elements within a package. The Open XML SDK encapsulates many common tasks that developers perform on Open XML packages, so that you can perform complex operations with just a few lines of code.«

Open XML Advantages over Interop

1. Open XML is an open standard for Word-processing documents, presentations, and spreadsheets that can be freely implemented by multiple applications on different platforms
2. The purpose of the Open XML standard is to de-couple documents created by Microsoft Office applications so that they can be manipulated by other applications independent of proprietary formats and without the loss of data.
3. As it is light weight, the processing is faster than interop objects
4. It has good Interoprability, Backwards Compatibility and Programmability
5. As it is Smaller File Size, it is to manage all variety of document stores, including Exchange servers, SharePoint, and of course network file storage.
6. It’s a IS29500 standard, free for all to use, and extremely well documented

You can unzip DOCX file

Do you know you can unzip DOCX file? DOCX is the combination of several well structured .XML file, An Open XML file is stored in a ZIP archive for packaging and compression. You can view the structure of any Open XML file using a ZIP viewer, Open XML document is built of multiple document parts. The relationships between the parts are themselves stored in document parts, each typical DOCX file has the following different parts.

See the below image to know the different XML parts:

Body is the main part of the document and it has many different parts as shown in the above figure.

Working with Paragraphs (First Assignment)

Paragraphs is the most basic unit of block-level content within a WordprocessingML document, paragraphs are stored using the <p> element, Paragraph different sub elements like ParagraphProperties (Optional), Run and Text.

Paragraph Properties

Paragraph properties are used for the formatting of the text, some of the examples of paragraph properties are alignment, border, hyphenation override, indentation, line spacing, shading, text direction. The OXML SDK Paragraph properties class represents the <pPr> element.

Run

The run element is provided to demarcate a region of text. The OXML SDK Run class represents the <r> element.

Text

This element contains actual Text of a document, With the <r> element, the text (<t>) element is the container for the text that makes up the document content.

Start with the Code (Create new word document and write in it)

Open Visual Studio and start with the first OpenXML assignment.

Create new Project/Application and add DLL reference (DLL should exist in Installed OpenXML API folder, e.g., C:Program FilesOpen XML SDKV2.0lib).

1. DocumentFormat.OpenXml

See the below snippet where we are creating new Word document with the help of OpenXML.

using (WordprocessingDocument doc = WordprocessingDocument.Create
("D:\test11.docx", DocumentFormat.OpenXml.WordprocessingDocumentType.Document))
       {
           
           MainDocumentPart mainPart = doc.AddMainDocumentPart();

           
           mainPart.Document = new Document();
           Body body = mainPart.Document.AppendChild(new Body());
           Paragraph para = body.AppendChild(new Paragraph());
           Run run = para.AppendChild(new Run());

           
           run.AppendChild(new Text("New text in document"));
       }

In the above simple snippet:

• We have use 'WordProcessingDocument' class for creating new document
• Add MainDocumentPart in document
• Then append Body to main document part
• Then add Paragraph to Body element
• Then add Run to Paragraph element
• Then add Text to Run element

That’s it. No need to save document anymore.

Now if you go and check for ‘test11.docx‘, then you can see it contains text ‘New text in document’.

Now try to unzip that Docx file, you will get below folder structure, you will get folders _rels, docsProps, word and [Content_Types].xml file.

Open Word folder and check document.xml. You will see the below snap:

In the above image, you can see <w:body>represents MainBody of the document, <w:p> is the paragraph element, <w:r>is the run element, <w:t>is the text element.

This is how OpenXML works.

Points of Interest

OpenXML is really an amazing thing, it fluently works with spreadsheets, charts, presentations, and Word processing documents. The Open XML file formats are useful for developers because they use an open standard and are based on well-known technologies: ZIP and XML.

References and Book of Facts

Following are the referral links for OpenXML:

• https://msdn.microsoft.com/EN-US/library/office/bb456488.aspx
• https://msdn.microsoft.com/EN-US/library/office/bb456487.aspx
• http://blogs.msdn.com/b/ericwhite/archive/2008/10/20/eric-white-s-blog-s-table-of-contents.aspx

Thanks

OpenXML is not a single cup of tea, I am continuing with a different assignment on OpenXML in the next version of this article. Till then, enjoy this stuff. Suggestions and queries are always welcome.

Posted on Wednesday, August 7th, 2013 at 7:32 am by .

Microsoft Word is about the authoring of documents. Documents contain pages, paragraphs, sentences and more. Today, I want to wade into the waters of manipulating Word document content. The plan is to get your feet wet by providing an overview of the key objects along with code samples.

Continuing the fine tradition of all Office applications (OneNote being the exception), Word has an extensive and mature object model. My goal is to show “a way” to accomplish some tasks in Microsoft Word. These samples are not necessarily, “the way” to do it. There is more than one way to achieve the same results.

Today, we are concerned with the structure of a Word document… not its stylings and presentation (I’ll concern ourselves with that topic next).

• Word document content objects
• Accessing document content objects with code
• Working with familiar Word content objects

Document content objects

Let’s look at the objects that combine together to construct a Word document.

• Document :: The document represents a single, solitary Word document. This is the parent object for all content within a Word document file. It lives in an appropriately named collection called Documents. I covered the document object in a previous article – Word application and base objects.
• Section :: Documents can contain multiple sections. This is how you apply different formatting, layout, and header/footer options to a Word document… by creating sections and formatting them differently.
• Page :: Represents a single page within a document. A page can reside within a Range.
• Paragraph :: A single paragraph of content. A paragraph can reside within a Selection, Document, or Range and is accessible via the Paragraphs collection object. Paragraphs also contain the formatting for content residing above it. Don’t ponder over that last sentence too much, I will explain it further in my next article.
• Sentence :: This object does not exist… strange as that might seem. Instead, there is the Paragraphs collection object. This collection contains a collection of Range objects, which in turn, contain all the sentences for the Range. Confused? The code samples will help bring focus to the picture.
• Selection :: This object contains the content selected either by the user or via code. It also is the insertion point if no selection exists. The insertion point is where the cursor blinks in the Word UI to inform the user of their location within the document.
• Range :: Think of this object like real-estate. It contains a contiguous section of a document. Perhaps its two most popular properties are Start and End. They contain ranges starting and ending character positions within the Word document.

There are more “content” objects than these but the list above are the major objects that provide access to everything else.

Accessing Word document content objects with code

I want to give you a lot of VB.NET code samples today. I’ll start with the Range object and keep going as long as I have paper. By the end of the samples, my hope is you will have a general idea of how to access and edit content within a Word document.

The Range object

The Word object model is extensive and more than a little complex. The best way to figure out how to make things happen via code is to learn to think like Word thinks. The quickest way to achieve this goal is to master the Range and the Selection objects. I covered the selection object in this article so I will focus on the Range object. Just know that together, these two objects allow you to select and find Word content.

Enumerate paragraphs in a range

This method loops through all the paragraphs in the active document and reverses their order in a new document.

Private Sub EnumerateParagraphs()
    Dim curDoc As Word.Document = WordApp.ActiveDocument
    Dim newDoc As Word.Document
    Dim rng As Word.Range
    Dim str As String = ""
    Dim i As Integer
 
    rng = curDoc.Content
    i = rng.Paragraphs.Count()
 
    Do Until i = 0
        str = str & rng.Paragraphs.Item(i).Range.Text & vbCrLf
        i = i - 1
    Loop
 
    newDoc = WordApp.Documents.Add
    newDoc.Range().Text = str
 
    Marshal.ReleaseComObject(rng)
    Marshal.ReleaseComObject(curDoc)
    Marshal.ReleaseComObject(newDoc)

The key is the use of the Range object and all the document content. The code first grabs all the document content and assigns it to a Range variable (rng). Then the code finds out how many paragraphs exist and loops backwards to create a string. This string is then inserted into a new document. It’s a good bar trick that only works in nerd bars.

Select the current page range

In this sample, we use a Range object that’s buried deeper in the Word object model. The reason for this sample is that I want to point out that the Range object is darn near everywhere within Word.

Private Sub SelectedPageRange()
    Dim curDoc As Word.Document
    curDoc = WordApp.ActiveDocument
 
    curDoc.Bookmarks("page").Range.Select()
 
    Marshal.ReleaseComObject(curDoc)
 
End Sub

In this procedure, I employ the predefined “page” bookmark. This is a standard Word bookmark that always exists and allows easy selection of the page containing the current focus (or selection).

You can learn more about predefined bookmarks at MSDN.

Enumerate sentences in a range

This one is similar to paragraphs but we switch sentences for paragraphs. The idea is the same… create a new document that contains the sentences in reverse order.

Private Sub EnumerateSentences()
    Dim curDoc As Word.Document = WordApp.ActiveDocument
    Dim newDoc As Word.Document
    Dim rng As Word.Range
    Dim str As String = ""
    Dim i As Integer
 
    rng = curDoc.Content
    i = rng.Sentences.Count()
 
    Do Until i = 0
        str = str & rng.Sentences.Item(i).Text
        i = i - 1
    Loop
 
    newDoc = WordApp.Documents.Add
    newDoc.Range().Text = str.ToUpper
 
    Marshal.ReleaseComObject(rng)
    Marshal.ReleaseComObject(curDoc)
    Marshal.ReleaseComObject(newDoc)
End Sub

To mix it up, the final document’s text is upper case. I know, this is dazzling trickery.

The takeaway is that the Range object contains a section of the Word document. Within it are major items like paragraphs and sentences.

The Section object

Documents can contain multiple sections. Sections allow you to define different page layouts and header/footer schemes.

Enumerate sections

You can loop through document sections by accessing the Sections collection. This collection resides directly beneath the Document object.

Private Sub EnumerateSections()
    Dim curDoc As Word.Document
    Dim newDoc As Word.Document
    Dim str As String = ""
    Dim i As Integer
 
    curDoc = WordApp.ActiveDocument
 
    For i = 1 To curDoc.Sections.Count
        str = str & "SECTION " & i & vbCr
        str = str & vbTab & "start = " & curDoc.Sections(i).Range.Start
        str = str & vbTab & "end = " & curDoc.Sections(i).Range.End & vbCrLf
    Next
 
    newDoc = WordApp.Documents.Add
    newDoc.Range().Text = str
 
    Marshal.ReleaseComObject(curDoc)
    Marshal.ReleaseComObject(newDoc)
End Sub

This procedure builds a string that 1) lists each document section and 2) contains the section’s Start and End character position. Notice the use of the Range object to read this information.

Create a new section

When building Word documents via code, you will likely need to create a new section. This procedure will do the trick.

Private Sub CreateSection()
    Dim curDoc As Word.Document
    curDoc = WordApp.ActiveDocument
 
    curDoc.Sections.Add(WordApp.Selection.Range)
 
    Marshal.ReleaseComObject(curDoc)
End Sub

This sample inserts a section break at the current selection (or cursor) location. Again, notice the use of the Range property. You can easily grab a different range within the document and pass it as the location of the page break.

The Page object

The page object resides in a “funny” location. Not “ha ha” funny… more like “why the hell is it here?” funny. You access document pages via the Document.ActiveWindow.Panes collection. Why? Because these are the rules.

Enumerate pages

Someday you might want to loop through all document pages and perform some very specific business logic on them. This code does exactly that.

Private Sub EnumeratePages()
    Dim curDoc As Word.Document
    Dim newDoc As Word.Document
    Dim pgs As Word.Pages
    Dim str As String = ""
    Dim i As Integer
 
    curDoc = WordApp.ActiveDocument
    pgs = curDoc.ActiveWindow.Panes(1).Pages
 
    For i = 1 To pgs.Count
        str = "PAGE " & i & vbCr
        str = str & vbTab & "height = " & pgs.Item(i).Height
        str = str & vbTab & "width = " & pgs.Item(i).Width & vbCrLf
    Next
 
    newDoc = WordApp.Documents.Add
    newDoc.Range().Text = str
 
    Marshal.ReleaseComObject(pgs)
    Marshal.ReleaseComObject(curDoc)
    Marshal.ReleaseComObject(newDoc)
End Sub

Here, the business logic is to create a string that contains the height and width of each page and then display it in a new document. Your business logic will probably be more complex than this. Consider this procedure a starter kit for processing document pages.

Insert a page break

To create a page, you create a page break.

Private Sub InsertPageBreak()
    Dim sel As Word.Selection
    sel = WordApp.Selection
 
    sel.InsertBreak(Type:=Word.WdBreakType.wdPageBreak)
 
    Marshal.ReleaseComObject(sel)
End Sub

I start by referencing the current insertion point via the Selection object. I then invoke the InsertBreak method and specify a page break. Walla! We have a new page.

Working with familiar (some) Word content objects

Now that you know the basics of working with the Range, Section, and Page objects, let’s look at working with typical Word content like tabless, comments, & text.

Insert a table

I use tables all the time. I can see how it would be useful to have a procedure that inserts a table exactly how I like it.

Private Sub InsertTable(rowCount As Integer, columnCount As Integer)
    Dim curDoc As Word.Document = WordApp.ActiveDocument
    Dim table As Word.Table
 
    table = curDoc.Tables.Add(WordApp.Selection.Range, rowCount, columnCount)
    table.Cell(1, 1).Range.Text = "Hello Table"
 
    Marshal.ReleaseComObject(table)
    Marshal.ReleaseComObject(curDoc)
End Sub

In this case, I like a table with 1 column and 7 rows and 0 formatting. The Tables collection resides under the Document object. To add a new table, you call the collection’s Add method and specify its location (via a Range object), number of rows, and number of columns.

Enumerate comments

Authoring a quality document of any type (blog, article, report, proposal, etc.) is a collaborative effort. Comments are key to the collaborative process. If you receive your document after this process and it is littered with helpful comments for improving it… the following code will come in handy.

Private Sub EnumerateComments()
    Dim curDoc As Word.Document = WordApp.ActiveDocument
 
    For i = 1 To curDoc.Comments.Count
        curDoc.Comments.Item(i).Range.Text = _
            curDoc.Comments.Item(i).Range.Text & vbCrLf & _
            "Corrected. It's all good now!"
    Next
 
    Marshal.ReleaseComObject(curDoc)
End Sub

Here, I loop through the Comments collection. This collection also resides directly under the Document object. For each comment, I insert a comment below the existing comment text.

Create a comment

Creating a comment is straight-forward. The approach below utilizes the current selection’s range as the insertion point.

Private Sub CreateComment(commentText As String)
    WordApp.Selection.Comments.Add(WordApp.Selection.Range, commentText)
End Sub

The text for the comment needs to be passed as the procedure’s parameter.

You can also create comments by calling Document.Comments.Add. If you do that, you need to pass a Range to specify where to insert the comment.

Delete all comments

Deleting all comments is delightfully easy. There is a method that takes care of them.

Private Sub DeleteComments()
    Dim curDoc As Word.Document = WordApp.ActiveDocument
 
    curDoc.DeleteAllComments()
 
    Marshal.ReleaseComObject(curDoc)
End Sub

There is no need to loop through the Comments collection.

Insert text

To insert text, you can utilize the Selection and Range objects.

Private Sub InsertText(textToInsert As String)
    WordApp.Selection.InsertAfter(textToInsert)
    'WordApp.Selection.InsertBefore(textToInsert)
    'WordApp.ActiveDocument.Range.InsertAfter(textToInsert)
End Sub

In this sample, I utilize the current selection to insert the passed string after the current selection. I’ve include commented code to show how you can chose to InsertBefore. Also, I’ve shown how to do the same with the Range object.

Find text

Finding text is a core competency in Word solution development. This sample performs search and replace.

Private Sub FindText()
    Dim rng As Word.Range
    rng = WordApp.ActiveDocument.Content
 
    With rng.Find
        .ClearFormatting()
        .Execute(FindText:="Hello Table", _
                 ReplaceWith:="Found Table", _
                 Replace:=Word.WdReplace.wdReplaceAll)
    End With
 
    Marshal.ReleaseComObject(rng)
End Sub

The procedure sets a Range object that contains all document Content. It then executes a Find & Replace action to replace the text inserted in the InsertTable method from earlier.

Copy and paste text

If you have text in a Word document, you will need to move it around.

Private Sub CopyAndPasteText()
    Dim curDoc As Word.Document = WordApp.ActiveDocument
    Dim rng As Word.Range
    'Dim sel As Word.Selection
    rng = curDoc.Range(curDoc.Paragraphs(1).Range.Start, _
                       curDoc.Paragraphs(3).Range.End)
    rng.Copy()
    'sel = curDoc.Range(curDoc.Paragraphs(1).Range, _
    '                    curDoc.Paragraphs(3).Range.End)
    'sel.Copy()

    WordApp.Selection.GoTo(What:=Word.WdGoToItem.wdGoToBookmark, _
                           Name:="EndOfDoc")
    WordApp.Selection.Paste()
 
    Marshal.ReleaseComObject(rng)
    Marshal.ReleaseComObject(curDoc)
End Sub

This method stores the first 3 paragraphs in a Range object, copies them, moves to the end of the document, and pastes the paragraphs. I’ve included commented code that shows how you could perform the copy using a Selection object.

***

We have now delved into the waters of Word document content manipulation. We’ll continue looking at scenarios in future articles!

Available downloads:

This sample Word add-in was developed using Add-in Express for Office and .net:

VB.NET Word Document Content add-in

Word add-in development in Visual Studio for beginners:

• Part 1: Word add-in development – Application and base objects
• Part 2: Customizing Word UI – What is and isn’t customizable
• Part 3: Customizing Word main menu, context menus and Backstage view
• Part 4: Creating custom Word ribbons and toolbars: VB.NET, C#
• Part 5: Building custom task panes for Word 2013 – 2003
• Part 6: Working with Word document content objects
• Part 8: Working with multiple Microsoft Word documents
• Part 9: Using custom XML parts in Word add-ins
• Part 10: Working with Word document properties, bookmarks, content controls and quick parts
• Part 11: Populating Word documents with data from external sources
• Part 12: Working with Microsoft Word templates