Wskazówki: rozszerzanie typu elementu projektu SharePoint

Artykuł
06/08/2015

Można użyć Modelu usługi łączności danych biznesowych element projektu, aby utworzyć model usługi łączności danych biznesowych (BDC) w programie SharePoint.Domyślnie podczas tworzenia modelu przy użyciu tego elementu projektu, dane w modelu są niewidoczne dla użytkowników.Należy także utworzyć list zewnętrzny w programie SharePoint, aby umożliwić użytkownikom przeglądanie danych.

W tym instruktażu utworzysz rozszerzeniem dla elementu projektu Model usługi łączności danych biznesowych.Deweloperzy mogą używać rozszerzenia do tworzenia list zewnętrznych we własnym projekcie, który wyświetla dane w modelu BDC.W tym instruktażu pokazano następujące zagadnienia:

Tworzenie rozszerzenia programu Visual Studio, który wykonuje dwa główne zadania:
- Generuje listę zewnętrzną, która wyświetla dane w modelu usługi BDC.Rozszerzenie wykorzystuje model obiektów dla systemu projektu programu SharePoint do generowania pliku Elements.xml, który definiuje listę.Dodaje także plik do projektu tak, że jest wdrażany wraz z modelem usługi BDC.
- Dodaje element menu skrótów do elementów projektu Model usługi łączności danych biznesowych w Eksploratorze rozwiązań.Deweloperzy mogą kliknąć element menu w celu wygenerowania listy zewnętrznej dla modelu BDC.
Kompilacja pakietu rozszerzeń Visual Studio (VSIX) do wdrażania zestawu rozszerzeń.
Testowanie rozszerzeń.

Wymagania wstępne

Potrzebne są następujące składniki na komputerze programowania w celu przeprowadzenia tego instruktażu:

Obsługiwane wersje systemu Microsoft Windows, SharePoint i Visual Studio.Aby uzyskać więcej informacji, zobacz Wymagania związane z opracowywaniem rozwiązań SharePoint.
Visual Studio SDK.W tym instruktażu wykorzystano szablon projektu VSIX w zestawie SDK, aby utworzyć pakiet VSIX w celu wdrożenia elementu projektu.Aby uzyskać więcej informacji, zobacz Rozszerzanie Narzędzi SharePoint w Visual Studio.

Znajomość następujących pojęć jest przydatna, ale nie jest to wymagana do ukończeni instruktażu:

Usługa BCD w Microsoft SharePoint Server 2010Aby uzyskać więcej informacji, zobacz Architektura BDC.
Schemat XML dla modeli usługi łączności danych biznesowych.Aby uzyskać więcej informacji, zobacz Infrastruktura modelu usługi BDC.

Tworzenie projektów

Do przeprowadzenia tego instruktażu, należy utworzyć dwa projekty:

Projekt VSIX do stworzenia pakietu VSIX, aby wdrożyć rozszerzenie elementu projektu.
Projekt biblioteki klas, który implementuje rozszerzenie elementu projektu.

Instruktaż należy rozpocząć od utworzenia projektów.

Aby utworzyć projekt VSIX

Rozpocznij Visual Studio.
W pasku menu wybierz Plik, Nowy, Projekt.
W oknie dialogowym Dodaj nowy projekt rozwiń węzeł Visual C# lub Visual Basic, a następnie wybierz węzeł Rozszerzalność.

[!UWAGA]

Węzeł Rozszerzalności jest dostępny tylko po zainstalowaniu programu Visual Studio SDK.Aby uzyskać więcej informacji, zobacz wcześniejszą sekcję na temat wymagań wstępnych w tym paragrafie.
Na liście u góry okna dialogowego Nowy projekt, wybierz .NET Framework 4.5.

Rozszerzenia narzędzi programu SharePoint wymagają funkcji w tej wersji systemu .NET Framework.
Wybierz szablon Projekt VSIX.
W polu Nazwa wprowadź GenerateExternalDataLists, a następnie wybierz przycisk OK.

Visual Studio dodaje GenerateExternalDataLists projekt do Eksploratora rozwiązań.
Jeśli plik source.extension.vsixmanifest nie jest otwierany automatycznie, otwórz menu skrótów w projekcie GenerateExternalDataLists, a następnie wybierz Otwórz.
Sprawdź, czy plik source.extension.vsixmanifest ma wpis, który nie jest pusty (wprowadź Contoso) dla pola Autor, Zapisz plik, a następnie zamknij go.

Aby utworzyć projekt rozszerzenia

W Eksploratorze rozwiązań otwórz menu skrótów dla węzła rozwiązania GenerateExternalDataLists, wybierz Dodaj, a następnie wybierz polecenie Nowy projekt.

[!UWAGA]

W projektach języka Visual Basic, węzeł rozwiązania pojawia się w Eksploratorze rozwiązania tylko wtedy, gdy zaznaczono pole wyboru Zawsze pokazuj rozwiązanie w Ogólne, Projekty i rozwiązania, Opcje — okno dialogowe.
W oknie dialogowym Dodaj nowy projekt rozwiń węzeł Visual C# lub Visual Basic, a następnie wybierz węzeł Windows.
Na liście u góry okna dialogowego wybierz opcję .NET Framework 4.5.
Z listy szablonów projektu, wybierz opcję Biblioteka klas.
W polu Nazwa wprowadź BdcProjectItemExtension, a następnie wybierz przycisk OK.

Visual Studio dodaje BdcProjectItemExtension projektu do rozwiązania i otwiera plik domyślny kodu Class1.
Usuń plik kodu Class1 z projektu.

Konfigurowanie projektu rozszerzenia

Zanim napiszesz kod, aby utworzyć rozszerzenie elementu projektu, dodaj pliki kodu i odwołania do zestawów do projektu rozszerzenia.

Aby skonfigurować projekt

W projekcie BdcProjectItemExtension należy dodać dwa pliki kodu, które mają następujące nazwy:
- ProjectItemExtension
- GenerateExternalDataLists
Wybierz projekt BdcProjectItemExtension, a następnie na pasku menu wybierz Projekt, Dodaj odwołanie.
Pod zestawy węzła wybierz węzeł Szablon a następnie zaznacz pole wyboru dla każdego następujących zestawów:
- System.ComponentModel.Composition
- WindowsBase
Pod zestawy węzła wybierz węzeł rozszerzenia a następnie zaznacz pole wyboru dla następującego zestawu:
- Microsoft.VisualStudio.SharePoint
Wybierz przycisk OK.

Definiowanie rozszerzenia elementu projektu

Utwórz klasę, która określa rozszerzenie dla elementu projektu Model usługi łączności danych biznesowych.Aby zdefiniować rozszerzenie, klasa implementuje ISharePointProjectItemTypeExtension interfejs.Implementuje ten interfejs, w każdym przypadku, gdy chcesz rozszerzyć istniejący typ elementu projektu.

Aby zdefiniować element projektu rozszerzenia

Wklej następujący kod do pliku kodu ProjectItemExtension.

[!UWAGA]

Po dodaniu tego kodu, projekt będzie miał pewne błędy kompilacji.Te błędy znikną po dodaniu kodu w dalszych krokach.

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

Tworzenie list danych zewnętrznych

Dodaj częściową definicję klasy GenerateExternalDataListsExtension, która tworzy listę danych zewnętrznych dla każdej jednostki modelu usługi BDC.Aby utworzyć listę danych zewnętrznych, ten kod najpierw odczytuje dane jednostki w modelu usługi BDC przez analizowanie danych XML w pliku modelu usługi BDC.Następnie tworzy wystąpienie listy, które jest oparte na modelu usługi BDC i dodaje instancję tej listy do projektu.

Do tworzenia list danych zewnętrznych

Wklej następujący kod do pliku kodu 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;
        }
    }
}

Punkt kontrolny

W tym momencie instruktażu, cały kod dla rozszerzenia elementu projektu jest obecnie w projekcie.Kompiluj rozwiązanie, aby upewnić się, że projekt kompiluje bez błędów.

Aby skompilować rozwiązanie

Na pasku menu wybierz Kompilacja, Skompiluj rozwiązanie.

Tworzenie pakietu VSIX do wdrożenia rozszerzenia elementu projektu

Aby wdrożyć rozszerzenie, należy użyć projektu VSIX w swoim rozwiązaniu, aby utworzyć pakiet VSIX.Najpierw należy skonfigurować pakiet VSIX modyfikując plik source.extension.vsixmanifest, który znajduje się w projekcie VSIX.Następnie utwórz pakiet VSIX przez utworzenie rozwiązania.

Aby skonfigurować i utworzyć pakiet VSIX

W Eksploratorze rozwiązań otwórz menu skrótu dla pliku source.extension.vsixmanifest w projekcie GenerateExternalDataLists, a następnie wybierz Otwórz.

Visual Studio otwiera plik w edytorze manifestu.Plik source.extension.vsixmanifest jest podstawą dla pliku extension.vsixmanifest jest wymagany przez wszystkie pakiety VSIX.Aby uzyskać więcej informacji na temat tego pliku, zobacz VSIX rozszerzenie schematu odwołania.
W polu Nazwa produktu wprowadź Generator listy danych zewnętrznych.
W polu Autor wprowadź Contoso.
W polu Opis wprowadź Rozszerzenie dla elementów projektu modelowania usługi łączności danych biznesowych, które mogą służyć do generowania list danych zewnętrznych.
W zakładce edytora Aktywa, wybierz przycisk Nowy.

Pojawi się okno dialogowe Dodaj nowy zasób.
Z listy Typ wybierz Microsoft.VisualStudio.MefComponent.

[!UWAGA]

Wartość ta odpowiada MefComponent elementowi w pliku extension.vsixmanifest.Ten element określa nazwę zestawu rozszerzeń w pakiecie VSIX.Aby uzyskać więcej informacji, zobacz MEFComponent Element.
Z listy Źródło, wybierz opcję Projekt w bieżącym rozwiązaniu.
Na liście Projekt wybierz opcję BdcProjectItemExtension, a następnie wybierz przycisk OK.
Na pasku menu wybierz Kompilacja, Skompiluj rozwiązanie.
Upewnij się, że projekt kompiluje i buduje bez błędów.
Upewnij się, że folder wyjściowy kompilacji dla projektu GenerateExternalDataLists zawiera teraz plik GenerateExternalDataLists.vsix.

Domyślnie folderem wyjściowym kompilacji jest ..\bin\Debug pod folderem, który zawiera plik projektu.

Testowanie rozszerzenia element projektu

Teraz można przystąpić do testowania rozszerzenie elementu projektu.Po pierwsze uruchom debugowanie projektu rozszerzenia w doświadczalnym wystąpieniu programu Visual Studio.Następnie należy użyć rozszerzenia w doświadczalnym wystąpieniu programu Visual Studio do generowania listy zewnętrznej dla modelu usługi BDC.Wreszcie, otwórz listę zewnętrzną w witrynie programu SharePoint, aby sprawdzić, czy działa zgodnie z oczekiwaniami.

Aby rozpocząć debugowanie rozszerzenia

W razie potrzeby uruchom ponownie Visual Studio przy użyciu poświadczeń administracyjnych, a następnie otwórz rozwiązanie GenerateExternalDataLists.
W projekcie BdcProjectItemExtension, otwórz plik kodu ProjectItemExtension, a następnie dodaj punkt przerwania w pierwszej linii kodu w metodzie Initialize.
Otwórz plik kodu GenerateExternalDataLists, a następnie Dodaj punkt przerwania w pierwszej linii kodu w GenerateExternalDataLists_Execute metody.
Rozpocznij debugowanie wybierając klawisz F5 lub pasek menu, po wybraniu opcji Debuguj, Rozpocznij debugowanie.

Visual Studio instaluje rozszerzenia do %UserProfile%\AppData\Local\Microsoft\VisualStudio\10.0Exp\Extensions\Contoso\External danych listy Generator\1.0 i uruchamia doświadczalne wystąpienie programu Visual Studio.Element projektu spowoduje przetestowanie w tym wystąpieniu programu Visual Studio.

Aby przetestować rozszerzenie

Na przykład, w eksperymentalnym programie Visual Studio, na pasku menu wybierz Plik, Nowy, Projekt.
W oknie dialogowym Nowy projekt, rozwiń węzeł Szablony, rozwiń węzeł Visual C#, rozwiń węzeł SharePoint, a następnie wybierz 2010.
Na liście u góry okna dialogowego, upewnij się, że zaznaczono .NET Framework 3.5.Projekty dla Microsoft SharePoint Server 2010 wymagają tej wersji systemu .NET Framework.
Z listy szablonów projektu, wybierz opcję Projekt programu SharePoint 2010.
W polu Nazwa wprowadź SharePointProjectTestBDC, a następnie wybierz przycisk OK.
W Kreatorze dostosowywania programu SharePoint, wprowadź adres URL witryny, którą chcesz używać do debugowania, wybierz polecenie Wdrażanie rozwiązania typu farmy, a następnie wybierz przycisk Zakończ.
Otwórz menu skrótów dla projektu SharePointProjectTestBDC, wybierz opcję Dodaj, a następnie Nowy element.
W oknie dialogowym Dodaj NewItem – SharePointProjectTestBDC rozwiń węzeł zainstalowanego języka, rozwiń węzeł SharePoint.
Wybierz węzeł 2010, a następnie zaznacz szablon Model usługi łączności danych biznesowych (tylko rozwiązanie dla farmy.
W polu Nazwa wprowadź TestBDCModel, a następnie wybierz przycisk Dodaj.
Sprawdź, czy kod w innym wystąpieniu programu Visual Studio zatrzymuje się na punkcie przerwania, który zostało ustawiony w Initialize metodzie pliku kodu ProjectItemExtension.
W przypadku zatrzymania programu Visual Studio, wybierz klawisz F5 lub pasek menu, wybierz polecenie Debugowanie, Kontynuuj, aby kontynuować debugowanie projektu.
W doświadczalnym wystąpieniu programu Visual Studio, wybierz klawisz F5 lub na pasku menu wybierz Debuguj, Rozpocznij debugowanie w celu kompilacji, wdrażania i uruchomienia projektu TestBDCModel.

Przeglądarka sieci web otworzy stronę domyślnej witryny programu SharePoint, która jest określona dla debugowania.
Sprawdź, czy sekcja Listy w obszarze szybkiego uruchamiania jeszcze nie zawiera listy, która opiera się na domyślnym modelu usługi BDC w projekcie.Za pomocą interfejsu użytkownika programu SharePoint lub za pomocą rozszerzenie elementu projektu, należy najpierw utworzyć listę danych zewnętrznych.
Zamknij przeglądarkę sieci web.
W wystąpieniu programu Visual Studio, w którym został otwarty projekt TestBDCModel, otwórz menu skrótów dla węzła TestBDCModel w Eksploratorze rozwiązań, a następnie wybierz Generowanie list zewnętrznych danych.
Sprawdź, czy kod w innym wystąpieniu programu Visual Studio zatrzymuje się na punkcie przerwania, który zostało ustawiony w GenerateExternalDataLists_Execute metodzie.Wybierz klawisz F5 lub na pasku menu wybierz polecenie Debugowanie, Kontynuuj, aby kontynuować debugowanie projektu.
Eksperymentalne wystąpienia programu Visual Studio dodaje wystąpienie listy o nazwie Entity1DataList do projektu TestBDCModel, i instancja także generuje funkcję o nazwie Funkcja2 dla instancji listy.
Wybierz klawisz F5 lub na pasku menu wybierz Debuguj, Rozpocznij debugowanie w celu kompilacji, wdrażania i uruchomienia projektu TestBDCModel.

Przeglądarka sieci web otworzy stronę domyślnej witryny programu SharePoint, która była używana do debugowania.
W sekcji Listy obszaru szybkiego uruchamiania wybierz listę Entity1DataList.
Sprawdź, czy lista zawiera kolumny o nazwie Identifier1 i Wiadomość, oprócz jednego elementu, który ma wartość Identifier1 0 i wartość wiadomości Hello World.

Model usługi łączności danych biznesowych generuje domyślny szablon projektu modelu usługi BDC, który udostępnia wszystkie te dane.
Zamknij przeglądarkę sieci web.

Czyszczenie komputera deweloperskiego

Po zakończeniu badania rozszerzenia elementu projektu, usuń listy zewnętrzne i model usługi BDC z witryny programu SharePoint, i usuń rozszerzenie elementu projektu z programu Visual Studio.

Aby usunąć listę danych zewnętrznych z witryny programu SharePoint

W obszarze Szybkie uruchamianie witryny programu SharePoint, wybierz listę Entity1DataList.
Na wstążce w witrynie programu SharePoint, wybierz kartę Lista.
W zakładce lista w grupie Ustawienia wybierz polecenie Ustawienia listy.
Pod uprawnienia i zarządzanie, wybierz polecenie Usuń tę listę, a następnie wybierz polecenie OK aby potwierdzić, że chcesz wysłać listę do Kosza.
Zamknij przeglądarkę sieci web.

Aby usunąć model BDC z witryny programu SharePoint

W doświadczalnym wystąpieniu programu Visual Studio, na pasku menu wybierz Kompilacja, Wycofaj.

Visual Studio usuwa model BDC z witryny programu SharePoint.

Aby usunąć rozszerzenie elementu projektu z programu Visual Studio

W doświadczalnym wystąpieniu programu Visual Studio, na pasku menu wybierz Narzędzia, Rozszerzenia i aktualizacje.

Zostanie otwarte okno dialogowe Rozszerzenia i aktualizacje.
Na liście rozszerzeń wybierz Generator listy danych zewnętrznych, a następnie wybierz przycisk Odinstaluj.
W oknie dialogowym, które się pojawi, wybierz Tak, aby potwierdzić, że chcesz odinstalować rozszerzenie.
Wybierz Uruchom ponownie teraz, aby ukończyć dezinstalację.
Zamknij oba wystąpienia programu Visual Studio (wystąpienie doświadczalne i wystąpienie, w którym rozwiązanie GenerateExternalDataLists jest otwarte).

Zobacz też

Koncepcje

Rozszerzanie systemu projektu SharePoint

Inne zasoby

Tworzenie modelu łączności danych biznesowych

Projektowanie modelu łączności danych biznesowych

Udostępnij za pośrednictwem