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

Artigo
08/01/2011

Você pode usar o Modelo de conectividade de dados de negócios o item de projeto para criar um modelo para o serviço de conectividade de dados de negócios (BDC) 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 no SharePoint para permitir aos usuários exibir os dados.

Esta explicação passo a passo, você criará uma extensão para o Modelo de conectividade de dados de negócios o item de projeto. Os desenvolvedores podem usar a extensão para criar uma lista no seu projeto que exibe os dados no modelo do BDC. Essa explicação passo a passo demonstra as seguintes tarefas:

Criação de uma extensão de Visual Studio que executa duas tarefas principais:
- Ele gera uma lista que exibe os dados em um modelo do BDC. A extensão usa o modelo de objeto para o sistema de projeto do SharePoint para gerar um arquivo elements XML que define a lista. Além disso, ele também adiciona o arquivo ao projeto para que ele é implantado junto com o modelo do BDC.
- Ele adiciona um item de menu de atalho para o Modelo de conectividade de dados de negócios itens de projeto Solution Explorer. Os desenvolvedores podem clicar neste item de menu para gerar uma lista para o modelo do BDC.
Construindo um pacote de extensão de Visual Studio (VSIX) para implantar o assembly de extensão.
Testando a extensão.

Pré-requisitos

É necessário que os seguintes componentes no computador de desenvolvimento para concluir este passo a passo:

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

Conhecimento dos seguintes conceitos é útil, mas não necessário para concluir o passo a passo:

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

A criação de projetos

Para concluir este passo a passo, você precisará criar dois projetos:

Um projeto VSIX para criar o pacote 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 através da criação de projetos.

Para criar o projeto VSIX

Inicie o Visual Studio
No menu File, aponte para New, e em seguida, clique em Project.
No Novo projeto caixa de diálogo caixa, expanda o Visual C# ou Visual Basic nós e em seguida, clique o extensibilidade nó.

Observação

O extensibilidade node está disponível somente se você instalar o SDK do Visual Studio 2010. Para obter mais informações, consulte a seção de pré-requisitos acima.
Na caixa de combinação na parte superior da caixa de diálogo, selecione .NET Framework 4. As extensões de ferramentas de SharePoint requerem recursos nesta versão do.NET Framework.
Clique o O projeto de VSIX modelo.
No nome , digite GenerateExternalDataLists.
Clique em OK.

Visual StudioAdiciona o GenerateExternalDataLists de projeto para Solution Explorer.

Observação
O extensibilidade node está disponível somente se você instalar o SDK do Visual Studio 2010. Para obter mais informações, consulte a seção de pré-requisitos acima.

Para criar o projeto de extensão

Em Solution Explorer, o botão direito do mouse no nó da solução, clique em Adde em seguida, clique em Novo projeto.

Observação
Em projetos de Visual Basic, o nó de solução aparece na Solution Explorer somente quando o Always show solution caixa de seleção estiver marcada na Geral, projetos e soluções, caixa de diálogo Options.

No Novo projeto caixa de diálogo caixa, expanda o Visual C# ou Visual Basic nós e clique Windows.
Na caixa de combinação na parte superior da caixa de diálogo, selecione .NET Framework 4.
Selecione o Biblioteca de classe o modelo de projeto.
No nome , digite BdcProjectItemExtension.
Clique em OK.

Visual StudioAdiciona o BdcProjectItemExtension o projeto à solução e abre o arquivo de código padrão Class1.
Exclua o arquivo de código Class1 do projeto.

Configurando o projeto de extensão

Antes de escrever código para criar a extensão de item de projeto, adicione os arquivos de código e referências de assembly para o projeto de extensão.

Para configurar o projeto.

No projeto BdcProjectItemExtension, adicione dois arquivos de código que têm os seguintes nomes:
- ProjectItemExtension
- GenerateExternalDataLists
No menu Project, escolha Add Reference.
Sobre o .NET guia, pressione CTRL e clique os assemblies a seguir e clique em OK:
- Microsoft.VisualStudio.SharePoint
- System.ComponentModel.Composition
- WindowsBase

Definir a extensão de Item de projeto

Criar uma classe que define a extensão para o Modelo de conectividade de dados de negócios o item de projeto. Para definir a extensão, a classe de implementa o ISharePointProjectItemTypeExtension interface. Implemente essa interface, sempre que você deseja estender um tipo existente de item de projeto.

Para definir a extensão de item de projeto

Clique duas vezes no arquivo de código ProjectItemExtension.

Cole o código a seguir no arquivo.

Observação
Após adicionar esse código, o projeto terá alguns erros de compilação. Esses erros desaparecem 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 listas de dados externos

Adicionar uma definição parcial da GenerateExternalDataListsExtension classe que cria uma lista de dados externos para cada entidade no modelo do BDC. Para criar a lista de dados externos, esse código primeiro lê os dados de entidade no modelo do BDC ao analisar os dados XML no arquivo de modelo do BDC. Em seguida, ele cria uma instância de lista que se baseia no modelo do BDC e adiciona essa instância de lista para o projeto.

Para criar os dados externos listas

Clique duas vezes no arquivo de código GenerateExternalDataLists.

Cole o código a seguir no arquivo.

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

Neste momento o passo a passo, todo o código para a extensão de item de projeto está agora no projeto. Crie a solução para certificar-se de que o projeto é compilado sem erros.

Para criar a solução

Sobre o Build menu, selecione Build Solution.

Criando um pacote VSIX para implantar a extensão de Item de projeto

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

Para configurar e criar o pacote VSIX

Em Solution Explorer, clique duas vezes o source.extension.vsixmanifest arquivo no projeto GenerateExternalDataLists.

Visual Studio abre o arquivo no editor de manifesto. O arquivo de source.extension.vsixmanifest é que a base para o arquivo extension.vsixmanifest é necessária para todos os pacotes VSIX. Para obter mais informações sobre este arquivo, consulte VSX Schema for Extensions.
No Nome do produto , digite Gerador de lista de dados externos.
No Autor , digite Contoso.
No Descrição , digite a lista de uma extensão para itens de projeto do modelo de conectividade de dados de negócios que podem ser usados para gerar dados externos.
No conteúdo seção do editor, clique na Adicionar conteúdo botão.

No Adicionar conteúdo na caixa de Selecione um tipo de conteúdo caixa de listagem, selecione MEF componente.

Observação
Este valor corresponde do MefComponent elemento no arquivo extension.vsixmanifest. Este elemento Especifica o nome de um assembly de extensão no pacote VSIX. Para obter mais informações, consulte MEFComponent Element (VSX Schema).

Em Selecionar uma fonte de, clique o projeto botão de opção e, em seguida, selecione BdcProjectItemExtension em que a caixa de listagem.
Clique em OK.
Sobre o Build menu, clique em Build Solution. Certifique-se de que o projeto é compilado sem erros.
Abra a pasta de saída de compilação do projeto GenerateExternalDataLists. Certifique-se de que esta pasta agora contém o arquivo GenerateExternalDataLists.vsix.

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

A extensão de Item de projeto de teste.

Agora você está pronto para testar a extensão de item de projeto. Primeiro, inicie a depuração do projeto de extensão na instância experimental do Visual Studio. Em seguida, use a extensão na instância experimental do Visual Studio para gerar uma lista para um modelo do BDC. Finalmente, abra a lista de externa no site do SharePoint para verificar se ele funciona como esperado.

Para iniciar a extensão de depuração.

Reinicie o Visual Studio com privilégios de administrador e abra a solução de GenerateExternalDataLists.
No projeto BdcProjectItemExtension, abra o arquivo de código de ProjectItemExtension e adicionar um ponto de interrupção na linha do código de Initialize método.
Abra o arquivo de código de GenerateExternalDataLists e adicionar um ponto de interrupção para a primeira linha do código de GenerateExternalDataLists_Execute método.
Pressione F5 para iniciar a depuração.

Visual Studio instala a extensão %UserProfile%\AppData\Local\Microsoft\VisualStudio\10.0Exp\Extensions\Contoso\External Generator\1.0 de lista de dados e inicia uma instância experimental do Visual Studio. Você testará o item de projeto nesta instância do Visual Studio.

Para testar a extensão.

Na instância experimental do Visual Studio, sobre o arquivo , aponte para novae, em seguida, clique em projeto.
Expanda Visual C#, expanda SharePointe em seguida, clique em 2010.
Na caixa de combinação na parte superior da caixa de diálogo, certifique-se de que .NET Framework 3.5 está selecionada. Projetos para Microsoft SharePoint Server 2010 exigem essa versão do.NET Framework.
Na lista de modelos de projeto, clique em Modelo de conectividade de dados de negócios.
No nome , digite TestBDCModel.
Clique em OK.
No O Assistente para personalização do SharePoint, digite a URL do site que você deseja usar para depuração e clique em Concluir.
Verificar que o código na instância de Visual Studio pára no ponto de interrupção que você definiu anteriormente na Initialize método. Pressione F5 nesta instância do Visual Studio para continuar a depurar o projeto.
Na instância experimental do Visual Studio, pressione F5 para construir, implantar e executar o projeto TestBDCModel. O navegador da Web abre para a página padrão do site do SharePoint que é usado para depuração.
Verifique o lista seção na área Inicialização rápida ainda não contém uma lista que é baseada no modelo BDC padrão no projeto. Crie primeiro uma lista de dados externos, usando a interface de usuário do SharePoint ou usando a extensão de item de projeto.
Feche o navegador da Web.
Na instância do Visual Studio que abriu o projeto de TestBDCModel, clique com o botão direito do BdcModel1 nó Solution Explorer e clique em Gerar a lista de dados externos.
Verificar que o código na instância de Visual Studio pára no ponto de interrupção que você definiu anteriormente na GenerateExternalDataLists_Execute método. Pressione F5 para continuar a depurar o projeto.
A instância experimental do Visual Studio adiciona uma instância de lista denominada Entity1DataList a TestBDCModel projeto e ele também gera um recurso chamado Feature2 para a instância de lista.
Pressione F5 para construir, implantar e executar o projeto TestBDCModel. O navegador da Web abre para a página padrão do site do SharePoint que é usado para depuração.
Verifique o lista seção no início rápido agora contém uma lista que é denominada Entity1DataList.
Clique na Entity1DataList lista.
Verifique se a lista contém colunas nomeadas como Identifier1 e mensagem e um item com o valor de Identifier1 de 0 e o valor de mensagem do Hello World. Todos esses dados é fornecida pelo modelo do BDC padrão gerado pelo Modelo de conectividade de dados de negócios o modelo de projeto.
Feche o navegador da Web.

Limpando o computador de desenvolvimento

Após concluir o teste a extensão de item de projeto, removerá a lista externa e o modelo do BDC do site do SharePoint e a extensão de item de projeto de Visual Studio.

Para remover a lista de dados externos no site do SharePoint

Na área Inicialização rápida do site do SharePoint, clique na Entity1DataList lista.
Na faixa de opções no site do SharePoint, clique no lista guia.
No lista tab, o configurações de grupo, clique em As configurações da lista.
Em permissões e gerenciamento, clique em Excluir esta lista de. Clique em OK para confirmar que você deseja enviar a lista para a Lixeira.
Feche o navegador da Web.

Para remover o modelo do BDC do site do SharePoint

Na instância experimental do Visual Studio, sobre o Build menu, clique em Retract.

Visual Studio remove o modelo do BDC do site do SharePoint.

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

Na instância experimental do Visual Studio, sobre o Ferramentas menu, clique em Extension Manager.

O Extension Manager abre a caixa de diálogo.
Na lista de extensões, clique em Gerador de lista de dados externose em seguida, clique em desinstalar.
Na caixa de diálogo que aparece, clique em Sim para confirmar que você deseja desinstalar a extensão.
Clique em Reiniciar agora para concluir a desinstalação.
Feche as duas instâncias de Visual Studio (a instância experimental e a instância do Visual Studio que abriu a solução de GenerateExternalDataLists).

Compartilhar via