Procedura dettagliata: estensione di un tipo di elemento di progetto SharePoint

Articolo
08/11/2011

È possibile utilizzare l'elemento del progetto Modello di integrazione applicativa dei dati per creare un modello per il servizio Integrazione applicativa dei dati (BDC, Business Data Connectivity) in SharePoint. Per impostazione predefinita, quando si crea un modello tramite questo elemento di progetto, i dati nel modello non vengono visualizzati agli utenti. Per cambiare questa condizione, è necessario creare anche un elenco esterno in SharePoint.

In questa procedura dettagliata verrà creata un'estensione per l'elemento di progetto Modello di integrazione applicativa dei dati. Gli sviluppatori possono utilizzare l'estensione per creare un elenco esterno nel progetto che consenta di visualizzare i dati nel modello BDC. In questa procedura dettagliata vengono illustrate le attività seguenti:

Creazione di un'estensione di Visual Studio che esegue due attività principali:
- Genera un elenco esterno che visualizza i dati in un modello BDC. L'estensione utilizza il modello a oggetti affinché il sistema di progetto SharePoint generi un file Elements.xml che definisce l'elenco. Inoltre aggiunge il file al progetto in modo che venga distribuito insieme al modello BDC.
- Aggiunge una voce di menu di scelta rapida agli elementi di progetto Modello di integrazione applicativa dei dati in Esplora soluzioni. Gli sviluppatori possono fare clic su questa voce di menu per generare un elenco esterno per il modello BDC.
Compilazione di un pacchetto Visual Studio Extension (VSIX) per distribuire l'assembly delle estensioni.
Test dell'estensione.

Prerequisiti

Per completare la procedura dettagliata, nel computer di sviluppo devono essere presenti i componenti elencati di seguito:

Edizioni supportate di Microsoft Windows, SharePoint e Visual Studio. Per ulteriori informazioni, vedere Requisiti per lo sviluppo di soluzioni SharePoint.
Campo Visual Studio 2010 SDK. In questa procedura dettagliata viene utilizzato il modello VSIX Project di SDK per creare un pacchetto VSIX e distribuire l'elemento di progetto. Per ulteriori informazioni, vedere Estensione degli strumenti di SharePoint in Visual Studio.

Per completare la procedura dettagliata è consigliabile conoscere i concetti riportati di seguito:

Servizio BDC in Microsoft SharePoint Server 2010. Per ulteriori informazioni, vedere l'argomento relativo all'architettura di integrazione applicativa dei dati (la pagina potrebbe essere in inglese).
XML Schema per i modelli BDC. Per ulteriori informazioni, vedere l'articolo relativo all'infrastruttura dei modelli di integrazione applicativa dei dati (la pagina potrebbe essere in inglese).

Creazione dei progetti

Per completare questa procedura dettagliata è necessario creare due progetti:

Un progetto VSIX per creare il pacchetto VSIX allo scopo di distribuire l'estensione di elemento di progetto.
Un progetto Libreria di classi che implementa l'estensione di elemento di progetto.

Iniziare la procedura dettagliata creando i progetti.

Per creare il progetto VSIX

Avviare Visual Studio.
Scegliere Nuovo dal menu File, quindi fare clic su Progetto.
Nella finestra di dialogo Nuovo progetto espandere i nodi Visual C# o Visual Basic, quindi fare clic sul nodo Extensibility.

Nota

Il nodo Extensibility è disponibile solo se si installa Visual Studio 2010 SDK. Per ulteriori informazioni, vedere la sezione dei prerequisiti riportata in precedenza.
Selezionare .NET Framework 4 dalla casella combinata nella parte superiore della finestra di dialogo. Le estensioni degli strumenti di SharePoint richiedono alcune funzionalità di questa versione di .NET Framework.
Scegliere il modello VSIX Project.
Nella casella Nome digitare GenerateExternalDataLists.
Scegliere OK.

Visual Studio aggiunge il progetto GenerateExternalDataLists a Esplora soluzioni.

Per creare il progetto di estensione

In Esplora soluzioni fare clic con il pulsante destro del mouse sul nodo della soluzione, scegliere Aggiungi, quindi Nuovo progetto.

Nota

Nei progetti di Visual Basic, il nodo della soluzione viene visualizzato in Esplora soluzioni solo quando la casella di controllo Mostra sempre soluzione viene selezionata in Finestra di dialogo Opzioni, Progetti e soluzioni, Generale.
Nella finestra di dialogo Nuovo progetto espandere i nodi Visual C# o Visual Basic, quindi fare clic su Windows.
Selezionare .NET Framework 4 dalla casella combinata nella parte superiore della finestra di dialogo.
Selezionare il modello di progetto Libreria di classi.
Nella casella Nome digitare BdcProjectItemExtension.
Fare clic su OK.

In Visual Studio il progetto BdcProjectItemExtension viene aggiunto alla soluzione e viene aperto il file di codice predefinito Class1.
Eliminare il file di codice Class1 dal progetto.

Configurazione del progetto di estensione

Prima di scrivere codice per creare l'estensione di elemento del progetto, aggiungere al progetto di estensione file di codice e riferimenti all'assembly.

Per configurare il progetto

Nel progetto BdcProjectItemExtension aggiungere due file di codice con i nomi seguenti:
- ProjectItemExtension
- GenerateExternalDataLists
Scegliere Aggiungi riferimento dal menu Progetto.
Nella scheda .NET premere CTRL e selezionare gli assembly seguenti, quindi fare clic su OK:
- Microsoft.VisualStudio.SharePoint
- System.ComponentModel.Composition
- WindowsBase

Definizione dell'estensione dell'elemento di progetto

Creare una classe che definisce l'estensione per l'elemento di progetto Modello di integrazione applicativa dei dati. Per definire l'estensione, la classe implementa l'interfaccia ISharePointProjectItemTypeExtension. Implementare questa interfaccia tutte le volte che si desidera estendere un tipo esistente di elemento di progetto.

Per definire l'estensione dell'elemento di progetto

Fare doppio clic sul file di codice ProjectItemExtension.

Incollare il codice riportato di seguito nel file.

Nota

Dopo aver aggiunto questo codice, il progetto presenterà alcuni errori di compilazione che scompariranno quando si aggiunge codice nei passaggi successivi.

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;
        }
    }
}

Creazione di elenchi di dati esterni

Aggiungere una definizione parziale della classe GenerateExternalDataListsExtension che crea un elenco di dati esterni per ogni entità nel modello BDC. Per creare l'elenco di dati esterni, questo codice innanzitutto legge i dati di entità nel modello BDC analizzando i dati XML nel file del modello BDC. Successivamente, crea un'istanza di elenco basata sul modello BDC e la aggiunge al progetto.

Per creare gli elenchi di dati esterni

Fare doppio clic sul file di codice GenerateExternalDataLists.

Incollare il codice riportato di seguito nel file.

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;
        }
    }
}

Verifica

In questa fase della procedura dettagliata, tutto il codice per l'estensione dell'elemento di progetto si trova nel progetto. Compilare la soluzione per assicurarsi che il progetto venga compilato correttamente.

Per compilare la soluzione

Scegliere Compila soluzione dal menu Compila.

Creazione di un pacchetto VSIX per distribuire l'estensione dell'elemento di progetto

Per distribuire l'estensione, utilizzare il progetto VSIX nella soluzione per creare un pacchetto VSIX. Anzitutto, configurare il pacchetto VSIX modificando il file source.extension.vsixmanifest incluso nel progetto VSIX. Quindi, creare il pacchetto VSIX compilando la soluzione.

Per configurare e creare il pacchetto VSIX

In Esplora soluzioni fare doppio clic sul file source.extension.vsixmanifest nel progetto GenerateExternalDataLists.

Visual Studio consente di aprire il file nell'editor del manifesto. Il file source.extension.vsixmanifest è la base del file extension.vsixmanifest richiesto da tutti i pacchetti VSIX. Per ulteriori informazioni su questo file, vedere VSIX Extension Schema Reference.
Nella casella Nome prodotto digitare External Data List Generator.
Nella casella Autore digitare Contoso.
Nella casella Descrizione digitare An extension for Business Data Connectivity Model project items that can be used to generate external data lists.
Nella sezione Contenuto dell'editor fare clic sul pulsante Aggiungi contenuto.
Nella finestra di dialogo Aggiungi contenuto selezionare Componente MEF nella casella di riepilogo Seleziona un tipo di contenuto.

Nota

Questo valore corrisponde all'elemento MefComponent del file extension.vsixmanifest. Questo elemento specifica il nome di un assembly dell'estensione nel pacchetto VSIX. Per ulteriori informazioni, vedere MEFComponent Element (VSX Schema).
In Selezionare un'origine fare clic sul pulsante di opzione Progetto e selezionare BdcProjectItemExtension nella casella di riepilogo accanto.
Fare clic su OK.
Scegliere Compila soluzione dal menu Compila. Assicurarsi che il progetto venga compilato correttamente.
Aprire la cartella di output di compilazione per il progetto GenerateExternalDataLists. Assicurarsi che questa cartella adesso contenga il file GenerateExternalDataLists.vsix.

Per impostazione predefinita, la cartella dell'output di compilazione è .. \bin\Debug sotto la cartella che contiene il file di progetto.

Test dell'estensione dell'elemento di progetto

È ora possibile testare l'estensione dell'elemento di progetto. Innanzitutto, avviare il debug del progetto di estensione nell'istanza sperimentale di Visual Studio. Successivamente, utilizzare l'estensione nell'istanza sperimentale di Visual Studio per generare un elenco esterno per un modello di integrazione applicativa dei dati. Infine, aprire l'elenco esterno sul sito di SharePoint per verificare che funzioni nel modo previsto.

Per avviare il debug dell'estensione

Riavviare Visual Studio con i privilegi di amministratore e aprire la soluzione GenerateExternalDataLists.
Nel progetto BdcProjectItemExtension aprire il file di codice ProjectItemExtension e aggiungere un punto di interruzione alla riga di codice nel metodo Initialize.
Aprire il file di codice GenerateExternalDataLists e aggiungere un punto di interruzione alla prima riga di codice nel metodo GenerateExternalDataLists_Execute.
Premere F5 per avviare il debug.

In Visual Studio i file di estensione vengono installati in %UserProfile%\Dati applicazione\Locale\Microsoft\VisualStudio\10.0Exp\Extensions\External Data List Generator\1.0 e viene avviata un'istanza sperimentale di Visual Studio. L'elemento del progetto verrà testato in questa istanza di Visual Studio.

Per testare l'estensione

Nell'istanza sperimentale di Visual Studio scegliere Nuovo dal menu File, quindi fare clic su Progetto.
Espandere Visual C#, SharePoint, quindi fare clic su 2010.
Assicurarsi che nella casella combinata nella parte superiore della finestra di dialogo sia selezionata l'opzione .NET Framework 3.5. I progetti per Microsoft SharePoint Server 2010 richiedono questa versione di .NET Framework.
Nell'elenco dei modelli di progetto fare clic su Modello di integrazione applicativa dei dati.
Nella casella Nome digitare TestBDCModel.
Fare clic su OK.
In Personalizzazione guidata SharePoint digitare l'URL del sito che si desidera utilizzare per il debug, quindi scegliere Fine.
Verificare che il codice nell'altra istanza di Visual Studio venga interrotto in corrispondenza del punto di interruzione impostato precedentemente nel metodo Initialize. Premere F5 in questa istanza di Visual Studio per continuare il debug del progetto.
Nell'istanza sperimentale di Visual Studio premere F5 per compilare, distribuire ed eseguire il progetto TestBDCModel. Nel browser viene visualizzata la pagina predefinita del sito di SharePoint utilizzata per il debug.
Verificare che la sezione Elenchi nell'area Avvio veloce non contenga ancora un elenco basato sul modello BDC predefinito del progetto. È necessario innanzitutto creare un elenco di dati esterni mediante l'interfaccia utente di SharePoint o l'estensione dell'elemento di progetto.
Chiudere il browser Web.
Nell'istanza di Visual Studio in cui è aperto il progetto TestBDCModel fare clic con il pulsante destro del mouse sul nodo BdcModel1 in Esplora soluzioni, quindi selezionare Generate External Data List.
Verificare che il codice nell'altra istanza di Visual Studio venga interrotto in corrispondenza del punto di interruzione impostato precedentemente nel metodo GenerateExternalDataLists_Execute. Premere F5 per continuare il debug del progetto.
Nell'istanza sperimentale di Visual Studio viene aggiunta un'istanza di elenco denominata Entity1DataList al progetto TestBDCModel e viene generata una funzionalità denominata Feature2 per l'istanza di elenco.
Premere F5 per compilare, distribuire ed eseguire il progetto TestBDCModel. Nel browser viene visualizzata la pagina predefinita del sito di SharePoint utilizzata per il debug.
Verificare che nella sezione Elenchi di Avvio veloce sia contenuto ora un elenco denominato Entity1DataList.
Scegliere l'elenco Entity1DataList.
Verificare che nell'elenco siano contenute le colonne denominate Identifier1 e Message, nonché un elemento con il valore Identifier1 pari a 0 e il valore Message pari a Hello World. Tutti questi dati vengono forniti dal modello di integrazione applicativa dei dati predefinito generato dal modello di progetto Modello di integrazione applicativa dei dati.
Chiudere il browser Web.

Pulizia del computer di sviluppo

Dopo aver completato il test dell'estensione dell'elemento di progetto, rimuovere l'elenco esterno e il modello BDC dal sito di SharePoint, nonché l'estensione dell'elemento di progetto da Visual Studio.

Per rimuovere l'elenco di dati esterni dal sito di SharePoint

Nell'area Avvio veloce del sito di SharePoint fare clic sull'elenco Entity1DataList.
Nella barra multifunzione del sito di SharePoint fare clic sulla scheda Elenco.
Nel gruppo Impostazioni della scheda Elenco fare clic su Impostazioni elenco.
In Autorizzazioni e gestione fare clic su Elimina questo elenco. Fare clic su OK per confermare che si desidera spostare l'elenco nel cestino.
Chiudere il browser Web.

Per rimuovere il modello BDC dal sito di SharePoint

Scegliere Ritrai dal menu Compila nell'istanza sperimentale di Visual Studio.

Visual Studio rimuove il modello di integrazione applicativa dei dati dal sito di SharePoint.

Per rimuovere l'estensione dell'elemento di progetto da Visual Studio

Scegliere Gestione estensioni dal menu Strumenti nell'istanza sperimentale di Visual Studio.

Viene aperta la finestra di dialogo Gestione estensioni.
Nell'elenco di estensioni fare clic su External Data List Generator, quindi su Disinstalla.
Nella finestra di dialogo visualizzata fare clic su Sì per confermare che si desidera disinstallare l'estensione.
Fare clic su Riavvia per completare la disinstallazione.
Chiudere entrambe le istanze di Visual Studio, ovvero quella sperimentale e l'istanza in cui è aperta la soluzione GenerateExternalDataLists.

Vedere anche

Concetti

Estensione del sistema di progetto SharePoint

Altre risorse

Creazione di un modello di integrazione applicativa dei dati

Progettazione di un modello di integrazione applicativa dei dati

Condividi tramite