Brian Jones: Office Solutions https://docs.microsoft.com/archive/blogs/brian_jones/feed.xml I'm Brian Jones, the group program manager of the Office Solutions Framework team. Tue, 16 Apr 2019 04:49:13 GMT en-US hourly 1 The new app platform from a developer perspective https://docs.microsoft.com/archive/blogs/brian_jones/the-new-app-platform-from-a-developer-perspective Thu, 09 Aug 2012 21:15:46 GMT https://blogs.msdn.microsoft.com/brian_jones/2012/08/09/the-new-app-platform-from-a-developer-perspective/ On Monday, I posted on the Office Next blog about the experience from an end user perspective around apps for Office and SharePoint. Yesterday, I posted about it from the developer point of view. Tomorrow, I'll post from the IT/administrator point of view. Ultimately there are really three customers of this new model, and it's important to talk about it from all three points of view.

  • We had to make sure that the model was isolated so that end users could try out dozens of apps without degrading their overall experience. 
  • We had to make it so that developers could leverage their existing skills and easily connect to other existing services when building their apps. 
  • And we had to make sure administrators had the ability to easily push apps out to their users, and keep the overall system healthy and up to date.

If you are a developer, be sure to take a read through the post, and definitely check out dev.office.com

-Brian

]]> Announcing the app building contest https://docs.microsoft.com/archive/blogs/brian_jones/announcing-the-app-building-contest Thu, 09 Aug 2012 09:41:00 GMT https://blogs.msdn.microsoft.com/brian_jones/2012/08/09/announcing-the-app-building-contest/ Vivek announced a contest we're kicking off for people who are building apps for Office or SharePoint. Here's a link to the post: https://blogs.msdn.com/b/officeapps/archive/2012/08/07/game-on-win-big-prizes-in-the-app-contest.aspx

The short of it though is that there are some awesome prizes, and we're giving out a ton of them, so you have a high chance of winning (go to the contest page to get all the details):

Grand Prize (1 winner): The top judged app across all submissions will win
A) A $10,000 cash prize
B) App gets featured on the Office Store
C) App gets featured on the apps for Office Microsoft blog
D) Opportunity to meet with a Microsoft executive
E) 3 days of app consultation with a Microsoft Program Manager

First Prize (15 winners): The next 15 top judged apps (5 each per category: Office, SharePoint, and 3rd party APIs) will win
A) Xbox + Kinect
B) App gets featured on the Office Store
C) App gets featured on the apps for Office Microsoft blog

Second Prize (100 winners): The next 100 top judged apps will win a Microsoft Mouse or equivalent hardware

-Brian

 

]]> A look into the user experiences around apps for Office and SharePoint https://docs.microsoft.com/archive/blogs/brian_jones/a-look-into-the-user-experiences-around-apps-for-office-and-sharepoint Mon, 06 Aug 2012 18:31:40 GMT https://blogs.msdn.microsoft.com/brian_jones/2012/08/06/a-look-into-the-user-experiences-around-apps-for-office-and-sharepoint/ We're going to have a few posts this week up on the Office Next blog that drill into the new app model from three perspectives: the end user; the developer; and the administrator. This first post that goes into the end user experience is now live: https://blogs.office.com/b/office-next/archive/2012/08/06/introducing-apps-for-the-new-office-and-sharepoint-and-the-office-store.aspx

]]> Open XML SDK 2.5 is now available https://docs.microsoft.com/archive/blogs/brian_jones/open-xml-sdk-2-5-is-now-available Fri, 27 Jul 2012 08:50:40 GMT https://blogs.msdn.microsoft.com/brian_jones/2012/07/27/open-xml-sdk-2-5-is-now-available/ There is new a CTP available of the Open XML SDK version 2.5: https://www.microsoft.com/en-us/download/details.aspx?id=30425

As I mentioned in my post earlier this week, Open XML is an important piece of our overall application model for Office 365 solutions.

Here are a few of the things that are new in this version of the SDK:

  • New classes for file format extensions in Microsoft Office 2013 Preview
  • Built on .NET Framework 4.0
  • Reads the ISO Strict Format
  • Fixes to some of the bugs from 2.0 (e.g. whitespaces in .pptx document file)

Take a look!

-Brian

]]> New post up on the apps for Office blog https://docs.microsoft.com/archive/blogs/brian_jones/new-post-up-on-the-apps-for-office-blog Mon, 23 Jul 2012 08:47:43 GMT https://blogs.msdn.microsoft.com/brian_jones/2012/07/23/new-post-up-on-the-apps-for-office-blog/ I just posted on the apps for Office blog, giving some more background into the new model: https://blogs.msdn.com/b/officeapps/archive/2012/07/23/introducing-apps-for-the-new-office-and-sharepoint.aspx

]]> Test Message https://docs.microsoft.com/archive/blogs/brian_jones/test-message Tue, 10 Jul 2012 09:44:53 GMT https://blogs.msdn.microsoft.com/brian_jones/2012/07/10/test-message/ Test message... haven't used the blog in awhile, so want to make sure it still works! :-)

]]> Writing Large Excel Files with the Open XML SDK https://docs.microsoft.com/archive/blogs/brian_jones/writing-large-excel-files-with-the-open-xml-sdk Tue, 22 Jun 2010 09:37:49 GMT https://blogs.msdn.microsoft.com/brian_jones/2010/06/22/writing-large-excel-files-with-the-open-xml-sdk/ In my last post, I showed you guys how to use the Open XML SDK to read and parse large Excel files. Today, I am going to show you how to write large Excel files with the Open XML SDK. Like in the case of reading, the Open XML SDK provides two approaches for writing Open XML files: 1. using the DOM, 2. using the SAX-like writing capability. All of my examples on this blog have been around using the Open XML SDK DOM to write Open XML files. The DOM makes it easy because everything is strongly typed. Unfortunately, the DOM approach requires loading entire Open XML parts in memory, which can result in Out of Memory exceptions, especially when dealing with very large files. Let's compare the DOM and SAX-like approaches.

If you want to jump straight into the code, feel free to download the solution here.

Scenario

Imagine a scenario where I work for a financial company that deals with very large amounts of data. This data gets updated on a daily basis and is stored in a database. The company's analysts use Excel as a means of mining and understanding the data. To support the analysts' needs, the company needs to create and update Excel spreadsheets every morning. These spreadsheets typically grow to sizes exceeding hundreds of megabytes.

Solution

The scenario described above uses many of the general concepts described in a previous post on writing data from a database into an Excel file. Today, I will show you how to accomplish the scenario using both the DOM and SAX-like approaches. To accomplish the scenario we will need to take the following actions:

  1. Create an empty Spreadsheet template using Excel
  2. Open the template using the Open XML SDK
  3. Connect to the database that contains all the relevant data (for the sake of simplicity, this blog post will instead write random values to cells)
  4. Get the main workbook part
  5. Get the appropriate worksheet
  6. Get the sheetData element, which will contain the data for a given spreadsheet
  7. For the number of rows and columns that represent the dimensions of data to be inserted, add a new cell with appropriate data
  8. Append rows to the sheetData element
  9. Save and close

Step 1 – Setup the right template

As is the case for most of my blog posts, the easiest way to start any Open XML SDK solution is to create the right starting template. In this case, I am going to create a blank Excel spreadsheet with one sheet in Excel. The template will look like the following:

image

Open XML SDK DOM Approach

The SDK DOM approach is pretty straight forward. The method below will write random values to cells within a given set of dimensions specified by the number of rows and columns. The random values will be calculated by Excel using the RAND() formula, which is specified by the CellFormula class.

static void WriteRandomValuesDOM(string filename, int numRows, int numCols)
{
using (SpreadsheetDocument myDoc = SpreadsheetDocument.Open(filename, true))
{
WorkbookPart workbookPart = myDoc.WorkbookPart;
WorksheetPart worksheetPart = workbookPart.WorksheetParts.First();
 
SheetData sheetData = worksheetPart.Worksheet.Elements<SheetData>().First();
 
for (int row = 0; row < numRows; row++)
{
Row r = new Row();
for (int col = 0; col < numCols; col++)
{
Cell c = new Cell();
CellFormula f = new CellFormula();
f.CalculateCell = true;
f.Text = "RAND()";
c.Append(f);
CellValue v = new CellValue();
c.Append(v);
r.Append(c);
}
sheetData.Append(r);
}
}
}

The method above will definitely work for writing cell values within a worksheet. However, if the dimension specified is quite large then the program's memory footprint will also be quite large. In fact, you are left at the mercy of the garbage collector, which may result in the program throwing an Out of Memory exception.

Open XML SDK SAX-Like Approach

The OpenXmlReader and OpenXmlWriter can be used together to alleviate some of the performance and/or memory concerns when developing an Open XML solution. You can create an OpenXmlReader and an OpenXmlWriter object on an entire part without loading the part in memory. The OpenXmlReader class allows you to iterate the entire xml tree of a part one node at a time. Similarly, the OpenXmlWriter class allows you to write xml nodes within a part one node at a time.

In the case of this solution, we will need to read the original worksheet part and then update the worksheet with the appropriate data. We are going to use an OpenXmlReader object to read the original worksheet part and find the place in the file where we will add data. We are then going to use an OpenXmlWriter object to write values to the worksheet part. You may be tempted to create an OpenXmlReader object and an OpenXmlWriter object on the same part. I would recommend against using this strategy. Writing data to a part that you are reading using the OpenXmlReader and the OpenXmlWriter may result in the OpenXmlReader losing its place in the xml tree. Instead, you should create a temporary worksheet part where you can write values to using the OpenXmlWriter class. The following code creates an OpenXmlReader object and an OpenXmlWriter object for worksheet parts:

static void WriteRandomValuesSAX(string filename, int numRows, int numCols)
{
using (SpreadsheetDocument myDoc = SpreadsheetDocument.Open(filename, true))
{
WorkbookPart workbookPart = myDoc.WorkbookPart;
WorksheetPart worksheetPart = workbookPart.WorksheetParts.First();
string origninalSheetId = workbookPart.GetIdOfPart(worksheetPart);
 
WorksheetPart replacementPart =
workbookPart.AddNewPart<WorksheetPart>();
string replacementPartId = workbookPart.GetIdOfPart(replacementPart);
 
OpenXmlReader reader = OpenXmlReader.Create(worksheetPart);
OpenXmlWriter writer = OpenXmlWriter.Create(replacementPart);
 
...
}
}

Once we have the appropriate objects created, the next step is to write everything we read into the new worksheet part until we reach the SheetData object. Once we reach the SheetData object, we can start writing cell values within a given set of dimensions specified by the number of rows and columns. The following code accomplishes this task:

static void WriteRandomValuesSAX(string filename, int numRows, int numCols)
{
using (SpreadsheetDocument myDoc = SpreadsheetDocument.Open(filename, true))
{
...
 
Row r = new Row();
Cell c = new Cell();
CellFormula f = new CellFormula();
f.CalculateCell = true;
f.Text = "RAND()";
c.Append(f);
CellValue v = new CellValue();
c.Append(v);
 
while (reader.Read())
{
if (reader.ElementType == typeof(SheetData))
{
if (reader.IsEndElement)
continue;
writer.WriteStartElement(new SheetData());
 
for (int row = 0; row < numRows; row++)
{
writer.WriteStartElement(r);
for (int col = 0; col < numCols; col++)
{
writer.WriteElement(c);
}
writer.WriteEndElement();
}
 
writer.WriteEndElement();
}
else
{
if (reader.IsStartElement)
{
writer.WriteStartElement(reader);
}
else if (reader.IsEndElement)
{
writer.WriteEndElement();
}
}
}
 
...
}
}

Notice that the OpenXmlWriter class requires us to write both the start and end elements. Invoking the method WriteEndElement() off of the OpenXmlWriter class ensures that the appropriate start element is closed.

We're almost done. The last step is to close the reader and writer and replace the original worksheet part with the replacement part. Remember that the main workbook part contains the list of worksheets within the workbook, which means we need to update the xml contained in that part. The following code accomplishes these tasks:

static void WriteRandomValuesSAX(string filename, int numRows, int numCols)
{
using (SpreadsheetDocument myDoc = SpreadsheetDocument.Open(filename, true))
{
...
 
reader.Close();
writer.Close();
 
Sheet sheet = workbookPart.Workbook.Descendants<Sheet>()
.Where(s => s.Id.Value.Equals(origninalSheetId)).First();
sheet.Id.Value = replacementPartId;
workbookPart.DeletePart(worksheetPart);
}
}

Conclusion

This post gives you more insight into reading and writing large Open XML files, while avoiding performance or Out of Memory exceptions. Let me know if you guys have other Open XML SDK related post requests.

Zeyad Rajabi

]]> Parsing and Reading Large Excel Files with the Open XML SDK https://docs.microsoft.com/archive/blogs/brian_jones/parsing-and-reading-large-excel-files-with-the-open-xml-sdk Thu, 27 May 2010 13:03:43 GMT https://blogs.msdn.microsoft.com/brian_jones/2010/05/27/parsing-and-reading-large-excel-files-with-the-open-xml-sdk/ I want to thank you guys for leaving blog post requests. Today's post will focus on one of your requests: parsing and reading large Excel files with the Open XML SDK. The Open XML SDK provides two approaches for parsing Open XML files: 1. using the SDK DOM, 2. using the SAX-like reading/writing capabilities. The SDK DOM makes it easy to query and parse Open XML files due to strongly typed classes. Unfortunately, the DOM approach requires loading entire Open XML parts in memory, which can sometimes cause Out of Memory exceptions when dealing with really large files. The SAX-like reading/writing capability of the SDK provides a faster and less memory intensive approach. Let's compare the two approaches.

If you want to jump straight into the code, feel free to download the solution here.

Scenario

Imagine a scenario where I work for a financial company that deals with very large Excel spreadsheets. These spreadsheets are updated daily by analysts and can easily grow to sizes exceeding hundreds of megabytes. At the end of the day a solution is used to read and extract relevant data from every spreadsheet.

Here is a screenshot of an example workbook with millions of cells of data:

image

Solution

The scenario described above is pretty simple and involves many of the general concepts described in a previous post on reading data from Excel files. The main difference in today's post is that I will show you the solution using both the DOM and SAX-like approaches. To accomplish the scenario we will need to take the following actions:

  1. Open the workbook using the Open XML SDK
  2. Get the main workbook part
  3. Get the appropriate worksheet
  4. Read every cell value in the sheet

Open XML SDK DOM Approach

The SDK DOM approach is pretty straight forward. The method below will read every cell value for each row contained within the sheet data.

Note that code below works for cells that contain numeric values. Cells that contain other types of content will need a different type of solution.

static void ReadExcelFileDOM(string filename)
{
using (SpreadsheetDocument myDoc = SpreadsheetDocument.Open(filename, true))
{
WorkbookPart workbookPart = myDoc.WorkbookPart;
WorksheetPart worksheetPart = workbookPart.WorksheetParts.First();
SheetData sheetData =
worksheetPart.Worksheet.Elements<SheetData>().First();
foreach (Row r in sheetData.Elements<Row>())
{
foreach (Cell c in r.Elements<Cell>())
{
string text = c.CellValue.Text;
}
}
}
}

The method above will definitely work for reading cell values within a worksheet. However, if the worksheet is quite large then the program's memory footprint will also be quite large. In fact, you are left at the mercy of the garbage collector, which may result in the program throwing an Out of Memory exception.

Open XML SDK SAX-Like Approach

If you have performance and/or memory concerns when developing an Open XML solution then you should look into using the OpenXmlReader and OpenXmlWriter. In today's post I will cover how to use the OpenXmlReader. I'll try to cover the OpenXmlWriter in a future post.

The method below will read every cell value for each row contained within the sheet data using the SAX-like approach.

Note that code below works for cells that contain numeric values. Cells that contain other types of content will need a different type of solution.

static void ReadExcelFileSAX(string filename)
{
using (SpreadsheetDocument myDoc = SpreadsheetDocument.Open(filename, true))
{
WorkbookPart workbookPart = myDoc.WorkbookPart;
WorksheetPart worksheetPart = workbookPart.WorksheetParts.First();
 
OpenXmlReader reader = OpenXmlReader.Create(worksheetPart);
string text;
while (reader.Read())
{
if (reader.ElementType == typeof(CellValue))
{
text = reader.GetText();
}
}
}
}

The method above takes advantage of the OpenXmlReader class, which allows you to read an entire part without loading the part in memory. The Create method has the following signatures:

  • public static OpenXmlReader Create(OpenXmlElement openXmlElement);
  • public static OpenXmlReader Create(OpenXmlPart openXmlPart);
  • public static OpenXmlReader Create(Stream partStream);
  • public static OpenXmlReader Create(OpenXmlElement openXmlElement, bool readMiscNodes);
  • public static OpenXmlReader Create(OpenXmlPart openXmlPart, bool readMiscNodes);
  • public static OpenXmlReader Create(Stream partStream, bool readMiscNodes);

As you can see, the Create method allows you to read either a part or an xml subtree given a specific element. There are methods that allow you to skip miscellaneous nodes that are not associated with the Open XML format. Using the OpenXmlReader class allows you to iterate the entire xml tree one node at a time.

Conclusion

Hopefully, this post gives you more insight into reading large Open XML files, while avoiding performance or Out of Memory Exceptions. If you guys have other Open XML SDK related post requests, let me know.

Thanks,

Zeyad Rajabi

]]> Improvements Made to the Final Open XML SDK 2.0 compared to the December 2009 CTP https://docs.microsoft.com/archive/blogs/brian_jones/improvements-made-to-the-final-open-xml-sdk-2-0-compared-to-the-december-2009-ctp Mon, 03 May 2010 10:54:00 GMT https://blogs.msdn.microsoft.com/brian_jones/2010/05/03/improvements-made-to-the-final-open-xml-sdk-2-0-compared-to-the-december-2009-ctp/ In a previous post, where I announced the release of the Open XML SDK 2.0, I promised to give you guys a list of improvements and breaking changes made to the SDK compared to the December 2009 CTP.

We made a few tweaks to the SDK based on some of the great feedback we received from you guys. The following sections below outline these changes.

Autosave for Creating Documents

One of the changes we made to the SDK is around supporting autosave for document creation. Back in August 2009 we released a CTP that included autosave functionality when modifying parts within the Open XML package. This functionality allowed for changes to be automatically saved into the package, without the need to call Save() methods. We also provided a mechanism to turn off this functionality. This functionality worked great when opening existing files. However, we never added such functionality for newly created documents. That's what we added this time around for the final version of the SDK. Here are the new Create() methods:

  • public static WordprocessingDocument Create(Package package, WordprocessingDocumentType type, bool autoSave);
  • public static WordprocessingDocument Create(Stream stream, WordprocessingDocumentType type, bool autoSave);
  • public static WordprocessingDocument Create(string path, WordprocessingDocumentType type, bool autoSave);
  • public static SpreadsheetDocument Create(Package package, SpreadsheetDocumentType type, bool autoSave);
  • public static SpreadsheetDocument Create(Stream stream, SpreadsheetDocumentType type, bool autoSave);
  • public static SpreadsheetDocument Create(string path, SpreadsheetDocumentType type, bool autoSave);
  • public static PresentationDocument Create(Package package, PresentationDocumentType type, bool autoSave);
  • public static PresentationDocument Create(Stream stream, PresentationDocumentType type, bool autoSave);
  • public static PresentationDocument Create(string path, PresentationDocumentType type, bool autoSave);

Improved Namespace Processing

The older CTPs used a predefined mapping between the XML prefixes and the different namespaces. In other words, the SDK assumed a specific prefix for a specific namespace. For example, a WordprocessingML Paragraph would always write out the element <p> with the prefix w, such as <w:p>. The issue, that some of you brought up, is that the SDK didn't handle custom prefixes defined in XML fragments if those prefixes conflicted with the predefined list of prefixes of the SDK. With the final version of the SDK we fixed this issue. The final version of the SDK should be a lot more robust.

Breaking Changes in the Final Release of the Open XML SDK 2.0

The following table outlines changes made to Open XML SDK classes and attributes where there is a difference in the December 2009 CTP vs. the final RTW version of the Open XML SDK:

December 2009 CTP Class/Attribute Name

Final RTW SDK Class/Attribute Name

DocumentFormat.OpenXml.Spreadsheet.ObjectAnchor::Z_order

DocumentFormat.OpenXml.Spreadsheet.ObjectAnchor::ZOrder

DocumentFormat.OpenXml.AdditionalCharacteristics

DocumentFormat.OpenXml.AdditionalCharacteristicsInfo

DocumentFormat.OpenXml.Wordprocessing.Alias

DocumentFormat.OpenXml.Wordprocessing.SdtAlias

DocumentFormat.OpenXml.Wordprocessing.LatentStyleException

DocumentFormat.OpenXml.Wordprocessing.LatentStyleExceptionInfo

DocumentFormat.OpenXml.Drawing.Diagrams.Else

DocumentFormat.OpenXml.Drawing.Diagrams.DiagramChooseElse

DocumentFormat.OpenXml.Drawing.Diagrams.If

DocumentFormat.OpenXml.Drawing.Diagrams.DiagramChooseIf

DocumentFormat.OpenXml.Math.Function

DocumentFormat.OpenXml.Math.MathFunction

DocumentFormat.OpenXml.Vml.Handle

DocumentFormat.OpenXml.Vml.ShapeHandle

DocumentFormat.OpenXml.Vml.Handles

DocumentFormat.OpenXml.Vml.ShapeHandles

DocumentFormat.OpenXml.Office2010.Ink.Property

DocumentFormat.OpenXml.Office2010.Ink.ContextNodeProperty

DocumentFormat.OpenXml.CustomProperties.Property

DocumentFormat.OpenXml.CustomProperties.CustumDocumentProperty

DocumentFormat.OpenXml.Spreadsheet.Set

DocumentFormat.OpenXml.Spreadsheet.TupleSet

DocumentFormat.OpenXml.VariantTypes.VTOStream

DocumentFormat.OpenXml.VariantTypes.VTOStreamData

DocumentFormat.OpenXml.VariantTypes.VTStream

DocumentFormat.OpenXml.VariantTypes.VTStreamData

DocumentFormat.OpenXml.VariantTypes.VTVStream

DocumentFormat.OpenXml.VariantTypes.VTVStreamData

DocumentFormat.OpenXml.CustomProperties.CustumDocumentProperty

DocumentFormat.OpenXml.CustomProperties.CustomDocumentProperty

Note: The change from Alias to SdtAlias will affect the most people.

Zeyad Rajabi

]]> Zeyad Rajabi’s Open XML SDK Blog Map https://docs.microsoft.com/archive/blogs/brian_jones/zeyad-rajabis-open-xml-sdk-blog-map Tue, 06 Apr 2010 10:38:00 GMT https://blogs.msdn.microsoft.com/brian_jones/2010/04/06/zeyad-rajabis-open-xml-sdk-blog-map/ This post will represent the most up-to-date blog map for topics on the Open XML SDK.

Open XML SDK Basics

Topic

Description

Open XML SDK… the Basics

Learn about classes of the SDK and their first class properties. This post is a great introduction to the Open XML SDK.

Traversing in the Open XML DOM

Learn the basic techniques of traversing in the Open XML DOM tree using the Open XML SDK.

Open XML SDK Code Snippets

Learn how to leverage the Open XML SDK code snippets to create rich solutions.

Finding Open XML Errors with Open XML SDK Validation

Learn how to use the Open XML SDK to validate your Open XML files.

Open XML SDK Productivity Tool

Learn how to use the Open XML SDK Productivity Tool. This tool is the easiest way to learn about the Open XML file formats and the Open XML SDK.

Word

Topic

Description

The Easy Way to Assemble Multiple Documents

Learn how to leverage altChunks to easily create a robust document assembly solution in less than a thirty lines of code.

Taking Advantage of Bound Content Controls

Learn how to leverage bound content controls to bind to custom XML.

Pushing Data from a Database into a Word Document

Learn how to build a repeating table within WordprocessingML based on data within a database.

Removing Comments from a Wordprocessing Document Programmatically

Learn how to remove comments from a Word document.

Retrieving Word Content Based on Styles

Learn how to retrieve content in a document based on style information.

Removing Page and Section Breaks from a Word Document

Learn how to remove page and section breaks in a Word document.

Excel

Topic

Description

Document Assembly Solution for SpreadsheetML

Learn how to populate a spreadsheet with data from a real SQL database and create a cool looking chart based on that data.

Read Data from SpreadsheetML

Learn how to read data from a spreadsheet and insert it into some data source, like a database.

Writing Semantically Aware LINQ Queries Against Excel Tables

Learn how to write a generic LINQ query that can work against any data source, including an Excel table.

How to Copy a Worksheet within a Workbook

Learn how to copy a worksheet within the same workbook.

Removing Comments from Excel and PowerPoint Files

Learn how to remove comments from an Excel workbook.

Read Large Excel Files using the Open XML SDK Learn how to use the SAX-like capabilities of the Open XML SDK to read very large Excel files.

PowerPoint

Topic

Description

Creating a Presentation Report Based on Data

Learn how to create a rich presentation report based on data from a database.

How to Assemble Multiple PowerPoint Decks

Learn how to merge multiple PowerPoint decks together.

Removing Comments from Excel and PowerPoint Files

Learn how to remove comments from a PowerPoint deck.

Adding Repeating Data to PowerPoint

Learn how to create repeating data within a table on a PowerPoint slide.

Multiple Applications (Word, Excel, and PowerPoint)

Topic

Description

Importing Charts from Spreadsheets to Wordprocessing Documents

Learn how to import a chart from a spreadsheet to a Word document.

Importing a Table from WordprocessingML to SpreadsheetML

Learn how to import a table from a Wordprocessing document into a spreadsheet.

Importing SmartArt from PowerPoint to Word

Learn how to import SmartArt from a PowerPoint deck into a Word document.

Embedding an Open XML File in another Open XML File

Learn how to embed Open XML files within other Open XML documents.

Embedding Any File Type, Like PDF, in an Open XML File

Learn how to embed any file within Open XML documents.

The Open XML SDK and Fluent UI Extensibility

Learn how to add custom UI to a set of documents within a directory.

Document Assembly: Merging Excel, PowerPoint, and Word Content Together

Learn how to take multiple Word, Excel and PowerPoint documents and merge them all together to form a final Word document.

Office Services

Topic

Description

Extending the Reach of Excel Services with the Open XML SDK

Learn how to extend the reach of Excel Services and hosted charts to gather data from within a library of Word documents.

Leveraging the Power of Word Automation Services and the Open XML SDK

Learn how to use Word Automation Services to update a table of contents of several documents have been merged with the Open XML SDK

Open XML SDK + Office Services: Better Together

Learn how to leverage all three components, the SDK and the two Office services, to create a very cool mash up document assembly solution

Presentations

 

Zeyad Rajabi

]]>