Exemplarische Vorgehensweise: Erweitern des Server-Explorers für die Anzeige von Webparts

Artikel
02/20/2013

In Visual Studio können Sie den Knoten SharePoint-Verbindungen von Server-Explorer verwenden, um Komponenten auf SharePoint-Websites anzuzeigen.wird jedoch nicht Server-Explorer einige Komponenten standardmäßig an.In dieser exemplarischen Vorgehensweise erweitern Sie Server-Explorer, dass es den Webpartkatalog jeder verbundenen SharePoint-Website angezeigt wird.

Diese exemplarische Vorgehensweise enthält die folgenden Aufgaben:

Erstellen einer Visual Studio-Erweiterung, die den Server-Explorer auf folgende Weise erweitert:
- Die Erweiterung wird ein Knoten Webpartkatalog unter jedem SharePoint-Websiteknoten in Server-Explorer hinzu.Dieser neue Knoten enthält untergeordnete Knoten, die jedes Webpart im Webpartkatalog auf der Website darstellen.
- Die Erweiterung wird ein neuer Knotentyp definiert, der eine Webpart-Instanz darstellt.Dieser neue Knotentyp ist die Grundlage für die untergeordneten Knoten unter dem neuen Knoten Webpartkatalog.Der neue Webpartknotentyp zeigt im Eigenschaftenfenster Informationen zum zugehörigen Webpart an.Der Knotentyp umfasst auch ein benutzerdefiniertes Kontextmenüelement, das Sie als Ausgangspunkt zum Ausführen anderer Aufgaben verwenden können, die dem Webpart verknüpfen.
Zwei benutzerdefinierte SharePoint-Befehle erstellen, die die Erweiterungsassembly aufruft.SharePoint-Befehle sind Methoden, die von Erweiterungsassemblys aufgerufen werden können, um APIs im Serverobjektmodell für SharePoint zu verwenden.In dieser exemplarischen Vorgehensweise erstellen Sie Befehle, die Webpartinformationen von der lokalen SharePoint-Website auf dem Entwicklungscomputer abrufen.Weitere Informationen finden Sie unter Aufrufe in die SharePoint-Objektmodelle.
Erstellen eines Visual Studio-Erweiterungspakets (VSIX) zum Bereitstellen der Erweiterung.
Debuggen und Testen der Erweiterung.

Hinweis
Eine alternative Version dieser exemplarischen Vorgehensweise, die das Clientobjektmodell für SharePoint anstelle des Serverobjektmodells verwendet, finden Sie unter Exemplarische Vorgehensweise: Aufrufe in das SharePoint-Clientobjektmodell innerhalb einer Server-Explorererweiterung.

Vorbereitungsmaßnahmen

Zum Durchführen dieser exemplarischen Vorgehensweise werden auf dem Entwicklungscomputer die folgenden Komponenten benötigt:

Unterstützte Editionen von Windows, SharePoint und Visual Studio.Weitere Informationen finden Sie unter Anforderungen für die Entwicklung von SharePoint-Lösungen.
Das Visual Studio SDK.Bei dieser exemplarischen Vorgehensweise wird mithilfe der Vorlage VSIX Project aus dem SDK ein VSIX-Paket zum Bereitstellen des Projektelements erstellt.Weitere Informationen finden Sie unter Erweitern der SharePoint-Tools in Visual Studio.

Kenntnisse der folgenden Konzepte sind hilfreich, wenn auch für die Durchführung der exemplarischen Vorgehensweise nicht erforderlich:

Verwenden des Serverobjektmodells für SharePoint.Weitere Informationen finden Sie im Thema zur Verwendung des serverseitigen SharePoint Foundation-Objektmodells (möglicherweise in englischer Sprache).
Webparts in SharePoint-Lösungen.Weitere Informationen finden Sie in der Übersicht über Webparts (möglicherweise in englischer Sprache).

Erstellen der Projekte

Um diese exemplarische Vorgehensweise abzuschließen, müssen Sie drei Projekte erstellen:

Ein VSIX-Projekt für die Erstellung des VSIX-Pakets zum Bereitstellen der Erweiterung.
Ein Klassenbibliotheksprojekt, von dem die Erweiterung implementiert wird.Dieses Projekt muss .NET Framework 4.5 abzielen.
Ein Klassenbibliotheksprojekt, das die benutzerdefinierten SharePoint-Befehle definiert.Für dieses Projekt muss .NET Framework 3.5 als Zielversion verwendet werden.

Beginnen Sie mit der exemplarischen Vorgehensweise, indem Sie beide Projekte erstellen.

So erstellen Sie das VSIX-Projekt

Starten Sie Visual Studio.
Wählen Sie in der Menüleiste Datei, Neu, Projekt aus.

Im Dialogfeld Neues Projekt erweitern Sie die Visual C# oder Knoten Visual Basic, und wählen Sie dann den Knoten Erweiterungen aus.

Hinweis
Der Knoten Erweiterungen ist nur verfügbar, wenn Sie das Visual Studio SDK installieren.Weitere Informationen finden Sie weiter oben in diesem Thema im Abschnitt zu den erforderlichen Komponenten.

am oberen Rand des Dialogfelds wählen Sie .NET Framework 4.5 in der Liste der Versionen von .NET Framework aus.
Wählen Sie die VSIX-Projekt Vorlage aus, geben Sie das Projekt WebPartNode, und wählen Sie dann die Schaltfläche OK aus.

Visual Studio fügt das Projekt WebPartNode zum Projektmappen-Explorer hinzu.

So erstellen Sie das Erweiterungsprojekt

In Projektmappen-Explorer öffnen Sie das Kontextmenü für den Projektmappenknoten, wählen Sie Hinzufügen aus und wählen dann Neues Projekt aus.

Hinweis
In Visual Basic-Projekten wird der Projektmappenknoten nur im Projektmappen-Explorer angezeigt, wenn das Kontrollkästchen Projektmappe immer anzeigen in General, Projects and Solutions, Options Dialog Box aktiviert ist.

Erweitern Sie im Dialogfeld Neues Projekt den Knoten Visual C# oder den Knoten Visual Basic, und wählen Sie dann den Knoten Windows aus.
am oberen Rand des Dialogfelds wählen Sie .NET Framework 4.5 in der Liste der Versionen von .NET Framework aus.
In der Liste der Projektvorlagen, wählen Sie Klassenbibliothek aus, nennen Sie das Projekt WebPartNodeExtension, und wählen Sie dann die Schaltfläche OK aus.

Visual Studio fügt das Projekt WebPartNodeExtension der Projektmappe hinzu und öffnet die standardmäßige Class1-Codedatei.
Löschen Sie die Class1-Codedatei aus dem Projekt.

So erstellen Sie das SharePoint-Befehlsprojekt

In Projektmappen-Explorer öffnen Sie das Kontextmenü für den Projektmappenknoten, wählen Sie Hinzufügen aus und wählen dann Neues Projekt aus.

Hinweis
In Visual Basic-Projekten wird der Projektmappenknoten nur im Projektmappen-Explorer angezeigt, wenn das Kontrollkästchen Projektmappe immer anzeigen in General, Projects and Solutions, Options Dialog Box aktiviert ist.

Im Dialogfeld Neues Projekt erweitern Sie den Knoten Visual C# oder Knoten Visual Basic, und wählen Sie dann den Knoten Fenster aus.
am oberen Rand des Dialogfelds wählen Sie .NET Framework 3.5 in der Liste der Versionen von .NET Framework aus.
In der Liste der Projektvorlagen, wählen Sie Klassenbibliothek aus, nennen Sie das Projekt WebPartCommands, und wählen Sie dann die Schaltfläche OK aus.

Visual Studio fügt das Projekt WebPartCommands zur aktuellen Projektmappe hinzu und öffnet die Class1-Codedatei.
Löschen Sie die Class1-Codedatei aus dem Projekt.

Konfigurieren der Projekte

Bevor Sie Code schreiben, um die Erweiterung zu erstellen, müssen Sie Codedateien und Assemblyverweise hinzufügen und konfigurieren.

So konfigurieren Sie das Projekt "WebPartNodeExtension"

Fügen Sie im Projekt "WebPartNodeExtension" vier Codedateien hinzu, die die folgenden Namen aufweisen:
- SiteNodeExtension
- WebPartNodeTypeProvider
- WebPartNodeInfo
- WebPartCommandIds
Öffnen Sie das Kontextmenü für das WebPartNodeExtension Projekt, und wählen Sie dann Verweis hinzufügen aus.
Im Dialogfeld Verweis-Manager – WebPartNodeExtensionFramework wählen Sie die Registerkarte aus, und aktivieren Sie dann das Kontrollkästchen für jede der folgenden Assemblys aus:
- System.ComponentModel.Composition
- System.Windows.Forms
Wählen Sie die Registerkarte aus Erweiterungen, aktivieren Sie das Kontrollkästchen für die Microsoft.VisualStudio.SharePoint-Assembly aus, und wählen Sie dann die Schaltfläche OK aus.
In Projektmappen-Explorer öffnen Sie das Kontextmenü für den WebPartNodeExtension Projektknoten, und wählen Sie dann Eigenschaften aus.

Der Projekt-Designer wird geöffnet.
Wählen Sie die Registerkarte aus. Anwendung
Standardnamespace im Feld (C#) oder in Feld Stammnamespace (Visual Basic), geben Sie ServerExplorer.SharePointConnections.WebPartNode ein.

So konfigurieren Sie das Projekt WebPartCommands

Fügen Sie im Projekt WebPartCommands eine Codedatei hinzu, die WebPartCommands ".
In Projektmappen-Explorer öffnen Sie das Kontextmenü für den WebPartCommands Projektknoten, wählen Sie Hinzufügen aus und wählen dann Vorhandenes Element aus.
Im Dialogfeld Vorhandenes Element hinzufügen navigieren Sie zu dem Ordner, der die Codedateien für das Projekt "WebPartNodeExtension" enthält, und wählen Sie dann die Codedateien WebPartNodeInfo und WebPartCommandIds aus.
Wählen Sie den Pfeil neben der Schaltfläche Hinzufügen aus, und wählen Sie dann Als Link hinzufügen im Menü aus, das angezeigt wird.

Visual Studio fügt dem Projekt WebPartCommands die Codedateien als Links hinzu.Folglich sind die Codedateien im Projekt "WebPartNodeExtension", der Code aus den Dateien aber auch im Projekt WebPartCommands kompiliert.
Öffnen Sie das Kontextmenü für das WebPartCommands Projekt erneut, und wählen Sie Verweis hinzufügen aus.
Im Dialogfeld Verweis-Manager – WebPartCommands wählen Sie die Registerkarte aus Erweiterungen, aktivieren Sie das Kontrollkästchen für jede der folgenden Assemblys aus, und wählen Sie dann die Schaltfläche OK aus:
- Microsoft.SharePoint
- Microsoft.VisualStudio.SharePoint.Commands
In Projektmappen-Explorer öffnen Sie das Kontextmenü für das WebPartCommands Projekt erneut, und wählen Sie dann Eigenschaften aus.

Der Projekt-Designer wird geöffnet.
Wählen Sie die Registerkarte aus. Anwendung
Standardnamespace im Feld (C#) oder in Feld Stammnamespace (Visual Basic), geben Sie ServerExplorer.SharePointConnections.WebPartNode ein.

Erstellen von Symbolen für die neuen Knoten

Erstellen Sie zwei Symbole für die Server-Explorer-Erweiterung: ein Symbol für den neuen Knoten Webpartkatalog und ein anderes Symbol für untergeordnete Webpartknoten unter dem Knoten Webpartkatalog.Später in dieser exemplarischen Vorgehensweise schreiben Sie Code, der diese Symbole den Knoten zuordnet.

So erstellen Sie Symbole für die Knoten

In Projektmappen-Explorer öffnen Sie das Kontextmenü für das WebPartNodeExtension Projekt, und wählen Sie dann Eigenschaften aus.
Der Projekt-Designer wird geöffnet.
Wählen Sie die Registerkarte Ressourcen aus, und wählen Sie dann den Link Dieses Projekt enthält keine Standardressourcendatei. Klicken Sie hier, um eine zu erstellen aus.

Visual Studio erstellt eine Ressourcendatei und öffnet sie im Designer.
am oberen Rand des Designers wählen Sie den Pfeil neben dem Ressource hinzufügen Menübefehl aus, und wählen Sie dann Neues Symbol hinzufügen im Menü aus, das angezeigt wird.
Im Dialogfeld Neue Ressource hinzufügen geben Sie das neue Symbol WebPartsNode, und wählen Sie dann die Schaltfläche Hinzufügen aus.

Das neue Symbol wird in der Bildbearbeitung geöffnet.
Bearbeiten Sie die 16x16-Version des Symbols, dass es einen Entwurf aufweist, den Sie leicht erkennen können.
Öffnen Sie das Kontextmenü für die 32x32-Version des Symbols, und wählen Sie dann Bildtyp löschen aus.
Wiederholen Sie die Schritte 5 bis 8, um den Projektressourcen ebenfalls ein Symbol hinzuzufügen, und benennen Sie dieses Symbol Webpart.
In Projektmappen-ExplorerRessourcen unter dem Ordner für das Projekt WebPartNodeExtension, öffnen Sie das Kontextmenü für WebPartsNode.ico.
Im Eigenschaften Sie im auf den Pfeil neben Buildvorgang aus, und wählen Sie dann Eingebettete Ressource im Menü aus, das angezeigt wird.
Wiederholen Sie die letzten zwei Schritte für WebPart.ico.

Hinzufügen des Webpartkatalogknotens zum Server-Explorer

Erstellen Sie eine Klasse, die jedem SharePoint-Websiteknoten den neuen Knoten Webpartkatalog hinzufügt.Zum Hinzufügen des neuen Knotens implementiert die Klasse die IExplorerNodeTypeExtension-Schnittstelle.Implementieren Sie diese Schnittstelle immer dann, wenn Sie das Verhalten eines vorhandenen Knotens in Server-Explorer erweitern möchten, wie Hinzufügen eines untergeordneten Knoten zu einem Knoten.

So fügen Sie den Webpartkatalogknoten zum Server-Explorer hinzu

Öffnen Sie im Projekt "WebPartNodeExtension" die SiteNodeExtension-Codedatei, und fügen Sie dann den folgenden Code in die ein.

Hinweis
Nachdem Sie diesen Code hinzufügen, weist das Projekt mehrere Compilerfehler, aber sie wechseln weg, wenn Sie Code in späteren Schritten hinzufügen.

Imports System.Collections.Generic
Imports System.ComponentModel.Composition
Imports Microsoft.VisualStudio.SharePoint.Explorer

Namespace ServerExplorer.SharePointConnections.WebPartNode

    ' Export attribute: Enables Visual Studio to discover and load this extension.
    ' ExplorerNodeType attribute:  Indicates that this class extends SharePoint site nodes in Server Explorer.
    ' WebPartNodeTypeProvider class: Represents an extension of SharePoint site nodes in Server Explorer.
    <Export(GetType(IExplorerNodeTypeExtension))> _
    <ExplorerNodeType(ExplorerNodeTypes.SiteNode)> _
    Friend Class SiteNodeExtension
        Implements IExplorerNodeTypeExtension

        Private Sub Initialize(ByVal nodeType As IExplorerNodeType) _
            Implements IExplorerNodeTypeExtension.Initialize

            ' The NodeChildrenRequested event is raised when the user expands the
            ' SharePoint site node in Server Explorer.
            AddHandler nodeType.NodeChildrenRequested, AddressOf NodeChildrenRequested
        End Sub

        ' Creates the new Web Part Gallery node with the specified icon.
        Private Sub NodeChildrenRequested(ByVal Sender As Object, ByVal e As ExplorerNodeEventArgs)

            ' The CreateWebPartNodes argument is a delegate that Visual Studio calls 
            ' to create the child nodes under the Web Part Gallery node.
            e.Node.ChildNodes.AddFolder("Web Part Gallery", My.Resources.WebPartsNode.ToBitmap(), _
                AddressOf CreateWebPartNodes)
        End Sub

        ' Creates all of the individual Web Part nodes under the new Web Part Gallery node.
        Private Sub CreateWebPartNodes(ByVal parentNode As IExplorerNode)

            ' Call the custom SharePoint command to get items from the Web Part gallery.
            Dim webParts = parentNode.Context.SharePointConnection.ExecuteCommand(Of WebPartNodeInfo())( _
                WebPartCommandIds.GetWebParts)
            If webParts IsNot Nothing Then
                For Each webPart As WebPartNodeInfo In webParts

                    ' Create a new annotation object to store the current Web Part item with the new node.
                    Dim annotations = New Dictionary(Of Object, Object)()
                    annotations.Add(GetType(WebPartNodeInfo), webPart)

                    ' Create the new node for the current Web Part item.
                    parentNode.ChildNodes.Add(WebPartNodeTypeProvider.WebPartNodeTypeId, _
                        webPart.Name, annotations)
                Next
            End If
        End Sub

    End Class
End Namespace

using System.Collections.Generic;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.SharePoint.Explorer;

namespace ServerExplorer.SharePointConnections.WebPartNode
{
    // Enables Visual Studio to discover and load this extension.
    [Export(typeof(IExplorerNodeTypeExtension))]        

    // Indicates that this class extends SharePoint site nodes in Server Explorer.
    [ExplorerNodeType(ExplorerNodeTypes.SiteNode)]

    // Represents an extension of SharePoint site nodes in Server Explorer.
    internal class SiteNodeExtension : IExplorerNodeTypeExtension
    {
        public void Initialize(IExplorerNodeType nodeType)
        {
            // The NodeChildrenRequested event is raised when the user expands the
            // SharePoint site node in Server Explorer.
            nodeType.NodeChildrenRequested += NodeChildrenRequested;
        }

        // Creates the new Web Part Gallery node with the specified icon.
        private void NodeChildrenRequested(object sender, ExplorerNodeEventArgs e)
        {
            // The CreateWebPartNodes argument is a delegate that Visual Studio calls 
            // to create the child nodes under the Web Part Gallery node.
            e.Node.ChildNodes.AddFolder("Web Part Gallery",
                Properties.Resources.WebPartsNode.ToBitmap(), CreateWebPartNodes);
        }

        // Creates all of the individual Web Part nodes under the new Web Part Gallery node.
        private void CreateWebPartNodes(IExplorerNode parentNode)
        {
            // Call the custom SharePoint command to get items from the Web Part gallery.
            var webParts = parentNode.Context.SharePointConnection.ExecuteCommand<WebPartNodeInfo[]>(
                WebPartCommandIds.GetWebParts);

            if (webParts != null)
            {
                foreach (WebPartNodeInfo webPart in webParts)
                {
                    // Create a new annotation object to store the current Web Part item with the new node.
                    var annotations = new Dictionary<object, object>() 
                    { 
                        { typeof(WebPartNodeInfo), webPart } 
                    };

                    // Create the new node for the current Web Part item.
                    parentNode.ChildNodes.Add(WebPartNodeTypeProvider.WebPartNodeTypeId,
                        webPart.Name, annotations);
                }
            }
        }
    }
}

Definieren eines Knotentyps, der ein Webpart darstellt

Erstellen Sie eine Klasse, die einen neuen Knotentyp definiert, der ein Webpart darstellt.Visual Studio verwendet diesen neuen Knotentyp, um untergeordnete Knoten unter dem Knoten Webpartkatalog anzuzeigen.Jeder untergeordnete Knoten stellt ein einzelnes Webpart auf der SharePoint-Website.

Um den neuen Knotentyp zu definieren, implementiert die Klasse die IExplorerNodeTypeProvider-Schnittstelle.Implementieren Sie diese Schnittstelle immer dann, wenn Sie einen neuen Knotentyp im Server-Explorer definieren möchten.

So definieren Sie den Webpartknotentyp

Öffnen Sie im Projekt "WebPartNodeExtension" die WebPartNodeTypeProvder-Codedatei, und fügen Sie dann den folgenden Code in die ein.

Imports System
Imports System.Collections.Generic
Imports System.Windows.Forms
Imports System.ComponentModel.Composition
Imports Microsoft.VisualStudio.SharePoint
Imports Microsoft.VisualStudio.SharePoint.Explorer

Namespace ServerExplorer.SharePointConnections.WebPartNode

    ' Export attribute: Enables Visual Studio to discover and load this extension.
    ' ExplorerNodeType attribute: Specifies the ID for this new node type.
    ' WebPartNodeTypeProvider class: Defines a new node type that represents a Web Part on a SharePoint site.
    <Export(GetType(IExplorerNodeTypeProvider))> _
    <ExplorerNodeType(WebPartNodeTypeProvider.WebPartNodeTypeId)> _
    Friend Class WebPartNodeTypeProvider
        Implements IExplorerNodeTypeProvider

        Friend Const WebPartNodeTypeId As String = "Contoso.WebPart"

        Private Sub InitializeType(ByVal typeDefinition As IExplorerNodeTypeDefinition) _
            Implements IExplorerNodeTypeProvider.InitializeType

            typeDefinition.DefaultIcon = My.Resources.WebPart.ToBitmap()
            typeDefinition.IsAlwaysLeaf = True
            AddHandler typeDefinition.NodePropertiesRequested, AddressOf NodePropertiesRequested
        End Sub

        ' Retrieves properties that are displayed in the Properties window when
        ' a Web Part node is selected.
        Private Sub NodePropertiesRequested(ByVal Sernder As Object, _
            ByVal e As ExplorerNodePropertiesRequestedEventArgs)

            Dim nodeInfo = e.Node.Annotations.GetValue(Of WebPartNodeInfo)()

            ' Call the custom SharePoint command to get the Web Part properties.
            Dim properties As Dictionary(Of String, String) = _
                e.Node.Context.SharePointConnection.ExecuteCommand( _
                Of WebPartNodeInfo, Dictionary(Of String, String))(
                WebPartCommandIds.GetWebPartProperties, nodeInfo)
            Dim propertySource As Object = e.Node.Context.CreatePropertySourceObject(properties)
            e.PropertySources.Add(propertySource)
        End Sub

    End Class
End Namespace

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.SharePoint;
using Microsoft.VisualStudio.SharePoint.Explorer;

namespace ServerExplorer.SharePointConnections.WebPartNode
{
    // Enables Visual Studio to discover and load this extension.
    [Export(typeof(IExplorerNodeTypeProvider))]

    // Specifies the ID for this new node type.
    [ExplorerNodeType(WebPartNodeTypeProvider.WebPartNodeTypeId)]

    // Defines a new node type that represents a Web Part on a SharePoint site.
    internal class WebPartNodeTypeProvider : IExplorerNodeTypeProvider
    {
        internal const string WebPartNodeTypeId = "Contoso.WebPart";

        public void InitializeType(IExplorerNodeTypeDefinition typeDefinition)
        {
            typeDefinition.DefaultIcon = Properties.Resources.WebPart.ToBitmap();
            typeDefinition.IsAlwaysLeaf = true;
            typeDefinition.NodePropertiesRequested += NodePropertiesRequested;
        }

        // Retrieves properties that are displayed in the Properties window when
        // a Web Part node is selected.
        private void NodePropertiesRequested(object sender,
            ExplorerNodePropertiesRequestedEventArgs e)
        {
            var webPartNodeInfo = e.Node.Annotations.GetValue<WebPartNodeInfo>();

            // Call the custom SharePoint command to get the Web Part properties.
            Dictionary<string, string> properties =
                e.Node.Context.SharePointConnection.ExecuteCommand<
                WebPartNodeInfo, Dictionary<string, string>>(
                WebPartCommandIds.GetWebPartProperties, webPartNodeInfo);

            object propertySource = e.Node.Context.CreatePropertySourceObject(properties);
            e.PropertySources.Add(propertySource);
        }
    }
}

Definieren der Webpart-Datenklasse

Definieren Sie eine Klasse, die die Daten für ein einzelnes Webpart auf der SharePoint-Website enthält.Später in dieser exemplarischen Vorgehensweise, erstellen Sie einen benutzerdefinierten SharePoint-Befehl, der Daten zu jedem Webpart auf der Website abruft und die Daten anschließend Instanzen dieser Klasse zuweist.

So definieren Sie die Webpart-Datenklasse

Öffnen Sie im Projekt "WebPartNodeExtension" die WebPartNodeInfo-Codedatei, und fügen Sie dann den folgenden Code in die ein.

Imports System

Namespace ServerExplorer.SharePointConnections.WebPartNode

    ' Contains basic data about a single Web Part on the SharePoint site. This class is 
    ' serializable so that instances of it can be sent between the WebPartNode and 
    ' WebPartCommands assemblies.
    <Serializable()> _
    Public Class WebPartNodeInfo

        Private siteIdValue As Guid
        Public Property SiteId As Guid
            Get
                Return siteIdValue
            End Get
            Set(ByVal value As Guid)
                siteIdValue = value
            End Set
        End Property

        Private idValue As Integer
        Public Property Id As Integer
            Get
                Return idValue
            End Get
            Set(ByVal value As Integer)
                idValue = value
            End Set
        End Property

        Private uniqueIdValue As Guid
        Public Property UniqueId As Guid
            Get
                Return uniqueIdValue
            End Get
            Set(ByVal value As Guid)
                uniqueIdValue = value
            End Set
        End Property

        Private nameValue As String
        Public Property Name As String
            Get
                Return nameValue
            End Get
            Set(ByVal value As String)
                nameValue = value
            End Set
        End Property

        Private imageUrlValue As String
        Public Property ImageUrl As String
            Get
                Return imageUrlValue
            End Get
            Set(ByVal value As String)
                imageUrlValue = value
            End Set
        End Property

    End Class
End Namespace

using System;

namespace ServerExplorer.SharePointConnections.WebPartNode
{
    // Contains basic data about a single Web Part on the SharePoint site. This class is 
    // serializable so that instances of it can be sent between the WebPartNode and 
    // WebPartCommands assemblies.
    [Serializable]
    public class WebPartNodeInfo
    {
        public Guid SiteId { get; set; }
        public int Id { get; set; }
        public Guid UniqueId { get; set; }
        public string Name { get; set; }
        public string ImageUrl { get; set; }
    }
}

Definieren der IDs für den SharePoint-Befehl

Definieren Sie mehrere Zeichenfolgen, die die benutzerdefinierten SharePoint-Befehle identifizieren.Sie implementieren die Befehle später in dieser exemplarischen Vorgehensweise.

So definieren Sie die Befehls-IDs

Öffnen Sie im Projekt "WebPartNodeExtension" die WebPartCommandIds-Codedatei, und fügen Sie dann den folgenden Code in die ein.

Namespace ServerExplorer.SharePointConnections.WebPartNode

    Public Class WebPartCommandIds
        Public Const GetWebParts As String = "WebPart.GetWebParts"
        Public Const GetWebPartProperties As String = "WebPart.GetProperties"
    End Class

End Namespace

namespace ServerExplorer.SharePointConnections.WebPartNode
{
    public static class WebPartCommandIds
    {
        public const string GetWebParts = "WebPart.GetWebParts";
        public const string GetWebPartProperties = "WebPart.GetProperties";
    }
}

Erstellen der benutzerdefinierten SharePoint-Befehle

Erstellen Sie benutzerdefinierte Befehle, die in das Serverobjektmodell aufrufen, damit SharePoint Daten über die Webparts auf der SharePoint-Website abruft.Jeder Befehl ist eine Methode, auf die das SharePointCommandAttribute angewendet wurde.

So definieren Sie die SharePoint-Befehle

Öffnen Sie im Projekt WebPartCommands die WebPartCommands-Codedatei, und fügen Sie dann den folgenden Code in die ein.

Imports System.Collections.Generic
Imports Microsoft.SharePoint
Imports Microsoft.VisualStudio.SharePoint.Commands

Namespace ServerExplorer.SharePointConnections.WebPartNode

    Friend Class WebPartsCommands

        ' Gets data for each Web Part on the SharePoint site, and returns an array of 
        ' serializable objects that contain the data.
        <SharePointCommand(WebPartCommandIds.GetWebParts)> _
        Private Shared Function GetWebParts(ByVal context As ISharePointCommandContext) As WebPartNodeInfo()

            Dim nodeInfos = New List(Of WebPartNodeInfo)()
            Dim webParts As SPListItemCollection = context.Site.GetCatalog( _
                SPListTemplateType.WebPartCatalog).Items

            For Each webPart As SPListItem In webParts
                Dim nodeInfo As WebPartNodeInfo = New WebPartNodeInfo()
                With nodeInfo
                    .Id = webPart.ID
                    .SiteId = webPart.ParentList.ParentWeb.ID
                    .Name = webPart.Title
                    .UniqueId = webPart.UniqueId
                    .ImageUrl = webPart.ParentList.ImageUrl
                End With
                nodeInfos.Add(nodeInfo)
            Next
            Return nodeInfos.ToArray()
        End Function

        ' Gets additional property data for a specific Web Part.
        <SharePointCommand(WebPartCommandIds.GetWebPartProperties)> _
        Private Shared Function GetWebPartProperties(ByVal context As ISharePointCommandContext, _
            ByVal webPartNodeInfo As WebPartNodeInfo) As Dictionary(Of String, String)

            Dim webParts As SPList = context.Site.GetCatalog(SPListTemplateType.WebPartCatalog)
            Dim webPart As SPListItem = webParts.Items(webPartNodeInfo.UniqueId)
            Return SharePointCommandServices.GetProperties(webPart)
        End Function
    End Class
End Namespace

using System.Collections.Generic;
using Microsoft.SharePoint;
using Microsoft.VisualStudio.SharePoint.Commands;

namespace ServerExplorer.SharePointConnections.WebPartNode
{
    internal class WebPartsCommands
    {
        // Gets data for each Web Part on the SharePoint site, and returns an array of 
        // serializable objects that contain the data.
        [SharePointCommand(WebPartCommandIds.GetWebParts)]
        private static WebPartNodeInfo[] GetWebParts(ISharePointCommandContext context)
        {
            var nodeInfos = new List<WebPartNodeInfo>();
            SPListItemCollection webParts = context.Site.GetCatalog(
                SPListTemplateType.WebPartCatalog).Items;

            foreach (SPListItem webPart in webParts)
            {
                WebPartNodeInfo nodeInfo = new WebPartNodeInfo
                {
                    Id = webPart.ID,
                    SiteId = webPart.ParentList.ParentWeb.ID,
                    Name = webPart.Title,
                    UniqueId = webPart.UniqueId,
                    ImageUrl = webPart.ParentList.ImageUrl
                };
                nodeInfos.Add(nodeInfo);
            }

            return nodeInfos.ToArray();
        }

        // Gets additional property data for a specific Web Part.
        [SharePointCommand(WebPartCommandIds.GetWebPartProperties)]
        private static Dictionary<string, string> GetWebPartProperties(ISharePointCommandContext context, 
            WebPartNodeInfo nodeInfo)
        {
            SPList webParts = context.Site.GetCatalog(SPListTemplateType.WebPartCatalog);
            SPListItem webPart = webParts.Items[nodeInfo.UniqueId];

            return SharePointCommandServices.GetProperties(webPart);
        }
    }
}

Checkpoint

Ab diesem Punkt in der exemplarischen Vorgehensweise wurde der ganze für den Knoten Webpartkatalog und die SharePoint-Befehle benötigte Code in das Projekt eingefügt.Erstellen Sie die Projektmappe, um sicherzustellen, dass beide Projekte ohne Fehler kompiliert werden.

So erstellen Sie die Projektmappe

Klicken Sie auf der Menüleiste wählen Sie Erstellen, Projektmappe erstellen aus.

Vorsicht
Zu diesem Zeitpunkt enthält das Projekt WebPartNode möglicherweise einen Buildfehler, da die VSIX-Manifestdatei keinen Wert für Autor verfügt.Dieser Fehler wird weg, wenn Sie einen Wert in späteren Schritten hinzufügen.

Erstellen eines VSIX-Pakets zum Bereitstellen der Erweiterung

Zum Bereitstellen der Erweiterung erstellen Sie anhand des VSIX-Projekts in der Lösung ein VSIX-Paket.Konfigurieren Sie zuerst das VSIX-Paket, indem Sie die source.extension.vsixmanifest-Datei im VSIX-Projekt ändern.Erstellen Sie anschließend das VSIX-Paket, indem Sie die Lösung erstellen.

So konfigurieren Sie das VSIX-Paket

In Projektmappen-Explorer unter dem Knoten, öffnen Sie die Datei source.extension.vsixmanifest im Manifest-Editor.

Die Datei "source.extension.vsixmanifest" bildet die Grundlage für die Datei, die alle VSIX-Pakete benötigen.Weitere Informationen zu dieser Datei finden Sie unter VSIX-Erweiterungs-Schemareferenz.
Im Feld geben Sie ProduktnameWebpartkatalog-Knoten für Server-Explorer ein.
Im Feld geben Sie AutorContoso ein.
Im Feld Beschreibung geben Sie Fügt dem Knoten SharePoint-Verbindungen im Server-Explorer einen benutzerdefinierten Webpartkatalogknoten hinzu ein. This extension uses a custom SharePoint command to call into the server object model.
Wählen Sie die Registerkarte des Editors Objekte aus, und wählen Sie dann die Schaltfläche Neu aus.

Das Dialogfeld wird angezeigt. Neue Anlage hinzufügen

In der Liste wählen Sie TypMicrosoft.VisualStudio.MefComponent aus.

Hinweis
Dieser Wert entspricht dem MefComponent-Element in der Datei "extension.vsixmanifest".Von diesem Element wird der Name einer Erweiterungsassembly im VSIX-Paket angegeben.Weitere Informationen finden Sie unter MEFComponent Element.

In der Liste wählen Sie QuelleEin Projekt in der aktuellen Projektmappe aus.
In der Liste wählen Sie ProjektWebPartNodeExtension aus und wählen dann die Schaltfläche OK aus.
im Manifest-Editor wählen Sie die Schaltfläche Neu erneut aus.

Das Dialogfeld wird angezeigt. Neue Anlage hinzufügen

Im Feld geben Sie TypSharePoint.Commands.v4 ein.

Hinweis
Dieses Element gibt eine benutzerdefinierte Erweiterung an, die Sie in die Visual Studio-Erweiterung einschließen möchten.Weitere Informationen finden Sie unter Vermögensteil (VSX Schema).

In der Liste Quelle wählen Sie das Ein Projekt in der aktuellen Projektmappe Listeneintrag aus.
In der Liste wählen Sie ProjektWebPartCommands aus und wählen dann die Schaltfläche OK aus.
Klicken Sie auf der Menüleiste wählen Sie Erstellen, Projektmappe erstellen aus, und überprüfen Sie, ob die Projektmappe fehlerfrei kompiliert.
Stellen Sie sicher, dass der Buildausgabeordner für das Projekt WebPartNode jetzt die Datei WebPartNode.vsix enthält.

Standardmäßig ist der Buildausgabeordner derOrdner "\bin\Debug" im Ordner mit der Projektdatei.

Testen der Erweiterung

Sie sind nun bereit, den neuen Knoten Webpartkatalog in Server-Explorer zu testen.Debuggen Sie die Erweiterung zunächst in einer experimentellen Instanz von Visual Studio.Verwenden Sie dann den neuen Knoten Webparts in der experimentellen Instanz von Visual Studio.

So debuggen Sie die Erweiterung

Starten Sie neu Visual Studio mit Administratorrechten, und öffnen Sie dann die öffnen.
Öffnen Sie im Projekt "WebPartNodeExtension" die SiteNodeExtension-Codedatei, und fügen Sie anschließend einen Haltepunkt der ersten Codezeile in den NodeChildrenRequested und CreateWebPartNodes-Methoden hinzu.
Drücken Sie die F5-TASTE, um das Debuggen zu starten.

Visual Studio installiert die Erweiterung in %UserProfile%\AppData\Local\Microsoft\VisualStudio\11.0Exp\Extensions\Contoso\Web Part Gallery Node Extension for Server Explorer\1.0 und startet eine experimentelle Instanz von Visual Studio.Sie testen das Projektelement in dieser Instanz von Visual Studio.

So testen Sie die Erweiterung

Klicken Sie in der experimentellen Instanz von Visual Studio, auf der Menüleiste, wählen Sie Ansicht, Server-Explorer aus.
Führen Sie die folgenden Schritte aus, wenn die SharePoint-Website, die Sie für die Tests verwenden möchten, nicht unter dem Knoten in SharePoint-VerbindungenServer-Explorer angezeigt:
1. In Server-Explorer öffnen Sie das Kontextmenü für SharePoint-Verbindungen, und wählen Sie dann Verbindung hinzufügen aus.
2. Im Dialogfeld SharePoint-Verbindung hinzufügen geben Sie die URL für die SharePoint-Website, mit der Sie eine Verbindung herstellen möchten, und wählen Sie dann die Schaltfläche OK aus.
  
  Um die SharePoint-Website auf dem Entwicklungscomputer anzugeben, geben Sie https://localhost ein.
Erweitern Sie den Website-Verbindungsknoten (den die URL der Website angezeigt wird), und erweitern Sie dann einen untergeordneten Websiteknoten (beispielsweise, Teamwebsite).
Überprüfen Sie, ob die Codeausführung in der anderen Instanz von Visual Studio auf dem Haltepunkt festgelegt wird, den Sie zuvor in der NodeChildrenRequested-Methode und dann F5 auswählen, um fortfahren, um das Projekt zu debuggen.
Klicken Sie in der experimentellen Instanz von Visual Studio, überprüfen Sie, ob ein neuer Knoten, der Webpartkatalog genannt wird, unter dem Websiteknoten der obersten Ebene angezeigt, und erweitern Sie dann den Knoten Webpartkatalog.
Überprüfen Sie, ob die Codeausführung in der anderen Instanz von Visual Studio an dem Haltepunkt unterbrochen wird, den Sie zuvor in der festgelegt CreateWebPartNodes-Methode und dann die F5-Taste auswählen, um fortfahren, um das Projekt zu debuggen.
Klicken Sie in der experimentellen Instanz von Visual Studio, stellen Sie sicher, dass alle Webparts der verbundenen Website unter dem Knoten in WebpartkatalogServer-Explorer angezeigt werden.
In Server-Explorer öffnen Sie das Kontextmenü für eines der Webparts, und wählen Sie dann Eigenschaften aus.
In der Instanz von Visual Studio, die Sie debuggen, überprüfen Sie, ob die Details zum Webpart im Eigenschaften angezeigt werden.

Deinstallieren der Erweiterung aus Visual Studio

Nach dem Testen der Erweiterung deinstallieren Sie die Erweiterung aus Visual Studio.

So deinstallieren Sie die Erweiterung

Klicken Sie in der experimentellen Instanz von Visual Studio, auf der Menüleiste, wählen Sie Tools, Erweiterungen und Updates aus.

Das Dialogfeld wird geöffnet. Erweiterungen und Updates
In der Liste der Erweiterungen, wählen Sie Webpartkatalog-Knoten-Erweiterung für Server-Explorer aus und wählen dann die Schaltfläche Deinstallieren aus.
Im Dialogfeld, das angezeigt wird, wählen Sie die Schaltfläche Ja, um zu bestätigen, dass Sie die Erweiterung deinstallieren möchten, und wählen Sie dann die Schaltfläche Jetzt neu starten, um die Deinstallation abzuschließen.
Schließen Sie beide Instanzen von Visual Studio (die experimentelle Instanz und die Instanz von Visual Studio, in der die Projektmappe "WebPartNode" geöffnet ist).

Siehe auch

Freigeben über