Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais
Informations
Le sujet que vous avez demandé est indiqué ci-dessous. Toutefois, ce sujet ne figure pas dans la bibliothèque.

Remplacer les listes SharePoint créées à partir de définitions de liste

Remplacer les listes et bibliothèques qui ont été créés à l'aide de définitions de liste dans SharePoint.

Dernière modification :vendredi 7 août 2015

S’applique à :SharePoint 2013 | SharePoint Add-ins | SharePoint Online

Note Remarque

Le nom « Applications pour SharePoint » est remplacé par « Compléments SharePoint ». Lors de la période de transition, il se peut que la documentation et l’interface utilisateur de certains produits SharePoint et outils Visual Studio utilisent toujours le terme « applications pour SharePoint ». Pour plus d’informations, voir Nouveau nom des applications pour Office et SharePoint.

Si les définitions de liste vous permet de créer des listes dans votre solution de batterie de serveurs, découvrez comment les transformer en nouvelles solutions qui fournissent des fonctionnalités similaires à l'aide du modèle d'objet client (CSOM). Cet article explique comment utiliser le modèle d'objet client (CSOM) pour :

  • Trouvez des listes et bibliothèques qui ont été créés à l'aide de définitions de liste.

  • Créer et configurer de nouvelles listes.

  • Ajouter et supprimer des affichages de listes.

  • Migrer le contenu à partir de la liste d'origine vers la nouvelle liste.

Remarque importante Importante

Solutions de batterie de serveurs ne peuvent pas être migrées vers SharePoint Online. En appliquant les techniques et le code décrit dans cet article, vous pouvez créer une nouvelle solution avec une fonctionnalité similaire qui fournissent de votre solutions de batterie de serveurs, qui peut ensuite être déployée sur SharePoint Online. Si vous utilisez une approche de la transformation de la place, vous devrez déployer la nouvelle solution à SharePoint Online. Si vous utilisez le basculement ou l'approche de migration de contenu, les outils tiers peuvent créer des listes pour vous. Pour plus d'informations, voir les approches de Transformation pour déployer votre complément SharePoint nouvelle. Le code dans cet article requiert un code supplémentaire pour fournir une solution de travail entièrement. Par exemple, cet article n'aborde pas la méthode d'authentification à Office 365, comment implémenter la gestion des exceptions nécessaire et ainsi de suite. Pour les exemples de code supplémentaire, voir le projet de pratiques et de modèles de développeur Office 365.

Utilisez les techniques décrites dans cet article pour mettre à jour uniquement quelques listes à la fois. En outre, lors de la recherche de listes pour mettre à jour, vous devez filtrer pas les listes par type de liste.

Contribuer à ce contenu

Vous pouvez obtenir les dernières mises à jour ou contribuer à cet article sur Github. Vous pouvez également contribuer à cet article et d’autres exemples sur GitHub. Pour obtenir la liste complète des exemples, consultez le Centre des développeurs des pratiques et modèles. Nous accueillons avec plaisir vos contributions.

Dans l'idéal, vous devez consulter votre existant solutions de batterie de serveurs, en savoir plus sur les techniques décrites dans cet article et planifier puis comment appliquer ces techniques à votre existant solutions de batterie de serveurs. Si vous n'êtes pas familiarisé avec solutions de batterie de serveurs ou n'avez pas une existante solution de batterie de serveurs pour travailler avec, il peut être utile pour vous permet de :

  1. Télécharger la solution de Contoso.Intranet. Passez en revue les examiner l'état initial du site et de bibliothèque de remplacement pour obtenir une présentation rapide des comment listes ont été créées de façon déclarative à l'aide de définitions de liste.

    Remarque Remarque

    Dans Contoso.Intranet, dans le fichier elements.xml pour SP\ListTemplate\LTContosoLibrary, l'ID du modèle de liste personnalisée est 10003. Vous utiliserez ce pour identifier le modèle qui a été utilisé pour créer la liste. Consultez également les paramètres de configuration et les vues qui sont définies dans votre liste.

  2. Découvrez les solutions de batterie de serveurs. Pour plus d'informations, voir Vue d'ensemble des Architectures de SharePoint 2010 et créer des solutions de batterie de serveurs dans SharePoint 2013.

Pour remplacer les listes créées à partir de définitions de liste :

  1. Trouvez des listes créées à l'aide d'un modèle de base spécifique.

  2. Créer la liste à l'aide de la définition de liste d'out-of-the-box.

  3. Configurer les paramètres de la liste.

  4. Définir des types de contenu sur la nouvelle liste basée sur les types de contenu qui ont été définis dans la liste d'origine.

  5. (Facultatif) Ajouter des affichages.

  6. (Facultatif) Supprimer des vues.

  7. Migrer le contenu à partir de la liste d'origine vers la nouvelle liste.

Dans le code suivant, la méthode montre comment rechercher des listes créées à l'aide d'un modèle de base spécifique. Cette méthode :

  1. Utilise le ClientContext pour obtenir toutes les listes du site web en cours à l'aide de Web.Lists. L'instruction Include est utilisée dans l'expression lambda pour retourner une collection de listes. Les listes renvoyées doivent avoir des valeurs de propriété spécifiées pour BaseTemplate, BaseTypeet titre.

  2. Pour chaque liste dans la collection de listes renvoyées, si la List.BaseTemplate est égale à 10003, ajoute la liste à une collection de listes d'être remplacé, appelée listsToReplace. N'oubliez pas que 10003 a identificateur du modèle de liste personnalisé que dans l'exemple de Contoso.Intranet nous avons passé en revue.

Remarque Remarque

Le code dans cet article est fourni tel quel, sans garantie d’aucune sorte, expresse ou implicite, y compris mais sans s’y limiter, aucune garantie implicite d’adéquation à un usage particulier, à une qualité marchande ou une absence de contrefaçon.

static void Main(string[] args)
{
    using (var clientContext = new ClientContext("http://w15-sp/sites/ftclab"))
    {
        Web web = clientContext.Web;
        ListCollection listCollection = web.Lists;
        clientContext.Load(listCollection,
                            l => l.Include(list => list.BaseTemplate,
                                            list => list.BaseType,
                                            list => list.Title));
        clientContext.ExecuteQuery();
        var listsToReplace = new List<List>();
        foreach (List list in listCollection)
        {
            // 10003 is the custom list template ID of the list template you're replacing.
            if (list.BaseTemplate == 10003)
            {
                listsToReplace.Add(list);
            }
        }
        foreach (List list in listsToReplace)
        {
            ReplaceList(clientContext, listCollection, list);
        }
    }
}
Remarque importanteImportante

Dans le code précédent, vous tout d'abord effectuer une itération sur la ListCollection pour sélectionner les listes doivent être modifiées et ensuite appelez ReplaceList, qui commence à modifier les listes. Ce modèle est nécessaire, car la modification du contenu d'une collection tout en effectuant une itération sur la collection lève une exception.

Après avoir identifié une liste qui doit être remplacée, ReplaceList indique l'ordre des opérations à effectuer pour remplacer la liste.

private static void ReplaceList(ClientContext clientContext, ListCollection listCollection, List listToBeReplaced)
{
    var newList = CreateReplacementList(clientContext, listCollection, listToBeReplaced);

    SetListSettings(clientContext, listToBeReplaced, newList);

    SetContentTypes(clientContext, listToBeReplaced, newList);

    AddViews(clientContext, listToBeReplaced, newList);

    RemoveViews(clientContext, listToBeReplaced, newList);

    MigrateContent(clientContext, listToBeReplaced, newList);
}

Pour créer une nouvelle liste, CreateReplacementList utilise ListCreationInformation. Le titre de la nouvelle liste est défini sur le titre de la liste existante, avec module complémentaire ajouté à la fin. L'énumération ListTemplateType est utilisée pour définir le type de modèle de la liste dans une bibliothèque de documents. Si vous créez une liste basée sur un type de modèle différent, assurez-vous d'utiliser le type de modèle approprié. Par exemple, si vous créez une liste Calendrier, utilisez ListTemplateType.Events au lieu de ListTemplateType.DocumentLibrary.

private static List CreateReplacementList(ClientContext clientContext, ListCollection lists,List listToBeReplaced)
{
    var creationInformation = new ListCreationInformation
    {
        Title = listToBeReplaced.Title + "add-in",
        TemplateType = (int) ListTemplateType.DocumentLibrary,
    };
    List newList = lists.Add(creationInformation);
    clientContext.ExecuteQuery();
    return newList;
}

SetListSettings applique les paramètres de liste d'origine vers la nouvelle liste par :

  1. Obtention des différents paramètres de la liste à partir de la liste d'origine.

  2. Appliquer le paramètre de la liste à partir de la liste d'origine vers la nouvelle liste.

private static void SetListSettings(ClientContext clientContext, List listToBeReplaced, List newList)
{
    clientContext.Load(listToBeReplaced, 
                        l => l.EnableVersioning, 
                        l => l.EnableModeration, 
                        l => l.EnableMinorVersions,
                        l => l.DraftVersionVisibility );
    clientContext.ExecuteQuery();
    newList.EnableVersioning = listToBeReplaced.EnableVersioning;
    newList.EnableModeration = listToBeReplaced.EnableModeration;
    newList.EnableMinorVersions= listToBeReplaced.EnableMinorVersions;
    newList.DraftVersionVisibility = listToBeReplaced.DraftVersionVisibility;
    newList.Update();
    clientContext.ExecuteQuery();
}
RemarqueRemarque

Selon vos besoins, les paramètres de la liste de vos listes d'origine peuvent être différents. Passez en revue vos paramètres de la liste et modifiez SetListSettings pour vous assurer que vos paramètres de liste d'origine sont appliqués à vos nouvelles listes.

SetContentTypes définit les types de contenu sur la nouvelle liste par :

  1. Obtention d'informations de type de contenu à partir de la liste d'origine.

  2. Obtention d'informations de type de contenu à partir de la nouvelle liste.

  3. Déterminer si la liste d'origine permet de types de contenu. Si la liste d'origine n'active pas les types de contenu, SetContentTypes se ferme. Si la liste d'origine activé les types de contenu, puis SetContentTypes permet de types de contenu dans la liste à l'aide newList.ContentTypesEnabled = true.

  4. Pour chaque type de contenu dans la liste d'origine, le contenu de la recherche de types de dans la nouvelle liste pour trouver une correspondance content type basé sur le nom du type de contenu à l'aide de newList.ContentTypes.Any (ct = > ct. Nom == contentType.Name). Si le type de contenu n'est pas dans la nouvelle liste, elle est ajoutée à la liste.

  5. Chargement newList une deuxième fois, car AddExistingContentType peut avoir modifié les types de contenu.

  6. Pour chaque type de contenu dans newList, déterminer si le type de contenu correspond à un type de contenu dans la liste d'origine en fonction de ContentType.Name à l'aide de listToBeReplaced.ContentTypes.Any (ct = > ct. Nom == contentType.Name). Si une correspondance est introuvable, le type de contenu est ajouté à contentTypesToDelete pour être supprimés de la nouvelle liste.

  7. Suppression du type de contenu en appelant ContentType.DeleteObject.

RemarqueRemarque

Si vous utilisez une approche place transformation et vos types de contenu ont été déployés de manière déclarative à l'aide de l'infrastructure de la fonctionnalité, vous devez :

  1. Créer des types de contenu.

  2. Définir le type de contenu sur les éléments de liste lors de la migration du contenu à partir de la liste d'origine vers la nouvelle liste dans MigrateContent.

private static void SetContentTypes(ClientContext clientContext, List listToBeReplaced, List newList)
{
    clientContext.Load(listToBeReplaced,
                        l => l.ContentTypesEnabled,
                        l => l.ContentTypes);
    clientContext.Load(newList,
                        l => l.ContentTypesEnabled,
                        l => l.ContentTypes);
    clientContext.ExecuteQuery();

    // If the original list doesn't use content types, do not proceed any further.
    if (!listToBeReplaced.ContentTypesEnabled) return;

    newList.ContentTypesEnabled = true;
    newList.Update();
    clientContext.ExecuteQuery();
    foreach (var contentType in listToBeReplaced.ContentTypes)
    {
        if (!newList.ContentTypes.Any(ct => ct.Name == contentType.Name))
        {
            // Current content type needs to be added to the new list. Note that the content type is added to the list, not the site.           
            newList.ContentTypes.AddExistingContentType(contentType.Parent);
            newList.Update();
            clientContext.ExecuteQuery();
        }
    }
    // Reload the content types on newList because they might have changed when AddExistingContentType was called. 
    clientContext.Load(newList, l => l.ContentTypes);
    clientContext.ExecuteQuery();
    // Remove any content types that are not needed.
    var contentTypesToDelete = new List<ContentType>();
    foreach (var contentType in newList.ContentTypes)
    {
        if (!listToBeReplaced.ContentTypes.Any(ct => ct.Name == contentType.Name))
        {
            // Current content type needs to be removed from new list.
            contentTypesToDelete.Add(contentType);
        }
    }
    foreach (var contentType in contentTypesToDelete)
    {
        contentType.DeleteObject();
    }
    newList.Update();
    clientContext.ExecuteQuery();
}
RemarqueRemarque

À ce stade, la nouvelle liste peut accepter le contenu de la liste d'origine. Vous pouvez éventuellement ajouter et supprimer des affichages.

Les utilisateurs peuvent ajouter ou supprimer les vues définies dans une liste pour répondre aux besoins de leur entreprise. Pour cette raison, vous devrez peut-être ajouter ou supprimer des affichages sur la nouvelle liste. AddViews ajoute des affichages dans la liste d'origine vers la nouvelle liste par :

  1. À l'aide de List.Views pour obtenir toutes les vues de la liste d'origine.

  2. À l'aide de l'expression lambda pour charger les diverses propriétés d'affichage sur la collection views .

  3. Pour chaque mode d'affichage dans la liste d'origine, la création d'une vue à l'aide de ViewCreationInformation. Différentes propriétés sont définies sur la nouvelle vue basée sur les propriétés d'affichage à partir de l'affichage d'origine. La méthode d'assistance GetViewType est appelée pour déterminer le ViewType de l'affichage. La nouvelle vue est ensuite ajoutée à la liste des vues appelée viewsToCreate.

  4. Ajout d'affichages à la collection List.Views à l'aide de la méthode Add sur la collection de vues de la liste.

private static void AddViews(ClientContext clientContext, List listToBeReplaced, List newList)
{
    ViewCollection views = listToBeReplaced.Views;
    clientContext.Load(views,
                        v => v.Include(view => view.Paged,
                            view => view.PersonalView,
                            view => view.ViewQuery,
                            view => view.Title,
                            view => view.RowLimit,
                            view => view.DefaultView,
                            view => view.ViewFields,
                            view => view.ViewType));
    clientContext.ExecuteQuery();

    // Build a list of views which exist on the original list only.
    var viewsToCreate = new List<ViewCreationInformation>();
    foreach (View view in listToBeReplaced.Views)
    {
      var createInfo = new ViewCreationInformation
      {
          Paged = view.Paged,
          PersonalView = view.PersonalView,
          Query = view.ViewQuery,
          Title = view.Title,
          RowLimit = view.RowLimit,
          SetAsDefaultView = view.DefaultView,
          ViewFields = view.ViewFields.ToArray(),
          ViewTypeKind = GetViewType(view.ViewType),
      };
      viewsToCreate.Add(createInfo);
    }
    
    foreach (ViewCreationInformation newView in viewsToCreate)
    {
        newList.Views.Add(newView);
    }
    newList.Update();
}

private static ViewType GetViewType(string viewType)
{
    switch (viewType)
    {
        case "HTML":
            return ViewType.Html;
        case "GRID":
            return ViewType.Grid;
        case "CALENDAR":
            return ViewType.Calendar;
        case "RECURRENCE":
            return ViewType.Recurrence;
        case "CHART":
            return ViewType.Chart;
        case "GANTT":
            return ViewType.Gantt;
        default:
            return ViewType.None;
    }
}

Dans le code suivant, RemoveViews supprime les affichages de la nouvelle liste par :

  1. Obtenir les affichages de liste sur la nouvelle liste à l'aide de la propriété List.Views .

  2. Pour chaque mode d'affichage sur la nouvelle liste, déterminant si cet affichage n'existe pas dans la liste d'origine en alignant sur le titre de la vue à l'aide de ! listToBeReplaced.Views.Any (v = > v.Title == view. Titre. Si un affichage de la nouvelle liste ne dispose pas d'une vue correspondante dans la liste d'origine, puis ajoutez l'affichage à viewsToRemove.

  3. Suppression de tous les affichages des viewsToRemove à l'aide de View.DeleteObject.

private static void RemoveViews(ClientContext clientContext, List listToBeReplaced, List newList)
{
    // Get the list of views on the new list.
    clientContext.Load(newList, l => l.Views);
    clientContext.ExecuteQuery();

    var viewsToRemove = new List<View>();
    foreach (View view in newList.Views)
    {
        if (!listToBeReplaced.Views.Any(v => v.Title == view.Title))
        {
            // If there is no matching view in the source list, add the view to the list of views to be deleted.
            viewsToRemove.Add(view);
        }
    }
    foreach (View view in viewsToRemove)
    {
        view.DeleteObject();
    }
    newList.Update();
    clientContext.ExecuteQuery();
}

MigrateContent migre le contenu à partir de la liste d'origine vers la nouvelle liste par :

  1. Récupération de la destination de copier les fichiers ou le dossier racine de la nouvelle liste, à l'aide de List.RootFolder. L'URL relative de serveur de la liste du dossier de destination est extraite à l'aide de Folder.ServerRelativeUrl.

  2. Récupération de la source des fichiers ou le dossier racine de la liste d'origine, à l'aide de List.RootFolder. L'URL relative de serveur du dossier de liste et de tous les fichiers dans le dossier racine de la source sont chargés à l'aide de l'objet clientContext .

  3. Pour chaque fichier de la source, créez newUrl, qui stocke la nouvelle URL du fichier. newUrl est créée en remplaçant le dossier racine source par dossier de racine de destination.

  4. À l'aide de File.CopyTo pour copier le fichier à l'URL de la racine du dossier de destination. Vous pouvez aussi choisir d'utiliser la méthode File.MoveTo pour déplacer le fichier vers l'URL de destination.

RemarqueRemarque

Le code suivant renvoie tous les éléments de liste. Dans votre environnement de production, envisagez d'optimiser le code suivant à l'implémentation d'une boucle et l'utilisation de plusieurs itérations pour migrer des petites quantités d'éléments de liste.

private static void MigrateContent(ClientContext clientContext, List listToBeReplaced, List newList)
{
    ListItemCollection items = listToBeReplaced.GetItems(CamlQuery.CreateAllItemsQuery());
    Folder destination = newList.RootFolder;
    Folder source = listToBeReplaced.RootFolder;
    clientContext.Load(destination,
                        d => d.ServerRelativeUrl);
    clientContext.Load(source,
                        s => s.Files,
                        s => s.ServerRelativeUrl);
    clientContext.Load(items,
                        i => i.IncludeWithDefaultProperties(item => item.File));
    clientContext.ExecuteQuery();


    foreach (File file in source.Files)
    {
        string newUrl = file.ServerRelativeUrl.Replace(source.ServerRelativeUrl, destination.ServerRelativeUrl);
          file.CopyTo(newUrl, true);
          //file.MoveTo(newUrl, MoveOperations.Overwrite);
    }
    clientContext.ExecuteQuery();
}
RemarqueRemarque

Le code précédent montre comment migrer des fichiers stockés dans le dossier racine d'une liste. Si votre liste comporte des sous-dossiers, vous devez ajouter du code pour migrer les sous-dossiers et leur contenu. Si votre liste utilise le flux de travail, le code supplémentaire est requis pour associer le flux de travail pour la nouvelle liste.

Afficher: