C# Word document manipulation without MSO Word installed!

Hi there folks!
I didn't forget about the promise I made, blogging about .NET 4.0 and VS 2010 new and spicy features, but before that, I need to blog about an interesting experience on developing a MSO word solution.

For starters, the discovery was when I found the Open XML SDK that allows me to manipulate my Word document without having office installed on the server running my application, which is a major breakthrough!
The code I used to add custom properties was taken from MSDN and I show it to you here:

public bool WDSetCustomProperty(string docName, string propertyName, object propertyValue, PropertyTypes propertyType)
    {
      const string documentRelationshipType =
        "http://schemas.openxmlformats.org/officeDocument/" +
        "2006/relationships/officeDocument";
      const string customPropertiesRelationshipType =
        "http://schemas.openxmlformats.org/officeDocument/" +
        "2006/relationships/custom-properties";
      const string customPropertiesSchema =
        "http://schemas.openxmlformats.org/officeDocument/" +
        "2006/custom-properties";
      const string customVTypesSchema =
        "http://schemas.openxmlformats.org/officeDocument/" +
        "2006/docPropsVTypes";

      bool retVal = false;
      PackagePart documentPart = null;
      string propertyTypeName = "vt:lpwstr";
      string propertyValueString = null;

      //  Calculate the correct type.
      switch (propertyType)
      {
        case PropertyTypes.DateTime:
          propertyTypeName = "vt:filetime";
          //  Make sure you were passed a real date, 
          //  and if so, format in the correct way. The date/time 
          //  value passed in should represent a UTC date/time.
          if (propertyValue.GetType() == typeof(System.DateTime))
          {
            propertyValueString = string.Format("{0:s}Z",
              Convert.ToDateTime(propertyValue));
          }
          break;

        case PropertyTypes.NumberInteger:
          propertyTypeName = "vt:i4";
          if (propertyValue.GetType() == typeof(System.Int32))
          {
            propertyValueString =
              Convert.ToInt32(propertyValue).ToString();
          }
          break;

        case PropertyTypes.NumberDouble:
          propertyTypeName = "vt:r8";
          if (propertyValue.GetType() == typeof(System.Double))
          {
            propertyValueString =
              Convert.ToDouble(propertyValue).ToString();
          }
          break;

        case PropertyTypes.Text:
          propertyTypeName = "vt:lpwstr";
          propertyValueString = Convert.ToString(propertyValue);
          break;

        case PropertyTypes.YesNo:
          propertyTypeName = "vt:bool";
          if (propertyValue.GetType() == typeof(System.Boolean))
          {
            //  Must be lower case!
            propertyValueString =
              Convert.ToBoolean(propertyValue).ToString().ToLower();
          }
          break;
      }

      if (propertyValueString == null)
      {
        //  If the code cannot convert the 
        //  property to a valid value, throw an exception.
        throw new InvalidDataException("Invalid parameter value.");
      }

      using (Package wdPackage = Package.Open(
        docName, FileMode.Open, FileAccess.ReadWrite))
      {
        //  Get the main document part (document.xml).
        foreach (PackageRelationship relationship in
          wdPackage.GetRelationshipsByType(documentRelationshipType))
        {
          Uri documentUri = PackUriHelper.ResolvePartUri(
            new Uri("/", UriKind.Relative), relationship.TargetUri);
          documentPart = wdPackage.GetPart(documentUri);
          //  There is only one document.
          break;
        }

        //  Work with the custom properties part.
        PackagePart customPropsPart = null;

        //  Get the custom part (custom.xml). It may not exist.
        foreach (PackageRelationship relationship in
          wdPackage.GetRelationshipsByType(
          customPropertiesRelationshipType))
        {
          Uri documentUri = PackUriHelper.ResolvePartUri(
            new Uri("/", UriKind.Relative), relationship.TargetUri);
          customPropsPart = wdPackage.GetPart(documentUri);
          //  There is only one custom properties part, 
          // if it exists at all.
          break;
        }

        //  Manage namespaces to perform Xml XPath queries.
        NameTable nt = new NameTable();
        XmlNamespaceManager nsManager = new XmlNamespaceManager(nt);
        nsManager.AddNamespace("d", customPropertiesSchema);
        nsManager.AddNamespace("vt", customVTypesSchema);

        Uri customPropsUri =
          new Uri("/docProps/custom.xml", UriKind.Relative);
        XmlDocument customPropsDoc = null;
        XmlNode rootNode = null;

        if (customPropsPart == null)
        {
          customPropsDoc = new XmlDocument(nt);

          //  The part does not exist. Create it now.
          customPropsPart = wdPackage.CreatePart(
            customPropsUri, "application/vnd.openxmlformats-officedocument.custom-properties+xml");

          //  Set up the rudimentary custom part.
          rootNode = customPropsDoc.
            CreateElement("Properties", customPropertiesSchema);
          rootNode.Attributes.Append(
            customPropsDoc.CreateAttribute("xmlns:vt"));
          rootNode.Attributes["xmlns:vt"].Value = customVTypesSchema;

          customPropsDoc.AppendChild(rootNode);

          //  Create the document's relationship to the 
          //  new custom properties part.
          wdPackage.CreateRelationship(customPropsUri,
            TargetMode.Internal, customPropertiesRelationshipType);
        }
        else
        {
          //  Load the contents of the custom properties part 
          //  into an XML document.
          customPropsDoc = new XmlDocument(nt);
          customPropsDoc.Load(customPropsPart.GetStream());
          rootNode = customPropsDoc.DocumentElement;
        }

        string searchString =
          string.Format("d:Properties/d:property[@name='{0}']",
          propertyName);
        XmlNode node = customPropsDoc.SelectSingleNode(
          searchString, nsManager);

        XmlNode valueNode = null;

        if (node != null)
        {
          //  You found the node. Now check its type.
          if (node.HasChildNodes)
          {
            valueNode = node.ChildNodes[0];
            if (valueNode != null)
            {
              string typeName = valueNode.Name;
              if (propertyTypeName == typeName)
              {
                //  The types are the same. 
                //  Replace the value of the node.
                valueNode.InnerText = propertyValueString;
                //  If the property existed, and its type
                //  has not changed, you are finished.
                retVal = true;
              }
              else
              {
                //  Types are different. Delete the node
                //  and clear the node variable.
                node.ParentNode.RemoveChild(node);
                node = null;
              }
            }
          }
        }

        if (node == null)
        {
          string pidValue = "2";

          XmlNode propertiesNode = customPropsDoc.DocumentElement;
          if (propertiesNode.HasChildNodes)
          {
            XmlNode lastNode = propertiesNode.LastChild;
            if (lastNode != null)
            {
              XmlAttribute pidAttr = lastNode.Attributes["pid"];
              if (!(pidAttr == null))
              {
                pidValue = pidAttr.Value;
                //  Increment pidValue, so that the new property
                //  gets a pid value one higher. This value should be 
                //  numeric, but it never hurt so to confirm.
                int value = 0;
                if (int.TryParse(pidValue, out value))
                {
                  pidValue = Convert.ToString(value + 1);
                }
              }
            }
          }

          node = customPropsDoc.
            CreateElement("property", customPropertiesSchema);
          node.Attributes.Append(customPropsDoc.CreateAttribute("name"));
          node.Attributes["name"].Value = propertyName;

          node.Attributes.Append(customPropsDoc.CreateAttribute("fmtid"));
          node.Attributes["fmtid"].Value =
            "{D5CDD505-2E9C-101B-9397-08002B2CF9AE}";

          node.Attributes.Append(customPropsDoc.CreateAttribute("pid"));
          node.Attributes["pid"].Value = pidValue;

          valueNode = customPropsDoc.
            CreateElement(propertyTypeName, customVTypesSchema);
          valueNode.InnerText = propertyValueString;
          node.AppendChild(valueNode);
          rootNode.AppendChild(node);
          retVal = true;

        }

        //  Save the properties XML back to its part.
        customPropsDoc.Save(customPropsPart.
          GetStream(FileMode.Create, FileAccess.Write));

      }



      return retVal;
    }

The purpose of having this is to write some custom properties, for my Word Add-in to work properly, which is quite handy in most situations.

Hope this is as much value to you as it was to me!

Be back soon