Using C# and COM Interoperability to Extract from a UML tool into a Microsoft Word Document

public void WriteAllApisToWord()
{
object fileName = "normal.dot";
object readOnly = false;
object isVisible = true;
object missing = System.Reflection.Missing.Value;
object newTemplate = false;
object docType = 0;
// Create a new word document to type into
Word.Document aDoc = WordApp.Documents.Add(ref fileName, ref newTemplate, ref docType, ref isVisible);
// Write a Title for the document in bold and centered on the page
WordApp.Selection.ParagraphFormat.Alignment = Word.WdParagraphAlignment.wdAlignParagraphCenter;
WordApp.Selection.Font.Bold = (int)Word.WdConstants.wdToggle;
WordApp.Selection.TypeText("API of Classes Extracted from the WithClass Diagram\n\n");
// Toggle centering and bold Off
WordApp.Selection.Font.Bold = (int)Word.WdConstants.wdToggle;
WordApp.Selection.ParagraphFormat.Alignment = Word.WdParagraphAlignment.wdAlignParagraphLeft;
// Loop through each class diagram
WCApp.ActiveDocument.ClassDiagrams.Restart();
while (WCApp.ActiveDocument.ClassDiagrams.IsLast() == false)
{
With_Class.ClassDiagram nextClassDiagram =
(With_Class.ClassDiagram)WCApp.ActiveDocument.ClassDiagrams.GetNext();
// Loop through each collection of classes in the diagram
nextClassDiagram.Classes.Restart();
while (nextClassDiagram.Classes.IsLast() == false)
{
// Write class name in Bold Italic in Microsoft Word
With_Class.Class nextClass = nextClassDiagram.Classes.GetNext();
WordApp.Selection.Font.Bold = (int)Word.WdConstants.wdToggle;
WordApp.Selection.Font.Italic = (int)Word.WdConstants.wdToggle;
WordApp.Selection.TypeText(nextClass.Name + "\n");
WordApp.Selection.Font.Bold = (int)Word.WdConstants.wdToggle;
WordApp.Selection.Font.Italic = (int)Word.WdConstants.wdToggle;
// Write Attributes and Operations into Word
WriteClassAPIToWord(aDoc, nextClass);
}
}
}

We perform similar looping through data of WithClass for both attributes and operations. Below is the method used to extract attribute information into Word. The method simply loops through each attribute in a particular class using again - Restart, IsLast, GetNext in a while loop. The attribute is obtained each time through the loop and this attribute can be used to extract various attribute properties into word such as attribute type, initial value, and visibility (Note that the UML attribute is not to be confused with the attribute intrinsic to the .NET library):

Listing 3 - Writing the class attributes to Microsoft Word

public void WriteAttribute(Word.Document aDoc, With_Class.Attribute attribute)
{
// Type the name of the attribute into Word in Italics
WordApp.Selection.TypeText("Attribute Name:\t ");
WordApp.Selection.Font.Italic = (int)Word.WdConstants.wdToggle;
WordApp.Selection.TypeText(attribute.Name + "\n");
WordApp.Selection.Font.Italic = (int)Word.WdConstants.wdToggle;
// Type some of the attribute properties. Each property is followed by a return character
WordApp.Selection.TypeText("Type:\t " + attribute.Type + "\n");
WordApp.Selection.TypeText("Modifier:\t " + attribute.Visibility + "\n"); WordApp.Selection.TypeText("Initial
Value:\t " + attribute.InitialValue + "\n");
WordApp.Selection.TypeText("Additional Properties:\t");
// Also type some of the Attribute indicators such as constant, static, read-only
if (attribute.IsConstant)
WordApp.Selection.TypeText("constant ");
if (attribute.IsStatic)
WordApp.Selection.TypeText("static ");
if (attribute.IsArray)
WordApp.Selection.TypeText("array ");
if (attribute.IsReadOnly)
WordApp.Selection.TypeText("read-only ");
// Put paragraph breaks after each attribute
WordApp.Selection.TypeParagraph();
WordApp.Selection.TypeParagraph();
}

The routine for extracting information from the operations of the class looks very similar. Below is the routine for extracting operation information from WithClass into Microsoft Word.

Listing 4 - Writing the Operations to Microsoft Word

public void WriteOperation(Word.Document aDoc, With_Class.Operation operation)
{
// Write the Operation name out to Microsoft Word in Italics
WordApp.Selection.TypeText("Operation Name:\t ");
WordApp.Selection.Font.Italic = (int)Word.WdConstants.wdToggle;
WordApp.Selection.TypeText(operation.Name + "\n");
// Write out a few operation properties such as Return Type and Visibility
WordApp.Selection.Font.Italic = (int)Word.WdConstants.wdToggle;
WordApp.Selection.TypeText("Return Type:\t " + operation.ReturnType + "\n");
WordApp.Selection.TypeText("Modifier:\t " + operation.Visibility + "\n");
WordApp.Selection.TypeText("Additional Properties:\t");
// Write some of the operation special modifiers such as static, abstract, and virtual
if (operation.IsStatic)
WordApp.Selection.TypeText("static ");
if (operation.IsVirtual)
WordApp.Selection.TypeText("virtual ");
if (operation.IsAbstract)
WordApp.Selection.TypeText("abstract ");
// Linebreak
WordApp.Selection.TypeParagraph();
// Loop through each operation parameter and type them all on a line in Microsoft Word
operation.Parameters.Restart();
WordApp.Selection.TypeText("Parameters:\t");
while (operation.Parameters.IsLast() == false)
{
With_Class.Parameter p = operation.Parameters.GetNext();
WordApp.Selection.TypeText(p.Name + ":" + p.Type + " ");
}
// Leave a space for the next operation
WordApp.Selection.TypeParagraph();
WordApp.Selection.TypeParagraph();
}

Conclusion

You may also note that you could probably extract most of this information directly from reflection, but I suspect extracting object-oriented data using WithClass may be a bit less code and less complicated once you understand WithClass's COM structure. These same techniques for creating class reports using WithClass can also be extended to creating reports for State Charts and Interaction Diagrams.

What's great about .NET and C#, is COM structures present in Applications such as Word, WithClass, or Excel, look and act like C# classes so you no longer have to distinguish them in your head as being "special" COM objects. The fact that the COM architecture is hidden from you in this case is a good thing.