Come posso incorporare qualsiasi tipo di file in Microsoft Word utilizzando OpenXml 2.0

Question

Ho passato molto tempo a cercare di capire un buon modo per incorporare qualsiasi file in Microsoft Word utilizzando OpenXml 2.0; I documenti di Office sono abbastanza semplici, ma per quanto riguarda altri tipi di file come PDF, TXT, GIF, JPG, HTML, ecc.

Qual è un buon modo per farlo funzionare per qualsiasi tipo di file, in C#?

Answer 1

incorporare oggetti esteri (PDF, TXT, GIF, ecc ...) in Microsoft Word utilizzando OpenXml 2.0 (Beh, in collaborazione con COM)

Ho un sacco da questo sito, ecco ho chiesto e ho risposto alla mia stessa domanda per ridare un po 'su un argomento in cui ho avuto difficoltà a trovare risposte, spero che aiuti le persone.

Ci sono diversi esempi là fuori che mostrano come incorporare un documento di Office in un altro documento di Office usando OpenXml 2.0, ciò che non è là fuori e facilmente comprensibile è come incorporare praticamente qualsiasi file in e Office Document.

Ho imparato molto dal codice di altre persone, quindi questo è il mio tentativo di contribuire. Poiché sto già utilizzando OpenXml per generare documenti e ho bisogno di incorporare altri file in Word, ho deciso di utilizzare una collaborazione di OpenXml e COM (dll di Microsoft Office 2007) per raggiungere il mio obiettivo. Se sei come me, "invocare l'applicazione server OLE per creare un IStorage" non significa molto per te.

In questo esempio mi piacerebbe mostrare come utilizzo COM per PROGRAMMARE ottenere le informazioni sui dati binari OLE del file allegato, e quindi come ho usato quelle informazioni nel mio documento OpenXml. Fondamentalmente, sto programmaticamente guardando il Document Reflector di OpenXml 2.0 per ottenere le informazioni di cui ho bisogno.

mio codice qui sotto è suddiviso in diverse classi, ma qui è uno schema di quello che sto facendo:

1. Crea un OpenXml WordProcessingDocument, ottenere lo System.IO.FileInfo per il file che si desidera Incorpora
2. creare un oggetto OpenXmlEmbeddedObject personalizzato (questo è quello che contiene tutti i dati binari)
3. utilizzare i dati binari dal passaggio precedente per creare dati e immagine flussi
4. utilizzare tali flussi come l'oggetto file e file di immagine per il tuo OpenXml Documento

So che c'è un sacco di codice, e non molte spiegazioni ... Speriamo che è facile da seguire e sarà aiutare le persone 

Requisiti: • DocumentFormat.OpenXml dll (OpenXml 2.0) • DLL WindowsBase • Microsoft.Office.Interop.dll Word (Office 2007 - Versione 12)

• Questa la classe principale che inizia tutto, si apre una WordProcessingDocument e la classe di avere il file allegato

using DocumentFormat.OpenXml.Packaging; 
using System.IO; 
using DocumentFormat.OpenXml; 
using DocumentFormat.OpenXml.Wordprocessing; 

public class MyReport 
{ 
    private MainDocumentPart _mainDocumentPart; 

    public void CreateReport() 
    { 
     using (WordprocessingDocument wpDocument = WordprocessingDocument.Create(@"TempPath\MyReport.docx", WordprocessingDocumentType.Document)) 
     { 
      _mainDocumentPart = wpDocument.AddMainDocumentPart(); 
      _mainDocumentPart.Document = new Document(new Body()); 

      AttachFile(@"MyFilePath\MyFile.pdf", true); 
     } 
    } 

    private void AttachFile(string filePathAndName, bool displayAsIcon) 
    { 
     FileInfo fileInfo = new FileInfo(filePathAndName); 

     OpenXmlHelper.AppendEmbeddedObject(_mainDocumentPart, fileInfo, displayAsIcon); 
    } 
} 

• Questa classe in una classe di supporto OpenXml , detiene tutta la logica per incorporare un oggetto nel file OpenXml

using DocumentFormat.OpenXml; 
using DocumentFormat.OpenXml.Packaging; 
using DocumentFormat.OpenXml.Validation; 
using DocumentFormat.OpenXml.Wordprocessing; 
using OVML = DocumentFormat.OpenXml.Vml.Office; 
using V = DocumentFormat.OpenXml.Vml; 

public class OpenXmlHelper 
{ 
    /// <summary> 
    /// Appends an Embedded Object into the specified Main Document 
    /// </summary> 
    /// <param name="mainDocumentPart">The MainDocument Part of your OpenXml Word Doc</param> 
    /// <param name="fileInfo">The FileInfo object associated with the file being embedded</param> 
    /// <param name="displayAsIcon">Whether or not to display the embedded file as an Icon (Otherwise it will display a snapshot of the file)</param> 
    public static void AppendEmbeddedObject(MainDocumentPart mainDocumentPart, FileInfo fileInfo, bool displayAsIcon) 
    { 
     OpenXmlEmbeddedObject openXmlEmbeddedObject = new OpenXmlEmbeddedObject(fileInfo, displayAsIcon); 

     if (!String.IsNullOrEmpty(openXmlEmbeddedObject.OleObjectBinaryData)) 
     { 
      using (Stream dataStream = new MemoryStream(Convert.FromBase64String(openXmlEmbeddedObject.OleObjectBinaryData))) 
      { 
       if (!String.IsNullOrEmpty(openXmlEmbeddedObject.OleImageBinaryData)) 
       { 
        using (Stream emfStream = new MemoryStream(Convert.FromBase64String(openXmlEmbeddedObject.OleImageBinaryData))) 
        { 
         string imagePartId = GetUniqueXmlItemID(); 
         ImagePart imagePart = mainDocumentPart.AddImagePart(ImagePartType.Emf, imagePartId); 

         if (emfStream != null) 
         { 
          imagePart.FeedData(emfStream); 
         } 

         string embeddedPackagePartId = GetUniqueXmlItemID(); 

         if (dataStream != null) 
         { 
          if (openXmlEmbeddedObject.ObjectIsOfficeDocument) 
          { 
           EmbeddedPackagePart embeddedObjectPart = mainDocumentPart.AddNewPart<EmbeddedPackagePart>(
            openXmlEmbeddedObject.FileContentType, embeddedPackagePartId); 
           embeddedObjectPart.FeedData(dataStream); 
          } 
          else 
          { 
           EmbeddedObjectPart embeddedObjectPart = mainDocumentPart.AddNewPart<EmbeddedObjectPart>(
            openXmlEmbeddedObject.FileContentType, embeddedPackagePartId); 
           embeddedObjectPart.FeedData(dataStream); 
          } 
         } 

         if (!displayAsIcon && !openXmlEmbeddedObject.ObjectIsPicture) 
         { 
          Paragraph attachmentHeader = CreateParagraph(String.Format("Attachment: {0} (Double-Click to Open)", fileInfo.Name)); 
          mainDocumentPart.Document.Body.Append(attachmentHeader); 
         } 

         Paragraph embeddedObjectParagraph = GetEmbeededObjectParagraph(openXmlEmbeddedObject.FileType, 
          imagePartId, openXmlEmbeddedObject.OleImageStyle, embeddedPackagePartId); 

         mainDocumentPart.Document.Body.Append(embeddedObjectParagraph); 
        } 
       } 
      } 
     } 
    } 

    /// <summary> 
    /// Gets Paragraph that includes the embedded object 
    /// </summary> 
    private static Paragraph GetEmbeededObjectParagraph(string fileType, string imageID, string imageStyle, string embeddedPackageID) 
    { 
     EmbeddedObject embeddedObject = new EmbeddedObject(); 

     string shapeID = GetUniqueXmlItemID(); 
     V.Shape shape = new V.Shape() { Id = shapeID, Style = imageStyle }; 
     V.ImageData imageData = new V.ImageData() { Title = "", RelationshipId = imageID }; 

     shape.Append(imageData); 
     OVML.OleObject oleObject = new OVML.OleObject() 
     { 
      Type = OVML.OleValues.Embed, 
      ProgId = fileType, 
      ShapeId = shapeID, 
      DrawAspect = OVML.OleDrawAspectValues.Icon, 
      ObjectId = GetUniqueXmlItemID(), 
      Id = embeddedPackageID 
     }; 

     embeddedObject.Append(shape); 
     embeddedObject.Append(oleObject); 

     Paragraph paragraphImage = new Paragraph(); 

     Run runImage = new Run(embeddedObject); 
     paragraphImage.Append(runImage); 

     return paragraphImage; 
    } 

    /// <summary> 
    /// Gets a Unique ID for an XML Item, for reference purposes 
    /// </summary> 
    /// <returns>A GUID string with removed dashes</returns> 
    public static string GetUniqueXmlItemID() 
    { 
     return "r" + System.Guid.NewGuid().ToString().Replace("-", ""); 
    } 

    private static Paragraph CreateParagraph(string paragraphText) 
    { 
     Paragraph paragraph = new Paragraph(); 
     ParagraphProperties paragraphProperties = new ParagraphProperties(); 

     paragraphProperties.Append(new Justification() 
     { 
      Val = JustificationValues.Left 
     }); 

     paragraphProperties.Append(new SpacingBetweenLines() 
     { 
      After = Convert.ToString(100), 
      Line = Convert.ToString(100), 
      LineRule = LineSpacingRuleValues.AtLeast 
     }); 

     Run run = new Run(); 
     RunProperties runProperties = new RunProperties(); 

     Text text = new Text(); 

     if (!String.IsNullOrEmpty(paragraphText)) 
     { 
      text.Text = paragraphText; 
     } 

     run.Append(runProperties); 
     run.Append(text); 

     paragraph.Append(paragraphProperties); 
     paragraph.Append(run); 

     return paragraph; 
    } 

} 

• Questa è la parte più importante di questo processo, utilizza il server OLE interno di Microsoft, crea le informazioni Binary DATA e Binary EMF per un file. Tutto ciò che devi fare è chiamare il costruttore OpenXmlEmbeddedObject e tutto ciò di cui si è preso cura. Imiterà il processo che si verifica quando trascini manualmente qualsiasi file in Word; c'è una specie di conversione che si attiva quando lo fai, trasformando il file in un oggetto OLE, in modo che Microsoft possa riconoscere il file. o Le parti più importanti di questa classe sono le proprietà OleObjectBinaryData e OleImageBinaryData; contengono le informazioni binarie della stringa 64bit per i dati del file e l'immagine '.emf'. o Se si sceglie di non visualizzare il file come un'icona, i dati dell'immagine ".emf" creeranno un'istantanea del file, ad esempio la prima pagina del file pdf, in cui è ancora possibile fare doppio clic su aperto o Se si intende inserire un'immagine e sceglie di non visualizzare come un'icona, quindi le proprietà OleObjectBinaryData e OleImageBinaryData sarà la stessa

using System.Runtime.InteropServices; 
using System.Xml; 
using System.Diagnostics; 
using System.IO; 
using System.Drawing; 
using Microsoft.Office.Interop.Word; 

public class OpenXmlEmbeddedObject 
{ 
    #region Constants 

    private const string _defaultOleContentType = "application/vnd.openxmlformats-officedocument.oleObject"; 
    private const string _oleObjectDataTag = "application/vnd"; 
    private const string _oleImageDataTag = "image/x-emf"; 

    #endregion Constants 

    #region Member Variables 

    private static FileInfo _fileInfo; 
    private static string _filePathAndName; 
    private static bool _displayAsIcon; 
    private static bool _objectIsPicture; 

    private object _objectMissing = System.Reflection.Missing.Value; 
    private object _objectFalse = false; 
    private object _objectTrue = true; 

    #endregion Member Variables 

    #region Properties 

    /// <summary> 
    /// The File Type, as stored in Registry (Ex: a GIF Image = 'giffile') 
    /// </summary> 
    public string FileType 
    { 
     get 
     { 
      if (String.IsNullOrEmpty(_fileType) && _fileInfo != null) 
      { 
       _fileType = GetFileType(_fileInfo, false); 
      } 

      return _fileType; 
     } 
    } 
    private string _fileType; 

    /// <summary> 
    /// The File Context Type, as storered in Registry (Ex: a GIF Image = 'image/gif') 
    /// * Is converted into the 'Default Office Context Type' for non-office files 
    /// </summary> 
    public string FileContentType 
    { 
     get 
     { 
      if (String.IsNullOrEmpty(_fileContentType) && _fileInfo != null) 
      { 
       _fileContentType = GetFileContentType(_fileInfo); 

       if (!_fileContentType.Contains("officedocument")) 
       { 
        _fileContentType = _defaultOleContentType; 
       } 
      } 

      return _fileContentType; 
     } 
    } 
    private string _fileContentType; 

    /// <summary> 
    /// Gets the ContentType Text for the file 
    /// </summary> 
    public static string GetFileContentType(FileInfo fileInfo) 
    { 
     if (fileInfo == null) 
     { 
      throw new ArgumentNullException("fileInfo"); 
     } 

     string mime = "application/octetstream"; 

     string ext = System.IO.Path.GetExtension(fileInfo.Name).ToLower(); 

     Microsoft.Win32.RegistryKey rk = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(ext); 

     if (rk != null && rk.GetValue("Content Type") != null) 
     { 
      mime = rk.GetValue("Content Type").ToString(); 
     } 

     return mime; 
    } 

    public bool ObjectIsOfficeDocument 
    { 
     get { return FileContentType != _defaultOleContentType; } 
    } 

    public bool ObjectIsPicture 
    { 
     get { return _objectIsPicture; } 
    } 

    public string OleObjectBinaryData 
    { 
     get { return _oleObjectBinaryData; } 
     set { _oleObjectBinaryData = value; } 
    } 
    private string _oleObjectBinaryData; 

    public string OleImageBinaryData 
    { 
     get { return _oleImageBinaryData; } 
     set { _oleImageBinaryData = value; } 
    } 
    private string _oleImageBinaryData; 

    /// <summary> 
    /// The OpenXml information for the Word Application that is created (Make-Shoft Code Reflector) 
    /// </summary> 
    public string WordOpenXml 
    { 
     get { return _wordOpenXml; } 
     set { _wordOpenXml = value; } 
    } 
    private String _wordOpenXml; 

    /// <summary> 
    /// The XmlDocument that is created based on the OpenXml Data from WordOpenXml 
    /// </summary> 
    public XmlDocument OpenXmlDocument 
    { 
     get 
     { 
      if (_openXmlDocument == null && !String.IsNullOrEmpty(WordOpenXml)) 
      { 
       _openXmlDocument = new XmlDocument(); 
       _openXmlDocument.LoadXml(WordOpenXml); 
      } 

      return _openXmlDocument; 
     } 
    } 
    private XmlDocument _openXmlDocument; 

    /// <summary> 
    /// The XmlNodeList, for all Nodes containing 'binaryData' 
    /// </summary> 
    public XmlNodeList BinaryDataXmlNodesList 
    { 
     get 
     { 
      if (_binaryDataXmlNodesList == null && OpenXmlDocument != null) 
      { 
       _binaryDataXmlNodesList = OpenXmlDocument.GetElementsByTagName("pkg:binaryData"); 
      } 

      return _binaryDataXmlNodesList; 
     } 
    } 
    private XmlNodeList _binaryDataXmlNodesList; 

    /// <summary> 
    /// Icon Object for the file 
    /// </summary> 
    public Icon ObjectIcon 
    { 
     get 
     { 
      if (_objectIcon == null) 
      { 
       _objectIcon = Enterprise.Windows.Win32.Win32.GetLargeIcon(_filePathAndName); 
      } 

      return _objectIcon; 
     } 
    } 
    private Icon _objectIcon; 

    /// <summary> 
    /// File Name for the Icon being created 
    /// </summary> 
    public string ObjectIconFile 
    { 
     get 
     { 
      if (String.IsNullOrEmpty(_objectIconFile)) 
      { 
       _objectIconFile = String.Format("{0}.ico", _filePathAndName.Replace(".", "")); 
      } 

      return _objectIconFile; 
     } 
    } 
    private string _objectIconFile; 

    /// <summary> 
    /// Gets the original height and width of the emf file being created 
    /// </summary> 
    public string OleImageStyle 
    { 
     get 
     { 
      if (String.IsNullOrEmpty(_oleImageStyle) && !String.IsNullOrEmpty(WordOpenXml)) 
      { 
       XmlNodeList xmlNodeList = OpenXmlDocument.GetElementsByTagName("v:shape"); 
       if (xmlNodeList != null && xmlNodeList.Count > 0) 
       { 
        foreach (XmlAttribute attribute in xmlNodeList[0].Attributes) 
        { 
         if (attribute.Name == "style") 
         { 
          _oleImageStyle = attribute.Value; 
         } 
        } 
       } 
      } 

      return _oleImageStyle; 
     } 

     set { _oleImageStyle = value; } 
    } 
    private string _oleImageStyle; 

    #endregion Properties 

    #region Constructor 

    /// <summary> 
    /// Generates binary information for the file being passed in 
    /// </summary> 
    /// <param name="fileInfo">The FileInfo object for the file to be embedded</param> 
    /// <param name="displayAsIcon">Whether or not to display the file as an Icon (Otherwise it will show a snapshot view of the file)</param> 
    public OpenXmlEmbeddedObject(FileInfo fileInfo, bool displayAsIcon) 
    { 
     _fileInfo = fileInfo; 
     _filePathAndName = fileInfo.ToString(); 
     _displayAsIcon = displayAsIcon; 

     SetupOleFileInformation(); 
    } 

    #endregion Constructor 

    #region Methods 

    /// <summary> 
    /// Creates a temporary Word App in order to add an OLE Object, get's the OpenXML data from the file (similar to the Code Reflector info) 
    /// </summary> 
    private void SetupOleFileInformation() 
    { 
     Microsoft.Office.Interop.Word.Application wordApplication = new Microsoft.Office.Interop.Word.Application(); 

     Microsoft.Office.Interop.Word.Document wordDocument = wordApplication.Documents.Add(ref _objectMissing, ref _objectMissing, 
      ref _objectMissing, ref _objectMissing); 

     object iconObjectFileName = _objectMissing; 
     object objectClassType = FileType; 
     object objectFilename = _fileInfo.ToString(); 

     Microsoft.Office.Interop.Word.InlineShape inlineShape = null; 

     if (_displayAsIcon) 
     { 
      if (ObjectIcon != null) 
      { 
       using (FileStream iconStream = new FileStream(ObjectIconFile, FileMode.Create)) 
       { 
        ObjectIcon.Save(iconStream); 
        iconObjectFileName = ObjectIconFile; 
       } 
      } 

      object objectIconLabel = _fileInfo.Name; 

      inlineShape = wordDocument.InlineShapes.AddOLEObject(ref objectClassType, 
       ref objectFilename, ref _objectFalse, ref _objectTrue, ref iconObjectFileName, 
       ref _objectMissing, ref objectIconLabel, ref _objectMissing); 
     } 
     else 
     { 
      try 
      { 
       Image image = Image.FromFile(_fileInfo.ToString()); 
       _objectIsPicture = true; 
       OleImageStyle = String.Format("height:{0}pt;width:{1}pt", image.Height, image.Width); 

       wordDocument.InlineShapes.AddPicture(_fileInfo.ToString(), ref _objectMissing, ref _objectTrue, ref _objectMissing); 
      } 
      catch 
      { 
       inlineShape = wordDocument.InlineShapes.AddOLEObject(ref objectClassType, 
        ref objectFilename, ref _objectFalse, ref _objectFalse, ref _objectMissing, ref _objectMissing, 
        ref _objectMissing, ref _objectMissing); 
      } 
     } 

     WordOpenXml = wordDocument.Range(ref _objectMissing, ref _objectMissing).WordOpenXML; 

     if (_objectIsPicture) 
     { 
      OleObjectBinaryData = GetPictureBinaryData(); 
      OleImageBinaryData = GetPictureBinaryData(); 
     } 
     else 
     { 
      OleObjectBinaryData = GetOleBinaryData(_oleObjectDataTag); 
      OleImageBinaryData = GetOleBinaryData(_oleImageDataTag); 
     } 

     // Not sure why, but Excel seems to hang in the processes if you attach an Excel file… 
     // This kills the excel process that has been started < 15 seconds ago (so not to kill the user's other Excel processes that may be open) 
     if (FileType.StartsWith("Excel")) 
     { 
      Process[] processes = Process.GetProcessesByName("EXCEL"); 
      foreach (Process process in processes) 
      { 
       if (DateTime.Now.Subtract(process.StartTime).Seconds <= 15) 
       { 
        process.Kill(); 
        break; 
       } 
      } 
     } 

     wordDocument.Close(ref _objectFalse, ref _objectMissing, ref _objectMissing); 
     wordApplication.Quit(ref _objectMissing, ref _objectMissing, ref _objectMissing); 
    } 

    /// <summary> 
    /// Gets the binary data from the Xml File that is associated with the Tag passed in 
    /// </summary> 
    /// <param name="binaryDataXmlTag">the Tag to look for in the OpenXml</param> 
    /// <returns></returns> 
    private string GetOleBinaryData(string binaryDataXmlTag) 
    { 
     string binaryData = null; 
     if (BinaryDataXmlNodesList != null) 
     { 
      foreach (XmlNode xmlNode in BinaryDataXmlNodesList) 
      { 
       if (xmlNode.ParentNode != null) 
       { 
        foreach (XmlAttribute attr in xmlNode.ParentNode.Attributes) 
        { 
         if (String.IsNullOrEmpty(binaryData) && attr.Value.Contains(binaryDataXmlTag)) 
         { 
          binaryData = xmlNode.InnerText; 
          break; 
         } 
        } 
       } 
      } 
     } 

     return binaryData; 
    } 

    /// <summary> 
    /// Gets the image Binary data, if the file is an image 
    /// </summary> 
    /// <returns></returns> 
    private string GetPictureBinaryData() 
    { 
     string binaryData = null; 
     if (BinaryDataXmlNodesList != null) 
     { 
      foreach (XmlNode xmlNode in BinaryDataXmlNodesList) 
      { 
       binaryData = xmlNode.InnerText; 
       break; 
      } 
     } 

     return binaryData; 
    } 

    /// <summary> 
    /// Gets the file type description ("Application", "Text Document", etc.) for the file. 
    /// </summary> 
    /// <param name="fileInfo">FileInfo containing extention</param> 
    /// <returns>Type Description</returns> 
    public static string GetFileType(FileInfo fileInfo, bool returnDescription) 
    { 
     if (fileInfo == null) 
     { 
      throw new ArgumentNullException("fileInfo"); 
     } 

     string description = "File"; 
     if (string.IsNullOrEmpty(fileInfo.Extension)) 
     { 
      return description; 
     } 
     description = string.Format("{0} File", fileInfo.Extension.Substring(1).ToUpper()); 
     RegistryKey typeKey = Registry.ClassesRoot.OpenSubKey(fileInfo.Extension); 
     if (typeKey == null) 
     { 
      return description; 
     } 
     string type = Convert.ToString(typeKey.GetValue(string.Empty)); 
     RegistryKey key = Registry.ClassesRoot.OpenSubKey(type); 
     if (key == null) 
     { 
      return description; 
     } 

     if (returnDescription) 
     { 
      description = Convert.ToString(key.GetValue(string.Empty)); 
      return description; 
     } 
     else 
     { 
      return type; 
     } 
    } 

    #endregion Methods 
} 

Answer 2

la mia risposta here sarà dirà come fare questo, ma non mostra con l'SDK o una lingua specifica.

Answer 3

_objectIcon = Enterprise.Windows.Win32.Win32.GetLargeIcon(_filePathAndName); 

sembra essere rotto, ma

_objectIcon = System.Drawing.Icon.ExtractAssociatedIcon(_filePathAndName); 

dovrebbe anche funzionare.

Answer 4

Questa è una grande risposta e mi ha aiutato molto, ma il potenziale bug che bic utente menzionato esiste anche

in

OpenXmlEmbeddedObject(FileInfo fileInfo, bool displayAsIcon) 

alla linea 242,

_filePathAndName = fileInfo.ToString(); 

in

SetupOleFileInformation() 

alla linea 264,

object objectFilename = _fileInfo.ToString(); 

linea 289, e

Image image = Image.FromFile(_fileInfo.ToString()); 

linea 293

wordDocument.InlineShapes.AddPicture(_fileInfo.toString(), ref _objectMissing, ref _objectTrue, ref _objectMissing); 

Tutti questi devono essere "FullName" invece di "ToString()" se la il codice dovrebbe funzionare anche con percorsi relativi. Spero che questo aiuti chiunque voglia usare il codice di D Lyonnais!