Interop word save as pdf

Use a foreach loop instead of a for loop — it solved my problem.

int j = 0;
foreach (Microsoft.Office.Interop.Word.Page p in pane.Pages)
{
    var bits = p.EnhMetaFileBits;
    var target = path1 +j.ToString()+  "_image.doc";
    try
    {
        using (var ms = new MemoryStream((byte[])(bits)))
        {
            var image = System.Drawing.Image.FromStream(ms);
            var pngTarget = Path.ChangeExtension(target, "png");
            image.Save(pngTarget, System.Drawing.Imaging.ImageFormat.Png);
        }
    }
    catch (System.Exception ex)
    {
        MessageBox.Show(ex.Message);  
    }
    j++;
}

Here is a modification of a program that worked for me. It uses Word 2007 with the Save As PDF add-in installed. It searches a directory for .doc files, opens them in Word and then saves them as a PDF. Note that you’ll need to add a reference to Microsoft.Office.Interop.Word to the solution.

using Microsoft.Office.Interop.Word;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

...

// Create a new Microsoft Word application object
Microsoft.Office.Interop.Word.Application word = new Microsoft.Office.Interop.Word.Application();

// C# doesn't have optional arguments so we'll need a dummy value
object oMissing = System.Reflection.Missing.Value;

// Get list of Word files in specified directory
DirectoryInfo dirInfo = new DirectoryInfo(@"\serverfolder");
FileInfo[] wordFiles = dirInfo.GetFiles("*.doc");

word.Visible = false;
word.ScreenUpdating = false;

foreach (FileInfo wordFile in wordFiles)
{
    // Cast as Object for word Open method
    Object filename = (Object)wordFile.FullName;

    // Use the dummy value as a placeholder for optional arguments
    Document doc = word.Documents.Open(ref filename, ref oMissing,
        ref oMissing, ref oMissing, ref oMissing, ref oMissing, ref oMissing,
        ref oMissing, ref oMissing, ref oMissing, ref oMissing, ref oMissing,
        ref oMissing, ref oMissing, ref oMissing, ref oMissing);
    doc.Activate();

    object outputFileName = wordFile.FullName.Replace(".doc", ".pdf");
    object fileFormat = WdSaveFormat.wdFormatPDF;

    // Save document into PDF Format
    doc.SaveAs(ref outputFileName,
        ref fileFormat, ref oMissing, ref oMissing,
        ref oMissing, ref oMissing, ref oMissing, ref oMissing,
        ref oMissing, ref oMissing, ref oMissing, ref oMissing,
        ref oMissing, ref oMissing, ref oMissing, ref oMissing);

    // Close the Word document, but leave the Word application open.
    // doc has to be cast to type _Document so that it will find the
    // correct Close method.                
    object saveChanges = WdSaveOptions.wdDoNotSaveChanges;
    ((_Document)doc).Close(ref saveChanges, ref oMissing, ref oMissing);
    doc = null;
}

// word has to be cast to type _Application so that it will find
// the correct Quit method.
((_Application)word).Quit(ref oMissing, ref oMissing, ref oMissing);
word = null;

If you want to convert a document to PDF you can save it as PDF (File -> Export -> PDF). But what if you have a lot of documents you want to convert to PDF. Then the Office Interop Assemblies could help you. This blog explains how you could use the Office Interop Assemblies to convert Word, PowerPoint and Excel files to PDF.

Prerequisites:
– Microsoft Office needs to be installed
– Some dev skills

This is not something you would like to use on a large production environment. But if you are in need of a onetime solution this could be a solution. Always keep in mind that you backup your Office documents and check the results after converting.

Word

Add Assembly reference to project: Microsoft.Office.Interop.Word

Code:

var wordApp = new Microsoft.Office.Interop.Word.Application();
var wordDocument = wordApp.Documents.Open(@"C:WordDocument.docx");
           
wordDocument.ExportAsFixedFormat(@"C:NewPDFFile.PDF", Microsoft.Office.Interop.Word.WdExportFormat.wdExportFormatPDF);

wordDocument.Close(Microsoft.Office.Interop.Word.WdSaveOptions.wdDoNotSaveChanges, 
                   Microsoft.Office.Interop.Word.WdOriginalFormat.wdOriginalDocumentFormat, 
                   false); //Close document

wordApp.Quit(); //Important: When you forget this Word keeps running in the background

PowerPoint

Add Assembly reference to project: Microsoft.Office.Interop.PowerPoint

Code:

var powerpointApp = new Microsoft.Office.Interop.PowerPoint.Application();

var powerpointDocument = powerpointApp.Presentations.Open(@"C:PowerPoint.pptx", 
                Microsoft.Office.Core.MsoTriState.msoTrue, //ReadOnly
                Microsoft.Office.Core.MsoTriState.msoFalse, //Untitled
                Microsoft.Office.Core.MsoTriState.msoFalse); //Window not visible during converting
           
powerpointDocument.ExportAsFixedFormat(@"C:NewPDFFile.pdf", 
                Microsoft.Office.Interop.PowerPoint.PpFixedFormatType.ppFixedFormatTypePDF);

powerpointDocument.Close(); //Close document
powerpointApp.Quit(); //Important: When you forget this PowerPoint keeps running in the background

Excel

Add assembly reference to project: Microsoft.Office.Interop.Excel

Code:

var excelApp = new Microsoft.Office.Interop.Excel.Application();

var excelDocument = excelApp.Workbooks.Open(@"C:ExcelDocument.xlsx");

excelDocument.ExportAsFixedFormat(Microsoft.Office.Interop.Excel.XlFixedFormatType.xlTypePDF, 
                                  @"C:NewPDFFile.pdf"); 

excelDocument.Close(false, "", false); //Close document
excelApp.Quit(); //Important: When you forget this Excel keeps running in the background

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using Microsoft.Office.Interop.Word;

public partial class Default2 : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        Microsoft.Office.Interop.Word.Application appWord = new Microsoft.Office.Interop.Word.Application();
        wordDocument = appWord.Documents.Open(@"D:desktopxxxxxx.docx");
        wordDocument.ExportAsFixedFormat(@"D:desktopDocTo.pdf", WdExportFormat.wdExportFormatPDF);
    }

    public Microsoft.Office.Interop.Word.Document wordDocument { get; set; }
}

try this code… working successfully…

If you have used newer versions of MS Office, you might have noticed that we can save a Word document or Excel sheet as PDF. This is a useful feature. But how can we do this programmatically?

This post shows how to convert a Word document to PDF grammatically using C#.

To work with Word files, we need to add reference to Microsoft.Office.Interop.Word.dll first. Install it with the following command or you can also get it from NuGet.

Install-Package Microsoft.Office.Interop.Word -Version 15.0.4797.1003

Next, add required namespaces:

using Microsoft.Office.Interop.Word;

Convert Word to PDF

Here’s a small program that converts a Word file to PDF.

using Microsoft.Office.Interop.Word;
using System;

namespace ConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Converting...");
            Application app = new Application();
            Document doc = app.Documents.Open(@"D:/test.docx");
            doc.SaveAs2(@"D:/test.pdf", WdSaveFormat.wdFormatPDF);
            doc.Close();
            app.Quit();
            Console.WriteLine("Completed");
        }
    }
}

Please note that a new WINWORD.exe process is started each time when you run the code. This will eat up all the memory if the Close() method is not called.

This package offers several other features also. For example, we can count the number of characters or grammatical errors in a word file.

Count the number of characters:

var c = doc.Characters;
Console.Write(c.Count);

Count grammatical errors:

var e = doc.GrammaticalErrors;
Console.WriteLine(e.Count);

Note: Like Word files, we can also convert Excel sheets and PPT files to PDF by adding appropriate packages.

Who never had the urge to convert one or more MS Word DOC and DOCX files into a PDF at least once? Truth to be told, it wasn’t that trivial back in the day: until the release of Office 2010, when the PDF extension appeared among the various  formats supported by the Save As… command, using Ghostscript-based software or installing PDF printer drivers was the only way to go.

After Office 2010 the problem was finally solved even for the average user, with the sole exception that he still has to have MS Office installed on his machine. Those who didn’t have it can continue to use the aforementioned free alternatives ond purchase a software that will take care of the job for them.

What about doing that in a programmatic approach? What if we are developing a C# application and we need to convert some DOC or DOCX files into PDF, thus making then available to download without giving the source document to the users, possibly without having to waste an Office license to our web server/web publishing machine?

The answer, still MS-branded, comes by the name of Microsoft Office primary interop assemblies (PIAs), aka Microsoft Office Interop. Specifically, to work with Word files, you’re going to need the Microsoft.Office.Interop.Word.dll. If you’re using Visual Studio, you can get it from NuGet and attach to your application using the Package Explorer, otherwise you will have to download and install the official distribution package.

As soon as you do that, you’ll be able to open and edit any MS Word document from the FileSystem or from a Byte Array, as explained in this post. Here’s a brief example showing what you can do:

Alternatively, if you don’t like the SaveAs2 method, you can use the ExportAsFixedFormat() method instead and achieve a nearly identical result:

It’s worth noting that everything we said about MS Word can also be done with the other software contained within the MS Office bundle such as MS Excel, MS Powerpoint and more.

IMPORTANT: Do not underestimate the call to

app.Quit()

! If you don’t do that, the MS Word instance will be left open on your server (see this thread on StackOverflow for more info on that issue). If you want to be sure to avoid such dreadful scenario entirely you should strengthen the given implementation adding a try/catch fallback strategy such as the follow:

Unfortunately these objects don’t implement

IDisposable

, otherwise it would’ve been even easier.

That’s about it: happy converting!

UPDATE: in case you run into DCOM issues and/or permission errors when publishing your web application project based upon the Microsoft.Office.Interop package into a Windows Server + IIS production machine, read this post to fix them!

Recently, I had a great interest in how to convert Office documents to PDF or XPS. Therefore, I collected lots of materials. Now, I want to share a method I think is useful.

First, Office SaveAs PDF and XPS (an Add-in for Office 2007) needs to be installed. You can download it from the Microsoft official website.

Then, open VS. Take VS 2005 as an example. Create a new Windows application project and add the following COM components as references.

Microsoft Word 12.0 Object Library
Microsoft PowerPoint 12.0 Object Library
Microsoft Excel 12.0 Object Library

using Word = Microsoft.Office.Interop.Word;
using Excel = Microsoft.Office.Interop.Excel;
using PowerPoint = Microsoft.Office.Interop.PowerPoint;
using Microsoft.Office.Core;

Word.WdExportFormat wd = Microsoft.Office.Interop.Word.WdExportFormat.wdExportFormatPDF;
Excel.XlFixedFormatType excelType = Microsoft.Office.Interop.Excel.XlFixedFormatType.xlTypePDF;
PowerPoint.PpSaveAsFileType ppType = Microsoft.Office.Interop.PowerPoint.PpSaveAsFileType.ppSaveAsPDF;

private bool Convert(string sourcePath, string targetPath, Word.WdExportFormat exportFormat)
{
    bool result;
    object paramMissing = Type.Missing;
    Word.ApplicationClass wordApplication = new Word.ApplicationClass();
    Word.Document wordDocument = null;
    try
    {
         object paramSourceDocPath = sourcePath;
         string paramExportFilePath = targetPath;
         Word.WdExportFormat paramExportFormat = exportFormat;
         bool paramOpenAfterExport = false;
         Word.WdExportOptimizeFor paramExportOptimizeFor =
         Word.WdExportOptimizeFor.wdExportOptimizeForPrint;
         Word.WdExportRange paramExportRange = Word.WdExportRange.wdExportAllDocument;
          int paramStartPage = 0;
          int paramEndPage = 0;
          Word.WdExportItem paramExportItem = Word.WdExportItem.wdExportDocumentContent;
          bool paramIncludeDocProps = true;
          bool paramKeepIRM = true;
          Word.WdExportCreateBookmarks paramCreateBookmarks =
          Word.WdExportCreateBookmarks.wdExportCreateWordBookmarks;
          bool paramDocStructureTags = true;
          bool paramBitmapMissingFonts = true;
          bool paramUseISO19005_1 = false;
          wordDocument = wordApplication.Documents.Open(
                                 ref paramSourceDocPath, ref paramMissing, ref paramMissing,
                                 ref paramMissing, ref paramMissing, ref paramMissing,
                                 ref paramMissing, ref paramMissing, ref paramMissing,
                                 ref paramMissing, ref paramMissing, ref paramMissing,
                                 ref paramMissing, ref paramMissing, ref paramMissing,
                                 ref paramMissing);

          if (wordDocument != null)
              wordDocument.ExportAsFixedFormat(paramExportFilePath,
              paramExportFormat, paramOpenAfterExport,
              paramExportOptimizeFor, paramExportRange, paramStartPage,
              paramEndPage, paramExportItem, paramIncludeDocProps,
              paramKeepIRM, paramCreateBookmarks, paramDocStructureTags,
              paramBitmapMissingFonts, paramUseISO19005_1,
              ref paramMissing);
              result = true;
    }
    finally
    {
        if (wordDocument != null)
        {
            wordDocument.Close(ref paramMissing, ref paramMissing, ref paramMissing);
            wordDocument = null;
        }
        if (wordApplication != null)
        {
            wordApplication.Quit(ref paramMissing, ref paramMissing, ref paramMissing);
            wordApplication = null;
        }
        GC.Collect();
        GC.WaitForPendingFinalizers();
        GC.Collect();
        GC.WaitForPendingFinalizers();
    }
    return result;
}

private bool Convert(string sourcePath, string targetPath, XlFixedFormatType targetType)
{
    bool result;
    object missing = Type.Missing;
    ApplicationClass application = null;
    Workbook workBook = null;
    try
    {
        application = new ApplicationClass();
        object target = targetPath;
        object type = targetType;
        workBook = application.Workbooks.Open(sourcePath, missing, missing, missing, missing, missing,
                           missing, missing, missing, missing, missing, missing, missing, missing, missing);
        workBook.ExportAsFixedFormat(targetType, target, XlFixedFormatQuality.xlQualityStandard, true, false, missing, missing, missing, missing);
        result = true;
    }
    catch
    {
        result = false;
    }
    finally
    {
        if (workBook != null)
        {
            workBook.Close(true, missing, missing);
            workBook = null;
        }
        if (application != null)
        {
            application.Quit();
            application = null;
        }
        GC.Collect();
        GC.WaitForPendingFinalizers();
        GC.Collect();
        GC.WaitForPendingFinalizers();
    }
    return result;

}

By the way, I found a Free PDF Converter which can convert office files to PDF. That Free PDF Converter is also created via C#.

Convert PowerPoint to PDF

private bool Convert(string sourcePath, string targetPath, PpSaveAsFileType targetFileType)
{
        bool result;
        object missing = Type.Missing;
        ApplicationClass application = null;
        Presentation persentation = null;
        try
        {
                application = new ApplicationClass();
                persentation = application.Presentations.Open(sourcePath, MsoTriState.msoTrue, MsoTriState.msoFalse, MsoTriState.msoFalse);
                persentation.SaveAs(targetPath, targetFileType, Microsoft.Office.Core.MsoTriState.msoTrue);

                result = true;
        }
        catch
        {
                result = false;
        }
        finally
        {
                if (persentation != null)
                {
                        persentation.Close();
                        persentation = null;
                }
                if (application != null)
                {
                        application.Quit();
                        application = null;
                }
                GC.Collect();
                GC.WaitForPendingFinalizers();
                GC.Collect();
                GC.WaitForPendingFinalizers();
        }
        return result;
}

If we want to convert Word or Excel to XPS, we can use XPS virtual printer. After installing .Net Framework 3.5, the XPS virtual printer will be installed by default. And we set it as the default printer.

Microsoft XPS Document Writer

Word to XPS

public void PrintWord(string wordfile)
{
        oWord.ApplicationClass word = new oWord.ApplicationClass();
        Type wordType = word.GetType();

        //Open Word Document

        oWord.Documents docs = word.Documents;
        Type docsType = docs.GetType();
        object objDocName = wordfile;
        oWord.Document doc = (oWord.Document)docsType.InvokeMember("Open", System.Reflection.BindingFlags.InvokeMethod, null, docs, new Object[] { objDocName, true, true });

        //Print and Export to Specified File
        //Use doc.PrintOut(); method. But it is complicated to call the parameters. Suggest to use Type.InvokeMember. We just set four main parameters to call PrintOut.

        Type docType = doc.GetType();
        object printFileName = wordfile + ".xps";
        docType.InvokeMember("PrintOut", System.Reflection.BindingFlags.InvokeMethod, null, doc, new object[] { false, false, oWord.WdPrintOutRange.wdPrintAllDocument, printFileName });

        //Quit Word
        wordType.InvokeMember("Quit", System.Reflection.BindingFlags.InvokeMethod, null, word, null);
}

Excel to XPS

public void PrintExcel(string execlfile)
{
        Excel.ApplicationClass eapp = new Excel.ApplicationClass();
        Type eType = eapp.GetType();
        Excel.Workbooks Ewb = eapp.Workbooks;
        Type elType = Ewb.GetType();
        object objelName = execlfile;
        Excel.Workbook ebook = (Excel.Workbook)elType.InvokeMember("Open", System.Reflection.BindingFlags.InvokeMethod, null, Ewb, new Object[] { objelName, true, true });

        object printFileName = execlfile + ".xps";

        Object oMissing = System.Reflection.Missing.Value;
        ebook.PrintOut(oMissing, oMissing, oMissing, oMissing, oMissing, true, oMissing, printFileName);

        eType.InvokeMember("Quit", System.Reflection.BindingFlags.InvokeMethod, null, eapp, null);
}

In the same manner, if a PDF virtual printer is installed on the computer, for example, 5D PDF, we can set it as the default printer to convert other formats to PDF.

Also, we can put the methods in a Windows Service to do background conversion of documents.