Once the template is loaded the styles defined in the template can be used. As long as the styles are the default for the header and the paragraphs only the level needs to be defined.

Templates can also define custom styles. When the name of the style in the template is known the style can be used with the Document Generator library.
The style can be applied to paragraphs and headers

In this post I showed you how you can use a template when creating documents and how to use custom styles in the template.
In the next part I will show how you can replace content in documents using Content Controls.

To explain the library I decided to write a serie of articles and this is the first part. It will explain how to get started with the library.

Pre-requisites

The library is using OOXML SDK 2.5 for creating OOXML documents and this requires .Net Framework 4.0.

Installation

Document generator does not require any installation. Download the zip file with the latest version and extract the contents to a directory of choice. The zip file contains:

• DocumentGenerator.dll
• DocumentFormat.OpenXml.dll (This is the dll for the OOXML SDK 2.5)
• ICSharpCode.SharpZipLib.dll (This dll is required for creating ODF files)

Setup the project

1. Create a new console project in Visual Studio
2. Add a reference to the dll’s for the document generation:
   • DocumentGenerator.dll
   • DocumentFormat.OpenXml.dll
   • ICSharpCode.SharpZipLib.dll

 Generate Documents

1. The first step in generating a document is to create a Textdocument object. This is the container of the document to generate and is the same for OOXML and ODF documents. For OOXML documents it is also possible to start from a template (.dotx) or an existing document (.docx).
//Create a new text document
var document = TextDocument.Create();

//Create a new text document with a file name (including the file location)
//The Boolean indicates whether the file can be overridden if a file
//with the same name is found.
var document = TextDocument.Create("MyFilename", true);

//Create a new text document based on a template
var document = TextDocument.Create("MyFilename","myTemplate", true);

//Open an existing ooxml document.
var document = TextDocument.Open("MyFile");
2. When the text document is created headers and paragraphs can be added.
//Add a paragraph to the document. Level is an integer used for the style.
//of the paragraph, e.g. level "0" set style "Normal"
//and level "1" style "Normal1"
document.AddParagraph("The paragraph text", level);

//Add a paragraph and a header. Level is an integer is used for the style.
//E.g. level "1" applies "Header1" level "2" applies "Header2"
document.AddParagraph("The header","The paragraph text", level);

//Add only a header. Leaving the text for the paragraph empty
//will add only a header.
document.AddParagraph("The header",string.Empty, level);
3. Finally the document can be save in OOXML or ODF format.
//First set a filename (including the file location), if not already set
document.Filename = "MyFile";

//Save the document in OOXML format.
document.Save(DocumentType.OOXMLTextDocument);

//Save the document in ODF format.
document.Save(DocumentType.ODFTextDocument);

In this post I showed you how you can create a document, add contents to the document and save this document in either OOXML or ODF format.
I also showed how you can use a dotx template or an existing ooxml document to create new documents.

In the next post I will go through some more advanced features such as creating tables and lists and replace content in OOXML documents.
If you cannot wait for these posts you can have a look a the DocumentGeneratorTest project in Codeplex to see the use of these features.

For a project I am working on I am using the bitwise comparison extensively, so using the HasFlag method would make the code much more readable. Before using it I wanted to get some more information about how the HasFlag method works and I found this article. It shows the inner workings of the method, but also mentions that there is a performance cost to pay. However it does not mention what the cost is.

I therefor did my own test to see what the performance overhead would be and if it was worth to change.

The first part was to create an enumeration

public enum EnumValues

{

  Value1 = 1,

  Value2 = 2,

  ...,

  Value16 = 32768

}

Next I needed a class to evaluate the different comparison methods

public class EnumsClass

{

  public bool CheckEnum(EnumValues values)

  {

    bool isTrue = false;

    if ((values & EnumValues.Value8) == EnumValues.Value8) isTrue = true;

    return isTrue;

  }



  public bool CheckEnumWithFlagMethod(EnumValues values)

  {

    bool isTrue = false;

    if (values.HasFlag(EnumValues.Value8)) isTrue = true;

    return isTrue;

  }

}

The last part I needed was a class to call these two methods and determine how long each of the methods would take to run. I decided to use the unit test in Visual Studio 2012 as this also shows how long each test method takes.

[TestClass]

public class EnumTest

{

  private EnumsClass _enumsClass;



  [TestInitialize]

  public void Initialize()

  {

    _enumsClass = new EnumsClass();

  }



  [TestMethod]

  public void TestForFalseValueWithFlag()

  {

    Assert.IsFalse(_enumsClass.CheckEnumWithFlagMethod(EnumValues.Value1 | EnumValues.Value10));

  }



  [TestMethod]

  public void TestForFalseValue()

  {

    Assert.IsFalse(_enumsClass.CheckEnum(EnumValues.Value1 | EnumValues.Value10));

  }



  [TestMethod]

  public void TestForTrueValue()

  {

    Assert.IsTrue(_enumsClass.CheckEnum(EnumValues.Value8 | EnumValues.Value10));

  }



  [TestMethod]

  public void TestForTrueValueWithFlag()

  {

    Assert.IsTrue(_enumsClass.CheckEnumWithFlagMethod(EnumValues.Value8 | EnumValues.Value10));

  }

}

To make sure that there was no difference between a true and false result I used both methods in the EnumsClass to return both true and false. I also repeated the different calls multiple times in a foreach loop. The results are in the below.

So, there is an performance cost to using the HasFlag() method. It seems that the HasFlag() method is about 6 times as slow as the good old bitwise comparison. However you will notice the difference once you need to execute the call over 100000 times.
It is up to the programmer to see if the performance cost is worth the readability. I will stick to the bitwise comparison for now.

Because of my work most post will probably be about Visual Studio and C#, but we will see when time goes by.