Passo a passo: Estendendo um tipo de Item de projeto do SharePoint

Artigo
02/25/2013

Você pode usar o item de projeto de Modelo de conectividade de dados corporativos para criar um modelo para o serviço de (BDC) de conectividade de dados comerciais no SharePoint.Por padrão, quando você cria um modelo usando este item de projeto, os dados no modelo não são exibidos para os usuários.Você também deve criar uma lista externa no SharePoint para permitir que os usuários para exibir os dados.

Em essa explicação passo a passo, você criará uma extensão para o item de projeto de Modelo de conectividade de dados corporativos .Os desenvolvedores podem usar a extensão para criar uma lista externa em seu projeto que exibe os dados no modelo de BDC.Essa explicação passo a passo demonstra as seguintes tarefas:

Criando uma extensão do Visual Studio que executa duas tarefas principais:
- Gera uma lista externo que exibe os dados em um modelo de BDC.A extensão usa o modelo de objeto para o sistema de projeto do SharePoint gerar um arquivo de Elements.xml que define a lista.Também adicionar o arquivo ao projeto de modo que é implantado com o modelo de BDC.
- Adiciona um item de menu de atalho para itens de projeto de Modelo de conectividade de dados corporativos em Gerenciador de Soluções.Os desenvolvedores podem clicar em este item de menu para gerar uma lista externa para o modelo de BDC.
Criando um pacote de extensão (Visual Studio) VSIX para implantar o assembly de extensão.
testando a extensão.

Pré-requisitos

Você precisa dos seguintes componentes no computador de desenvolvimento de concluir este explicação passo a passo:

Edições suportadas do Microsoft Windows, do SharePoint e Visual Studio.Para obter mais informações, consulte Requisitos para o desenvolvimento de soluções do SharePoint.
O SDK do Visual Studio.Essa explicação passo a passo usa o modelo de projeto de VSIX no SDK para criar um conjunto de VSIX para implantar o item de projeto.Para obter mais informações, consulte Estender as ferramentas do SharePoint em Visual Studio.

Conhecer os seguintes conceitos é útil, mas não necessário, concluir a explicação passo a passo:

o serviço de BDC em Microsoft SharePoint Server 2010.Para obter mais informações, consulte arquitetura de BDC.
o esquema XML para modelos de BDC.Para obter mais informações, consulte Infra-estrutura do modelo de BDC.

Criando projetos

Para concluir esta explicação passo a passo, você precisa criar dois projetos:

Um projeto de VSIX criar o conjunto de VSIX para implantar a extensão de item de projeto.
Um projeto de biblioteca de classe que implementa a extensão de item de projeto.

Inicie o passo-a-passo criando projetos.

Para criar o projeto VSIX

Inicie o Visual Studio
Em a barra de menu, escolha Arquivo, Novo, Projeto.

Em a caixa de diálogo de Novo Projeto , expanda os nós de Visual C# ou de Visual Basic , e então escolha o nó de Extensibilidade .

Observação
O nó de Extensibilidade está disponível somente se você instalar o Visual Studio SDK.Para obter mais informações, consulte a seção de pré-requisito anteriormente em este tópico.

Em a lista na parte superior da caixa de diálogo de Novo Projeto , escolha o .NET Framework 4,5.

As extensões de ferramentas do SharePoint exigem recursos em esta versão do.NET Framework.
Escolha o modelo de projeto de VSIX .
Em a caixa de Nome , entre em GenerateExternalDataLists, e então escolha o botão de OK .

Visual Studio adiciona o projeto de GenerateExternalDataLists a Gerenciador de Soluções.
Se o arquivo de source.extension.vsixmanifest não abre automaticamente, abra o menu de atalho no projeto de GenerateExternalDataLists, e então escolha Abrir
Verifique se o arquivo de source.extension.vsixmanifest tenha uma entrada de linha em branco entre Contoso (em) para o campo de autor, salve o arquivo, e feche-o.

Para criar o projeto de extensão

Em Gerenciador de Soluções, abra o menu de atalho para o nó da solução de GenerateExternalDataListsAdicionar, escolha, e escolha Novo Projeto.

Observação
Em projetos Visual Basic, o nó da solução aparece em Gerenciador de Soluções somente quando a caixa de seleção de Sempre mostrar solução está selecionada em General, Projects and Solutions, Options Dialog Box.

Em a caixa de diálogo de Adicionar novo projeto , expanda os nós de Visual C# ou de Visual Basic , e então escolha o nó de Janelas .
Em a lista na parte superior da caixa de diálogo, escolha o .NET Framework 4,5.
Em a lista de modelos de projeto, escolha Biblioteca de Classes.
Em a caixa de Nome , entre em BdcProjectItemExtension, e então escolha o botão de OK .

Visual Studio adiciona o projeto de BdcProjectItemExtension a solução e abre o arquivo de código Class1 de opção.
Exclua o arquivo de código Class1 do projeto.

Configurando o projeto de extensão

Antes que você escreva código para criar a extensão de item de projeto, adicione arquivos de código e as referências assembly para a extensão projeto.

para configurar o projeto

Em o projeto de BdcProjectItemExtension, adicione dois arquivos de código que possuem os seguintes nomes:
- ProjectItemExtension
- GenerateExternalDataLists
Escolha o projeto de BdcProjectItemExtension e, em seguida, na barra de menu, escolha Projeto, Adicionar Referência.
Sob o nó de Assemblies , escolha o nó de estrutura , o e selecione a caixa de seleção para cada um dos seguintes conjuntos de módulos (assemblies):
- System.ComponentModel.Composition
- WindowsBase
Sob o nó de Assemblies , escolha o nó de Extensões , selecione a caixa de seleção para o assembly seguir:
- Microsoft.VisualStudio.SharePoint
Escolha o botão OK.

Definindo a extensão do item de projeto

Crie uma classe que define a extensão para o item de projeto de Modelo de conectividade de dados corporativos .para definir a extensão, a classe implementa a interface de ISharePointProjectItemTypeExtension .Implementar essa interface sempre que você deseja estender um tipo existente de item de projeto.

Para definir a extensão de item de projeto

Cole o seguinte código no arquivo de código de ProjectItemExtension.

Observação
Após adicionar este código, compilar o projeto mandará alguns erros.Esses erros partirão quando você adiciona o código em etapas 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;
        }
    }
}

criando as listas de dados externos

Adicione uma definição de classe parcial de GenerateExternalDataListsExtension que cria uma lista de dados externos para cada entidade no modelo de BDC.Para criar a lista de dados externos, esse código primeiro ler os dados de entidade no modelo de BDC analisar os dados XML no arquivo de modelo de BDC.Em seguida, cria uma instância de lista que é baseado no modelo de BDC e adiciona essa instância de lista do projeto.

para criar as listas de dados externos

Cole o seguinte código no arquivo de código de 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;
        }
    }
}

Ponto de Verificação

Em esse ponto do passo-a-passo, todo o código para a extensão de item de projeto agora está no projeto.Crie a solução para certificar-se de que o projeto compila sem erros.

Para criar a solução

Em a barra de menu, escolha Compilar, Compilar solução.

Criando um conjunto de VSIX para implantar a extensão de item de projeto

Para implantar a extensão, use o projeto de VSIX em sua solução criar um conjunto de VSIX.Primeiro, configure o conjunto de VSIX modificando o arquivo de source.extension.vsixmanifest que está incluído no projeto de VSIX.Em seguida, crie o conjunto de VSIX criando a solução.

Para configurar e criar o conjunto de VSIX

Em Gerenciador de Soluções, abra o menu de atalho para o arquivo de source.extension.vsixmanifest no projeto de GenerateExternalDataLists, e então escolha Abrir.

O Visual Studio abre o arquivo no editor manifesto.O arquivo de source.extension.vsixmanifest é a base para o arquivo de extension.vsixmanifest é necessário por todos os pacotes de VSIX.Para obter mais informações sobre este arquivo, consulte Referência de esquema de extensão VSIX.
Em a caixa de Nome do produto , entre em Gerador de lista de dados externos.
Em a caixa de Autor , entre em Contoso.
Em a caixa de Descrição , digite o Uma extensão para itens de projecto-modelo de conectividade de dados comerciais que podem ser usados para gerar listas de dados externos.
Em a guia de Ativos do editor, escolha o botão de Novo .

a caixa de diálogo de adicionar o novo recurso aparece.

Em a lista de Tipo , escolha Microsoft.VisualStudio.MefComponent.

Observação
Esse valor corresponde ao elemento de MefComponent no arquivo de extension.vsixmanifest.Esse elemento especifica o nome de um assembly de extensão no conjunto de VSIX.Para obter mais informações, consulte MEFComponent Element.

Em a lista de Origem , escolha Um projeto na solução atual.
Em a lista de Projeto , escolha, e escolha BdcProjectItemExtensionno botão de OK .
Em a barra de menu, escolha Compilar, Compilar solução.
Certifique-se que o projeto compila e compila sem erros.
Certifique-se de que a pasta de saída de compilação para o projeto de GenerateExternalDataLists agora contém o arquivo de GenerateExternalDataLists.vsix.

Por padrão, a pasta de saída de compilação é.\ bin \ debug de sob a pasta que contém o arquivo de projeto.

Testando a extensão do item de projeto

Você agora está pronto para testar a extensão do item de projeto.Primeiro, iniciar a depuração o projeto de extensão na instância de avaliação do Visual Studio.Em seguida, use a extensão na instância de avaliação do Visual Studio para gerar uma lista externa para um modelo de BDC.Finalmente, abra a lista externa no site do SharePoint para que verifique se ela funciona como esperado.

Para iniciar a depuração da extensão

Se necessário, reinicie o Visual Studio com credenciais administrativas, e abre na solução de GenerateExternalDataLists.
Em o projeto de BdcProjectItemExtension, abra o arquivo de código de ProjectItemExtension, e adicione um ponto de interrupção na linha de código no método de Initialize .
Abra o arquivo de código de GenerateExternalDataLists, e adicione um ponto de interrupção na primeira linha de código no método de GenerateExternalDataLists_Execute .
Iniciar a depuração escolhendo a tecla F5 ou, na barra de menus, escolhendo Depurar, Iniciar Depuração.

O Visual Studio instala a extensão em %UserProfile%\AppData\Local\Microsoft\VisualStudio\10.0Exp\Extensions\Contoso\External Data List Generator\1.0 e inicia uma instância de avaliação do Visual Studio.Você irá testar o item de projeto em esse caso do Visual Studio.

para testar a extensão

Em a instância de avaliação do Visual Studio, na barra de menu, escolha Arquivo, Novo, Projeto.
Em a caixa de diálogo de Novo Projeto , expanda o nó de Modelos , expanda o nó de Visual C# , expanda o nó de SharePoint , e então escolha 2010.
Em a lista na parte superior da caixa de diálogo, certifique-se que está selecionado o .NET Framework 3,5 .Os projetos para Microsoft SharePoint Server 2010 exigem esta versão do .NET Framework.
Em a lista de modelos de projeto, escolha Projeto do SharePoint 2010.
Em a caixa de Nome , entre em SharePointProjectTestBDC, e então escolha o botão de OK .
Em o assistente de personalização do SharePoint, digite o URL do site que você deseja usar para depurar Implantar como uma solução de farm, escolha, e escolha o botão de Concluir.
Abra o menu de atalho para o projeto de SharePointProjectTestBDC Adicionar, escolha, e escolha Novo Item.
Em a caixa de diálogo de Adicione NewItem – SharePointProjectTestBDC , expanda o nó da linguagem instalado, expandir o nó de SharePoint .
Escolha o nó de 2010 , e então escolha o modelo de Modelo de conectividade de dados comerciais solução de farm (somente) .
Em a caixa de Nome , entre em TestBDCModel, e então escolha o botão de Adicionar .
Verifique se o código em outra instância do Visual Studio pára no ponto de interrupção que você definir no método de Initialize do arquivo de código de ProjectItemExtension.
Em a instância parada do Visual Studio, escolha a chave de F5 , ou na barra de menu, escolha Depurar, Continuar para continuar a depuração o projeto.
Em a instância de avaliação do Visual Studio, escolha a chave de F5 , ou, na barra de menu, escolha Depurar, Iniciar Depuração para criar, implantar, e executar o projeto de TestBDCModel .

Navegador da web abre para a página do site padrão do SharePoint que é especificada para depuração.
Verifique se a seção de Listas na área de lançamento rápido ainda não contém uma lista que é baseado no modelo de opção BDC no projeto.Você deve primeiro criar uma lista de dados externos, usando a interface do usuário do SharePoint ou usando a extensão de item de projeto.
Feche o navegador da web.
Em a instância do Visual Studio que tem o projeto de TestBDCModel aberto, abra o menu de atalho para o nó de TestBDCModel em Gerenciador de Soluções, e então escolha Gera a lista de dados externos.
Verifique se o código em outra instância do Visual Studio pára no ponto de interrupção que você definiou no método de GenerateExternalDataLists_Execute .Escolha a chave de F5 , ou, na barra de menu, escolha Depurar, Continuar para continuar a depuração o projeto.
A instância de avaliação do Visual Studio adiciona uma instância de lista que é chamada Entity1DataList ao projeto de TestBDCModel, e também a instância gera um recurso denominado Feature2 para a instância da lista.
Escolha a chave de F5 , ou, na barra de menu, escolha Depurar, Iniciar Depuração para criar, implantar, e executar o projeto de TestBDCModel.

Navegador da web abre para a página do site padrão do SharePoint que é usada para depuração.
Em a seção de Listas da área de lançamento rápido, escolha a lista de Entity1DataList .
Verifique se a lista contém as colunas que são chamadas e Identifier1 mensagem, além de um item que tem um valor de Identifier1 de 0 e um valor de mensagem de hello world.

O modelo de projeto Modelo de conectividade de dados corporativos gera o modelo de opção BDC que fornece todos esses dados.
Feche o navegador da web.

Limpando o computador de desenvolvimento

Depois que você concluir testar a extensão do item de projeto, remova a lista externo e o modelo de BDC de site web do SharePoint e remover a extensão de item de projeto do Visual Studio.

Para remover a lista de dados externos de site web do SharePoint

Em a área de lançamento rápido de site web do SharePoint, escolha a lista de Entity1DataList .
Em fita no site do SharePoint, escolha a guia de Lista .
Em a guia de Lista , no grupo de Configurações , escolha Configurações da lista.
Em Permissões e GerenciamentoExcluir essa lista, escolha, e escolha OK para confirmar que você deseja enviar a lista para a recycle bin.
Feche o navegador da web.

Para remover o BDC a modelagem de site web do SharePoint

Em a instância de avaliação do Visual Studio, na barra de menu, escolha Compilar, retraia.

O Visual Studio remove o modelo de BDC de site web do SharePoint.

Para remover a extensão de item de projeto do Visual Studio

Em a instância de avaliação do Visual Studio, na barra de menu, escolha Ferramentas, Extensões e Atualizações.

a caixa de diálogo de Extensões e Atualizações abre.
Em a lista de extensões Gerador de lista de dados externos, escolha, e escolha no botão de Desinstalar .
Em a caixa de diálogo que aparece, escolha Sim para confirmar que você deseja desinstalar a extensão.
Escolha Reiniciar Agora para concluir a desinstalação.
Feche as duas instâncias do Visual Studio (a instância de avaliação e instância na qual a solução de GenerateExternalDataLists estiver aberta.)

Consulte também

Conceitos

Estendendo o sistema de projeto do SharePoint

Outros recursos

Criando um modelo de conectividade de dados de negócios

Elaborar um modelo de conectividade de dados de negócios

Compartilhar via