Instruktaż: Rozszerzenie typu element projektu programu SharePoint

Artykuł
02/27/2013

Można użyć Model usługi łączności danych biznesowych elementu projektu do tworzenia modeli usługi łączności danych biznesowych (BDC) w programie SharePoint.Domyślnie podczas tworzenia modelu przy użyciu tego elementu projektu danych w modelu nie jest wyświetlany użytkownikom.Należy również utworzyć listy zewnętrznej programu SharePoint, aby umożliwić użytkownikom wyświetlanie danych.

W tym instruktażu utworzy rozszerzenie dla Model usługi łączności danych biznesowych element projektu.Deweloperzy mogą używać rozszerzenia, aby utworzyć listę zewnętrzną w ich projekt, który wyświetla dane w modelu usługi BDC.W tym instruktażu przedstawiono następujące zadania:

Tworzenie rozszerzeń programu Visual Studio, które wykonuje dwa główne zadania:
- Generuje listy zewnętrznej, który wyświetla dane w modelu usługi BDC.Rozszerzenie używa modelu systemu projektu programu SharePoint do generowania pliku Elements.xml, który definiuje listę.Dodaje także plik do projektu tak, że system został wdrożony z modelu usługi BDC.
- Dodaje element menu skrótów, aby Model usługi łączności danych biznesowych projektu elementów w Solution Explorer.Deweloperzy mogą kliknij ten element menu, aby wygenerować listę zewnętrzną dla modelu usługi BDC.
Budowanie pakietu Visual Studio rozszerzenie (VSIX) do wdrażania zestawu rozszerzeń.
Testowanie rozszerzenia.

Wymagania wstępne

Potrzebne są następujące składniki na komputerze deweloperskim do przeprowadzenia tego instruktażu:

Obsługiwane wersje systemu Microsoft Windows, programu SharePoint i Visual Studio.Aby uzyskać więcej informacji, zobacz Wymagania dotyczące rozwiązań programu SharePoint.
The Visual Studio SDK.W tym instruktażu wykorzystano Projektu VSIX szablon w zestawie SDK, aby utworzyć pakiet VSIX wdrożyć element projektu.Aby uzyskać więcej informacji, zobacz Rozszerzanie narzędzi programu SharePoint w programie Visual Studio.

Znajomość następujące pojęcia jest przydatne, ale nie jest to wymagane, aby ukończyć Instruktaż:

Usługa BDC w Microsoft SharePoint Server 2010.Aby uzyskać więcej informacji, zobacz Usługi BDC architektura.
Schemat XML dla modeli usługi BDC.Aby uzyskać więcej informacji, zobacz Infrastruktury modelu usługi BDC.

Tworzenie projektów

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

Projekt VSIX, aby utworzyć pakiet VSIX wdrożyć rozszerzenie elementu projektu.
Projektu biblioteki klas, który implementuje rozszerzenie elementu projektu.

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

Aby utworzyć projekt VSIX

Start Visual Studio.
Na pasku menu wybierz pliku, Nowa, Projekt.
W Nowy projekt okno dialogowe rozwiń Visual C# lub języka Visual Basic węzłów, a następnie wybierz polecenie rozszerzalności węzła.

[!UWAGA]

Rozszerzalności węzeł jest dostępne tylko po zainstalowaniu programu Visual Studio SDK.Aby uzyskać więcej informacji zobacz sekcję Warunki wstępne, wcześniej w tym temacie.
Na liście u góry Nowy projekt okno dialogowe Wybierz 4.5.NET Framework.

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

Visual Studiododaje GenerateExternalDataLists projekt Solution Explorer.
Jeśli plik source.extension.vsixmanifest nie jest otwierany automatycznie, otwórz menu skrótów w programie project GenerateExternalDataLists, a następnie wybierz Otwórz
Sprawdź, czy plik source.extension.vsixmanifest ma wpis nie jest puste (wprowadź Contoso) dla pola Autor, Zapisz plik, a następnie zamknij go.

Aby utworzyć rozszerzenie projektu

W Solution Explorer, otwórz menu skrótów dla GenerateExternalDataLists rozwiązanie węzła, wybierz Dodaj, a następnie wybierz polecenie Nowy projekt.

[!UWAGA]

W projektach programu Visual Basic, węzeł rozwiązanie pojawia się w Solution Explorer tylko wtedy, gdy Zawsze pokazuj rozwiązanie pole wyboru jest zaznaczone w General, Projects and Solutions, Options Dialog Box.
W Dodać nowy projekt okno dialogowe rozwiń Visual C# lub języka Visual Basic węzły, a następnie wybierz polecenie Windows węzła.
W górnej części okna dialogowego wybierz 4.5.NET Framework.
Na liście szablonów projektu, wybierz opcję Biblioteka klas.
W Nazwa wprowadź BdcProjectItemExtension, a następnie wybierz polecenie OK przycisk.

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

Konfigurowanie rozszerzenie projektu

Przed pisać kod, aby utworzyć rozszerzenie element projektu, należy dodać pliki kodu i odwołania do zestawów do rozszerzenie projektu.

Aby skonfigurować projektu

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

Definiowanie rozszerzenie element projektu

Tworzenie klasy, która określa rozszerzenie dla Model usługi łączności danych biznesowych element projektu.Aby zdefiniować rozszerzenie implementuje klasy ISharePointProjectItemTypeExtension interfejsu.Implementuje ten interfejs, w każdym przypadku, gdy chcesz rozszerzyć istniejącego typu element projektu.

Aby zdefiniować rozszerzenie element projektu

Wklej następujący kod w pliku kod ProjectItemExtension.

[!UWAGA]

Po dodaniu tego kodu, projekt będzie mieć pewne błędy kompilacji.Te błędy zniknie 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 zewnętrznych danych

Dodawanie definicji częściowej GenerateExternalDataListsExtension klasy, 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 danych podmiotu w modelu usługi BDC przez analizowanie danych XML w pliku modelu usługi BDC.Następnie tworzy wystąpienie listy, który jest oparty na modelu usługi BDC i dodaje instancję tej listy do projektu.

Aby utworzyć listę danych zewnętrznych

Wklej następujący kod do pliku kod 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 w instruktażu, cały kod dla rozszerzenia elementu projektu jest teraz w projekcie.Tworzenie rozwiązania, aby upewnić się, że projekt kompiluje się bez błędów.

Rozwiązanie

Na pasku menu wybierz budować, Budowania rozwiązania.

Tworzenie pakiet VSIX wdrożyć rozszerzenie element projektu

Aby wdrożyć rozszerzenie, należy użyć projektu VSIX w swoje rozwiązanie tworzenia pakiet VSIX.Najpierw należy skonfigurować pakiet VSIX modyfikując plik source.extension.vsixmanifest, który jest zawarty w projekcie VSIX.Następnie utwórz pakiet VSIX przez budowania rozwiązania.

Aby skonfigurować i utworzyć pakiet VSIX

W Solution Explorer, aby otworzyć menu skrótów dla pliku source.extension.vsixmanifest w programie project GenerateExternalDataLists, a następnie wybierz Otwórz.

Visual Studio otwiera plik w edytorze manifestu.Plik source.extension.vsixmanifest jest podstawą do pliku extension.vsixmanifest jest wymagane przez wszystkie pakiety VSIX.Aby uzyskać więcej informacji na temat tego pliku, zobacz VSIX rozszerzenie schematu odwołania.
W Nazwa produktu wprowadź Zewnętrzny Generator listy danych.
W autora wprowadź Contoso.
W Opis wprowadź Wyświetla rozszerzenie dla elementów projektu modelu łączności danych biznesowych, które służy do generowania danych zewnętrznych.
Na aktywów kartę Edytor, należy wybrać Nowa przycisk.

Dodać nowego środka pojawi się okno dialogowe.
W typu listy, wybierz opcję Microsoft.VisualStudio.MefComponent.

[!UWAGA]

Wartość ta odpowiada MefComponent elementu w pliku extension.vsixmanifest.Ten element Określa nazwę zestawu rozszerzeń w pakiecie VSIX.Aby uzyskać więcej informacji, zobacz MEFComponent Element.
W źródło listy, wybierz opcję projektu w bieżącym rozwiązaniem.
W Projekt listy, wybierz opcję BdcProjectItemExtension, a następnie wybierz polecenie OK przycisk.
Na pasku menu wybierz budować, Budowania rozwiązania.
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 folder wyjściowy kompilacji jest...folder \bin\Debug w folderze, który zawiera plik projektu.

Testowanie rozszerzenie element projektu

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

Aby rozpocząć debugowanie rozszerzenia

Jeśli to konieczne, ponownie uruchom Visual Studio z poświadczeniami administracyjnymi, a następnie otwórz rozwiązanie GenerateExternalDataLists.
Projektu, BdcProjectItemExtension, otwórz plik ProjectItemExtension kod, a następnie Dodaj punkt przerwania do linii kodu w Initialize metoda.
Otwórz plik GenerateExternalDataLists kod, a następnie Dodaj punkt przerwania w pierwszej linii kodu w GenerateExternalDataLists_Execute metoda.
Rozpocząć debugowanie wybierając klawisz F5 lub, na pasku menu, wybierając Debug, Start Debugging.

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

Aby przetestować rozszerzenia

Eksperymentalne wystąpienie programu Visual Studio, na pasku menu wybierz pliku, Nowa, Projekt.
W Nowy projekt okno dialogowe rozwiń Szablony węzła, rozwiń Visual C# węzła, rozwiń węzeł SharePoint węzła, a następnie wybierz 2010.
Upewnij się, że na liście u góry okna dialogowego 3.5.NET Framework jest zaznaczone.Projekty dla Microsoft SharePoint Server 2010 wymaga ta wersja programu.NET Framework.
Na liście szablonów projektu, wybierz opcję Programu SharePoint 2010 projektu.
W Nazwa wprowadź SharePointProjectTestBDC, a następnie wybierz polecenie OK przycisk.
Kreatora dostosowania programu SharePoint, wprowadź adres URL witryny, którą chcesz używać do debugowania, wybierz wdrożyć rozwiązanie farmy, a następnie wybierz polecenie zakończyćprzycisk.
Otwórz menu skrótów dla projektu SharePointProjectTestBDC, wybierz polecenie Dodaj, a następnie wybierz polecenie Nowego elementu.
W Dodać NewItem-SharePointProjectTestBDC okno dialogowe pole, rozwiń węzeł zainstalowanego języka, rozwiń węzeł SharePoint węzła.
Wybierz 2010 węzła, a następnie wybierz polecenie Model usługi łączności danych biznesowych (tylko rozwiązanie gospodarstwa) szablonu.
W Nazwa wprowadź TestBDCModel, a następnie wybierz polecenie Dodaj przycisk.
Sprawdź, że kod w inne wystąpienie programu Visual Studio zatrzymuje się na punkt przerwania, ustawione w Initialize metoda kod pliku ProjectItemExtension.
W przypadku zatrzymania programu Visual Studio, F5 klucz lub paska menu, wybierz debugowania, Kontynuuj kontynuowanie debugowania projektu.
Eksperymentalne wystąpienie programu Visual Studio, wybierz F5 klucz lub, na pasku menu wybierz Debug, Start Debugging do budowania, wdrażania i uruchomić TestBDCModel projektu.

Otwiera przeglądarkę sieci web do domyślnej strony witryny programu SharePoint, która jest określona dla debugowania.
Sprawdź, czy zawiera listę sekcji w obszarze szybkiego uruchamiania jeszcze nie zawiera listę opartą na domyślny model usługi BDC w projekcie.Lista danych zewnętrznych, należy najpierw utworzyć za pomocą interfejsu użytkownika programu SharePoint lub za pomocą rozszerzenia elementu projektu.
Zamknij przeglądarkę sieci web.
W wystąpieniu programu Visual Studio, który został otwarty projekt TestBDCModel, otwórz menu skrótów dla TestBDCModel węzeł w Solution Explorer, a następnie wybierz polecenie Wygenerować listę danych zewnętrznych.
Sprawdź, że kod w inne wystąpienie programu Visual Studio zatrzymuje się na punkt przerwania, ustawione w GenerateExternalDataLists_Execute metoda.Wybierz F5 klucz lub, na pasku menu wybierz Debug, Kontynuuj na kontynuowanie debugowania projektu.
Eksperymentalne wystąpienie programu Visual Studio dodaje instancję listy o nazwie Entity1DataList do TestBDCModel projektu i instancji generuje również funkcję o nazwie funkcje2 dla instancji list.
Wybierz F5 klucz lub, na pasku menu wybierz Debug, Start Debugging do budowania, wdrażania i uruchomić projekt TestBDCModel.

Otwiera przeglądarkę sieci web do domyślnej strony witryny programu SharePoint, który jest używany do debugowania.
W zawiera listę sekcji obszaru szybkiego uruchamiania wybierz Entity1DataList listy.
Sprawdź, czy lista zawiera kolumny o nazwie Identifier1 i wiadomości, oprócz jednego elementu, który ma wartość Identifier1 0 i wartość wiadomość Hello World.

Model usługi łączności danych biznesowych szablon projektu generuje domyślny model usługi BDC zawiera wszystkich danych.
Zamknij przeglądarkę sieci web.

Oczyszczanie na komputerze deweloperskim

Po zakończeniu badania rozszerzenie element projektu, usunąć listy zewnętrznej i modelu usługi BDC w witrynie programu SharePoint i usuń rozszerzenie elementu projektu z programu Visual Studio.

Aby usunąć listę danych zewnętrznych w witrynie programu SharePoint

Wybierz w obszarze paska Szybkie uruchamianie witryny programu SharePoint, Entity1DataList listy.
Na Wstążce w witrynie programu SharePoint, należy wybrać Lista kartę.
Na Lista kartę w Ustawienia grupy, wybierz opcję Ustawienia listy.
Pod uprawnienia i zarządzanie, wybierz opcję Usuń tę listę, a następnie wybierz polecenie OK potwierdzić, że chcesz wysłać listy do Kosza.
Zamknij przeglądarkę sieci web.

Aby usunąć modelu usługi BDC w witrynie programu SharePoint

Eksperymentalne wystąpienie programu Visual Studio, na pasku menu wybierz budować, anulowanie.

Visual Studio usuwa modelu usługi BDC w witrynie programu SharePoint.

Aby usunąć rozszerzenie elementu projektu z programu Visual Studio

Eksperymentalne wystąpienie programu Visual Studio, na pasku menu wybierz Narzędzia, rozszerzenia i aktualizacje.

Rozszerzenia i aktualizacje zostanie otwarte okno dialogowe.
Na liście Rozszerzenia wybierz Zewnętrznych Generator listy danych, a następnie wybierz polecenie odinstalować przycisk.
W wyświetlonym oknie dialogowym wybierz Tak , aby potwierdzić, że chcesz odinstalować rozszerzenie.
Wybierz Uruchom ponownie teraz do ukończenia dezinstalacji.
Zamknij oba wystąpienia programu Visual Studio (wystąpienie eksperymentalnych i instancji, w którym otwarty jest rozwiązanie GenerateExternalDataLists).

Zobacz też

Koncepcje

Rozszerzenia systemu projektu programu SharePoint

Inne zasoby

Tworzenie modelu połączeń danych biznesowych

Projektowanie modelu połączeń danych biznesowych

Udostępnij za pośrednictwem