Partager via

Utilisation du modèle objet de client géré SharePoint Foundation 2010 avec le kit de développement Open XML SDK 2.0

  • Article

Résumé :   Le modèle objet de client géré Microsoft SharePoint Foundation 2010 vous permet d’écrire des applications basées sur le Microsoft .NET Framework qui accèdent au contenu SharePoint à partir de clients, sans installer de code sur le serveur qui exécute SharePoint Foundation 2010. Le kit de développement Open XML SDK 2.0 for Microsoft Office vous permet d’écrire des applications pour créer, modifier et interroger des documents au format Open XML, le format par défaut des documents de Microsoft Office System 2007 et de Microsoft Office 2010. En utilisant ces deux technologies conjointement, vous pouvez écrire des applications côté client qui travaillent avec des documents au format Open XML stockés dans des bibliothèques de documents.

Dernière modification : vendredi 4 novembre 2011

S’applique à : Business Connectivity Services | Office 2010 | Open XML | SharePoint Designer 2010 | SharePoint Foundation 2010 | SharePoint Online | SharePoint Server 2010 | Visual Studio

Dans cet article
Vue d’ensemble
Extraire des documents de bibliothèques de documents
Modifier des documents dans des bibliothèques de documents
Télécharger des documents vers des bibliothèques de documents
Créer des documents en mémoire et les ajouter à des bibliothèques de documents
Traiter tous les documents d’une bibliothèque
Créer des documents de traitement de texte au format XML ouvert à partir de bibliothèques Wiki
Conclusion
Ressources supplémentaires

Auteur :  Eric White, Microsoft Corporation

Sommaire

  • Vue d’ensemble

  • Extraire des documents de bibliothèques de documents

  • Modifier des documents dans des bibliothèques de documents

  • Télécharger des documents vers des bibliothèques de documents

  • Créer des documents en mémoire et les ajouter à des bibliothèques de documents

  • Traiter tous les documents d’une bibliothèque

  • Créer des documents de traitement de texte au format XML ouvert à partir de bibliothèques Wiki

  • Conclusion

  • Ressources supplémentaires

Vue d’ensemble

Le modèle objet de client géré Microsoft SharePoint Foundation 2010 est un ensemble de bibliothèques gérées basées sur Microsoft .NET Framework qui vous permettent d’écrire du code pour des ordinateurs clients afin de travailler avec de nombreux objets courants dans des sites SharePoint. Les programmes qui s’exécutent sur le client peuvent ajouter et supprimer des listes, ajouter, mettre à jour et supprimer des éléments dans une liste, modifier des documents dans des bibliothèques de documents, créer des sites, gérer des autorisations concernant des éléments, et ajouter et supprimer des composants WebPart sur une page.

Le format de fichiers XML ouvert, le format de document de Microsoft Office 2007 et d’Office 2010, conforme à la norme ISO/IEC (IS29500), qui décrit la structure interne des documents de type traitement de texte, feuille de calcul ou présentation. Les fichiers au format XML ouvert sont stockés conformément aux spécifications Open Packaging Conventions (Partie 2 d’IS29500). Ce sont pratiquement des fichiers ZIP qui contiennent des parties XML. Le kit de développement Open XML SDK 2.0 for Microsoft Office est une bibliothèque gérée basée sur .NET Framework qui facilite l’écriture de programmes pour créer, modifier et interroger des documents au format XML ouvert. À la fin de cet article, vous trouverez une liste de ressources qui vous aideront à commencer à utiliser le kit de développement Open XML SDK 2.0.

En utilisant ces deux technologies conjointement, vous pouvez créer des scénarios intéressants, notamment :

  • Vous pouvez écrire une application côté client qui crée un document de traitement de texte ou de présentation à partir d’un contenu récupéré ailleurs, et télécharge automatiquement ce document vers une bibliothèque de documents sur un site SharePoint.

  • Vous pouvez écrire une application qui interroge tous les documents d’une bibliothèque de documents et extrait des informations de chacun.

  • Vous pouvez écrire une application qui traite tous les documents dans une bibliothèque de documents et apporte les mêmes modifications à chacun. Un scénario intéressant est la possibilité de supprimer tous les commentaires et informations personnelles, et d’accepter toutes les marques de révision dans chaque document de la bibliothèque de documents.

  • Vous pouvez extraire le contenu d’un site Wiki, et construire un document au format XML ouvert à partir de ce contenu.

Cet article repose sur les informations présentées dans l’article Utilisation du modèle objet de client géré SharePoint Foundation 2010. Pour plus d’informations sur le fonctionnement du modèle objet de client géré SharePoint Foundation 2010, consultez cet article.

Extraire des documents de bibliothèques de documents

Il existe deux opérations de base pour travailler avec le modèle objet de client géré SharePoint Foundation 2010 et le format XML ouvert : extraire et enregistrer des documents. L’exemple suivant récupère un document dans une bibliothèque de documents et imprime le texte du premier paragraphe.

Notes

Cet article utilise des applications console Microsoft Windows pour le code d’exemple. Cependant, vous pouvez utilisez la même approche avec d’autres types d’application.

Pour générer cet exemple, vous devez ajouter les références à quatre assemblys. Deux assemblys sont nécessaires pour accéder au modèle objet de client géré SharePoint Foundation 2010 : Microsoft.SharePoint.Client.dll et Microsoft.SharePoint.Client.Runtime.dll. Deux assemblys sont nécessaires pour utiliser le kit de développement Open XML SDK 2.0 : DocumentFormat.OpenXml.dll et WindowsBase.dll. Pour des instructions détaillées sur la façon de générer une application console qui utilise le modèle objet de client géré SharePoint Foundation 2010, voir Utilisation du modèle objet de client géré SharePoint Foundation 2010.

Pour générer les exemples présentés dans cet article, vous devez télécharger et installer le kit de développement Open XML SDK 2.0. Pour des instructions détaillées sur la façon de générer des applications Open XML SDK 2.0, voir Bienvenue dans le Kit de développement Open XML SDK 2.0 pour Microsoft Office. Pour télécharger le kit de développement Open XML SDK 2.0, voir Open XML SDK 2.0.

using System;
using System.IO;
using System.Linq;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
using Microsoft.SharePoint.Client;
// The following using directive resolves the ambiguity
// between the System.IO.File class and Microsoft.SharePoint.Client.File
// class.
using ClientOM = Microsoft.SharePoint.Client;

class Program
{
    static private void CopyStream(Stream source, Stream destination)
    {
        byte[] buffer = new byte[32768];
        int bytesRead;
        do
        {
            bytesRead = source.Read(buffer, 0, buffer.Length);
            destination.Write(buffer, 0, bytesRead);
        } while (bytesRead != 0);
    }

    static void Main(string[] args)
    {
        ClientContext clientContext =
            new ClientContext("http://intranet.contoso.com");
        List sharedDocumentsList = clientContext.Web.Lists
            .GetByTitle("Shared Documents");
        CamlQuery camlQuery = new CamlQuery();
        camlQuery.ViewXml =
            @"<View>
                <Query>
                  <Where>
                    <Eq>
                      <FieldRef Name='FileLeafRef'/>
                      <Value Type='Text'>Test.docx</Value>
                    </Eq>
                  </Where>
                  <RowLimit>1</RowLimit>
                </Query>
              </View>";
        ListItemCollection listItems = sharedDocumentsList.GetItems(camlQuery);
        clientContext.Load(sharedDocumentsList);
        clientContext.Load(listItems);
        clientContext.ExecuteQuery();
        if (listItems.Count == 1)
        {
            ClientOM.ListItem item = listItems[0];
            Console.WriteLine("FileLeafRef: {0}", item["FileLeafRef"]);
            Console.WriteLine("FileDirRef: {0}", item["FileDirRef"]);
            Console.WriteLine("FileRef: {0}", item["FileRef"]);
            Console.WriteLine("File Type: {0}", item["File_x0020_Type"]);
            FileInformation fileInformation =
                ClientOM.File.OpenBinaryDirect(clientContext, (string)item["FileRef"]);
            using (MemoryStream memoryStream = new MemoryStream())
            {
                CopyStream(fileInformation.Stream, memoryStream);
                using (WordprocessingDocument doc =
                    WordprocessingDocument.Open(memoryStream, false))
                {
                    var firstParagraph = doc
                        .MainDocumentPart
                        .Document
                        .Body
                        .Elements<Paragraph>()
                        .FirstOrDefault();
                    if (firstParagraph != null)
                    {
                        string text = firstParagraph.InnerText;
                        Console.WriteLine(text);
                    }
                    else
                        Console.WriteLine("Document doesn't contain any paragraphs.");
                }
            }
        }
        else
            Console.WriteLine("Document not found.");
    }
}

Cet exemple produit une sortie identique à ce qui suit :

FileLeafRef: Test.docx
FileDirRef: /Shared Documents
FileRef: /Shared Documents/Test.docx
File Type: docx
This is the text of the first paragraph.

Cet exemple imprime les champs souvent utilisés lorsque vous travaillez avec des documents dans des bibliothèques de documents :

  • Le champ FileLeafRef contient le nom du fichier.

  • Le champ FileDirRef contient le nom de la bibliothèque de documents. Si le fichier se trouve dans un dossier, le champ FileDirRef contient aussi le nom du dossier.

  • Le champ FileRef contient le nom complet, qui inclut le nom de la bibliothèque de documents, éventuellement le nom des dossiers, et le nom du fichier.

La requête CAML, qui recherche un élément dans la bibliothèque de documents, contient le champ FileLeafRef ayant la valeur Test.docx, et définit l’élément RowLimit de l’élément View avec la valeur 1.

camlQuery.ViewXml =
    @"<View>
        <Query>
          <Where>
            <Eq>
              <FieldRef Name='FileLeafRef'/>
              <Value Type='Text'>Test.docx</Value>
            </Eq>
          </Where>
          <RowLimit>1</RowLimit>
        </Query>
      </View>";

Comme cet exemple définit l’élément RowLimit avec la valeur 1, la requête renvoie un objet ListItemCollection contenant zéro ou un élément. Par conséquent, vous pouvez effectuer le test listItems.Count == 1 pour déterminer si la requête trouve le document.

Pour récupérer le fichier, nous utilisons la méthode OpenBinaryDirect() qui renvoie un objet de type FileInformation.

FileInformation fileInformation =
    ClientOM.File.OpenBinaryDirect(clientContext, (string)item["FileRef"]);

L’objet FileInformation contient une référence à un flux que vous pouvez utiliser pour transmettre le fichier à notre application. Cependant, ce flux n’est pas redimensionnable. La méthode Open() de la classe WordprocessingDocument accepte un flux en tant qu’argument. Mais, ce flux doit être redimensionnable. Par conséquent, vous devez créer un objet MemoryStream (éventuellement en anglais), puis copier à partir du flux renvoyé par la propriété Stream dans l’objet MemoryStream. Si nous essayons d’ouvrir l’objet WordprocessingDocument à partir du flux renvoyé par la propriété Stream, la méthode Open() génère une exception, System.IO.IOException (éventuellement en anglais), avec le message « Impossible d’ouvrir le package car la valeur FileMode ou FileAccess n’est pas valide pour le flux ».

Vous pouvez constater qu’il n’a pas été nécessaire d’appeler la méthode ExecuteQuery() avant d’accéder à la propriété Stream. En effet, la méthode OpenBinaryDirect() ne participe pas à la communication réseau normale XML/JSON du modèle objet client. L’article Using the SharePoint Foundation 2010 Managed Client Object Model explique la façon dont la partie client du modèle objet client rassemble les requêtes sous forme XML, envoie ce code XML au serveur, qui traite les demandes puis envoie la réponse dans JSON. Si vous téléchargez des fichiers en utilisant XML et JSON, le modèle objet client convertit le document au format XML ouvert binaire dans un codage en base 64. Cependant, recourir à ce codage est moins efficace qu’envoyer directement les données binaires. Nous recommandons, lorsque c’est possible, d’envoyer les données binaires directement. Cela rend l’application plus efficace et diminue le trafic réseau.

Une fois que vous disposez d’un objet MemoryStream, qui est redimensionnable s’il a été créé à l’aide du constructeur sans paramètre, vous ouvrez le document en utilisant la méthode Open() et le traitez de façon habituelle.

Remarque de mise en gardeAttention

La classe MemoryStream contient un constructeur (éventuellement en anglais) qui accepte un tableau d’octets, qui est ensuite utilisé comme magasin de sauvegarde pour le flux. Cependant, ce constructeur renvoie un flux mémoire qui n’est pas redimensionnable. Par conséquent, vous ne pouvez jamais utiliser ce constructeur pour créer un flux mémoire pour une utilisation avec l’API Open XML.

Modifier des documents dans des bibliothèques de documents

Vous pouvez modifier l’exemple précédent afin qu’il modifie le document, puis replace le document modifié dans la bibliothèque.

using System;
using System.IO;
using System.Linq;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
using Microsoft.SharePoint.Client;
using ClientOM = Microsoft.SharePoint.Client;

class Program
{
    static private void CopyStream(Stream source, Stream destination)
    {
        byte[] buffer = new byte[32768];
        int bytesRead;
        do
        {
            bytesRead = source.Read(buffer, 0, buffer.Length);
            destination.Write(buffer, 0, bytesRead);
        } while (bytesRead != 0);
    }

    static void Main(string[] args)
    {
        ClientContext clientContext =
            new ClientContext("http://intranet.contoso.com");
        List sharedDocumentsList = clientContext.Web.Lists
            .GetByTitle("Shared Documents");
        CamlQuery camlQuery = new CamlQuery();
        camlQuery.ViewXml =
            @"<View>
                <Query>
                  <Where>
                    <Eq>
                      <FieldRef Name='FileLeafRef'/>
                      <Value Type='Text'>Test.docx</Value>
                    </Eq>
                  </Where>
                  <RowLimit>1</RowLimit>
                </Query>
              </View>";
        ListItemCollection listItems =
            sharedDocumentsList.GetItems(camlQuery);
        clientContext.Load(sharedDocumentsList);
        clientContext.Load(listItems);
        clientContext.ExecuteQuery();
        if (listItems.Count == 1)
        {
            ClientOM.ListItem item = listItems[0];
            Console.WriteLine("FileLeafRef: {0}", item["FileLeafRef"]);
            Console.WriteLine("FileDirRef: {0}", item["FileDirRef"]);
            Console.WriteLine("FileRef: {0}", item["FileRef"]);
            Console.WriteLine("File Type: {0}", item["File_x0020_Type"]);
            FileInformation fileInformation =
                ClientOM.File.OpenBinaryDirect(clientContext,
                (string)item["FileRef"]);
            using (MemoryStream memoryStream = new MemoryStream())
            {
                CopyStream(fileInformation.Stream, memoryStream);
                using (WordprocessingDocument doc =
                    WordprocessingDocument.Open(memoryStream, true))
                {
                    // Insert a new paragraph at the beginning of the
                    //document.
                    doc.MainDocumentPart.Document.Body.InsertAt(new Paragraph(new Run(new Text("Newly inserted paragraph."))), 0);
                }
                // Seek to beginning before writing to the SharePoint server.
                memoryStream.Seek(0, SeekOrigin.Begin);
                // SaveBinaryDirect replaces the document on the SharePoint server.
                ClientOM.File.SaveBinaryDirect(clientContext,(string)item["FileRef"], memoryStream, true);
            }
        }
        else
            Console.WriteLine("Document not found.");
    }
}

Notez que cet exemple passe la valeur true à la méthode Open() afin que vous puissiez modifier le document. Après avoir ouvert le document en utilisant la méthode Open(), vous pouvez modifier le document de la façon habituelle.

Après avoir quitté la portée créée par l’instruction qui ouvre le document en appelant la méthode Open(), l’objet MemoryStream contient le document modifié. Avant de retransmettre le document au serveur, positionnez le début du flux. Puis, appelez la méthode SaveBinaryDirect() qui replace le document modifié dans la bibliothèque de documents.

Télécharger des documents vers des bibliothèques de documents

L’opération suivante consiste à télécharger des documents vers une bibliothèque de documents. Pour télécharger un document, vous pouvez appeler la méthode SaveBinaryDirect(), en passant l’URL associée au serveur et un flux. L’exemple suivant télécharge un nouveau document vers le dossier Documents partagés d’un site SharePoint.

using System;
using System.IO;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
using Microsoft.SharePoint.Client;
// The following directive avoids ambiguity between the
// System.IO.File class and Microsoft.SharePoint.Client.File class.
using ClientOM = Microsoft.SharePoint.Client;

class Program
{
    static void Main(string[] args)
    {
        ClientContext clientContext =
            new ClientContext("http://intranet.contoso.com");
        using (FileStream fileStream =
            new FileStream("NewDocument.docx", FileMode.Open))
            ClientOM.File.SaveBinaryDirect(clientContext,
                "/Shared Documents/NewDocument.docx", fileStream, true);
    }
}

Créer des documents en mémoire et les ajouter à des bibliothèques de documents

Il y a deux moyens courants pour créer des documents en utilisant les formats de l’API Open XML :

  • Utilisez un document existant comme modèle, ouvrez-le, modifiez-le de la façon voulue, puis enregistrez-le à l’endroit souhaité.

  • Créez un document. Souvent, vous utilisez pour cela l’outil DocumentReflector inclus dans le kit de développement Open XML SDK 2.0 for Microsoft Office. Cet outil permet de générer le code Microsoft Visual C# pour créer tout document au format XML ouvert.

Dans les deux cas, vous pouvez créer le document dans un objet MemoryStream. L’exemple suivant lit un document dans un tableau d’octets, crée un flux mémoire redimensionnable à l’aide du constructeur MemoryStream sans argument, écrit le tableau d’octets dans le MemoryStream, modifie ce document en mémoire, puis télécharge le document modifié vers la bibliothèque Documents partagés d’un site SharePoint.

Pour exécuter cet exemple, créez un document de traitement de texte nommé Template.docx, initialisez-le avec le contenu souhaité (ou bien sans aucun contenu), et placez-le dans le répertoire bin où vous exécutez l’exemple. L’exemple insère un nouveau paragraphe au début du document avant de télécharger ce dernier vers la bibliothèque de documents.

using System;
using System.IO;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
using Microsoft.SharePoint.Client;
using ClientOM = Microsoft.SharePoint.Client;

class Program
{
    static void Main(string[] args)
    {
        ClientContext clientContext =
            new ClientContext("http://intranet.contoso.com");
        byte[] byteArray = System.IO.File.ReadAllBytes("Template.docx");
        using (MemoryStream memoryStream = new MemoryStream())
        {
            memoryStream.Write(byteArray, 0, (int)byteArray.Length);
            using (WordprocessingDocument doc =
                WordprocessingDocument.Open(memoryStream, true))
            {
                // Insert a new paragraph at the beginning of the
                //document.
                doc.MainDocumentPart.Document.Body.InsertAt(
                    new Paragraph(
                        new Run(
                            new Text("Newly inserted paragraph."))), 0);
            }
            string fileUrl = "/Shared Documents/NewDocumentFromTemplate.docx";
            memoryStream.Seek(0, SeekOrigin.Begin);
            ClientOM.File.SaveBinaryDirect(clientContext, fileUrl, memoryStream, true);
        }
    }
}

Traiter tous les documents d’une bibliothèque

Parfois, vous voulez itérer sur tous les documents d’une bibliothèque de documents, en effectuant la même requête ou modification sur chaque document. La bibliothèque peut contenir des dossiers qui contiennent des documents et, éventuellement, des sous-dossiers. L’exemple suivant montre comment utiliser l’attribut Scope=’Recursive’ de l’élément View pour traiter tous les documents d’une bibliothèque de documents. Cela inclut les documents qui se trouvent dans des sous-dossiers.

Remarque de mise en gardeAttention

Si vous traitez tous les documents d’une grande bibliothèque contenant plus de 2 000 documents, vous devez implémenter un algorithme de pagination. Pour des informations détaillées, voir Using the SharePoint Foundation 2010 Managed Client Object Model. Si vous construisez une application interactive pour cela, vous pouvez utiliser un traitement asynchrone. Pour plus d’informations, voir Traitement asynchrone.

 
using System;
using System.IO;
using System.Linq;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
using Microsoft.SharePoint.Client;
using ClientOM = Microsoft.SharePoint.Client;

class Program
{
    static private void CopyStream(Stream source, Stream destination)
    {
        byte[] buffer = new byte[32768];
        int bytesRead;
        do
        {
            bytesRead = source.Read(buffer, 0, buffer.Length);
            destination.Write(buffer, 0, bytesRead);
        } while (bytesRead != 0);
    }

    static void Main(string[] args)
    {
        ClientContext clientContext =
            new ClientContext("http://intranet.contoso.com");
        List sharedDocumentsList = clientContext.Web.Lists
            .GetByTitle("Shared Documents");
        CamlQuery camlQuery = new CamlQuery();
        camlQuery.ViewXml =
            @"<View Scope='Recursive'>
                <Query>
                  <Where>
                    <Eq>
                      <FieldRef Name='File_x0020_Type'/><Value Type='Text'>docx</Value>
                    </Eq>
                  </Where>
                </Query>
              </View>";
        ListItemCollection listItems =
            sharedDocumentsList.GetItems(camlQuery);
        clientContext.Load(listItems);
        clientContext.ExecuteQuery();
        foreach (var item in listItems)
        {
            Console.WriteLine("FileLeafRef: {0}", item["FileLeafRef"]);
            Console.WriteLine("FileDirRef: {0}", item["FileDirRef"]);
            Console.WriteLine("FileRef: {0}", item["FileRef"]);
            FileInformation fileInformation =
                ClientOM.File.OpenBinaryDirect(clientContext,
                (string)item["FileRef"]);
            using (MemoryStream memoryStream = new MemoryStream())
            {
                CopyStream(fileInformation.Stream, memoryStream);
                using (WordprocessingDocument doc =
                    WordprocessingDocument.Open(memoryStream, true))
                {
                    var firstParagraph = doc.MainDocumentPart.Document
                        .Body.Elements<Paragraph>().FirstOrDefault();
                    if (firstParagraph != null)
                    {
                        string text = firstParagraph.InnerText;
                        Console.WriteLine("  First paragraph text: {0}",
                            text);
                    }
                    else
                        Console.WriteLine(
                            "Document doesn't contain any paragraphs.");
                }
            }
            Console.WriteLine();
        }
    }
}

Pour traiter tous les documents au format XML ouvert dans une bibliothèque de documents ou dans un dossier, il est commode d’utiliser une requête CAML pour filtrer les documents du type de document voulu, « docx » dans cet exemple. Le code en gras dans la requête Langage CAML (Collaborative Application Markup Language) de l’exemple montre comment faire.

Le projet PowerTools for Open XML contient une bibliothèque pour accepter toutes les marques de révision d’un document de traitement de texte. La modification de cet exemple pour créer un programme qui itère sur tous les documents d’une bibliothèque de documents, en acceptant les révisions de chacun, est simple. Pour rechercher la classe RevisionAccepter, voir la section Téléchargements (Downloads) du site PowerTools for Open XML (éventuellement en anglais).

Créer des documents de traitement de texte au format XML ouvert à partir de bibliothèques Wiki

L’utilisation de l’API Open XML conjointement au modèle objet client permet des solutions innovantes. Par exemple, un utilisateur Wiki veut distribuer un document à des personnes n’ayant pas accès à ce site Wiki. Ces personnes peuvent être des clients ou des fournisseurs qui n’ont pas accès au réseau de l’entreprise, mais ont besoin des informations contenues dans ce site. Vous pouvez convertir une bibliothèques Wiki SharePoint dans un document au format XML ouvert que vous pouvez envoyer à quiconque ayant Microsoft Office Word 2007 ou Microsoft Word 2010. Cette section vous montre comment procéder en utilisant le modèle objet client.

Utilisez les capacités altChunk du format XML ouvert pour réaliser cela. WordprocessingML fournit la possibilité d’importer du contenu externe via l’élément altChunk. Pour utiliser altChunk, procédez comme suit :

  • Créez un composant supplémentaire dans le package. Ce composant peut comporter plusieurs types de contenu. Cela inclut des documents entiers au format XML ouvert, du code HTML ou du texte brut. Dans cet exemple, vous utilisez la possibilité d’importer du HTML.

  • Stockez le contenu que vous souhaitez importer dans le composant.

  • Lorsque vous créez le composant, vous créez une relation entre le composant du document principal et le composant au nouveau format.

  • Ajoutez un élément w:altChunk à l’endroit où vous voulez importer le contenu de l’autre format. L’attribut r:id de l’élément w:altChunk identifie le contenu à importer. L’élément w:altChunk est un contenu au niveau bloc, ce qui signifie que vous pouvez l’insérer dans le document partout où il est possible d’insérer un élément paragraphe (w:p).

    Cet exemple extrait le code HTML de chaque rubrique du Wiki et insère chaque page dans son propre composant, puis importe chaque composant dans le document en utilisant l’élément w:altChunk.

Important

Un point important à noter est que altChunk est utilisé uniquement pour importer du contenu. Si vous ouvrez le document en utilisant Word 2007 ou Word 2010, puis l’enregistrez, le document enregistré ne contient pas le composant de contenu au format autre, ni le balisage altChunk qui y réfère. Word 2007 ou Word 2010 convertit le code HTML en balisage WordprocessingML en tant qu’éléments paragraphe (w:p), éléments exécutables (w:r) et éléments texte (w:t).

L’exemple suivant extrait le contenu de chaque page Wiki en tant qu’HTML.

using System;
using System.Xml.Linq;
using Microsoft.SharePoint.Client;

class RetrieveListItems
{
    static void Main()
    {
        ClientContext clientContext = new ClientContext("http://intranet.contoso.com");
        List oList = clientContext.Web.Lists.GetByTitle("Eric's Wiki");
        CamlQuery camlQuery = new CamlQuery();
        camlQuery.ViewXml = @"<View/>";
        ListItemCollection listItems = oList.GetItems(camlQuery);
        clientContext.Load(
             listItems,
             items => items.Include(
                 item => item["FileRef"],
                 item => item["WikiField"]));
        clientContext.ExecuteQuery();
        foreach (ListItem oListItem in listItems)
        {
            Console.WriteLine("FileRef: {0}", oListItem["FileRef"]);
            XElement e = XElement.Parse((string)oListItem["WikiField"]);
            Console.WriteLine(e);
            Console.WriteLine("====================================");
        }
    }
}

Ensuite, remplacez l’URL passée au constructeur [M:Microsoft.SharePoint.Client.ClientContext.#Ctor] par l’URL du site SharePoint. Remplacez le titre passé à la méthode GetByTitle() par le titre d’une bibliothèque Wiki du site SharePoint.

Cet exemple utilise LINQ vers XML pour formater (indenter) le code XHTML extrait de la bibliothèque Wiki. Lorsque vous exécutez cet exemple, vous obtenez un résultat semblable au suivant.

FileRef: /Erics Wiki/AnotherPage.aspx
<div class="ExternalClass7EB3EF2C25AB481081BEE2BF8D80B6B8">
  <table id="layoutsTable" style="width:100%">
    <tbody>
      <tr style="vertical-align:top">
        <td style="width:100%">
          <div class="ms-rte-layoutszone-outer" style="width:100%"><div><p>This is some content in another page.</p><p> </p><p><strong>Here is some bold text.</strong></p><p></p></div></div>
        </td>
      </tr>
    </tbody>
  </table>

  <span id="layoutsData" style="display:none">false,false,1</span>
</div>
====================================
FileRef: /Erics Wiki/This is a longer title of a page.aspx
<div class="ExternalClass980D47DB1C51449E9684343F131C5689">
  <table id="layoutsTable" style="width:100%">
    <tbody>
      <tr style="vertical-align:top">
        <td style="width:100%">
          <div class="ms-rte-layoutszone-outer" style="width:100%"><div><p>This page contains some content we will extend in the future.</p><p></p></div></div>
        </td>
      </tr>
    </tbody>
  </table>

  <span id="layoutsData" style="display:none">false,false,1</span>
</div>

Comme vous pouvez le constater, le contenu de chaque page de la bibliothèque Wiki est contenu dans un élément <div>. À l’intérieur de l’élément <div>, se trouve un élément de tableau que le Wiki utilise pour la mise en page. L’élément qui vous intéresse est l’élément <div> contenu dans la cellule du tableau dont l’attribut de classe a la valeur ms-rte-layoutszone-outer. Lors de la construction du HTML pour insérer le composant importé au format autre, vous insérez cet élément <div> interne dans l’élément <body> du document HTML. L’exemple de code écrit le nouveau HTML construit dans le composant de contenu autre.

Remarque sur Visual BasicRemarque sur Visual Basic

Cette conversion ne convertit pas les liens Wiki en signets et liens à l’intérieur du document. De plus, certains caractères qui peuvent être insérés dans la page Wiki ne se convertissent pas correctement. Il s’agit d’une démonstration de faisabilité, dont le but est de montrer les possibilités d’utilisation du modèle objet client avec les formats de l’API Open XML. L’intention n’est pas de résoudre tous les problèmes associés à la conversion d’un Wiki SharePoint en document au format XML ouvert.

Voici un exemple qui extrait le contenu de toutes les pages d’un Wiki SharePoint, et crée un document de traitement de texte avec ce contenu.

using System;
using System.Linq;
using System.IO;
using System.Xml.Linq;
using Microsoft.SharePoint.Client;
using ClientOM = Microsoft.SharePoint.Client;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;

class RetrieveListItems
{
    static void Main()
    {
        ClientContext clientContext =
            new ClientContext("http://intranet.contoso.com");
        List oList = clientContext.Web.Lists.GetByTitle("Eric's Wiki");
        CamlQuery camlQuery = new CamlQuery();
        camlQuery.ViewXml = @"<View/>";
        ListItemCollection listItems = oList.GetItems(camlQuery);
        clientContext.Load(
             listItems,
             items => items.Include(
                 item => item["FileLeafRef"],
                 item => item["WikiField"]));
        clientContext.ExecuteQuery();

        System.IO.File.Delete("WikiDocument.docx");
        System.IO.File.Copy("EmptyDocument.docx", "WikiDocument.docx");
        int altChunkIdCounter = 1;
        int blockLevelCounter = 0;
        bool first = true;
        using (WordprocessingDocument myDoc =
            WordprocessingDocument.Open("WikiDocument.docx", true))
        {
            MainDocumentPart mainPart = myDoc.MainDocumentPart;
            mainPart.Document.Body.RemoveAllChildren<Paragraph>();
            foreach (ClientOM.ListItem listItem in listItems)
            {
                string wikiPageTitleAspx = (string)listItem["FileLeafRef"];
                string wikiPageTitle = wikiPageTitleAspx.Substring(
                    0, wikiPageTitleAspx.Length - 5);
                if (first)
                {
                    first = false;
                    mainPart.Document.Body.InsertAt(new Paragraph(
                        new ParagraphProperties(
                            new RunProperties(
                                new RunFonts() {
                                    AsciiTheme = ThemeFontValues.MajorHighAnsi,
                                    HighAnsiTheme = ThemeFontValues.MajorHighAnsi },
                                new Bold(),
                                new Color() { Val = "1F497D",
                                    ThemeColor = ThemeColorValues.Text2 },
                                new FontSize() { Val = 28 },
                                new FontSizeComplexScript() { Val = 28 }),
                            new ParagraphStyleId() { Val = "Heading1" }),
                        new Run(
                            new RunProperties(
                                new RunFonts() {
                                    AsciiTheme = ThemeFontValues.MajorHighAnsi,
                                    HighAnsiTheme = ThemeFontValues.MajorHighAnsi },
                                new Bold(),
                                new Color() { Val = "1F497D",
                                    ThemeColor = ThemeColorValues.Text2 },
                                new FontSize() { Val = 28 },
                                new FontSizeComplexScript() { Val = 28 }),
                            new Text(wikiPageTitle))),
                        blockLevelCounter++);
                }
                else
                {
                    mainPart.Document.Body.InsertAt(new Paragraph(
                        new Run(
                            new Break() { Type = BreakValues.Page } )),
                        blockLevelCounter++);
                    mainPart.Document.Body.InsertAt(new Paragraph(
                        new ParagraphProperties(
                            new RunProperties(
                                new RunFonts() {
                                    AsciiTheme = ThemeFontValues.MajorHighAnsi,
                                    HighAnsiTheme = ThemeFontValues.MajorHighAnsi },
                                new Bold(),
                                new Color() { Val = "1F497D",
                                    ThemeColor = ThemeColorValues.Text2 },
                                new FontSize() { Val = 28 },
                                new FontSizeComplexScript() { Val = 28 }),
                            new ParagraphStyleId() { Val = "Heading1" }),
                        new Run(
                            new RunProperties(
                                new RunFonts() {
                                    AsciiTheme = ThemeFontValues.MajorHighAnsi,
                                    HighAnsiTheme = ThemeFontValues.MajorHighAnsi },
                                new Bold(),
                                new Color() { Val = "1F497D",
                                    ThemeColor = ThemeColorValues.Text2 },
                                new FontSize() { Val = 28 },
                                new FontSizeComplexScript() { Val = 28 }),
                            new Text(wikiPageTitle))),
                        blockLevelCounter++);
                }
                XElement wikiField = XElement.Parse((string)listItem["WikiField"]);
                XElement div = wikiField.Descendants("div").Where(e =>
                    (string)e.Attribute("class") == "ms-rte-layoutszone-inner" )
                    .FirstOrDefault();
                string html = String.Format(
                    "<html><head/><body>{0}</body></html>",
                    div != null ? div.ToString() : "");
                string altChunkId = String.Format("AltChunkId{0}",
                    altChunkIdCounter++);
                AlternativeFormatImportPart chunk =
                    mainPart.AddAlternativeFormatImportPart(
                    AlternativeFormatImportPartType.Xhtml, altChunkId);
                using (Stream chunkStream = chunk.GetStream(FileMode.Create,
                    FileAccess.Write))
                using (StreamWriter stringStream = new StreamWriter(chunkStream))
                    stringStream.Write(html);
                AltChunk altChunk = new AltChunk();
                altChunk.Id = altChunkId;
                mainPart.Document.Body.InsertAt(altChunk,
                    blockLevelCounter++);
            }
            mainPart.Document.Save();
        }
    }
}

 

Il fournit un tas de fonctionnalités en mois de 130 lignes de code. Voici comment l’une des pages du Wiki SharePoint apparaît.

Figure 1. Page d’une bibliothèque Wiki

Figure 1

 

La même page, apparaît dans Word 2010 de la manière suivante :

Figure 2. Même page en tant que document de traitement de texte au format XML ouvert

Figure 2

 

Conclusion

Le modèle objet de client géré SharePoint Foundation 2010 vous permet d’écrire de puissantes applications côté client qui fonctionnent avec SharePoint Foundation 2010 et SharePoint Server 2010. Le kit de développement Kit de développement Open XML SDK 2.0 vous permet de créer, modifier et interroger des documents au format XML ouvert. Utilisés conjointement, ils vous offrent de nouvelles possibilités d’utilisation des documents au format XML ouvert pour collaborer et partager des informations.

Ressources supplémentaires

Cet article combine les deux technologies : le kit de développement Kit de développement Open XML SDK 2.0 et le modèle objet de client géré SharePoint Foundation 2010. Pour démarrer avec Open XML, voir Open XML Developer Center on MSDN (éventuellement en anglais). Vous y trouverez beaucoup de contenu, dont des articles, des vidéos de démonstration et des liens vers de nombreux billets de blog. En particulier, les liens suivants fournissent des informations importantes pour la prise en main du kit de développement Open XML SDK 2.0 :

De nombreuses ressources vous aident à commencer à utiliser le modèle objet de client géré SharePoint Foundation 2010. Lisez d’abord l’article Utilisation du modèle objet de client géré SharePoint Foundation 2010. Les ressources suivantes, à propos du modèle objet client, sont également intéressantes :