Procédure pas à pas : extension d'un type d'élément de projet SharePoint

Article
08/10/2011

Vous pouvez utiliser l'élément de projet Modèle BDC (Business Data Connectivity afin de créer un modèle pour le service BDC dans SharePoint. Par défaut, lorsque vous créez un modèle à l'aide de cet élément de projet, les données du modèle ne sont pas présentées aux utilisateurs. Pour qu'ils puissent consulter les données, vous êtes tenu de générer une liste externe dans SharePoint.

Au cours de cette procédure, vous allez créer une extension pour l'élément de projet Modèle de connectivité de données métiers. Les développeurs peuvent tirer parti de cette extension pour créer une liste externe au sein de leur projet dans le but d'afficher les données dans le modèle BDC. Cette procédure pas à pas présente les tâches suivantes :

Création d'une extension Visual Studio qui exécute deux tâches principales :
- Elle établit une liste externe présentant les données dans un modèle BDC. L'extension utilise le modèle d'objet pour le système de projet SharePoint afin de générer un fichier Elements.xml qui définit la liste. Elle ajoute, en outre, le fichier au projet afin de le déployer en même temps que le modèle BDC.
- Elle ajoute un élément de menu contextuel aux éléments de projet Modèle de connectivité de données métiers dans l'Explorateur de solutions. Les développeurs peuvent cliquer sur cet élément de menu pour générer une liste externe pour le modèle BDC.
Génération d'un package Visual Studio Extension (VSIX) pour déployer l'assembly de l'extension.
Test de l'extension.

Composants requis

Vous avez besoin des composants suivants sur l'ordinateur de développement pour terminer cette procédure pas à pas :

Éditions de Microsoft Windows, SharePoint et Visual Studio prises en charge. Pour plus d'informations, consultez Configuration requise pour développer des solutions SharePoint.
Kit de développement logiciel (SDK) Visual Studio 2010. Cette procédure pas à pas utilise le modèle Projet VSIX du Kit de développement logiciel (SDK) pour créer un package VSIX afin de déployer l'élément de projet. Pour plus d'informations, consultez Extension des outils SharePoint dans Visual Studio.

Une connaissance des concepts suivants est utile, mais pas obligatoire, pour effectuer cette procédure pas à pas :

Service BDC dans Microsoft SharePoint Server 2010. Pour plus d'informations, consultez Architecture BDC (page éventuellement en anglais).
Schéma XML pour les modèles BDC. Pour plus d'informations, consultez Infrastructure de modèle BDC (page éventuellement en anglais).

Création du projet

Pour exécuter cette procédure pas à pas, vous devez créer deux projets :

Un projet VSIX pour créer le package VSIX afin de déployer l'extension d'élément de projet.
Un projet de bibliothèque de classes qui implémente l'extension d'élément de projet.

Démarrez la procédure pas à pas en créant les projets.

Pour créer le projet VSIX

Démarrez Visual Studio.
Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet.
Dans la boîte de dialogue Nouveau projet, développez les nœuds Visual C# ou Visual Basic, puis cliquez sur le nœud Extensibilité.

Notes

Le nœud Extensibilité est disponible uniquement si vous installez le Kit de développement logiciel (SDK) Visual Studio 2010. Pour plus d'informations, reportez-vous à la section traitant des conditions requises ci-dessus.
Dans la zone de liste déroulante en haut de la boîte de dialogue, sélectionnez .NET Framework 4. Les extensions des outils SharePoint nécessitent des fonctionnalités dans cette version du .NET Framework.
Cliquez sur le modèle Projet VSIX.
Dans la zone Nom, tapez GenerateExternalDataLists.
Cliquez sur OK.

Visual Studio ajoute le projet GenerateExternalDataLists à l'Explorateur de solutions.

Pour créer le projet d'extension

Cliquez avec le bouton droit sur le nœud de la solution dans l'Explorateur de solutions, cliquez sur Ajouter, puis sur Nouveau projet.

Notes

Dans les projets Visual Basic, le nœud de la solution s'affiche dans l'Explorateur de solutions à condition d'avoir activé la case à cocher Toujours afficher la solution dans la Général, Projets et solutions, boîte de dialogue Options.
Dans la boîte de dialogue Nouveau projet, développez le nœud Visual C# ou Visual Basic, puis cliquez sur Fenêtres.
Dans la zone de liste déroulante en haut de la boîte de dialogue, sélectionnez .NET Framework 4.
Sélectionnez le modèle de projet Bibliothèque de classes.
Dans la zone de texte Nom, tapez BdcProjectItemExtension.
Cliquez sur OK.

Visual Studio ajoute le projet BdcProjectItemExtension à la solution et ouvre le fichier de code Class1 par défaut.
Supprimez le fichier de code Class1 du projet.

Configuration du projet d'extension

Avant d'écrire le code pour créer l'extension d'élément de projet, ajoutez les fichiers de code et les références d'assembly au projet d'extension.

Pour configurer le projet

Dans le projet BdcProjectItemExtension, ajoutez deux fichiers de code portant les noms suivants :
- ProjectItemExtension
- GenerateExternalDataLists
Dans le menu Projet, cliquez sur Ajouter une référence.
Sous l'onglet .NET, appuyez sur CTRL et cliquez sur les assemblys suivants, puis cliquez sur OK.
- Microsoft.VisualStudio.SharePoint
- System.ComponentModel.Composition
- WindowsBase

Définition de l'extension d'élément de projet

Créez une classe qui définit l'extension pour l'élément de projet Modèle de connectivité de données métiers. Pour définir l'extension, la classe implémente l'interface ISharePointProjectItemTypeExtension. Mettez en œuvre cette interface chaque fois que vous souhaitez étendre un type d'élément de projet existant.

Pour définir l'extension d'élément de projet

Double-cliquez sur le fichier de code ProjectItemExtension.

Collez le code suivant dans le fichier.

Notes

Après l'ajout de ce code, le projet comportera des erreurs de compilation. Ces erreurs disparaîtront lorsque vous ajouterez du code dans les étapes ultérieures.

Imports Microsoft.VisualStudio.SharePoint
Imports System.ComponentModel.Composition

Namespace Contoso.SharePointProjectItemExtensions.GenerateExternalDataLists

    ' Export attribute: Enables Visual Studio to discover and load this extension.
    ' SharePointProjectItemType attribute: Specifies the ID of the project item to extend.
    ' GenerateExternalDataListsExtension class: Defines the extension for the BDC project item.
    '     The other part of the partial class contains the logic for generating the external data lists. 
    <Export(GetType(ISharePointProjectItemTypeExtension))> _
    <SharePointProjectItemType("Microsoft.VisualStudio.SharePoint.BusinessDataConnectivity")> _
    Partial Friend Class GenerateExternalDataListsExtension
        Implements ISharePointProjectItemTypeExtension

        ' Creates the new shortcut menu item that the user clicks to generate the external data lists.
        Private Sub Initialize(ByVal SharePointProjectItemType As ISharePointProjectItemType) _
            Implements ISharePointProjectItemTypeExtension.Initialize
            AddHandler SharePointProjectItemType.ProjectItemMenuItemsRequested,
                AddressOf SharePointProjectItemMenuItemsRequested
        End Sub

        Private Sub SharePointProjectItemMenuItemsRequested(ByVal Sender As Object, _
            ByVal e As SharePointProjectItemMenuItemsRequestedEventArgs)
            Dim generateListMenuItem As IMenuItem = e.ViewMenuItems.Add("Generate External Data List")
            AddHandler generateListMenuItem.Click, AddressOf GenerateExternalDataLists_Execute
        End Sub
    End Class
End Namespace

using Microsoft.VisualStudio.SharePoint;
using System.ComponentModel.Composition;

namespace Contoso.SharePointProjectItemExtensions.GenerateExternalDataLists
{
    // Enables Visual Studio to discover and load this extension.
    [Export(typeof(ISharePointProjectItemTypeExtension))]

    // Specifies the ID of the project item to extend.
    [SharePointProjectItemType("Microsoft.VisualStudio.SharePoint.BusinessDataConnectivity")]

    // Defines the extension for the BDC project item. The other part of the partial class contains
    // the logic for generating the external data lists. 
    internal partial class GenerateExternalDataListsExtension : ISharePointProjectItemTypeExtension
    {
        // Implements IProjectItemTypeExtension.Initialize. Creates the new shortcut menu item that
        // the user clicks to generate the external data lists.
        public void Initialize(ISharePointProjectItemType projectItemType)
        {
            projectItemType.ProjectItemMenuItemsRequested += ProjectItemMenuItemsRequested;
        }

        private void ProjectItemMenuItemsRequested(object sender, SharePointProjectItemMenuItemsRequestedEventArgs e)
        {
            e.ViewMenuItems.Add("Generate External Data List").Click += GenerateExternalDataLists_Execute;
        }
    }
}

Création des listes de données externes

Ajoutez une définition partielle de la classe GenerateExternalDataListsExtension prévue pour créer une liste de données externes pour chaque entité dans le modèle BDC. Pour établir la liste de données externes, ce code commence par lire les données d'entité dans le modèle BDC en analysant les données XML du fichier du modèle BDC. Il génère ensuite une instance de liste basée sur le modèle BDC et ajoute cette instance de liste au projet.

Pour créer les listes de données externes

Double-cliquez sur le fichier de code GenerateExternalDataLists.

Collez le code suivant dans le fichier.

Imports Microsoft.VisualStudio.SharePoint
Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic
Imports System.IO
Imports System.Linq
Imports System.Text
Imports System.Xml.Linq

Namespace Contoso.SharePointProjectItemExtensions.GenerateExternalDataLists

    ' Creates the external data lists for the BDC item. The other part of the partial class 
    ' defines the BDC project item extension.
    Partial Friend Class GenerateExternalDataListsExtension

        Private Const ModelFileNameString As String = "ModelFileName"
        Private Const EXTENSION_BDCM As String = ".bdcm"
        Private Const NamespaceString As String = "https://schemas.microsoft.com/windows/2007/BusinessDataCatalog"
        Private Shared ReadOnly BdcNamespace As XNamespace = XNamespace.Get(NamespaceString)

        ' Generates an external data list for each Entity in the BDC model. This event handler is called
        ' when the developer clicks the shortcut menu item that the extension adds to the BDC project item.
        Private Sub GenerateExternalDataLists_Execute(ByVal Sender As Object, ByVal e As MenuItemEventArgs)

            Dim projectItem As ISharePointProjectItem = CType(e.Owner, ISharePointProjectItem)
            Dim bdcmFile As ISharePointProjectItemFile = GetModelFile(projectItem)

            Dim doc As XDocument = XDocument.Load(bdcmFile.FullPath)
            Dim skippedEntities As List(Of XElement) = New List(Of XElement)()

            ' Try to generate an external data list for each entity defined in the BDC model file.
            For Each entity As XElement In doc.Root.Elements(BdcNamespace + "LobSystems").Elements( _
                BdcNamespace + "LobSystem").Elements(BdcNamespace + "Entities").Elements(BdcNamespace + "Entity")

                If False = GenerateExternalDataList(projectItem, entity) Then
                    skippedEntities.Add(entity)
                End If
            Next

            ' Report skipped entities.
            If skippedEntities.Count <> 0 Then
                Dim entityNameList As StringBuilder = Nothing
                skippedEntities.ForEach(Function(entity As XElement)
                                            If (entityNameList Is Nothing) Then
                                                entityNameList = New StringBuilder()
                                            Else
                                                entityNameList.AppendLine(",")
                                            End If
                                            entityNameList.Append(entity.Attribute("Name").Value)
                                        End Function)

                Dim message As String = String.Format("The following Entities were skipped because " &
                    "either a LobSystemInstance, SpecificFinder, or Finder was not found for them. \r\n{0}", _
                    entityNameList)
                projectItem.Project.ProjectService.Logger.WriteLine(message, LogCategory.Warning)
            End If
        End Sub

        ' Gets the ISharePointProjectItemFile object for the BDC model file.
        Private Function GetModelFile(ByVal projectItem As ISharePointProjectItem) As ISharePointProjectItemFile

            Dim modelFileName As String = Nothing
            If projectItem.FeatureProperties.TryGetValue(ModelFileNameString, modelFileName) Then
                modelFileName = Path.GetFileName(modelFileName)
                Return (From file In projectItem.Files _
                        Where String.Compare(file.Name, modelFileName, StringComparison.OrdinalIgnoreCase) = 0 _
                        Select file).FirstOrDefault()
            Else
                ' If we can't find the ModelFileName through the FeatureProperties, 
                ' get the first file that has a '.bdcm' extension
                Return (From file In projectItem.Files _
                        Where file.Name.EndsWith(EXTENSION_BDCM, StringComparison.OrdinalIgnoreCase) _
                        Select file).FirstOrDefault()
            End If
        End Function

        ' Boilerplate XML for the new list instance that is based on the BDC model.
        Private Const externalDataListContent As String = _
            "<?xml version=""1.0"" encoding=""utf-8""?>" & vbCrLf & _
            "        <Elements https://schemas.microsoft.com/sharepoint/"">" & vbCrLf & _
            "          <ListInstance Title=""$EntityName$DataList""" & vbCrLf & _
            "                        OnQuickLaunch=""TRUE""" & vbCrLf & _
            "                        TemplateType=""104""" & vbCrLf & _
            "                        FeatureId=""$SharePoint.Feature.Id$""" & vbCrLf & _
            "                        Url=""Lists/$EntityName$DataList""" & vbCrLf & _
            "                        Description=""Default List for $EntityName$."">" & vbCrLf & _
            "            <DataSource>" & vbCrLf & _
            "              <Property Name=""LobSystemInstance"" Value=""$LobSystemInstance$"" />" & vbCrLf & _
            "              <Property Name=""EntityNamespace"" Value=""$EntityNamespace$"" />" & vbCrLf & _
            "              <Property Name=""Entity"" Value=""$EntityName$"" />" & vbCrLf & _
            "              <Property Name=""SpecificFinder"" Value=""$SpecificFinder$"" />" & vbCrLf & _
            "              <Property Name=""Finder"" Value=""$Finder$"" />" & vbCrLf & _
            "            </DataSource>" & vbCrLf & _
            "          </ListInstance>" & vbCrLf & _
            "        </Elements>"

        ' Tries to generate an external data list for the specified BDC model project item and entity.
        Private Function GenerateExternalDataList(ByVal projectItem As ISharePointProjectItem, ByVal entity As XElement) As Boolean

            Dim lobSystemInstanceName As String = GetLobSystemInstanceName(entity)
            Dim specificFinderName As String = GetSpecificFinderName(entity)
            Dim finderName As String = GetFinderName(entity)
            Dim entityName As String = entity.Attribute("Name").Value

            If String.IsNullOrEmpty(lobSystemInstanceName) Or String.IsNullOrEmpty(specificFinderName) Or _
                String.IsNullOrEmpty(finderName) Then
                Return False
            End If

            Dim newExternalDataListName As String = entityName & "DataList"
            Dim existingProjectItem As ISharePointProjectItem = (From existingItem As ISharePointProjectItem In projectItem.Project.ProjectItems
                                                Where existingItem.Name = newExternalDataListName
                                                Select existingItem).FirstOrDefault()

            ' Add a new list instance and populate it with data from the BDC model.
            If existingProjectItem Is Nothing Then
                Dim newExternalDataList As ISharePointProjectItem = projectItem.Project.ProjectItems.Add(newExternalDataListName, _
                    "Microsoft.VisualStudio.SharePoint.ListInstance")

                Dim newExternalDataListString As String = externalDataListContent
                newExternalDataListString = newExternalDataListString.Replace("$EntityName$", entityName)
                newExternalDataListString = newExternalDataListString.Replace("$LobSystemInstance$", lobSystemInstanceName)
                newExternalDataListString = newExternalDataListString.Replace("$EntityNamespace$", entity.Attribute("Namespace").Value)
                newExternalDataListString = newExternalDataListString.Replace("$SpecificFinder$", specificFinderName)
                newExternalDataListString = newExternalDataListString.Replace("$Finder$", finderName)

                Dim elementsXmlPath As String = Path.Combine(newExternalDataList.FullPath, "Elements.xml")
                File.WriteAllText(elementsXmlPath, newExternalDataListString)
                Dim elementsFile As ISharePointProjectItemFile = newExternalDataList.Files.AddFromFile(elementsXmlPath)
                elementsFile.DeploymentType = DeploymentType.ElementManifest
            End If

            Return True
        End Function

        Private Function GetLobSystemInstanceName(ByVal entity As XElement) As String

            Dim lobSystemInstances As XElement = entity.Parent.Parent.Element(BdcNamespace + "LobSystemInstances")
            If lobSystemInstances IsNot Nothing Then
                Dim lobSystemInstance As XElement = lobSystemInstances.Elements(BdcNamespace + "LobSystemInstance").FirstOrDefault()
                If lobSystemInstance IsNot Nothing Then
                    Return lobSystemInstance.Attribute("Name").Value
                End If
            End If
            Return Nothing
        End Function

        Private Function GetSpecificFinderName(ByVal entity As XElement) As String
            Return GetMethodInstance(entity, "SpecificFinder")
        End Function

        Private Function GetFinderName(ByVal entity As XElement) As String
            Return GetMethodInstance(entity, "Finder")
        End Function

        Private Function GetMethodInstance(ByVal entity As XElement, ByVal methodInstanceType As String) As String
            Dim methods As XElement = entity.Element(BdcNamespace + "Methods")
            If methods IsNot Nothing Then
                For Each method As XElement In methods.Elements(BdcNamespace + "Method")
                    Dim methodInstances As XElement = method.Element(BdcNamespace + "MethodInstances")
                    If methodInstances IsNot Nothing Then
                        For Each methodInstance As XElement In methodInstances.Elements(BdcNamespace + "MethodInstance")
                            If methodInstance.Attribute("Type").Value = methodInstanceType Then
                                Return methodInstance.Attribute("Name").Value
                            End If
                        Next
                    End If
                Next
            End If
            Return Nothing
        End Function

    End Class
End Namespace

using Microsoft.VisualStudio.SharePoint;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml.Linq;

namespace Contoso.SharePointProjectItemExtensions.GenerateExternalDataLists
{
    // Creates the external data lists for the BDC item. The other part of the partial class 
    // defines the BDC project item extension.
    internal partial class GenerateExternalDataListsExtension
    {
        private const string ModelFileNameString = "ModelFileName";
        private const string EXTENSION_BDCM = ".bdcm";
        private const string NamespaceString = "https://schemas.microsoft.com/windows/2007/BusinessDataCatalog";
        private static readonly XNamespace BdcNamespace = XNamespace.Get(NamespaceString);

        // Generates an external data list for each Entity in the BDC model. This event handler is called
        // when the developer clicks the shortcut menu item that the extension adds to the BDC project item.
        private void GenerateExternalDataLists_Execute(object sender, MenuItemEventArgs e)
        {
            ISharePointProjectItem projectItem = (ISharePointProjectItem)e.Owner;
            ISharePointProjectItemFile bdcmFile = GetModelFile(projectItem);

            XDocument doc = XDocument.Load(bdcmFile.FullPath);
            List<XElement> skippedEntities = new List<XElement>();

            // Try to generate an external data list for each entity defined in the BDC model file.
            foreach (XElement entity in doc.Root.Elements(BdcNamespace + "LobSystems").Elements(
                BdcNamespace + "LobSystem").Elements(BdcNamespace + "Entities").Elements(BdcNamespace + "Entity"))
            {
                if (!GenerateExternalDataList(projectItem, entity))
                {
                    skippedEntities.Add(entity);
                }
            }

            // Report skipped entities.
            if (skippedEntities.Count != 0)
            {
                StringBuilder entityNameList = null;
                skippedEntities.ForEach(delegate(XElement entity)
                {
                    if (entityNameList == null)
                    {
                        entityNameList = new StringBuilder();
                    }
                    else
                    {
                        entityNameList.AppendLine(",");
                    }
                    entityNameList.Append(entity.Attribute("Name").Value);
                });

                string message = string.Format("The following Entities were skipped because either a LobSystemInstance, " +
                    "SpecificFinder, or Finder was not found for them. \r\n{0}", entityNameList);
                projectItem.Project.ProjectService.Logger.WriteLine(message, LogCategory.Warning);
            }
        }

        // Gets the ISharePointProjectItemFile object for the BDC model file.
        private ISharePointProjectItemFile GetModelFile(ISharePointProjectItem projectItem)
        {
            string modelFileName;
            if (projectItem.FeatureProperties.TryGetValue(ModelFileNameString, out modelFileName))
            {
                modelFileName = Path.GetFileName(modelFileName);
                return (from file in projectItem.Files
                        where string.Compare(file.Name, modelFileName, StringComparison.OrdinalIgnoreCase) == 0
                        select file).FirstOrDefault();
            }
            else
            {
                // if we can't find the ModelFileName through the FeatureProperties, 
                // get the first file that has a '.bdcm' extension
                return (from file in projectItem.Files
                        where file.Name.EndsWith(EXTENSION_BDCM, StringComparison.OrdinalIgnoreCase)
                        select file).FirstOrDefault();
            }
        }

        // Boilerplate XML for the new list instance that is based on the BDC model.
        private const string externalDataListContent =
            @"<?xml version=""1.0"" encoding=""utf-8""?>
            <Elements https://schemas.microsoft.com/sharepoint/"">
              <ListInstance Title=""$EntityName$DataList""
                            OnQuickLaunch=""TRUE""
                            TemplateType=""104""
                            FeatureId=""$SharePoint.Feature.Id$""
                            Url=""Lists/$EntityName$DataList""
                            Description=""Default List for $EntityName$."">
                <DataSource>
                  <Property Name=""LobSystemInstance"" Value=""$LobSystemInstance$"" />
                  <Property Name=""EntityNamespace"" Value=""$EntityNamespace$"" />
                  <Property Name=""Entity"" Value=""$EntityName$"" />
                  <Property Name=""SpecificFinder"" Value=""$SpecificFinder$"" />
                  <Property Name=""Finder"" Value=""$Finder$"" />
                </DataSource>
              </ListInstance>
            </Elements>";

        // Tries to generate an external data list for the specified BDC model project item and entity.
        private bool GenerateExternalDataList(ISharePointProjectItem projectItem, XElement entity)
        {
            string lobSystemInstanceName = GetLobSystemInstanceName(entity);
            string specificFinderName = GetSpecificFinderName(entity);
            string finderName = GetFinderName(entity);
            string entityName = entity.Attribute("Name").Value;

            if (string.IsNullOrEmpty(lobSystemInstanceName) || string.IsNullOrEmpty(specificFinderName) || 
                string.IsNullOrEmpty(finderName))
            {
                return false;
            }

            string newExternalDataListName = entityName + "DataList";
            ISharePointProjectItem existingProjectItem = (from ISharePointProjectItem existingItem in projectItem.Project.ProjectItems
                                                where existingItem.Name == newExternalDataListName
                                                select existingItem).FirstOrDefault();

            // Add a new list instance and populate it with data from the BDC model.
            if (existingProjectItem == null)
            {
                ISharePointProjectItem newExternalDataList = projectItem.Project.ProjectItems.Add(newExternalDataListName, 
                    "Microsoft.VisualStudio.SharePoint.ListInstance");

                string newExternalDataListString = externalDataListContent;
                newExternalDataListString = newExternalDataListString.Replace("$EntityName$", entityName);
                newExternalDataListString = newExternalDataListString.Replace("$LobSystemInstance$", lobSystemInstanceName);
                newExternalDataListString = newExternalDataListString.Replace("$EntityNamespace$", entity.Attribute("Namespace").Value);
                newExternalDataListString = newExternalDataListString.Replace("$SpecificFinder$", specificFinderName);
                newExternalDataListString = newExternalDataListString.Replace("$Finder$", finderName);

                string elementsXmlPath = Path.Combine(newExternalDataList.FullPath, "Elements.xml");
                File.WriteAllText(elementsXmlPath, newExternalDataListString);
                ISharePointProjectItemFile elementsFile = newExternalDataList.Files.AddFromFile(elementsXmlPath);
                elementsFile.DeploymentType = DeploymentType.ElementManifest;
            }

            return true;
        }

        private string GetLobSystemInstanceName(XElement entity)
        {
            XElement lobSystemInstances = entity.Parent.Parent.Element(BdcNamespace + "LobSystemInstances");
            if (lobSystemInstances != null)
            {
                XElement lobSystemInstance = lobSystemInstances.Elements(BdcNamespace + "LobSystemInstance").FirstOrDefault();
                if (lobSystemInstance != null)
                {
                    return lobSystemInstance.Attribute("Name").Value;
                }
            }
            return null;
        }

        private string GetSpecificFinderName(XElement entity)
        {
            return GetMethodInstance(entity, "SpecificFinder");
        }

        private string GetFinderName(XElement entity)
        {
            return GetMethodInstance(entity, "Finder");
        }

        private string GetMethodInstance(XElement entity, string methodInstanceType)
        {
            XElement methods = entity.Element(BdcNamespace + "Methods");
            if (methods != null)
            {
                foreach (XElement method in methods.Elements(BdcNamespace + "Method"))
                {
                    XElement methodInstances = method.Element(BdcNamespace + "MethodInstances");
                    if (methodInstances != null)
                    {
                        foreach (XElement methodInstance in methodInstances.Elements(BdcNamespace + "MethodInstance"))
                        {
                            if (methodInstance.Attribute("Type").Value == methodInstanceType)
                            {
                                return methodInstance.Attribute("Name").Value;
                            }
                        }
                    }
                }
            }

            return null;
        }
    }
}

Point de contrôle

À ce stade de la procédure, l'intégralité du code de l'extension de l'élément de projet fait désormais partie du projet. Générez la solution afin de garantir sa compilation sans erreur.

Pour générer la solution

Dans le menu Générer, sélectionnez Générer la solution.

Création d'un package VSIX pour déployer l'extension d'élément de projet

Pour déployer l'extension, utilisez le projet VSIX inclus dans votre solution pour créer un package VSIX. En premier lieu, configurez le package VSIX en modifiant le fichier source.extension.vsixmanifest qui est inclus dans le projet VSIX. Ensuite, créez le package VSIX en générant la solution.

Pour configurer et créer le package VSIX

Dans l'Explorateur de solutions, double-cliquez sur le fichier source.extension.vsixmanifest dans le projet GenerateExternalDataLists.

Visual Studio ouvre le fichier dans l'éditeur de manifeste. Le fichier source.extension.vsixmanifest est la base du fichier extension.vsixmanifest requis par tous les packages VSIX. Pour plus d'informations sur ce fichier, consultez VSIX Extension Schema Reference.
Dans la zone Nom du produit, tapez Générateur de liste de données externe.
Dans la zone Auteur, tapez Contoso.
Dans la zone Description, tapez Extension pour les éléments de projet Modèle de connectivité de données métiers permettant de générer des listes de données externes.
Dans la section Contenu de l'éditeur, cliquez sur le bouton Ajouter du contenu.
Dans la boîte de dialogue Ajouter du contenu, dans la zone de liste Sélectionner un type de contenu, sélectionnez Composant MEF.

Notes

Cette valeur correspond à l'élément MefComponent dans le fichier extension.vsixmanifest. Cet élément spécifie le nom d'un assembly d'extension dans le package VSIX. Pour plus d'informations, consultez MEFComponent Element (VSX Schema).
Sous Sélectionner une source, cliquez sur la case d'option Projet et sélectionnez BdcProjectItemExtension dans la zone de liste en regard de cette dernière.
Cliquez sur OK.
Dans le menu Générer, cliquez sur Générer la solution. Assurez-vous que le projet se compile sans erreurs.
Ouvrez le dossier de sortie de la génération pour le projet GenerateExternalDataLists. Assurez-vous que ce dossier contient, à présent, le fichier GenerateExternalDataLists.vsix.

Par défaut, le dossier de sortie de la génération est le dossier .. \bin\Debug sous le dossier qui contient votre fichier projet.

Test de l'extension d'élément de projet

Vous êtes maintenant prêt à tester l'extension d'élément de projet. Tout d'abord, commencez à déboguer le projet d'extension dans l'instance expérimentale de Visual Studio. Utilisez ensuite l'extension dans l'instance expérimentale de Visual Studio pour générer une liste externe pour un modèle BDC. Pour finir, ouvrez la liste externe sur le site SharePoint pour vérifier si elle fonctionne comme prévu.

Pour démarrer le débogage de l'extension

Redémarrez Visual Studio avec les privilèges d'administrateur et ouvrez la solution GenerateExternalDataLists.
Dans le projet BdcProjectItemExtension, ouvrez le fichier de code ProjectItemExtension et ajoutez un point d'arrêt au niveau de la ligne de code dans la méthode Initialize.
Ouvrez le fichier de code GenerateExternalDataLists et ajoutez un point d'arrêt au niveau de la première ligne de code dans la méthode GenerateExternalDataLists_Execute.
Appuyez sur F5 pour démarrer le débogage.

Visual Studio installe l'extension sous %UserProfile%\AppData\Local\Microsoft\VisualStudio\10.0Exp\Extensions\Contoso\Générateur de liste de données externe\1.0 et démarre une instance expérimentale de Visual Studio. Vous testerez l'élément de projet dans cette instance de Visual Studio.

Pour tester l'extension

Dans l'instance expérimentale de Visual Studio, dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet.
Développez Visual C#, développez SharePoint, puis cliquez sur 2010.
Dans la zone de liste déroulante en haut de la boîte de dialogue, vérifiez que .NET Framework 3.5 est sélectionné. Les projets pour Microsoft SharePoint Server 2010 requièrent cette version du .NET Framework.
Dans la liste des modèles de projet, cliquez sur Modèle de connectivité de données métiers.
Dans la zone Nom, tapez TestModèleBDC.
Cliquez sur OK.
Dans l'Assistant Personnalisation de SharePoint, saisissez l'URL du site que vous souhaitez utiliser pour le débogage, puis cliquez sur Terminer.
Assurez-vous que le code dans l'autre instance de Visual Studio s'arrête au niveau du point d'arrêt que vous avez défini précédemment dans la méthode Initialize. Appuyez sur F5 dans cette instance de Visual Studio pour continuer à déboguer le projet.
Dans l'instance expérimentale de Visual Studio, appuyez sur F5 pour générer, déployer et exécuter le projet TestModèleBDC. Le navigateur Web s'ouvre à la page par défaut du site SharePoint utilisé pour le débogage.
Vérifiez si la section Listes dans la zone Lancement rapide ne contient pas déjà une liste basée sur le modèle BDC par défaut dans le projet. Vous devez commencer par créer une liste de données externes, via l'interface utilisateur SharePoint ou via l'extension d'élément de projet.
Fermez le navigateur Web.
Dans l'instance de Visual Studio dans laquelle le projet TestModèleBDC est ouvert, cliquez avec le bouton droit sur le nœud BdcModel1 dans l'Explorateur de solutions, puis cliquez sur Générer une liste de données externes.
Assurez-vous que le code dans l'autre instance de Visual Studio s'arrête au niveau du point d'arrêt que vous avez défini précédemment dans la méthode GenerateExternalDataLists_Execute. Appuyez sur F5 pour continuer de déboguer le projet.
L'instance expérimentale de Visual Studio ajoute une instance de liste nommée Entity1DataList au projet TestModèleBDC et génère une fonctionnalité appelée Feature2 pour l'instance de liste.
Appuyez sur F5 pour générer, déployer et exécuter le projet TestModèleBDC. Le navigateur Web s'ouvre à la page par défaut du site SharePoint utilisé pour le débogage.
Vérifiez si la section Listes dans la zone Lancement rapide contient maintenant une liste appelée Entity1DataList.
Cliquez sur la liste Entity1DataList.
Assurez-vous que la liste contient des colonnes nommées Identifier1 et Message, et un élément avec une valeur Identifier1 équivalente à 0 et une valeur Message équivalente à Hello World. Toute ces données sont fournies par le modèle BDC par défaut généré par le modèle de projet Modèle de connectivité de données métiers.
Fermez le navigateur Web.

Nettoyage de l'ordinateur de développement

Une fois le test de l'extension d'élément de projet terminé, supprimez la liste externe et le modèle BDC du site SharePoint et faites de même avec l'extension d'élément de projet dans Visual Studio.

Pour supprimer la liste de données externe du site SharePoint

Dans la zone Lancement rapide du site SharePoint, cliquez sur la liste Entity1DataList.
Dans le Ruban du site SharePoint, cliquez sur l'onglet Liste.
Dans le groupe Paramètres de l'onglet Liste, cliquez sur Paramètres de la liste.
Sous Autorisations et gestion, cliquez sur Supprimer cette liste. Cliquez sur OK pour confirmer l'envoi de la liste à la Corbeille.
Fermez le navigateur Web.

Pour supprimer le modèle BDC du site SharePoint

Dans l'instance expérimentale de Visual Studio, dans le menu Générer, cliquez sur Retirer.

Visual Studio supprime le modèle BDC du site SharePoint.

Pour supprimer l'extension d'élément de projet de Visual Studio

Dans l'instance expérimentale de Visual Studio, dans le menu Outils, cliquez sur Gestionnaire d'extensions.

La boîte de dialogue Gestionnaire d'extensions s'ouvre.
Dans la liste d'extensions, cliquez sur Générateur de liste de données externe, puis sur Désinstaller.
Dans la boîte de dialogue qui s'affiche, cliquez sur Oui pour confirmer que vous voulez désinstaller l'extension.
Cliquez sur Redémarrer maintenant pour terminer l'installation.
Fermez les deux instances de Visual Studio (l'instance expérimentale et l'instance de Visual Studio dans laquelle la solution GenerateExternalDataLists est ouverte).

Voir aussi

Concepts

Extension du système de projet SharePoint

Autres ressources

Création d'un modèle de connectivité de données métiers

Conception d'un modèle de connectivité de données métiers

Partager via