Comment extraire du texte à partir des documents MS office en C#

Pour Microsoft Word 2007 et Microsoft Word 2010 (.docx) de fichiers, vous pouvez utiliser le SDK Open XML. Cet extrait de code va ouvrir un document et le retourner à son contenu sous forme de texte. Il est particulièrement utile pour ceux qui cherchent à utiliser des expressions régulières pour analyser le contenu d'un document Word. Pour utiliser cette solution, vous aurait besoin de référence DocumentFormat.OpenXml.dll qui fait partie du SDK OpenXML.

Voir: http://msdn.microsoft.com/en-us/library/bb448854.aspx

 public static string TextFromWord(SPFile file)
    {
        const string wordmlNamespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";

        StringBuilder textBuilder = new StringBuilder();
        using (WordprocessingDocument wdDoc = WordprocessingDocument.Open(file.OpenBinaryStream(), false))
        {
            //Manage namespaces to perform XPath queries.  
            NameTable nt = new NameTable();
            XmlNamespaceManager nsManager = new XmlNamespaceManager(nt);
            nsManager.AddNamespace("w", wordmlNamespace);

            //Get the document part from the package.  
            //Load the XML in the document part into an XmlDocument instance.  
            XmlDocument xdoc = new XmlDocument(nt);
            xdoc.Load(wdDoc.MainDocumentPart.GetStream());

            XmlNodeList paragraphNodes = xdoc.SelectNodes("//w:p", nsManager);
            foreach (XmlNode paragraphNode in paragraphNodes)
            {
                XmlNodeList textNodes = paragraphNode.SelectNodes(".//w:t", nsManager);
                foreach (System.Xml.XmlNode textNode in textNodes)
                {
                    textBuilder.Append(textNode.InnerText);
                }
                textBuilder.Append(Environment.NewLine);
            }

        }
        return textBuilder.ToString();
    }

Laissez-moi juste corriger un peu la réponse donnée par KyleM. J'ai juste ajouté de traitement de deux nœuds supplémentaires, ce qui influence le résultat: l'un est responsable de l'horizontale tabulation avec "\t", d'autres - pour la tabulation verticale avec "\v". Voici le code:

    public static string ReadAllTextFromDocx(FileInfo fileInfo)
    {
        StringBuilder stringBuilder;
        using(WordprocessingDocument wordprocessingDocument = WordprocessingDocument.Open(dataSourceFileInfo.FullName, false))
        {
            NameTable nameTable = new NameTable();
            XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(nameTable);
            xmlNamespaceManager.AddNamespace("w", "http://schemas.openxmlformats.org/wordprocessingml/2006/main");

            string wordprocessingDocumentText;
            using(StreamReader streamReader = new StreamReader(wordprocessingDocument.MainDocumentPart.GetStream()))
            {
                wordprocessingDocumentText = streamReader.ReadToEnd();
            }

            stringBuilder = new StringBuilder(wordprocessingDocumentText.Length);

            XmlDocument xmlDocument = new XmlDocument(nameTable);
            xmlDocument.LoadXml(wordprocessingDocumentText);

            XmlNodeList paragraphNodes = xmlDocument.SelectNodes("//w:p", xmlNamespaceManager);
            foreach(XmlNode paragraphNode in paragraphNodes)
            {
                XmlNodeList textNodes = paragraphNode.SelectNodes(".//w:t | .//w:tab | .//w:br", xmlNamespaceManager);
                foreach(XmlNode textNode in textNodes)
                {
                    switch(textNode.Name)
                    {
                        case "w:t":
                            stringBuilder.Append(textNode.InnerText);
                            break;

                        case "w:tab":
                            stringBuilder.Append("\t");
                            break;

                        case "w:br":
                            stringBuilder.Append("\v");
                            break;
                    }
                }

                stringBuilder.Append(Environment.NewLine);
            }
        }

        return stringBuilder.ToString();
    }

Un peu en retard à la fête, mais tout de même - aujourd'hui, vous n'avez pas besoin de télécharger quoi que ce soit - tout est déjà installé .NET:
(assurez-vous d'ajouter une référence à System.IO.La Compression et du Système.IO.La Compression.Système de fichiers)

using System;
using System.Linq;
using System.Xml.Linq;
using System.Xml.XPath;
using System.Xml;
using System.Text;
using System.IO.Compression;

public static class DocxTextExtractor
{
    public static string Extract(string filename)
    {
        XmlNamespaceManager NsMgr = new XmlNamespaceManager(new NameTable());
        NsMgr.AddNamespace("w", "http://schemas.openxmlformats.org/wordprocessingml/2006/main");

        using (var archive = ZipFile.OpenRead(filename))
        {
            return XDocument
                .Load(archive.GetEntry(@"word/document.xml").Open())
                .XPathSelectElements("//w:p", NsMgr)
                .Aggregate(new StringBuilder(), (sb, p) => p
                    .XPathSelectElements(".//w:t|.//w:tab|.//w:br", NsMgr)
                    .Select(e => { switch (e.Name.LocalName) { case "br": return "\v"; case "tab": return "\t"; } return e.Value; })
                    .Aggregate(sb, (sb1, v) => sb1.Append(v)))
                .ToString();
        }
    }
}

J'ai fait un docx texte extracteur une fois, et c'était très simple. Fondamentalement, docx, et de l'autre (nouveau) les formats que je présume, est un fichier zip avec un tas de fichiers XML à la place. Le texte peut être extraite à l'aide d'un XmlReader et en utilisant seulement .NET-classes.

Je n'ai pas le code de plus, il semble que :(, mais j'ai trouvé un gars qui ont un semblable solution.

Peut-être que ce n'est pas viable pour vous si vous avez besoin de lire .doc et .les fichiers xls si, puisqu'ils sont les formats binaires et probablement beaucoup plus difficile à analyser.

Il y a aussi le OpenXML SDK, toujours en CTP si, publié par Microsoft.