Spire.Doc Version 14.10.9 — Detailed Upgrade Changes vs. 14.9.11

Summary

This upgrade contains several high-risk public API changes. The wholesale renumbering of the DocumentObjectType enum is the highest-risk item: without a recompile it causes silent behavioural errors.

• Every project that references Spire.Doc must be fully recompiled. Replacing only the DLL leads to MissingMethodException, TypeLoadException, or — because enum constants are inlined — silent use of the wrong numeric values.
• Permission identifiers change from string to int, affecting constructors, Id, collection lookup/indexers, and Paragraph.AppendPermStart/End.
• The SDT (Structured Document Tag) model is restructured: SDTContent/SDTInlineContent are removed, and SDT Row/Cell are no longer TableRow/TableCell, losing a large amount of table functionality.
• The collection hierarchy is restructured: DocumentObjectCollection becomes concrete and changes base class, DocumentSubsetCollection is removed, several collections change base class, and Add returns void instead of int.
• 19 types change base class, moving members up/down; ChildObjects/FirstChild/LastChild/GetIndex move down from DocumentObject to CompositeDocumentObject.
• Statistics: public types 508 → 507 (+8 / -9), public members 5460 → 5527 (+178 / -111 / ~97). 67 types collectively lose 250 effective member slots, which deduplicate to 90 unique signatures; 114 types have metadata changes.

1. Comparison Targets and File Information

The referenced-assembly lists of the two versions are identical (HarfBuzzSharp, mscorlib, System, System.Core, System.Data, System.Drawing, System.Web, System.Windows.Forms, System.Xml); no assembly dependency was added or removed.

Note: the assembly version has changed. .NET Framework strong-name binding does not automatically accept a higher version; without a bindingRedirect, older applications may fail at load time.

2. Statistics Overview

Counting conventions:

• "Public members" means members exported with BindingFlags.Public | DeclaredOnly, excluding inherited members; only public constructors are counted for constructors.
• "Effective member surface" means the accessible members after merging up the in-assembly base-class chain (constructors are not inherited).
• "Member slots" are counted repeatedly across types; when the same signature affects several types it counts as one unique signature.
• Modification categories can overlap (e.g. a member whose return type and parameter names both changed).

3. Highest-Priority Breaking Changes

3.1 Wholesale renumbering of the DocumentObjectType enum (highest risk: silent errors)

64 constants in the old version, 62 in the new: 4 SDT content constants removed, 2 SDT Mark constants added, and the numeric value of nearly every constant has changed.

Complete mapping table (only changed entries listed)

Complete value sequence in the old version

Document=0, Section=1, Body=2, HeaderFooter=3, Paragraph=4, StructureDocumentTag=5, StructureDocumentTagInline=6, StructureDocumentTagRow=7, StructureDocumentTagCell=8, SDTBlockContent=9, SDTInlineContent=10, SDTRowContent=11, SDTCellContent=12, Table=13, TableRow=14, TableCell=15, TextRange=16, Picture=17, FieldStart=18, Field=19, FieldMark=20, FieldSeparator=21, FieldEnd=22, MergeField=23, SeqField=24, EmbededField=25, ControlField=26, TextFormField=27, DropDownFormField=28, CheckBox=29, BookmarkStart=30, BookmarkEnd=31, MoveFromRangeStart=32, MoveFromRangeEnd=33, MoveToRangeStart=34, MoveToRangeEnd=35, PermissionStart=36, PermissionEnd=37, Shape=38, ShapeGroup=39, ShapeLine=40, ShapePath=41, ShapeRect=42, Comment=43, Footnote=44, TextBox=45, Break=46, Symbol=47, TOC=48, XmlParaItem=49, Undefined=50, CommentMark=51, OleObject=52, CustomXml=53, SmartTag=54, OfficeMath=55, System=56, Ruby=57, SubDocument=58, SpecialChar=59, GlossaryDocument=60, BuildingBlock=61, FormField=62, Any=63

Complete value sequence in the new version

Undefined=-2, System=-1, Any=0, Document=1, Section=2, Body=3, HeaderFooter=4, Paragraph=5, StructureDocumentTag=6, StructureDocumentTagMarkStart=7, StructureDocumentTagMarkEnd=8, StructureDocumentTagInline=9, StructureDocumentTagRow=10, StructureDocumentTagCell=11, Table=12, TableRow=13, TableCell=14, TextRange=15, Picture=16, FieldStart=17, Field=18, FieldMark=19, FieldSeparator=20, FieldEnd=21, MergeField=22, SeqField=23, EmbededField=24, ControlField=25, TextFormField=26, DropDownFormField=27, CheckBox=28, BookmarkStart=29, BookmarkEnd=30, MoveFromRangeStart=31, MoveFromRangeEnd=32, MoveToRangeStart=33, MoveToRangeEnd=34, PermissionStart=35, PermissionEnd=36, Shape=37, ShapeGroup=38, ShapeLine=39, ShapePath=40, ShapeRect=41, Comment=42, Footnote=43, TextBox=44, Break=45, Symbol=46, TOC=47, XmlParaItem=48, CommentMark=49, OleObject=50, CustomXml=51, SmartTag=52, OfficeMath=53, Ruby=54, SubDocument=55, SpecialChar=56, GlossaryDocument=57, BuildingBlock=58, FormField=59

Why this is the highest risk: the C# compiler inlines const enum values into the calling assembly. Existing assemblies do not re-read the new DLL's enum values at runtime; they keep using the old numbers from compile time. For example:

In addition, default(DocumentObjectType) now means Any instead of Document. Any code relying on the default value, numeric comparison, serialization/deserialization, database storage or caching must be migrated.

Remediation:

1. All consumers must be recompiled against the new DLL; replacing the DLL alone is not enough.
2. Remove numeric literals from the code (such as (DocumentObjectType)4) and use the constant names.
3. If enum values were ever persisted, build a mapping from "old constant name → new constant name" and take the new values; do not carry the numbers over directly.
4. Check that switch statements cover the new values; old value 63 (Any) has no corresponding member in the new version.

3.2 Permission identifiers change from string to int

Migration example:

// Old code
var start = new PermissionStart(doc, "editor-1");
var permission = new Permission(start);
string id = permission.Id;
var found = doc.Permissions.FindById("editor-1");
var byKey = doc.Permissions["editor-1"];       // old indexer
doc.Permissions.Remove(byKey);                  // old removal by object

// New code
var start = new PermissionStart(doc, 1);
var permission = start.Permission;            // no public constructor any more
int id = permission.Id;
permission.Editor = "editor-1";               // newly added string identifier
var found = doc.Permissions.FindById(1);
doc.Permissions.Remove(1);                     // newly added removal by id

If the business layer used strings as permission keys, you need to decide on the new integer ID allocation scheme (for example a database identity column or an in-document sequence number) and make sure PermissionStart, PermissionEnd and Permission all use the same integer.

3.3 SDT (Structured Document Tag) model restructuring

Removed types: Spire.Doc.Documents.SDTContent (base class Body), Spire.Doc.Documents.SDTInlineContent (base class DocumentObject).

Added types: StructureDocumentTagMarkStart, StructureDocumentTagMarkEnd (both inherit directly from ParagraphBase and expose only DocumentObjectType).

Structural changes:

How Row is constructed: StructureDocumentTagRow(Table ownerTable) is removed; StructureDocumentTagRow(Document doc) is added. How Cell is constructed: StructureDocumentTagCell(TableRow ownerRow) is removed; StructureDocumentTagCell(Document doc) is added.

Impact: any code that uses SDT rows/cells as ordinary table rows/cells (styling, row height, cell width, merging, splitting, XHTML insertion, iterating Table.Rows/Table.Cells) will either fail to compile or, at runtime, no longer recognise them as table structure. The new version turns them into "composite objects with child nodes"; contents are accessed through CompositeDocumentObject's DOM API (ChildObjects, AppendChild, InsertBefore, etc.). This is a semantic-level restructuring and cannot be solved by type casts alone.

Migration example:

// Old code
StructureDocumentTag sdt = new StructureDocumentTag(doc);
SDTContent content = sdt.SDTContent;
content.AddParagraph();

// New code
StructureDocumentTag sdt = new StructureDocumentTag(doc);
IBody body = sdt.Body;
body.AddParagraph();

// Old code: SDT cell as a TableCell
StructureDocumentTagCell cell = new StructureDocumentTagCell(row);
cell.CellFormat.Width = 100;

// New code: no more CellFormat; use CompositeDocumentObject child/child-content APIs
StructureDocumentTagCell cell = new StructureDocumentTagCell(doc);
// Concrete cell formatting must be achieved through child nodes or by redesigning the document structure; regression testing is required

3.4 Collection hierarchy restructuring

Core changes:

• DocumentObjectCollection changes from abstract to non-abstract, and its base class changes from DocumentItemCollectionBase to OwnerHolder; it has 0 public constructors (the export contains no public constructors) and is mainly obtained through properties.
• DocumentSubsetCollection and its nested SubSetEnumerator are removed.
• DocumentObjectCollection.Add changes its return type from int to void.
• DocumentObjectCollection gains strongly typed overloads taking DocumentObject; the existing IDocumentObject overloads are kept but their parameter name changes to documentObject.
• SectionCollection no longer has public constructors; IWSectionCollection is removed and replaced by an empty marker interface ISectionCollection.

Overview of base-class changes (collection-related):

Members whose Add return type changes from int to void (binary-breaking):

• DocumentObjectCollection.Add(IDocumentObject)
• ParagraphCollection.Add(IParagraph)
• TableCollection.Add(ITable)
• IParagraphCollection.Add(IParagraph)
• ITableCollection.Add(ITable)
• TableCollection.Insert(int, ITable) also changes from int to void

Migration example:

// Old code: relies on the returned index
int index = body.ChildObjects.Add(paragraph);
int index2 = body.Paragraphs.Add(paragraph);

// New code: Add returns void; call IndexOf yourself when you need the index
body.ChildObjects.Add(paragraph);
int index = body.ChildObjects.IndexOf(paragraph);
body.Paragraphs.Add(paragraph);
int index2 = body.Paragraphs.IndexOf(paragraph);

// Old code: strongly typed overloads
row.Cells.Add(cell);
table.Rows.Insert(0, row);

// New code: use the DocumentObject overloads (they return void)
row.Cells.Add((DocumentObject)cell);
table.Rows.Insert(0, (DocumentObject)row);

3.5 Base-class changes (19 types)

Base-class changes affect inherited members, is/as casting, overrides, serialization and binary member resolution all at once.

Key impacts:

• Comment, Footnote → InlineBody: both are now "inline bodies" with AddParagraph/AddTable, CharacterFormat and revision properties; but they lose some capabilities that came from ParagraphBase (such as ApplyCharacterFormat, ToString(string)).
• OfficeMath, ShapeBase → CompositeDocumentObject: shapes/formulas now have child nodes and body capabilities, but no longer inherit ParagraphBase.
• TableOfContent → Field: TOC is now a field, gaining IField/ITextRange and field-related capabilities.
• StructureDocumentTagRow/Cell → CompositeDocumentObject: no longer table rows/cells (see 3.3).
• ShapeItemCollection's base class changes "backwards" to DocumentItemCollectionBase, losing collection operations (see 3.4).

3.6 Base-class member moves down and cascading loss

The following members move down from DocumentObject to CompositeDocumentObject:

• ChildObjects
• FirstChild
• LastChild
• GetIndex(IDocumentObject)

As a result: composite types (Body, Section, Table, TableRow, TableCell, Document, Paragraph, Comment, Footnote, shapes, etc.) can still reach them through the new base class; but DocumentObject itself and 24 non-composite leaf types (BookmarkStart/End, Break, Field, TextRange, Symbol, PermissionStart/End, watermark types, etc.) no longer expose these members.

Explanation: ToString(string) disappears from 48 types because it is removed from the DocumentObject base class; ApplyCharacterFormat disappears from 11 types because those types no longer inherit ParagraphBase (ParagraphBase itself still keeps the method).

Binary impact: members moving up to a base class usually still resolve (the CLR walks up the base-class chain); members moving down to a derived class are different — member references in old IL usually point at the original declaring type DocumentObject, and the CLR does not search derived classes, so after replacing the DLL a MissingMethodException is very likely. Therefore "still reachable through the new base class" holds only for recompiled source; it does not make old binaries safe.

3.7 Return type changes (21 items)

Pattern summary:

• Body → IBody (7 items): BodyRegion.OwnerTextBody, Comment.Body, Footnote.Body, TextBox.Body, ITextBox.Body, FixedLayoutColumn.Body, TextBodySelection.TextBody.
• ParagraphBase → IParagraphBase (4 items): ParagraphItemCollection indexer, Paragraph indexer, IParagraph indexer, Document.CreateParagraphItem.
• int → void (6 items): collection Add/Insert (see 3.4).
• string → int (3 items): Id of Permission/PermissionStart/PermissionEnd.
• TextBox → ShapeObject (1 item): TextBoxCollection indexer.
• A further 2 items involve "cross-inheritance substitution" causing signature changes and are not counted in the same-key modifications above: DocPicture.Rotation (float → double; the old member hid the same-named base property, and the new version inherits from ShapeBase) and HeadersFooters.GetEnumerator (IEnumerator → IEnumerator<DocumentObject>). These two also break old binaries.

All of these changes alter CLR method signatures (the return type is part of the signature); old binaries will get MissingMethodException, and at source level an explicit cast or a switch to the interface is usually required.

3.8 Type removals and namespace migration

9 removed public types:

8 added public types:

Key points:

• Spire.Doc.CompoundFile.IDocCloneable → Spire.Doc.Interface.IDocCloneable. The interface's type identity changes, so code that explicitly references the old namespace fails to compile, and reflection lookups by full name fail as well.
• IWSectionCollection → ISectionCollection. The new interface is an empty marker interface (0 declared members); members come from ICollectionBase/IDocumentObjectCollection. SectionCollection implements the new interface.
• ITextBoxItemCollection had no public implementers in the old version and did not appear in any public member signature, so the practical impact is very small — but it is still a public type removal.
• DocumentObjectCollection+ChangeItems/ChangeItemsType are public nested delegate/enum types removed together with the collection restructuring; no corresponding public event members were found, so the impact is limited.

4. Other Breaking and Behavioural Changes

4.1 Constructor and parameter type changes

Parameter name changes (only affect named arguments; source is generally compatible):

• DocumentObjectCollection.Add/Contains/IndexOf/Insert/Remove: entity → documentObject
• Bookmark(BookmarkStart, BookmarkEnd): start/end → bookmarkStart/bookmarkEnd
• FormFieldCollection.ContainsName: itemName → formFieldName
• CompositeDocumentObject.IndexOf: docObject → child

4.2 Directly declared removals (54 items)

These are members declared on the old type itself that are removed in the new version; they exclude inherited members that the old type loses because of a base-class change. The latter are counted in the effective member surface (250 slots across 67 types), typically the cascading disappearance of ChildObjects, ToString(string) and ApplyCharacterFormat.

The full list is in Appendix D. The non-cascading items that need the most attention:

Two more items: the old declaration is replaced by a same-named base-class member, but the signature changes

In the old version DocPicture.Rotation hid ShapeBase.Rotation (double) with a float member; the new version removes that hiding declaration, so DocPicture.Rotation now resolves to double. Source that depends on float needs an explicit cast, and old binaries fail because of the return-type mismatch.

In addition, the strongly typed Add/IndexOf/Insert/Remove of CellCollection/RowCollection are removed, but the base class DocumentObjectCollection still provides DocumentObject versions; the 11 collection capabilities of ShapeItemCollection, however, have no base-class fallback.

4.3 Accessor changes

The setter of Document.TextBoxes is removed: old code that replaces the whole text-box collection will no longer compile and should instead add/remove through DocumentObjectCollection/TextBoxCollection methods on the existing collection.

4.4 Obsolete markers (warning level)

The following 4 members gain [Obsolete] (IsError = false, warning only):

• DocumentObjectCollection.Insert(int, IDocumentObject): recommended Owner.InsertBefore/InsertAfter
• DocumentObjectCollection.RemoveAt(int): recommended Owner.Remove(documentObject) or documentObject.Remove()
• ParagraphCollection.Insert(int, IParagraph): same as above
• TableCollection.Insert(int, ITable): same as above

This reflects the API direction of the new version: adding/removing through the collection itself is gradually giving way to DOM tree operations on CompositeDocumentObject.

4.5 Behavioural/semantic changes

• SDT Row/Cell are no longer table structure: traversal, styling, merging, splitting and XHTML insertion logic that depends on TableRow/TableCell must be redesigned.
• Comment/Footnote become InlineBody: Body returns IBody and AddParagraph/AddTable can be called directly; Comment.Items becomes CommentedItems; Footnote.TextBody is removed because Footnote is itself the body text.
• TOC becomes a Field: TableOfContent's base class changes to Field, which may affect field updates and type checks.
• Shapes/formulas become composite objects: ShapeBase, OfficeMath now have child nodes, body text and revision capabilities; DocPicture/TextBox/ShapeObject etc. implement IBody.
• Collection base classes and return types change: DocumentObjectCollection.Add no longer returns an index; the collection hierarchy is more uniform, but code depending on a specific base class or return value is affected.
• TextBoxCollection indexer returns ShapeObject: the retrieved object may be a shape other than TextBox; old code that assigns it directly to TextBox will fail.

5. Compatibility Impact Analysis

5.1 Binary compatibility

Conclusion: even if a bindingRedirect is configured so the assembly loads, the signature/inheritance changes above will still throw on first use; and the enum problem may not even throw, which is more harmful.

5.2 Source compatibility

• Compile-time errors: removed types/members, return type changes, parameter type changes, use of Add's return value, members becoming invisible because of base-class changes, removed setters.
• Compile-time warnings: 4 newly added [Obsolete].
• Source-compatible but noteworthy: parameter name changes only break named arguments; new interface members do not affect callers; new setters are compatible.
• Explicit casts needed: IParagraphBase/IBody/ShapeObject return values, ISectionCollection indexer, TextBoxCollection indexer.

5.3 Behavioural compatibility

Even after all source compiles, the following behaviours still need regression testing:

1. Table layout, width, merging, splitting and XHTML insertion for SDT rows/cells.
2. Matching of permission ranges (start/end/permission) and editor identities.
3. Body structure of comments/footnotes, and the differences between CommentedItems and the old Items.
4. The update behaviour of TOC now that it is a Field.
5. Child content and text extraction for shapes/text boxes/pictures as IBody.
6. Index, order, event/cache behaviour after collection Add.
7. Enumeration and Count of the header/footer collection.
8. DocumentObjectType branching during document traversal.

5.4 Compatibility matrix

6. Migration Guide

6.1 Migration order (recommended)

6.2 Key code migrations

(1) Enum checks

// After recompiling, use constant names — not numbers
if (obj.DocumentObjectType == DocumentObjectType.Paragraph) { ... }

// If you need to migrate old persisted numbers to the new enum, map by old constant name first:
// old 4 (Paragraph) -> new Paragraph (5)
// old 0 (Document)  -> new Document (1)
// old 63 (Any)      -> no corresponding member in the new version

(2) ChildObjects / child nodes

// Old code: accessible from any DocumentObject
DocumentObjectCollection children = documentObject.ChildObjects;

// New code: only composite objects have ChildObjects
if (documentObject is CompositeDocumentObject composite)
{
    DocumentObjectCollection children = composite.ChildObjects;
    DocumentObject first = composite.FirstChild;
    int index = composite.GetIndex(child);
}

(3) Adding to collections

// Add no longer returns an index
body.ChildObjects.Add(paragraph);
int index = body.ChildObjects.IndexOf(paragraph);

// Strongly typed collection overloads are gone; use the DocumentObject overloads
row.Cells.Add((DocumentObject)cell);
table.Rows.Insert(0, (DocumentObject)row);

(4) Interface return types

// Old code
ParagraphBase item = doc.CreateParagraphItem(ParagraphItemType.TextRange);
Body body = comment.Body;

// New code
IParagraphBase item = doc.CreateParagraphItem(ParagraphItemType.TextRange);
IBody body = comment.Body;

// Cast explicitly when you need the concrete type
var paragraph = (Paragraph)item;

(5) Comment / Footnote

// Comment.Items has been removed
foreach (IParagraphBase item in comment.CommentedItems) { ... }

// Footnote.TextBody has been removed; Footnote is itself an IBody
footnote.AddParagraph();
IBody footnoteBody = footnote.Body;

(6) TextBodyPart / TextBodySelection

part.Copy((IParagraphBase)paragraphBase, true);
part.PasteAfter((IParagraphBase)paragraphBase);
var selection = new TextBodySelection((IParagraphBase)start, (IParagraphBase)end);

(7) Shape formatting

// Old code: ApplyCharacterFormat directly on the shape
shape.ApplyCharacterFormat(format);

// New code: shapes no longer inherit ParagraphBase; use the CharacterFormat property / ApplyStyle
shape.ApplyStyle("MyStyle");
// or copy item by item into shape.CharacterFormat

(8) IDocCloneable / ISectionCollection

// Namespace migration
using Spire.Doc.Interface; // was Spire.Doc.CompoundFile
IDocCloneable cloneable = obj;

// IWSectionCollection -> ISectionCollection (empty marker interface)
ISectionCollection sections = document.Sections;
Section first = (Section)sections; // the indexer returns IDocumentObject

(9) TextBoxCollection indexer

// Old code
TextBox textBox = document.TextBoxes;

// New code: the indexer returns ShapeObject
TextBox textBox = (TextBox)document.TextBoxes;

6.3 Items that cannot be migrated automatically / need manual design

1. Persisted DocumentObjectType values: must be mapped semantically, not carried over numerically.
2. Table capabilities of SDT Row/Cell: the new model no longer provides CellFormat, RowFormat, Cells, merging/splitting, etc.; redesign or find alternative APIs.
3. Style.NameToBuiltIn: no equivalent replacement; maintain a name mapping table (built-in style names and enum names do not always match).
4. ApplyCharacterFormat: no equivalent method on shapes/comments/footnotes etc.; copying CharacterFormat item by item may not fully reproduce the original behaviour.
5. ToString(string separator): no direct replacement; walk the children and concatenate yourself.
6. ShapeItemCollection: the public type still exists, but all collection operations are gone, and no public member returns this type; if you use it via reflection/internal paths, switch to another collection.
7. Permission ID allocation: string → integer is a data-model change requiring a uniqueness and migration strategy.

7. Non-Breaking Enhancements (available for use)

7.1 DOM tree operations

DocumentObject gains GetText(), Remove(), GetAncestor(...), GetNextInPreOrder(...), GetPreviousInPreOrder(...), HasChildNodes; CompositeDocumentObject gains AppendChild, PrependChild, InsertBefore, InsertAfter, RemoveChild, RemoveAllChildren, RemoveChildRange, GetChild, GetChildNodes, an integer indexer, and ChildObjects/FirstChild/LastChild. This API group replaces part of the collection add/remove and manual traversal code.

7.2 Revision tracking

New IRevisionTracking (8 members), implemented by 35 types: IsInsertRevision, IsDeleteRevision, IsMoveFromRevision, IsMoveToRevision, InsertRevision, DeleteRevision, MoveFromRevision, MoveToRevision. Comments, footnotes, paragraphs, fields, shapes, watermarks etc. can all handle revisions uniformly.

7.3 Typed range collections

• CommentRangeCollection: Comment.CommentedItems, supports Count, indexer, Contains, IndexOf, ToArray, enumeration.
• TextRangeCollection: Paragraph.TextNodes, StructureDocumentTagInline.TextNodes, supports indexer, ToArray, enumeration.

7.4 Collection and query enhancements

• Several collections gain ToArray(): ParagraphCollection, TableCollection, CellCollection, RowCollection, FieldCollection, FormFieldCollection, TextBoxCollection, SectionCollection, ParagraphItemCollection, DocumentObjectCollection.
• BookmarkCollection: Count, GetEnumerator, Remove(string), ResetBookmarkCache.
• PermissionCollection: Count, GetEnumerator, Remove(int), FindById(int).
• HeadersFooters.GetHeaderFooterByType(HeaderFooterType).
• TableRow.FirstCell/LastCell.
• StyleCollection.GetNextAvailableIstd().
• DocumentNavigator: MoveToBodyStart/End, MoveToBookmark (including overloads), InsertDropDown.

7.5 Writable properties and convenience members

• Bookmark.Name is writable; Bookmark.Text, Bookmark.Remove(), BookmarkStart.Bookmark added.
• Field.Separator is writable.
• ShapeBase.Size is writable; Shape.Title added; DocPicture.Size is writable.
• Permission.Editor, Permission.Remove(), PermissionStart.Permission, PermissionEnd.PermissionStart.
• Break.Text, Symbol.Text.
• DocumentObject strongly typed overloads and Count on DocumentObjectCollection.

8. Full Change List and Tool Artifacts

CSV columns: change, priority, type, member_kind, member_name, category, action, old_signature, new_signature, details. change values: type_added, type_removed, type_modified, member_added, member_removed, member_modified. priority convention: P0 must fix (using the API causes a compile failure, runtime failure or silent error — 169 items), P1 recommended fix (compiles, but with obsolete warnings, named arguments, inheritance substitution or semantic risk — 64 items), P2 recompile only (new APIs or pure metadata changes — 319 items). action gives the recommended handling for each row.

9. Methodology and Validation

9.1 Export method

1. Use Assembly.ReflectionOnlyLoadFrom to load the target DLL for reflection only, without executing its business code.
2. Before GetTypes(), walk GetReferencedAssemblies() to preload dependencies; for dependencies present locally, fall back to ReflectionOnlyLoadFrom.
3. Use BindingFlags.Public | DeclaredOnly to export only members declared by the type itself; only public constructors are taken for constructors.
4. For nested types, require the entire DeclaringType chain to be public, so that public nested types inside internal types are not mistakenly counted as exported types (508 after the fix).
5. Generate ECMA-334 XML documentation IDs (T:/M:/P:/F:/E:) and cross-validate against the official XML documentation.
6. Compute the "effective member surface": merge members along the in-assembly base-class chain; constructors are not inherited; a member counts as "still accessible" only when the type itself or an ancestor still provides it with the same name and signature in the new version.

9.2 Validation

• Enum values: Spire.Doc has anti-disassembly protection enabled and ildasm reports "protected module". Instead, values were read independently via normal loading + Enum.GetValues, and the results matched the reflection export; it was also confirmed that DocumentObjectType has 64 items in the old version and 62 in the new one.
• Type count: the first export gave 538; the cause was "public nested types inside internal types" being miscounted; after fixing the visibility chain it became 508, as expected.
• Member keys: typeFullName|kind|name(paramTypeKeys), with generic parameters normalised to !0/!!0, to avoid misclassifying "overload removed + added" as a signature modification.
• docId matching: old 4247/5460 (77.8%), new 4297/5527 (77.7%); most unmatched items are public members without XML documentation.

9.3 Limitations

• Only the public API is compared; protected/internal members, method-body behaviour, performance and serialization formats are out of scope.
• No runtime functional testing was performed; behavioural conclusions are inferred from signatures, inheritance relationships and type semantics.
• Non-public interfaces produced by obfuscation (spr...) appear in GetInterfaces() results and have been filtered from the report; they may still be present in the exported JSON and must be filtered during analysis.
• "Moves" are determined only by inheritance relationships; no attempt is made to guess renames/migrations across unrelated types, to avoid false positives.
• Advanced metadata beyond custom attributes (other than Obsolete/Flags/EditorBrowsable) and event members was not analysed.

Appendix A: Added Types (8)

A.1 Public members of the added types

Notes: CommentRangeCollection and TextRangeCollection are the new typed collections; InlineBody is the new base class of Comment/Footnote; IRevisionTracking is the revision-tracking interface; IDocCloneable migrated from the CompoundFile namespace; ISectionCollection is an empty marker interface; the two StructureDocumentTagMark* types are SDT boundary marks.

Appendix B: Removed Types (9)

Notes: DocumentSubsetCollection was the base class of the old ParagraphCollection/TableCollection; SDTContent/SDTInlineContent were SDT content wrappers; CompoundFile.IDocCloneable moved to Interface; IWSectionCollection is replaced by ISectionCollection; ITextBoxItemCollection had no public implementers; the two nested types were public artifacts of the old collection change notification.

Appendix C: Added Members (178)

C.1 Members on added types (37)

All 37 of these members are on the 8 types added in this version; the full list is in Appendix A.1 and is not repeated here.

C.2 Members added to existing types (141)

Appendix D: Directly Declared Removals (54 items)

These members were declared on the old type itself, and neither that type nor any ancestor provides them in the new version. Inherited members lost because of base-class changes are not in this table; see the effective member surface statistics.

Appendix E: Removals Still Reachable by Inheritance (29 items)

These members were declared on some type in the old version; in the new version that type or an ancestor still provides a member with the same name and signature, so usually only a recompile is needed. However, DocPicture.Rotation and HeadersFooters.GetEnumerator changed signature and must not be treated as "fully compatible".

Appendix F: Non-Enum Modifications (37 items)

Appendix G: Base-Class Changes (19 items)

Appendix H: Summary of Type Metadata Interface Changes

114 types have metadata changes. The main additions/removals at the public interface level:

Among these, Spire.Doc.Interface.IDocCloneable is newly implemented by 114 types; IRevisionTracking is newly implemented by 35 types; IBody gains 7 new implementations (StructureDocumentTag, Comment, Footnote, DocOleObject, DocPicture, ShapeObject, TextBox), and StructureDocumentTagCell loses IBody; ITextRange gains 3 new implementations (Break, Symbol, TableOfContent), and IField gains 1 new implementation (TableOfContent).

Non-public/obfuscated interfaces (spr...) are not counted in this table; the full raw interface list is in the JSON artifacts.

Appendix I: Effective Member Surface Lost by Type (Top 20)