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

Articolo
02/18/2013

È 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 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.
Sulla barra dei menu, scegliere Il file, Nuova, Project.
Nella finestra di dialogo Nuovo progetto, espandere i nodi di Visual Basic o Visual C# quindi selezionare il nodo Extensibility.

[!NOTA]

Il nodo Extensibility è disponibile solo se si installa Visual Studio SDK.Per ulteriori informazioni, vedere la sezione precedente relativa ai prerequisiti.
Nell'elenco nella parte superiore della finestra di dialogo Nuovo progetto, scegliere .NET Framework 4.5.

Le estensioni degli strumenti di SharePoint richiedono alcune funzionalità di questa versione di .NET Framework.
Scegliere il modello Progetto VSIX.
Nella casella Nome, immettere GenerateExternalDataListsquindi scegliere il pulsante OK.

Visual Studio aggiunge il progetto GenerateExternalDataLists a Esplora soluzioni.
Se il file source.extension.vsixmanifest non viene visualizzato automaticamente, aprire il menu di scelta rapida il progetto GenerateExternalDataLists e quindi scegliere Apri
Verificare che il file source.extension.vsixmanifest dispone di una voce non vuoto (immettere Contoso) per il campo dell'autore, salvare e chiudere il file.

Per creare il progetto di estensione

In Esplora soluzioni, aprire il menu di scelta rapida del nodo della soluzione GenerateExternalDataLists, scegliere Aggiungiquindi scegliere 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 General, Projects and Solutions, Options Dialog Box.
Nella finestra di dialogo Aggiungi nuovo progetto, espandere i nodi di Visual Basic o Visual C# quindi selezionare il nodo Finestre.
Nell'elenco nella parte superiore della finestra di dialogo, scegliere .NET Framework 4.5.
Nell'elenco di modelli di progetto, scegliere Libreria di classi.
Nella casella Nome, immettere BdcProjectItemExtensionquindi scegliere il pulsante 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
Selezionare il progetto BdcProjectItemExtension quindi, nella barra dei menu, scegliere Project, Aggiungi riferimento.
Nel nodo Assembly, selezionare il nodo Framework e il selezionare la casella di controllo per ognuno degli assembly seguenti:
- System.ComponentModel.Composition
- WindowsBase
Nel nodo Assembly, selezionare il nodo Estensioni quindi selezionare la casella di controllo dell'assembly:
- Microsoft.VisualStudio.SharePoint
Scegliere il pulsante OK.

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

Incollare il codice seguente nel file di codice ProjectItemExtension.

[!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

Incollare il codice seguente nel file di codice 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;
        }
    }
}

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

Sulla barra dei menu, scegliere Compilazione, Compila soluzione.

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.Successivamente, creare il pacchetto VSIX compilando la soluzione.

Per configurare e creare il pacchetto VSIX

In Esplora soluzioni, aprire il menu di scelta rapida per il file source.extension.vsixmanifest nel progetto GenerateExternalDataLists e quindi scegliere Apri.

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 Informazioni di riferimento sullo schema dell'estensione VSIX.
Nella casella Nome prodotto, immettere Generatore di elenco dati esterno.
Nella casella Autore, immettere Contoso.
Nella casella Descrizione, immettere Un'estensione per gli elementi di progetto Modello di integrazione applicativa dei dati aziendali che possono essere utilizzati per compilare gli elenchi di dati esterni.
Nella scheda Asset dell'editor, scegliere il pulsante Nuova.

La finestra di dialogo Aggiungi nuovo asset visualizzato.
Nell'elenco Tipo, scegliere Microsoft.VisualStudio.MefComponent.

[!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.
Nell'elenco Alimentazione, scegliere Progetto nella soluzione corrente.
Nell'elenco Project, scegliere BdcProjectItemExtensionquindi scegliere il pulsante OK.
Sulla barra dei menu, scegliere Compilazione, Compila soluzione.
Assicurarsi che il progetto venga compilato e compilazione senza errori.
Verificare che la cartella di output di compilazione per il progetto GenerateExternalDataLists 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

Se necessario, il riavviare Visual Studio con credenziali amministrative quindi 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.
Avviare il debug scegliendo il tasto F5 o, sulla barra dei menu, scegliente Debug, Avvia 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, sulla barra dei menu, scegliere Il file, Nuova, Project.
Nella finestra di dialogo Nuovo progetto, espandere il nodo Modelli, espandere il nodo Visual C#, espandere il nodo SharePoint quindi scegliere 2010.
Nell'elenco nella parte superiore della finestra di dialogo, verificare che .NET Framework 3.5 sia selezionato.I progetti per Microsoft SharePoint Server 2010 richiedono questa versione di .NET Framework.
Nell'elenco di modelli di progetto, scegliere Progetto SharePoint 2010.
Nella casella Nome, immettere SharePointProjectTestBDCquindi scegliere il pulsante OK.
Nella personalizzazione guidata SharePoint, immettere l'url del sito che si desidera utilizzare per il debug, scegliere Distribuisci come soluzione farmquindi scegliere il pulsante Fine.
Aprire il menu di scelta rapida del progetto SharePointProjectTestBDC, scegliere Aggiungiquindi scegliere Nuovo elemento.
Nella finestra di dialogo Aggiungi nuovo elemento - SharePointProjectTestBDC, espandere il nodo installato di linguaggio, espandere il nodo SharePoint.
Scegliere il nodo 2010 quindi scegliere il modello Modello di integrazione applicativa dei dati (solo soluzioni farm).
Nella casella Nome, immettere TestBDCModelquindi scegliere il pulsante Aggiungi.
Verificare che il codice nell'altra istanza di Visual Studio venga interrotto in corrispondenza del punto di interruzione impostato nel metodo Initialize del file di codice ProjectItemExtension.
Nell'istanza interrotta di Visual Studio, scegliere la chiave F5, o nella barra dei menu, scegliere Debug, Continua per continuare il debug del progetto.
Nell'istanza sperimentale di Visual Studio, scegliere la chiave F5, o, sulla barra dei menu, scegliere Debug, Avvia debug per compilare, distribuire ed eseguire il progetto TestBDCModel.

Il browser viene visualizzata la pagina predefinita del sito di SharePoint specificato 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.
Nell'istanza di Visual Studio che ha aperto il progetto TestBDCModel, aprire il menu di scelta rapida del nodo TestBDCModel in Esplora soluzioniquindi scegliere Genera elenco dati esterno.
Verificare che il codice nell'altra istanza di Visual Studio venga interrotto in corrispondenza del punto di interruzione impostato nel metodo GenerateExternalDataLists_Execute.Scegliere la chiave F5, o, sulla barra dei menu, scegliere Debug, Continua per continuare il debug del progetto.
L'istanza sperimentale di Visual Studio aggiunge un'istanza di elenco denominata Entity1DataList al progetto TestBDCModel e l'istanza genera inoltre una funzionalità denominata Feature2 per l'istanza di elenco.
Scegliere la chiave F5, o, sulla barra dei menu, scegliere Debug, Avvia debug per compilare, distribuire ed eseguire il progetto TestBDCModel.

Il browser viene visualizzata la pagina predefinita del sito di SharePoint utilizzata per eseguire il debug.
Nella sezione Elenchi dell'area avvio veloce, scegliere l'elenco Entity1DataList.
Verificare che l'elenco contenga le colonne denominate Identifier1 e messaggi, oltre a un elemento con un valore di identificatore1 di 0 e un valore di messaggio di esempio.

Il modello di progetto Modello di integrazione applicativa dei dati genera il modello BDC predefinito che fornisce tutti questi dati.
Chiudere il browser.

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, scegliere l'elenco Entity1DataList.
Nella barra multifunzione del sito di SharePoint, scegliere la scheda Elenco.
Nella scheda Elenco, nel gruppo Impostazioni, scegliere Impostazioni elenco.
In Autorizzazioni e gestione, scegliere Elimina l'elencoquindi scegliere OK per confermare che si desidera spostare l'elenco nel cestino.
Chiudere il browser.

Per rimuovere il modello BDC dal sito di SharePoint

Nell'istanza sperimentale di Visual Studio, sulla barra dei menu, scegliere Compilazione, Ritrai.

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

Nell'istanza sperimentale di Visual Studio, sulla barra dei menu, scegliere Strumenti, Estensioni e aggiornamenti.

La finestra di dialogo Estensioni e aggiornamenti viene aperto.
Nell'elenco di estensioni selezionare, Generatore di elenco dati esternoquindi scegliere il pulsante Disinstalla.
Nella finestra di dialogo, scegliere Sì per confermare che si desidera disinstallare l'estensione.
Scegliere Riavvia ora per completare la disinstallazione.
Chiudere entrambe le istanze di Visual Studio (l'istanza sperimentale e l'istanza in cui la soluzione GenerateExternalDataLists è aperta).

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