연습: SharePoint 프로젝트 항목 형식 확장

아티클
02/21/2013

비즈니스 데이터 연결 모델 프로젝트 항목을 사용하여 SharePoint에서 BDC(비즈니스 데이터 연결) 서비스의 모델을 만들 수 있습니다.기본적으로 이 프로젝트 항목을 사용하여 모델을 만들면 모델의 데이터가 사용자에게 표시되지 않습니다.사용자가 데이터를 볼 수 있도록 하려면 SharePoint에서 외부 목록도 만들어야 합니다.

이 연습에서는 비즈니스 데이터 연결 모델 프로젝트 항목의 확장을 만듭니다.개발자는 확장을 사용하여 BDC 모델의 데이터를 표시하는 외부 목록을 프로젝트에 만들 수 있습니다.이 연습에서는 다음 작업을 수행합니다.

다음 두 가지 주요 작업을 수행하는 Visual Studio 확장 만들기
- BDC 모델의 데이터를 표시하는 외부 목록을 생성합니다.이 확장은 SharePoint 프로젝트 시스템의 개체 모델을 사용하여 목록을 정의하는 Elements.xml 파일을 생성합니다.또한 BDC 모델과 함께 배포되도록 프로젝트에 파일을 추가합니다.
- 솔루션 탐색기에서 비즈니스 데이터 연결 모델 프로젝트 항목에 대한 바로 가기 메뉴 항목을 추가합니다.개발자는 이 메뉴 항목을 클릭하여 BDC 모델에 대한 외부 목록을 생성할 수 있습니다.
확장 어셈블리를 배포하기 위한 VSIX(Visual Studio Extension) 패키지 빌드
확장 테스트

사전 요구 사항

이 연습을 완료하려면 개발 컴퓨터에 다음 구성 요소가 필요합니다.

지원되는 Microsoft Windows, SharePoint 및 Visual Studio 버전.자세한 내용은 SharePoint 솔루션 개발 요구 사항을 참조하십시오.
Visual Studio SDK이 연습에서는 SDK의 VSIX 프로젝트 템플릿을 사용하여 프로젝트 항목을 배포하기 위한 VSIX 패키지를 만듭니다.자세한 내용은 Visual Studio에서 SharePoint 도구 확장을 참조하십시오.

다음 개념을 알고 있으면 연습을 완료하는 데 도움이 되지만 반드시 필요하지는 않습니다.

Microsoft SharePoint Server 2010의 BDC 서비스.자세한 내용은 BDC Architecture를 참조하십시오.
BDC 모델의 XML 스키마.자세한 내용은 BDC Model Infrastructure를 참조하십시오.

프로젝트 만들기

이 연습을 완료하려면 두 프로젝트를 만들어야 합니다.

VSIX 패키지를 만들어 프로젝트 항목 확장을 배포하기 위한 VSIX 프로젝트
프로젝트 항목 확장을 구현하는 클래스 라이브러리 프로젝트

먼저 프로젝트를 만들어 연습을 시작합니다.

VSIX 프로젝트를 만들려면

Visual Studio를 시작합니다.
메뉴 모음에서 파일, 새로 만들기, 프로젝트를 선택합니다.
에 새 프로젝트 대화 상자에서 확장은 C# 또는 Visual Basic 노드를 다음 선택은 확장성 노드.

[!참고]

확장성 노드인 Visual Studio SDK를 설치한 경우에 사용할 수 있습니다.자세한 내용은 이 항목의 앞부분에 나오는 사전 요구 사항 단원을 참조하십시오.
목록 상단에 있는 새 프로젝트 대화 상자에서 선택 .NET Framework 4.5.

SharePoint 도구 확장을 사용하려면 이 .NET Framework 버전의 기능이 필요합니다.
선택 된 VSIX 프로젝트 템플릿.
에 이름 상자에 입력 GenerateExternalDataLists, 다음 선택은 확인 단추입니다.

Visual Studio에서 솔루션 탐색기에 GenerateExternalDataLists 프로젝트를 추가합니다.
Source.extension.vsixmanifest 파일이 자동으로 열리지 않으면 GenerateExternalDataLists 프로젝트에서 해당 바로 가기 메뉴를 엽니다 및 다음 선택 열기
Source.extension.vsixmanifest 파일에 빈 항목이 있는지 확인 하십시오 (Contoso를 입력) 작성자 필드에 파일을 저장 한 다음 닫습니다.

확장 프로젝트를 만들려면

솔루션 탐색기, 바로 가기 메뉴를 열고를 GenerateExternalDataLists 솔루션 노드를 선택 추가, 다음 선택 새 프로젝트.

[!참고]

Visual Basic 프로젝트에서는 General, Projects and Solutions, Options Dialog Box에서 솔루션 항상 표시 확인란을 선택한 경우에만 솔루션 탐색기에 솔루션 노드가 표시됩니다.
에 새 프로젝트 추가 대화 상자에서 확장은 C# 또는 Visual Basic 노드를 다음 선택은 Windows 노드.
대화 상자 맨 위에 있는 목록에서 선택한 .NET Framework 4.5.
프로젝트 템플릿 목록에서 선택 클래스 라이브러리.
에 이름 상자에 입력 BdcProjectItemExtension, 다음 선택은 확인 단추입니다.

Visual Studio에서 솔루션에 BdcProjectItemExtension 프로젝트를 추가하고 기본 Class1 코드 파일을 엽니다.
프로젝트에서 Class1 코드 파일을 삭제합니다.

확장 프로젝트 구성

프로젝트 항목 확장을 만드는 코드를 작성하기 전에 코드 파일과 어셈블리 참조를 확장 프로젝트에 추가합니다.

프로젝트를 구성하려면

BdcProjectItemExtension 프로젝트에서 다음과 같이 이름이 지정된 코드 파일 두 개를 추가합니다.
- ProjectItemExtension
- GenerateExternalDataLists
BdcProjectItemExtension 프로젝트를 선택 하 고 메뉴 표시줄에서 선택 프로젝트, 참조 추가.
아래는 어셈블리 노드를 선택 된 프레임 워크 노드와 각 다음 어셈블리에 대 한 확인란을 선택:
- System.ComponentModel.Composition
- WindowsBase
아래는 어셈블리 노드를 선택 된 확장 노드 및 다음 어셈블리에 대 한 확인란을 선택 후:
- Microsoft.VisualStudio.SharePoint
확인 단추를 선택합니다.

프로젝트 항목 확장 정의

비즈니스 데이터 연결 모델 프로젝트 항목의 확장을 정의하는 클래스를 만듭니다.확장을 정의하기 위해 클래스에서 ISharePointProjectItemTypeExtension 인터페이스를 구현합니다.기존 프로젝트 항목 형식을 확장하려는 경우 이 인터페이스를 구현합니다.

프로젝트 항목 확장을 정의하려면

다음 코드를 붙여에 ProjectItemExtension 코드 파일입니다.

[!참고]

이 코드를 추가한 후 프로젝트에 컴파일 오류가 발생 해야 합니다.이러한 오류는 이후 단계에서 코드를 추가하면 사라집니다.

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

외부 데이터 목록 만들기

BDC 모델의 각 엔터티에 대해 외부 데이터 목록을 만드는 GenerateExternalDataListsExtension 클래스의 부분 정의를 추가합니다.외부 데이터 목록을 만들기 위해 이 코드에서는 먼저 BDC 모델 파일의 XML 데이터를 구문 분석하여 BDC 모델의 엔터티 데이터를 읽습니다.그런 다음 BDC 모델을 기반으로 하여 목록 인스턴스를 만들고 프로젝트에 이 목록 인스턴스를 추가합니다.

외부 데이터 목록을 만들려면

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

검사점

이 연습의 이전 단계를 통해 프로젝트 항목 확장을 위한 모든 코드가 프로젝트에 포함되었습니다.솔루션을 빌드하여 프로젝트가 오류 없이 컴파일되는지 확인합니다.

솔루션을 빌드하려면

메뉴 표시줄에서 선택 빌드, 솔루션 빌드.

프로젝트 항목 확장을 배포하기 위한 VSIX 패키지 만들기

확장을 배포하려면 솔루션에서 VSIX 프로젝트를 사용하여 VSIX 패키지를 만듭니다.먼저 VSIX 프로젝트에 포함된 source.extension.vsixmanifest 파일을 수정하여 VSIX 패키지를 구성합니다.그런 다음 솔루션을 빌드하여 VSIX 패키지를 만듭니다.

VSIX 패키지를 구성하고 만들려면

솔루션 탐색기, GenerateExternalDataLists 프로젝트의 source.extension.vsixmanifest 파일에 대 한 바로 가기 메뉴를 엽니다 및 다음 선택 열기.

매니페스트 편집기에서 파일이 열립니다.source.extension.vsixmanifest 파일은 모든 VSIX 패키지에 필요한 extension.vsixmanifest 파일의 기초를 제공합니다.이 파일에 대한 자세한 내용은 VSIX 확장 스키마 참조를 참조하십시오.
에 있는 제품명 상자에 입력 외부 데이터 목록 생성기.
에 있는 작성자 상자에 입력 Contoso.
에 있는 설명이 상자에 입력 외부 데이터를 생성 하는 데 사용할 수 있습니다 비즈니스 데이터 연결 모델 프로젝트 항목의 확장을 나열.
에 자산 탭 편집기의 선택은 New 단추.

를 추가 하는 새로운 자산 대화 상자가 나타납니다.
에 있는 유형 목록에서 선택 Microsoft.VisualStudio.MefComponent.

[!참고]

이 값은 extension.vsixmanifest 파일의 MefComponent 요소에 해당합니다.이 요소는 VSIX 패키지의 확장 어셈블리 이름을 지정합니다.자세한 내용은 MEFComponent Element을 참조하십시오.
에 있는 원본 목록에서 선택 현재 솔루션의 프로젝트에.
에 프로젝트 목록에서 선택 BdcProjectItemExtension, 다음 선택은 확인 단추입니다.
메뉴 표시줄에서 선택 빌드, 솔루션 빌드.
프로젝트를 컴파일하고 오류 없이 빌드 되었는지 확인 합니다.
GenerateExternalDataLists 프로젝트의 빌드 출력 폴더에 이제 GenerateExternalDataLists.vsix 파일이 들어 있는지 확인 합니다.

기본적으로 빌드 출력 경로는 프로젝트 파일이 포함된 폴더 아래에 있는 ..\bin\Debug 폴더입니다.

프로젝트 항목 확장 테스트

이제 프로젝트 항목 확장을 테스트할 준비가 되었습니다.우선 실험 모드의 Visual Studio 인스턴스에서 확장 프로젝트 디버깅을 시작합니다.그런 다음 실험 모드의 Visual Studio 인스턴스에서 확장을 사용하여 BDC 모델에 대한 외부 목록을 생성합니다.마지막으로, SharePoint 사이트에서 외부 목록을 열어 예상대로 작동하는지 확인합니다.

확장 디버깅을 시작하려면

Visual Studio 관리자 자격 증명으로 다시 시작 하 고 GenerateExternalDataLists 솔루션을 엽니다.
BdcProjectItemExtension 프로젝트에 ProjectItemExtension 코드 파일을 열고 다음 코드 줄에 중단점을 추가 된 Initialize 메서드입니다.
GenerateExternalDataLists 코드 파일을 열고 다음 코드의 첫째 줄에 중단점을 추가 된 GenerateExternalDataLists_Execute 메서드가 있습니다.
선택, F5 키를 선택 하 여 또는 메뉴 모음에서 디버깅 시작 디버깅, 디버깅 시작.

Visual Studio에서는 확장을 %UserProfile%\AppData\Local\Microsoft\VisualStudio\10.0Exp\Extensions\Contoso\External Data List Generator\1.0에 설치하고 실험 모드의 Visual Studio 인스턴스를 시작합니다.이 Visual Studio 인스턴스에서 프로젝트 항목을 테스트합니다.

확장을 테스트하려면

Visual Studio 실험적 인스턴스에서 메뉴 표시줄에서 선택 파일, New, 프로젝트.
에 새 프로젝트 대화 상자에서 확장의 템플릿 노드를 확장의 C# 노드를 확장은 SharePoint 노드를 다음 선택 2010.
대화 상자 맨 위에 있는 목록에 있는지 확인 .NET Framework 3.5 을 선택 합니다.Microsoft SharePoint Server 2010용 프로젝트에는 이 .NET Framework 버전이 필요합니다.
프로젝트 템플릿 목록에서 선택 SharePoint 2010 프로젝트.
에 이름 상자에 입력 SharePointProjectTestBDC, 다음 선택은 확인 단추입니다.
SharePoint 사용자 지정 마법사에서 선택, 디버깅에 사용 하려는 사이트의 URL을 입력 합니다. 팜 솔루션으로 배포, 다음 선택은 마침단추입니다.
SharePointProjectTestBDC 프로젝트에 대 한 바로 가기 메뉴를 열고 추가, 다음 선택 새 항목.
에 추가 NewItem – SharePointProjectTestBDC 대화 상자, 설치 된 언어 노드를 확장 한의 SharePoint 노드.
선택은 2010 노드를 다음 선택은 비즈니스 데이터 연결 모델 (팜 솔루션에만 해당) 템플릿.
에 이름 상자에 입력 TestBDCModel, 다음 선택은 추가 단추입니다.
Visual Studio 다른 인스턴스에서 코드에 설정한 중단점에서 중지 하는지 확인은 Initialize ProjectItemExtension 코드 파일에 메서드.
Visual Studio 중지 된 인스턴스를 선택은 F5 , 키 또는 메뉴 표시줄에서 선택 디버그, 계속 프로젝트에 디버깅을 계속 합니다.
Visual Studio 실험적 인스턴스에서 선택의 F5 , 키 또는 메뉴 표시줄에서 선택 디버그, 디버깅 시작 빌드, 배포 및 실행은 TestBDCModel 프로젝트.

디버깅에 대 한 지정 된 SharePoint 사이트의 기본 페이지를 웹 브라우저를 엽니다.
확인은 목록 섹션에 있는 빠른 실행 영역 프로젝트의 기본 BDC 모델을 기반으로 하는 목록 아직 포함 되지 않습니다.먼저 SharePoint 사용자 인터페이스를 사용하거나 프로젝트 항목 확장을 사용하여 외부 데이터 목록을 만들어야 합니다.
웹 브라우저를 닫습니다.
Visual Studio TestBDCModel 프로젝트가 열려 있는 경우 바로 가기 메뉴를 열고를 TestBDCModel 노드에서 솔루션 탐색기, 다음 선택 외부 데이터 목록을 생성.
Visual Studio 다른 인스턴스에서 코드에 설정한 중단점에서 중지 하는지 확인은 GenerateExternalDataLists_Execute 메서드입니다.선택의 F5 , 키 또는 메뉴 표시줄에서 선택 디버그, 계속 프로젝트에 디버깅을 계속 합니다.
라는 목록 인스턴스를 추가 하는 Visual Studio 실험적 인스턴스에서 Entity1DataList Testbdcmodel를 프로젝트 및 인스턴스 라는 피쳐 생성도 Feature2 목록 인스턴스에 대 한.
선택은 F5 , 키 또는 메뉴 표시줄에서 선택 디버그, 디버깅 시작 빌드, 배포 및 TestBDCModel 프로젝트를 실행 합니다.

디버깅에 사용 되는 SharePoint 사이트의 기본 페이지를 웹 브라우저를 엽니다.
에 나열 섹션 빠른 실행 영역에 선택 된 Entity1DataList 목록.
목록 identifier1과 메시지를 메시지 값이 Hello World와 Identifier1 값이 0 항목 외에 명명 된 열이 있는지 확인 합니다.

비즈니스 데이터 연결 모델 프로젝트 템플릿은 모든이 데이터를 제공 하는 기본 BDC 모델을 생성 합니다.
웹 브라우저를 닫습니다.

개발 컴퓨터 정리

프로젝트 항목 확장의 테스트를 마쳤으면 SharePoint 사이트에서 외부 목록과 BDC 모델을 제거하고 Visual Studio에서 프로젝트 항목 확장을 제거합니다.

SharePoint 사이트에서 외부 데이터 목록을 제거하려면

SharePoint 사이트의 빠른 실행 영역에서 선택 된 Entity1DataList 목록입니다.
SharePoint 사이트에서 리본 메뉴에 선택 된 목록 탭.
에 목록 탭에 설정 선택, 그룹 목록 설정.
아래 사용 권한 및 관리, 선택 이 목록 삭제, 다음 선택 확인 목록을 휴지통으로 보낼 것인지 확인 하.
웹 브라우저를 닫습니다.

SharePoint 사이트에서 BDC 모델을 제거하려면

Visual Studio 실험적 인스턴스에서 메뉴 표시줄에서 선택 빌드, 리트랙트.

Visual Studio를 통해 SharePoint 사이트에서 BDC 모델이 제거됩니다.

Visual Studio에서 프로젝트 항목 확장을 제거하려면

Visual Studio 실험적 인스턴스에서 메뉴 표시줄에서 선택 도구, 확장 및 업데이트.

확장 및 업데이트 대화 상자가 열립니다.
확장명 목록에서 선택한 외부 데이터 목록 생성기, 다음 선택은 제거 단추입니다.
나타나는 대화 상자에서 선택한 예 확장을 제거를 확인 합니다.
선택 이제 다시 제거를 완료 합니다.
Visual Studio (실험적 인스턴스 및 GenerateExternalDataLists 솔루션에 열려 있는 인스턴스)을 모두 닫습니다.

참고 항목

개념

SharePoint 프로젝트 시스템 확장

기타 리소스

비즈니스 데이터 연결 모델 만들기

비즈니스 데이터 연결 모델 디자인

다음을 통해 공유