Remove Bookmarks in Word Document using C#

1. private void RemoveBookmarkWithContent(Bookmark bookmark)
2. {
3. // We need to store other bookmark nodes here, to move them away from the removed area.
4. Hashtable bookmarkNames = new Hashtable();
5. Hashtable bookmarkStarts = new Hashtable();
6. Hashtable bookmarkEnds = new Hashtable();
8. ArrayList nodesToRemove = new ArrayList();
10. BookmarkStart bookmarkStart = bookmark.BookmarkStart;
11. BookmarkEnd bookmarkEnd = bookmark.BookmarkEnd;
12. Document doc = bookmarkStart.Document;
13. Paragraph lastParagraph = doc.LastSection.Body.LastParagraph;
15. Node node = SeekFirstNodeOfBookmarkRange(bookmarkStart);
17. Paragraph endPara = FindParagraphNextAfterBookmark(bookmarkEnd);
19. // Iterate over all nodes that contain or are between bookmark start and end nodes.
20. while(node != bookmarkEnd)
21. {
22. node = node.NextPreOrder(doc);
24. // BookmarkStart/BookmarkEnd are saved to be handled separately later.
25. // All other nodes are collected as candidates for removal.
26. if (!StoreIfBookmark(bookmarkNames, bookmarkStarts, bookmarkEnds, node))
27. nodesToRemove.Add(node);
28. }
30. foreach (string name in bookmarkNames.Keys)
31. {
32. if ((bookmarkStarts.ContainsKey(name)) && (bookmarkEnds.ContainsKey(name)))
33. {
34. // If bookmark is nested, remove it altogether.
35. RemoveBookmarkNode(name, bookmarkStarts);
36. RemoveBookmarkNode(name, bookmarkEnds);
37. }
38. else
39. {
40. // If bookmark is overlapping, move the contained start/end node to the next paragraph after removed range.
41. if (bookmarkStarts.ContainsKey(name))
42. MoveBookmarkNode(name, bookmarkStarts, endPara);
43. else
44. MoveBookmarkNode(name, bookmarkEnds, endPara);
45. }
46. }
48. bool hasNodesToRemove = true;
50. while(hasNodesToRemove)
51. {
52. hasNodesToRemove = false;
54. for (int i = 0; i < nodesToRemove.Count; i++)
55. {
56. Node nodeToRemove = (Node)nodesToRemove[i];
58. // Skip already removed nodes.
59. if (nodeToRemove.ParentNode == null)
60. continue;
62. // Skip nodes that have child nodes.
63. if (nodeToRemove.IsComposite && (nodeToRemove as CompositeNode).HasChildNodes)
64. continue;
66. // Do not remove node if it is the last paragraph in the document.
67. if (nodeToRemove == lastParagraph)
68. continue;
70. // Remove node.
71. nodeToRemove.Remove();
73. // If at least one node was removed in loop, then the loop will be repeated.
74. hasNodesToRemove = true;
75. }
76. }
77. }
79. private Node SeekFirstNodeOfBookmarkRange(BookmarkStart bookmarkStart)
80. {
81. Node node = bookmarkStart;
83. Document doc = node.Document;
85. // Bookmark nodes located immediately before start of our bookmark should also be included in the removal process.
86. do
87. {
88. node = node.PreviousPreOrder(doc);
89. }
90. while(IsBookmarkNode(node));
92. // Look back from the bookmark start node to include containing nodes into removal process.
93. while(node.IsComposite)
94. {
95. Node prevNode = node.PreviousPreOrder(doc);
97. if (prevNode == null)
98. break;
99. else
100. node = prevNode;
101. }
103. return node;
104. }
106. private Paragraph FindParagraphNextAfterBookmark(BookmarkEnd bookmarkEnd)
107. {
108. // Find the paragraph that is next to removed bookmark range.
109. // It will be used to move all bookmark start/end nodes belonging to bookmarks overlapping our bookmark,
110. // so that they will be preserved after this bookmark removal.
111. Paragraph para;
113. Node node = bookmarkEnd;
114. Document doc = node.Document;
116. // It can be that the paragraph containing bookmark end node if the last paragraph in the bookmark range
117. // contains other nodes beside BookmarkEnd or is the last unremovable paragraph in the document.
118. if (node.NextSibling != null || node.ParentNode == doc.LastSection.Body.LastParagraph)
119. {
120. para = (Paragraph)bookmarkEnd.ParentNode;
121. }
122. // Or it can be the paragraph next to it.
123. else
124. {
125. while(node.NodeType != NodeType.Paragraph)
126. {
127. node = node.NextPreOrder(doc);
128. }
130. para = (Paragraph)node;
131. }
133. return para;
134. }
136. private bool IsBookmarkNode(Node node)
137. {
138. return (node.NodeType == NodeType.BookmarkStart) || (node.NodeType == NodeType.BookmarkEnd);
139. }
141. private bool StoreIfBookmark(Hashtable bookmarkNames, Hashtable bookmarkStarts, Hashtable bookmarkEnds, Node node)
142. {
143. if (node.NodeType == NodeType.BookmarkStart)
144. {
145. BookmarkStart bookmarkStart = (BookmarkStart)node;
146. bookmarkNames[bookmarkStart.Name] = null;
147. bookmarkStarts.Add(bookmarkStart.Name, bookmarkStart);
148. return true;
149. }
150. else if (node.NodeType == NodeType.BookmarkEnd)
151. {
152. BookmarkEnd bookmarkEnd = (BookmarkEnd)node;
153. bookmarkNames[bookmarkEnd.Name] = null;
154. bookmarkEnds.Add(bookmarkEnd.Name, bookmarkEnd);
155. return true;
156. }
158. return false;
159. }
161. private Node RemoveBookmarkNode(string name, Hashtable bookmarkNodes)
162. {
163. Node node = (Node)bookmarkNodes[name];
164. node.Remove();
165. bookmarkNodes.Remove(name);
166. return node;
167. }
169. private void MoveBookmarkNode(string name, Hashtable bookmarkNodes, Paragraph para)
170. {
171. para.PrependChild(RemoveBookmarkNode(name, bookmarkNodes));
172. }
173. [VB .NET]
175. Private Sub RemoveBookmarkWithContent(ByVal bookmark As Bookmark)
176. ‘ We need to store other bookmark nodes here, to move them away from the removed area.
177. Dim bookmarkNames As Hashtable = New Hashtable
178. Dim bookmarkStarts As Hashtable = New Hashtable
179. Dim bookmarkEnds As Hashtable = New Hashtable
181. Dim nodesToRemove As ArrayList = New ArrayList
183. Dim bookmarkStart As BookmarkStart = bookmark.BookmarkStart
184. Dim bookmarkEnd As BookmarkEnd = bookmark.BookmarkEnd
185. Dim node As Node = bookmarkStart
186. Dim doc As Document = node.Document
187. Dim lastParagraph As Paragraph = doc.LastSection.Body.LastParagraph
189. ‘ Bookmark nodes located immediately before start of our bookmark should also be included in the removal process.
190. Do
191. node = node.PreviousPreOrder(doc)
192. Loop While IsBookmarkNode(node)
194. ‘ Look back from the bookmark start node to include containing nodes into removal process.
195. Do While node.IsComposite
196. Dim prevNode As Node = node.PreviousPreOrder(doc)
198. If prevNode Is Nothing Then
199. Exit Do
200. Else
201. node = prevNode
202. End If
203. Loop
205. ‘ Find the paragraph that is next to removed bookmark range.
206. ‘ It will be used to move all bookmark start/end nodes belonging to bookmarks overlapping our bookmark,
207. ‘ so that they will be preserved after this bookmark removal.
208. Dim endPara As Paragraph
210. ‘ It can be the paragraph containing bookmark end node if the last paragraph in the bookmark range
211. ‘ contains other nodes beside BookmarkEnd or is the last unremovable paragraph in the document.
212. If Not bookmarkEnd.NextSibling Is Nothing OrElse bookmarkEnd.ParentNode Is lastParagraph Then
213. endPara = CType(bookmarkEnd.ParentNode, Paragraph)
214. ‘ Or it can be the paragraph next to it.
215. Else
216. Do While node.NodeType <> NodeType.Paragraph
217. node = node.NextPreOrder(doc)
218. Loop
220. endPara = CType(node, Paragraph)
221. End If
223. ‘ Iterate over all nodes that contain or are between bookmark start and end nodes.
224. Do While Not node Is bookmarkEnd
225. node = node.NextPreOrder(doc)
227. ‘ BookmarkStart/BookmarkEnd are saved to be handled separately later.
228. ‘ All other nodes are collected as candidates for removal.
229. If (Not StoreIfBookmark(bookmarkNames, bookmarkStarts, bookmarkEnds, node)) Then
230. nodesToRemove.Add(node)
231. End If
232. Loop
234. For Each name As String In bookmarkNames.Keys
235. If (bookmarkStarts.ContainsKey(name)) AndAlso (bookmarkEnds.ContainsKey(name)) Then
236. ‘ If bookmark is nested, remove it altogether.
237. RemoveBookmarkNode(name, bookmarkStarts)
238. RemoveBookmarkNode(name, bookmarkEnds)
239. Else
240. ‘ If bookmark is overlapping, move the contained start/end node to the next paragraph after removed range.
241. If bookmarkStarts.ContainsKey(name) Then
242. MoveBookmarkNode(name, bookmarkStarts, endPara)
243. Else
244. MoveBookmarkNode(name, bookmarkEnds, endPara)
245. End If
246. End If
247. Next name
249. Dim hasNodesToRemove As Boolean = True
251. Do While hasNodesToRemove
253. hasNodesToRemove = False
255. Dim i As Integer = 0
257. Do While i < nodesToRemove.Count
258. Dim nodeToRemove As Node = CType(nodesToRemove(i), Node)
259. ‘ Skip already removed nodes.
260. ‘ Skip nodes that have child nodes.
261. ‘ Do not remove node if it is the last paragraph in the document.
262. If Not (nodeToRemove.ParentNode Is Nothing) And _
263. Not (nodeToRemove.IsComposite AndAlso CType(nodeToRemove, CompositeNode).HasChildNodes) And _
264. Not (nodeToRemove Is lastParagraph) Then
265. ‘ Remove node.
266. nodeToRemove.Remove()
267. ‘ If at least one node was removed in loop, then the loop will be repeated.
268. hasNodesToRemove = True
269. End If
270. i += 1
271. Loop
272. Loop
273. End Sub
275. Private Function IsBookmarkNode(ByVal node As Node) As Boolean
276. Return (node.NodeType = NodeType.BookmarkStart) OrElse (node.NodeType = NodeType.BookmarkEnd)
277. End Function
279. Private Function StoreIfBookmark(ByVal bookmarkNames As Hashtable, ByVal bookmarkStarts As Hashtable, ByVal bookmarkEnds As Hashtable, ByVal node As Node) As Boolean
280. If node.NodeType = NodeType.BookmarkStart Then
281. Dim bookmarkStart As BookmarkStart = CType(node, BookmarkStart)
282. bookmarkNames(bookmarkStart.Name) = Nothing
283. bookmarkStarts.Add(bookmarkStart.Name, bookmarkStart)
284. Return True
285. ElseIf node.NodeType = NodeType.BookmarkEnd Then
286. Dim bookmarkEnd As BookmarkEnd = CType(node, BookmarkEnd)
287. bookmarkNames(bookmarkEnd.Name) = Nothing
288. bookmarkEnds.Add(bookmarkEnd.Name, bookmarkEnd)
289. Return True
290. End If
292. Return False
293. End Function
295. Private Function RemoveBookmarkNode(ByVal name As String, ByVal bookmarkNodes As Hashtable) As Node
296. Dim node As Node = CType(bookmarkNodes(name), Node)
297. node.Remove()
298. bookmarkNodes.Remove(name)
299. Return node
300. End Function
302. Private Sub MoveBookmarkNode(ByVal name As String, ByVal bookmarkNodes As Hashtable, ByVal para As Paragraph)
303. para.PrependChild(RemoveBookmarkNode(name, bookmarkNodes))
304. End Sub

private void RemoveBookmarkWithContent(Bookmark bookmark)
{
        // We need to store other bookmark nodes here, to move them away from the removed area.
        Hashtable bookmarkNames = new Hashtable();
        Hashtable bookmarkStarts = new Hashtable();
        Hashtable bookmarkEnds = new Hashtable();

        ArrayList nodesToRemove = new ArrayList();
        
        BookmarkStart bookmarkStart = bookmark.BookmarkStart;
        BookmarkEnd bookmarkEnd = bookmark.BookmarkEnd;
        Document doc = bookmarkStart.Document;
        Paragraph lastParagraph = doc.LastSection.Body.LastParagraph;

        Node node = SeekFirstNodeOfBookmarkRange(bookmarkStart);

        Paragraph endPara = FindParagraphNextAfterBookmark(bookmarkEnd);

        // Iterate over all nodes that contain or are between bookmark start and end nodes.
        while(node != bookmarkEnd)
        {
                node = node.NextPreOrder(doc);

                // BookmarkStart/BookmarkEnd are saved to be handled separately later.
                // All other nodes are collected as candidates for removal.
                if (!StoreIfBookmark(bookmarkNames, bookmarkStarts, bookmarkEnds, node))
                        nodesToRemove.Add(node);
        }

        foreach (string name in bookmarkNames.Keys)
        {
                if ((bookmarkStarts.ContainsKey(name)) && (bookmarkEnds.ContainsKey(name)))
                {
                        // If bookmark is nested, remove it altogether.
                        RemoveBookmarkNode(name, bookmarkStarts);
                        RemoveBookmarkNode(name, bookmarkEnds);
                }
                else
                {
                        // If bookmark is overlapping, move the contained start/end node to the next paragraph after removed range.
                        if (bookmarkStarts.ContainsKey(name))
                                MoveBookmarkNode(name, bookmarkStarts, endPara);
                        else
                                MoveBookmarkNode(name, bookmarkEnds, endPara);
                }
        }

        bool hasNodesToRemove = true;
        
        while(hasNodesToRemove)
        {
                hasNodesToRemove = false;

                for (int i = 0; i < nodesToRemove.Count; i++)
                {
                        Node nodeToRemove = (Node)nodesToRemove[i];

                        // Skip already removed nodes.
                        if (nodeToRemove.ParentNode == null)
                                continue;

                        // Skip nodes that have child nodes.
                        if (nodeToRemove.IsComposite && (nodeToRemove as CompositeNode).HasChildNodes)
                                continue;

                        // Do not remove node if it is the last paragraph in the document.
                        if (nodeToRemove == lastParagraph)
                                continue;

                        // Remove node.
                        nodeToRemove.Remove();

                        // If at least one node was removed in loop, then the loop will be repeated.
                        hasNodesToRemove = true;
                }
        }
}

private Node SeekFirstNodeOfBookmarkRange(BookmarkStart bookmarkStart)
{
        Node node = bookmarkStart;

        Document doc = node.Document;

        // Bookmark nodes located immediately before start of our bookmark should also be included in the removal process.
        do
        {
                node = node.PreviousPreOrder(doc);
        }
        while(IsBookmarkNode(node));

        // Look back from the bookmark start node to include containing nodes into removal process.
        while(node.IsComposite)
        {
                Node prevNode = node.PreviousPreOrder(doc);

                if (prevNode == null)
                        break;
                else
                        node = prevNode;
        }

        return node;
}

private Paragraph FindParagraphNextAfterBookmark(BookmarkEnd bookmarkEnd)
{
        // Find the paragraph that is next to removed bookmark range.
        // It will be used to move all bookmark start/end nodes belonging to bookmarks overlapping our bookmark,
        // so that they will be preserved after this bookmark removal.
        Paragraph para;

        Node node = bookmarkEnd;
        Document doc = node.Document;

        // It can be that the paragraph containing bookmark end node if the last paragraph in the bookmark range 
        // contains other nodes beside BookmarkEnd or is the last unremovable paragraph in the document.
        if (node.NextSibling != null || node.ParentNode == doc.LastSection.Body.LastParagraph)
        {
                para = (Paragraph)bookmarkEnd.ParentNode;
        }
                // Or it can be the paragraph next to it.
        else
        {
                while(node.NodeType != NodeType.Paragraph)
                {
                        node = node.NextPreOrder(doc);
                }

                para = (Paragraph)node;
        }

        return para;
}

private bool IsBookmarkNode(Node node)
{
        return (node.NodeType == NodeType.BookmarkStart) || (node.NodeType == NodeType.BookmarkEnd);
}

private bool StoreIfBookmark(Hashtable bookmarkNames, Hashtable bookmarkStarts, Hashtable bookmarkEnds, Node node)
{
        if (node.NodeType == NodeType.BookmarkStart)
        {
                BookmarkStart bookmarkStart = (BookmarkStart)node;
                bookmarkNames[bookmarkStart.Name] = null;
                bookmarkStarts.Add(bookmarkStart.Name, bookmarkStart);
                return true;
        }
        else if (node.NodeType == NodeType.BookmarkEnd)
        {
                BookmarkEnd bookmarkEnd = (BookmarkEnd)node;
                bookmarkNames[bookmarkEnd.Name] = null;
                bookmarkEnds.Add(bookmarkEnd.Name, bookmarkEnd);
                return true;
        }

        return false;
}

private Node RemoveBookmarkNode(string name, Hashtable bookmarkNodes)
{
        Node node = (Node)bookmarkNodes[name];
        node.Remove();
        bookmarkNodes.Remove(name);
        return node;
}

private void MoveBookmarkNode(string name, Hashtable bookmarkNodes, Paragraph para)
{
        para.PrependChild(RemoveBookmarkNode(name, bookmarkNodes));
}
[VB .NET] 

Private Sub RemoveBookmarkWithContent(ByVal bookmark As Bookmark)
        ‘ We need to store other bookmark nodes here, to move them away from the removed area.
        Dim bookmarkNames As Hashtable = New Hashtable
        Dim bookmarkStarts As Hashtable = New Hashtable
        Dim bookmarkEnds As Hashtable = New Hashtable

        Dim nodesToRemove As ArrayList = New ArrayList

        Dim bookmarkStart As BookmarkStart = bookmark.BookmarkStart
        Dim bookmarkEnd As BookmarkEnd = bookmark.BookmarkEnd
        Dim node As Node = bookmarkStart
        Dim doc As Document = node.Document
        Dim lastParagraph As Paragraph = doc.LastSection.Body.LastParagraph

        ‘ Bookmark nodes located immediately before start of our bookmark should also be included in the removal process.
        Do
                node = node.PreviousPreOrder(doc)
        Loop While IsBookmarkNode(node)

        ‘ Look back from the bookmark start node to include containing nodes into removal process.
        Do While node.IsComposite
                Dim prevNode As Node = node.PreviousPreOrder(doc)

                If prevNode Is Nothing Then
                        Exit Do
                Else
                        node = prevNode
                End If
        Loop

        ‘ Find the paragraph that is next to removed bookmark range.
        ‘ It will be used to move all bookmark start/end nodes belonging to bookmarks overlapping our bookmark,
        ‘ so that they will be preserved after this bookmark removal.
        Dim endPara As Paragraph

        ‘ It can be the paragraph containing bookmark end node if the last paragraph in the bookmark range 
        ‘ contains other nodes beside BookmarkEnd or is the last unremovable paragraph in the document.
        If Not bookmarkEnd.NextSibling Is Nothing OrElse bookmarkEnd.ParentNode Is lastParagraph Then
                endPara = CType(bookmarkEnd.ParentNode, Paragraph)
                ‘ Or it can be the paragraph next to it.
        Else
                Do While node.NodeType <> NodeType.Paragraph
                        node = node.NextPreOrder(doc)
                Loop

                endPara = CType(node, Paragraph)
        End If

        ‘ Iterate over all nodes that contain or are between bookmark start and end nodes.
        Do While Not node Is bookmarkEnd
                node = node.NextPreOrder(doc)

                ‘ BookmarkStart/BookmarkEnd are saved to be handled separately later.
                ‘ All other nodes are collected as candidates for removal.
                If (Not StoreIfBookmark(bookmarkNames, bookmarkStarts, bookmarkEnds, node)) Then
                        nodesToRemove.Add(node)
                End If
        Loop

        For Each name As String In bookmarkNames.Keys
                If (bookmarkStarts.ContainsKey(name)) AndAlso (bookmarkEnds.ContainsKey(name)) Then
                        ‘ If bookmark is nested, remove it altogether.
                        RemoveBookmarkNode(name, bookmarkStarts)
                        RemoveBookmarkNode(name, bookmarkEnds)
                Else
                        ‘ If bookmark is overlapping, move the contained start/end node to the next paragraph after removed range.
                        If bookmarkStarts.ContainsKey(name) Then
                                MoveBookmarkNode(name, bookmarkStarts, endPara)
                        Else
                                MoveBookmarkNode(name, bookmarkEnds, endPara)
                        End If
                End If
        Next name

        Dim hasNodesToRemove As Boolean = True

        Do While hasNodesToRemove

                hasNodesToRemove = False

                Dim i As Integer = 0

                Do While i < nodesToRemove.Count
                        Dim nodeToRemove As Node = CType(nodesToRemove(i), Node)
                        ‘ Skip already removed nodes.
                        ‘ Skip nodes that have child nodes.
                        ‘ Do not remove node if it is the last paragraph in the document.
                        If Not (nodeToRemove.ParentNode Is Nothing) And _
                                Not (nodeToRemove.IsComposite AndAlso CType(nodeToRemove, CompositeNode).HasChildNodes) And _
                                Not (nodeToRemove Is lastParagraph) Then
                                ‘ Remove node.
                                nodeToRemove.Remove()
                                ‘ If at least one node was removed in loop, then the loop will be repeated.
                                hasNodesToRemove = True
                        End If
                        i += 1
                Loop
        Loop
End Sub

Private Function IsBookmarkNode(ByVal node As Node) As Boolean
        Return (node.NodeType = NodeType.BookmarkStart) OrElse (node.NodeType = NodeType.BookmarkEnd)
End Function

Private Function StoreIfBookmark(ByVal bookmarkNames As Hashtable, ByVal bookmarkStarts As Hashtable, ByVal bookmarkEnds As Hashtable, ByVal node As Node) As Boolean
        If node.NodeType = NodeType.BookmarkStart Then
                Dim bookmarkStart As BookmarkStart = CType(node, BookmarkStart)
                bookmarkNames(bookmarkStart.Name) = Nothing
                bookmarkStarts.Add(bookmarkStart.Name, bookmarkStart)
                Return True
        ElseIf node.NodeType = NodeType.BookmarkEnd Then
                Dim bookmarkEnd As BookmarkEnd = CType(node, BookmarkEnd)
                bookmarkNames(bookmarkEnd.Name) = Nothing
                bookmarkEnds.Add(bookmarkEnd.Name, bookmarkEnd)
                Return True
        End If

        Return False
End Function

Private Function RemoveBookmarkNode(ByVal name As String, ByVal bookmarkNodes As Hashtable) As Node
        Dim node As Node = CType(bookmarkNodes(name), Node)
        node.Remove()
        bookmarkNodes.Remove(name)
        Return node
End Function

Private Sub MoveBookmarkNode(ByVal name As String, ByVal bookmarkNodes As Hashtable, ByVal para As Paragraph)
        para.PrependChild(RemoveBookmarkNode(name, bookmarkNodes))
End Sub