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

Article
02/19/2013

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 Visual Studio.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 la barre de menus, sélectionnez Fichier, Nouveau, Projet.
Dans la boîte de dialogue Nouveau projet , développez les nœuds Visual C# ou de Visual Basic , puis sélectionnez le nœud Extensibilité .

[!REMARQUE]

Le nœud Extensibilité est disponible uniquement si vous installez le kit de développement Visual Studio.Pour plus d'informations, consultez la section des composants requis plus haut dans cette rubrique.
Dans la liste située en haut de la boîte de dialogue Nouveau projet , choisissez .NET Framework 4,5.

Les extensions des outils SharePoint nécessitent des fonctionnalités dans cette version du .NET Framework.
Sélectionnez le modèle projet VSIX .
Dans la zone Nom , entrez GenerateExternalDataLists, puis choisissez le bouton OK .

Visual Studio ajoute le projet GenerateExternalDataLists à l'Explorateur de solutions.
Si le fichier source.extension.vsixmanifest ne s'ouvre pas automatiquement, ouvrez le menu contextuel du projet GenerateExternalDataLists, puis choisissez Ouvrir
Vérifiez que le fichier source.extension.vsixmanifest a une entrée non vide (entrez Contoso) pour le champ d'auteur, enregistrez le fichier, puis fermez -le.

Pour créer le projet d'extension

Dans Explorateur de solutions, ouvrez le menu contextuel du nœud de solution GenerateExternalDataLists , choisissez Ajouter, puis choisissez Nouveau projet.

[!REMARQUE]

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 General, Projects and Solutions, Options Dialog Box.
Dans la boîte de dialogue Ajouter un nouveau projet , développez les nœuds Visual C# ou de Visual Basic , puis sélectionnez le nœud Fenêtres .
Dans la liste située en haut de la boîte de dialogue, choisissez .NET Framework 4,5.
Dans la liste des modèles de projet, choisissez Bibliothèque de classes.
Dans la zone Nom , entrez BdcProjectItemExtension, puis choisissez le bouton 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
Sélectionnez le projet BdcProjectItemExtension, puis, dans la barre de menus, sélectionnez Projet, Ajouter une référence.
Sous le nœud Assemblys , sélectionnez le nœud framework , et sélectionnez la case à cocher pour chacun des assemblys suivants :
- System.ComponentModel.Composition
- WindowsBase
Sous le nœud Assemblys , sélectionnez le nœud Extensions , puis activez la case à cocher pour l'assembly suivant :
- Microsoft.VisualStudio.SharePoint
Cliquez sur le bouton OK.

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

Collez le code suivant dans le fichier de code ProjectItemExtension.

[!REMARQUE]

Après avoir ajouté 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

Collez le code suivant dans le fichier de code GenerateExternalDataLists.

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 la barre de menus, sélectionnez Générer, 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 Explorateur de solutions, ouvrez le menu contextuel du fichier source.extension.vsixmanifest dans le projet GenerateExternalDataLists, puis choisissez Ouvrir.

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 Référence de schéma d'extensions VSIX.
Dans la zone nom de produit , entrez Concepteur de liste de données externes.
Dans la zone Author , entrez Contoso.
Dans la zone Description , entrez l' Une extension pour les éléments de projet de modèle de connectivité de données métiers qui peuvent être utilisés pour générer des listes de données externes.
Sous l'onglet Composants de l'éditeur, choisissez le bouton Nouveau .

La boîte de dialogue ajoutez le nouveau ressource s'affiche.
Dans la liste Type , choisissez Microsoft.VisualStudio.MefComponent.

[!REMARQUE]

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.
Dans la liste Source , choisissez un projet dans la solution actuelle.
Dans la liste Projet , choisissez BdcProjectItemExtension, puis choisissez le bouton OK .
Dans la barre de menus, sélectionnez Générer, Générer la solution.
Assurez -vous que les compilations et le projet est généré sans erreur.
Assurez -vous que le dossier de sortie de la génération pour le projet GenerateExternalDataLists contient maintenant 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

Si nécessaire, la redémarrez Visual Studio avec les informations d'identification d'administration, et ouvrez la solution GenerateExternalDataLists.
Dans le projet BdcProjectItemExtension, ouvrez le fichier de code ProjectItemExtension, puis ajoutez un point d'arrêt à la ligne de code dans la méthode d' Initialize .
Ouvrez le fichier de code GenerateExternalDataLists, puis ajoutez un point d'arrêt sur la première ligne de code dans la méthode d' GenerateExternalDataLists_Execute .
Commencez à déboguer en choisissant la touche F5 ou, dans la barre de menus, choisissant Déboguer, 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, choisissez Fichier, Nouveau, Projet.
Dans la boîte de dialogue Nouveau projet , développez le nœud Modèles , développez le nœud Visual C# , développez le nœud SharePoint , puis choisissez 2010.
Dans la liste située en haut de la boîte de dialogue, assurez -vous 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, choisissez Projet SharePoint 2010.
Dans la zone Nom , entrez SharePointProjectTestBDC, puis choisissez le bouton OK .
Dans l'assistant personnalisation de SharePoint, entrez l'URL du site que vous souhaitez utiliser pour le débogage, choisissez Déployer une solution de batterie, puis choisissez le bouton Terminer.
Ouvrez le menu contextuel du projet de SharePointProjectTestBDC, choisissez Ajouter, puis choisissez Nouvel élément.
Dans la boîte de dialogue ajoutez NewItem – SharePointProjectTestBDC , développez le nœud de langue installée, développez le nœud SharePoint .
Sélectionnez le nœud 2010 , puis choisissez le modèle Business Data Connectivity Model (solution de batterie uniquement) .
Dans la zone Nom , entrez TestBDCModel, puis choisissez le bouton Ajouter .
Vérifiez que le code dans l'autre instance de Visual Studio s'arrête au point d'arrêt que vous avez défini dans la méthode d' Initialize de fichier de code ProjectItemExtension.
Dans l'instance arrêtée Visual Studio, choisissez la clé F5 , ou dans la barre de menus, sélectionnez Déboguer, Continuer pour continuer à déboguer le projet.
Dans l'instance expérimentale de Visual Studio, choisissez la clé F5 , ou, dans la barre de menus, sélectionnez Déboguer, Démarrer le débogage pour générer, déployer, et exécuter le projet TestBDCModel .

Le navigateur web s'ouvre à la page par défaut du site SharePoint spécifié pour le débogage.
Vérifiez si la section listes dans la zone de lancement rapide ne contient pas encore de 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 ouvrez, ouvrez le menu contextuel du nœud TestBDCModel dans Explorateur de solutions, puis choisissez générez la liste de données externes.
Vérifiez que le code dans l'autre instance de Visual Studio s'arrête au point d'arrêt que vous avez défini dans la méthode d' GenerateExternalDataLists_Execute .Choisissez la clé F5 , ou, dans la barre de menus, sélectionnez Déboguer, Continuer pour continuer à déboguer le projet.
L'instance expérimentale de Visual Studio ajoute une instance de liste nommée Entity1DataList au projet testmodèlebdc, et l'instance génère également une fonctionnalité nommée Feature2 pour l'instance de liste.
Choisissez la clé F5 , ou, dans la barre de menus, sélectionnez Déboguer, Démarrer le débogage 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.
Dans la section listes de la zone de lancement rapide, cliquez sur la liste Entity1DataList .
Vérifiez que la liste contient des colonnes nommées Identifier1 et message, en plus d'un élément ayant une valeur d'identificateur1 de 0 et une valeur de message Hello World.

Le modèle de projet Business Data Connectivity Model génère le modèle BDC par défaut qui fournit toutes ces données.
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 de lancement rapide du site SharePoint, choisissez la liste Entity1DataList .
Dans le ruban du site SharePoint, choisissez liste tableau.
Sous l'onglet liste , dans le groupe Paramètres , choisissez Paramètres de liste.
Sous autorisations et gestion, choisissez supprimez cette liste, puis choisissez OK pour confirmer que vous souhaitez envoyer 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, choisissez Générer, Retrait.

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, choisissez Outils, Extensions et mises à jour.

La boîte de dialogue Extensions et mises à jour s'ouvre.
Dans la liste d'extensions, choisissez Concepteur de liste de données externes, puis choisissez le bouton Désinstaller .
Dans la boîte de dialogue qui apparaît, sélectionnez oui pour confirmer que vous voulez désinstaller l'extension.
Choisissez Redémarrez maintenant pour terminer la désinstallation.
Fermez les deux instances de Visual Studio (l'instance expérimentale et l'instance 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