Tutorial: Extender un tipo de elemento de proyecto de SharePoint

Artículo
02/19/2013

Puede utilizar el elemento de proyecto Modelo de catálogo de datos profesionales para crear un modelo para el servicio Conectividad a datos profesionales (BDC) en SharePoint.De forma predeterminada, al crear un modelo utilizando este elemento de proyecto, los datos del modelo no se muestran a los usuarios.Por esta razón debe crear una lista externa en SharePoint que permita a los usuarios ver los datos.

En este tutorial, creará una extensión para el elemento de proyecto Modelo de conectividad a datos profesionales.Los desarrolladores pueden utilizar la extensión para crear una lista externa en sus proyectos que muestre los datos en el modelo BDC.En este tutorial se muestran las siguientes tareas:

Crear una extensión Visual Studio que realiza dos tareas principales:
- Genera una lista externa que muestra los datos en un modelo BDC.La extensión utiliza el modelo de objetos para que el sistema de proyectos de SharePoint genere un archivo Elements.xml que defina la lista.También agrega el archivo al proyecto para que se implemente junto con el modelo BDC.
- Agrega un elemento de menú contextual a los elementos de proyecto Modelo de conectividad a datos profesionales en el Explorador de soluciones.Los desarrolladores pueden hacer clic en este elemento de menú para generar una lista externa para el modelo BDC.
Compilar un paquete de extensión de Visual Studio (VSIX) para implementar el ensamblado de la extensión.
Probar la extensión.

Requisitos previos

Necesitará los componentes siguientes en el equipo de desarrollo para completar este tutorial:

Ediciones compatibles de Microsoft Windows, SharePoint y Visual Studio.Para obtener más información, vea Requisitos para desarrollar soluciones de SharePoint.
Visual Studio SDK.En este tutorial se utiliza la plantilla Proyecto VSIX del SDK para crear un paquete VSIX e implementar el elemento.Para obtener más información, vea Extender la Herramientas de SharePoint en Visual Studio.

El conocimiento de los siguientes conceptos es útil, aunque no necesario, para completar el tutorial.

El servicio BDC de Microsoft SharePoint Server 2010.Para obtener más información, vea BDC Architecture.
El esquema XML de los modelos BDC.Para obtener más información, vea Infraestructura del modelo BDC.

Crear los proyectos

Para completar este tutorial, debe crear dos proyectos:

Un proyecto VSIX para crear el paquete VSIX e implementar la extensión de elemento de proyecto.
Un proyecto de biblioteca de clases que implemente la extensión de elemento de proyecto.

Comience el tutorial creando ambos proyectos.

Para crear el proyecto VSIX

Inicie Visual Studio.
En la barra de menú, elija Archivo, Nuevo, Proyecto.
En el cuadro de diálogo Nuevo proyecto , expanda los nodos Visual c# o de Visual Basic y, a continuación el nodo Extensibilidad .

[!NOTA]

El nodo Extensibilidad solo está disponible si instala Visual Studio SDK.Para obtener más información, vea la sección Requisitos previos, anteriormente en este tema.
En la lista de la parte superior del cuadro de diálogo Nuevo proyecto , elija .NET Framework 4,5.

Las extensiones de herramientas de SharePoint requieren características de esta versión de .NET Framework.
Elija la plantilla Proyecto VSIX .
En el cuadro Nombre , entre en GenerateExternalDataLists, y elija el botón Aceptar .

Visual Studio agrega el proyecto GenerarListasDatosExternas al Explorador de soluciones.
Si no se abre el archivo source.extension.vsixmanifest automáticamente, abra el menú contextual del proyecto generarlistasdatosexternas y, a continuación Abrir
Compruebe que el archivo source.extension.vsixmanifest tiene una entrada de no de espacio en blanco (entre en Contoso) para el campo author, guarde el archivo, y ciérrelo.

Para crear la extensión de proyecto

En Explorador de soluciones, abra el menú contextual para el nodo de la solución GenerateExternalDataLists , elija Agregary, a continuación Nuevo proyecto.

[!NOTA]

En los proyectos de Visual Basic, el nodo de la solución aparece en el Explorador de soluciones solo cuando se activa la casilla Mostrar solución siempre en General, Projects and Solutions, Options Dialog Box.
En el cuadro de diálogo Agregar nuevo proyecto , expanda los nodos Visual c# o de Visual Basic y, a continuación el nodo Windows .
En la lista de la parte superior del cuadro de diálogo, elija .NET Framework 4,5.
En la lista de plantillas de proyecto, elija Biblioteca de clases.
En el cuadro Nombre , entre en BdcProjectItemExtension, y elija el botón Aceptar .

Visual Studio agrega el proyecto ExtensiónElementoProyectoBdc a la solución y abre el archivo de código predeterminado Class1.
Elimine el archivo de código Class1 del proyecto.

Configurar el proyecto de extensión

Antes de escribir el código para crear la extensión de elemento de proyecto, tiene que agregar los archivos de código y las referencias de ensamblado al proyecto de extensión.

Para configurar el proyecto

En el proyecto ExtensiónElementoProyectoBdc, agregue dos archivos de código que tienen los siguientes nombres:
- ProjectItemExtension
- GenerateExternalDataLists
Elija el proyecto extensiónelementoproyectobdc y, a continuación, en la barra de menú, elija Proyecto, Agregar referencia.
Bajo el nodo Ensamblados , elija el nodo Framework , y active la casilla para cada uno de los siguientes ensamblados:
- System.ComponentModel.Composition
- WindowsBase
Bajo el nodo Ensamblados , elija el nodo Extensiones , y seleccione la casilla para el ensamblado siguiente:
- Microsoft.VisualStudio.SharePoint
Elija el botón Aceptar .

Definir la extensión de los elementos de proyecto

Cree una clase que defina la extensión del elemento de proyecto Modelo de conectividad a datos profesionales.Para definir la extensión, la clase implementa la interfaz ISharePointProjectItemTypeExtension.Implemente esta interfaz para extender un tipo existente de elemento de proyecto todas las veces que desee.

Para definir la extensión del elemento de proyecto

Pegue el código siguiente en el archivo de código ProjectItemExtension.

[!NOTA]

Después de agregar este código, el proyecto tendrá algunos errores de compilación.Estos errores desaparecerán al agregar código en pasos posteriores.

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

Crear listas de datos externas

Agregue una definición parcial de la clase GenerateExternalDataListsExtension que cree una lista de datos externa para cada entidad del modelo BDC.Para crear la lista de datos externos, este código lee primero los datos de entidad del modelo BDC mediante el análisis de los datos XML del archivo del modelo BDC.A continuación, crea una instancia de la lista basada en el modelo BDC y la agrega al proyecto.

Para crear las listas de datos externas

Pegue el código siguiente en el archivo de código projectitemextension.

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

Punto de control

En este punto del tutorial, todo el código de la extensión del elemento de proyecto está en el proyecto.Compile la solución para asegurarse de que el proyecto se compila sin errores.

Para compilar la solución

En la barra de menú, elija Generar, Compilar solución.

Crear un paquete VSIX para implementar la extensión de elemento de proyecto

Para implementar la extensión, utilice el proyecto VSIX en la solución para crear un paquete VSIX.Primero, configure el paquete VSIX modificando el archivo source.extension.vsixmanifest incluido en el proyecto VSIX.A continuación, cree el paquete VSIX compilando la solución.

Para crear y configurar el paquete VSIX

En Explorador de soluciones, abra el menú contextual para el archivo source.extension.vsixmanifest del proyecto generarlistasdatosexternas y, a continuación Abrir.

Visual Studio abre el archivo en el editor de manifiestos.El archivo source.extension.vsixmanifest es la base del archivo extension.vsixmanifest que requieren todos los paquetes VSIX.Para obtener más información sobre este archivo, vea Referencia de esquema de extensión VSIX.
En el cuadro Nombre de producto , entre en Generador de la lista de datos externa.
En el cuadro Autor , entre en Contoso.
En el cuadro Descripción , escriba el Una extensión de elementos de proyecto modelo de conectividad a datos profesionales que pueden utilizarse para presentar listas de datos externas.
En la pestaña Activos de editor, elija el botón Nuevo .

El cuadro de diálogo Agregar nuevo activo aparece.
En la lista Tipo , elija Microsoft.VisualStudio.MefComponent.

[!NOTA]

Este valor corresponde al elemento MefComponent del archivo extension.vsixmanifest.Este elemento especifica el nombre de un ensamblado de extensión en el paquete VSIX.Para obtener más información, vea MEFComponent Element.
En la lista Origen , elija Un proyecto de la solución actual.
En la lista Proyecto , elija BdcProjectItemExtension, y elija el botón Aceptar .
En la barra de menú, elija Generar, Compilar solución.
Asegúrese de que se compila el proyecto se compila sin errores.
Asegúrese de que la carpeta de salida de la compilación del proyecto generarlistasdatosexterna ahora contiene el archivo generarlistasdatosexterna.vsix.

De forma predeterminada, la carpeta de resultado de compilación es ..\bin\Debug, que se encuentra bajo la carpeta que contiene el archivo de proyecto.

Probar la extensión de elemento de proyecto

Ya puede probar la extensión de elemento de proyecto.Primero, empiece a depurar el proyecto de extensión en la instancia experimental de Visual Studio.A continuación, utilice la extensión en la instancia experimental de Visual Studio para generar una lista externa para un modelo BDC.Finalmente, abra la lista externa en el sitio de SharePoint para comprobar que funciona según lo esperado.

Para comenzar a depurar la extensión

Si es necesario, el reinicie Visual Studio con credenciales administrativas, y abra la solución generarlistasdatosexternas.
En el proyecto extensiónelementoproyectobdc, abra el archivo de código ProjectItemExtension, y después agregue un punto de interrupción a la línea de código en el método Initialize .
Abra el archivo de código projectitemextension, y después agregue un punto de interrupción a la primera línea de código en el método GenerateExternalDataLists_Execute .
Empiece a depurar eligiendo la tecla F5 o, en la barra de menús, eligiendo Depurar, Iniciar depuración.

Visual Studio instala la extensión en %UserProfile%\AppData\Local\Microsoft\VisualStudio\10.0Exp\Extensions\Contoso\Generador Listas Datos Externas\1 .0 e inicia una instancia experimental de Visual Studio.Probará el elemento de proyecto en esta instancia de Visual Studio.

Para probar la extensión

En la instancia experimental de Visual Studio, en la barra de menú, elija Archivo, Nuevo, Proyecto.
En el cuadro de diálogo Nuevo proyecto , expanda el nodo Plantillas , expanda el nodo Visual c# , expanda el nodo SharePoint y, a continuación 2010.
En la lista de la parte superior del cuadro de diálogo, asegúrese de que .NET Framework 3.5 está seleccionado.Los proyectos de Microsoft SharePoint Server 2010 requieren esta versión de .NET Framework.
En la lista de plantillas de proyecto, elija Proyecto de SharePoint 2010.
En el cuadro Nombre , entre en SharePointProjectTestBDC, y elija el botón Aceptar .
En el Asistente para la personalización de SharePoint, escriba la dirección URL del sitio que desea utilizar para la depuración, elija Implementar como solución de granja de servidores, y después elija el botón Finalizar.
Abrir el menú contextual para el proyecto de SharePointProjectTestBDC, elija Agregary, a continuación Nuevo elemento.
En el cuadro de diálogo Agregue NewItem – SharePointProjectTestBDC , expanda el nodo instalado de lenguaje, expanda el nodo SharePoint .
Elija el nodo 2010 , y elija la plantilla Modelo de conectividad a datos profesionales (solo en una solución de granja de servidores) .
En el cuadro Nombre , entre en TestBDCModel, y elija el botón Agregar .
Compruebe que el código de la otra instancia de Visual Studio se detiene en el punto de interrupción que estableció en el método Initialize del archivo de código ProjectItemExtension.
En la instancia detenido de Visual Studio, elija la clave F5 , o en la barra de menús, elija Depurar, Continuar para continuar depurando el proyecto.
En la instancia experimental de Visual Studio, elija la clave F5 , o, en la barra de menú, elija Depurar, Iniciar depuración para compilar, implementar, y ejecute el proyecto TestBDCModel .

El explorador web se abre en la página predeterminada del sitio de SharePoint que se especifica para la depuración.
Compruebe que la sección Listas en el área de inicio rápido no contiene una lista basada en el modelo BDC predeterminado del proyecto.Primero debe crear una lista de datos externa mediante la interfaz de usuario de SharePoint o la extensión de elemento de proyecto.
Cierre el explorador web.
En la instancia de Visual Studio con el proyecto pruebamodelobdc abierto, abra el menú contextual para el nodo TestBDCModel en Explorador de solucionesy, a continuación Genere la lista de datos externa.
Compruebe que el código de la otra instancia de Visual Studio se detiene en el punto de interrupción que estableció en el método GenerateExternalDataLists_Execute .Elija la clave F5 , o, en la barra de menú, elija Depurar, Continuar para continuar depurando el proyecto.
La instancia experimental de Visual Studio agrega una instancia de la lista que se denomina Entity1DataList al proyecto Pruebamodelobdc, y la instancia también genera una característica denominada Feature2 para la instancia de lista.
Elija la clave F5 , o, en la barra de menú, elija Depurar, Iniciar depuración para compilar, implementar, y ejecutar el proyecto pruebamodelobdc.

El explorador web se abre en la página predeterminada del sitio de SharePoint que se utiliza para depurar.
En la sección Listas del área de inicio rápido, elija la lista Entity1DataList .
Compruebe que la lista contiene columnas denominadas Identifier1 y mensaje, además de un elemento que tenga un valor Identifier1 de 0 y un valor de mensaje Hello World.

La plantilla de proyecto Modelo de conectividad a datos profesionales genera el modelo BDC predeterminado que proporciona todos estos datos.
Cierre el explorador web.

Limpiar el equipo de desarrollo

Después de probar la extensión de elemento de proyecto, quite la lista externa y modelo BDC del sitio de SharePoint y quite la extensión de elemento de proyecto de Visual Studio.

Para quitar la lista de datos externa del sitio de SharePoint

En el área de inicio rápido del sitio de SharePoint, elija la lista Entity1DataList .
En la cinta del sitio de SharePoint, elija la ficha Lista .
En la pestaña Lista , en el grupo Configuración , elija Configuración de la lista.
En Permisos y administración, elija Eliminar esta lista, y elija Aceptar para confirmar que desea enviar la lista a la papelera de reciclaje.
Cierre el explorador web.

Para quitar el modelo BDC del sitio de SharePoint

En la instancia experimental de Visual Studio, en la barra de menú, elija Generar, Retirar.

Visual Studio quita el modelo BDC del sitio de SharePoint.

Para quitar la extensión del elemento de proyecto de Visual Studio

En la instancia experimental de Visual Studio, en la barra de menú, elija Herramientas, Extensiones y actualizaciones.

El cuadro de diálogo Extensiones y actualizaciones abra.
En la lista de extensiones, elija Generador de la lista de datos externa, y elija el botón Desinstalar .
En el cuadro de diálogo que aparece, elija Sí para confirmar que desea desinstalar la extensión.
Elija Reiniciar ahora para completar la desinstalación.
Cierre ambas instancias de Visual Studio (la instancia experimental y la instancia en las que la solución generarlistasdatosexternas está abierto).

Vea también

Conceptos

Extender el sistema de proyectos de SharePoint

Otros recursos

Crea un modelo de conectividad a datos profesionales

Diseñar un modelo de conectividad a datos profesionales

Compartir a través de