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

In Visual Studio 2010 können Sie den Knoten SharePoint-Verbindungen im Server-Explorer verwenden, um Komponenten auf SharePoint-Websites anzuzeigen. Einige Komponenten werden jedoch nicht standardmäßig im Server-Explorer angezeigt. In dieser exemplarischen Vorgehensweise erweitern Sie den Server-Explorer, sodass der 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:
- Unter jedem SharePoint-Websiteknoten im Server-Explorer wird der neue Knoten Webpartkatalog hinzugefügt. Dieser neue Knoten enthält untergeordnete Knoten, die jedes Webpart im Webpartkatalog auf der Website darstellen.
- Es 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 beinhaltet auch ein benutzerdefiniertes Kontextmenüelement, das Sie als Ausgangspunkt zum Ausführen anderer auf das Webpart bezogener Aufgaben verwenden können.
Erstellen von zwei benutzerdefinierten SharePoint-Befehlen, die von der Erweiterungsassembly aufgerufen werden. SharePoint-Befehle sind Methoden, die von Erweiterungsassemblys aufgerufen werden können, um APIs im SharePoint-Serverobjektmodell 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.

Tipp

Eine alternative Version dieser exemplarischen Vorgehensweise, in der anstelle des Serverobjektmodells das SharePoint-Clientobjektmodell verwendet wird, 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 Microsoft Windows, SharePoint und Visual Studio. Weitere Informationen finden Sie unter Anforderungen für die Entwicklung von SharePoint-Lösungen.
Visual Studio 2010 SDK. Diese exemplarische Vorgehensweise verwendet die Vorlage VSIX Project im SDK, um ein VSIX-Paket zum Bereitstellen des Projektelements zu erstellen. 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 SharePoint-Serverobjektmodells. 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

Zum Abschließen dieser exemplarischen Vorgehensweise 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. Für dieses Projekt muss .NET Framework 4 als Zielversion verwendet werden.
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.
Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt.
Erweitern Sie im Dialogfeld Neues Projekt den Knoten Visual C# oder Visual Basic, und wählen Sie dann den Knoten Erweiterungen aus.

Tipp

Der Knoten Erweiterungen ist nur verfügbar, wenn Sie Visual Studio 2010 SDK installieren. Weitere Informationen finden Sie im Abschnitt zu den erforderlichen Komponenten und Voraussetzungen weiter oben.
Wählen Sie im Kombinationsfeld am oberen Rand des Dialogfelds .NET Framework 4 aus.
Wählen Sie die Vorlage VSIX Projekt aus.
Geben Sie im Feld Name die Zeichenfolge WebPartNode ein.
Klicken Sie auf OK.

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

So erstellen Sie das Erweiterungsprojekt

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektmappenknoten, klicken Sie auf Hinzufügen und dann auf Neues Projekt.

Tipp

In Visual Basic-Projekten wird der Projektmappenknoten nur im Projektmappen-Explorer angezeigt, wenn das Kontrollkästchen Projektmappe immer anzeigen in Allgemein, Projekte und Projektmappen, Dialogfeld "Optionen" aktiviert ist.
Erweitern Sie im Dialogfeld Neues Projekt den Knoten Visual C# oder Visual Basic, und klicken Sie anschließend auf Windows.
Wählen Sie im Kombinationsfeld am oberen Rand des Dialogfelds die Option .NET Framework 4 aus.
Wählen Sie die Projektvorlage Klassenbibliothek aus.
Geben Sie im Feld Name den Namen WebPartNodeExtension ein.
Klicken Sie auf OK.

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

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektmappenknoten, klicken Sie auf Hinzufügen und dann auf Neues Projekt.

Tipp

In Visual Basic-Projekten wird der Projektmappenknoten nur im Projektmappen-Explorer angezeigt, wenn das Kontrollkästchen Projektmappe immer anzeigen in Allgemein, Projekte und Projektmappen, Dialogfeld "Optionen" aktiviert ist.
Erweitern Sie im Dialogfeld Neues Projekt den Knoten Visual C# oder Visual Basic, und klicken Sie anschließend auf Windows.
Wählen Sie im Kombinationsfeld am oberen Rand des Dialogfelds .NET Framework 3.5 aus.
Wählen Sie die Projektvorlage Klassenbibliothek aus.
Geben Sie im Feld Name die Zeichenfolge WebPartCommands ein.
Klicken Sie auf OK.

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 zum Erstellen der Erweiterung schreiben, müssen Sie Codedateien und Assemblyverweise hinzufügen und das Projekt konfigurieren.

So konfigurieren Sie das Projekt "WebPartNodeExtension"

Fügen Sie im Projekt "WebPartNodeExtension" vier Codedateien mit den folgenden Namen hinzu:
- SiteNodeExtension
- WebPartNodeTypeProvider
- WebPartNodeInfo
- WebPartCommandIds
Klicken Sie im Menü Projekt auf Verweis hinzufügen.
Halten Sie die Taste STRG gedrückt, und wählen Sie auf der Registerkarte .NET die folgenden Assemblys aus. Klicken Sie dann auf OK.
- Microsoft.VisualStudio.SharePoint
- System.ComponentModel.Composition
- System.Windows.Forms
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Knoten WebPartNodeExtension, und wählen Sie Eigenschaften aus.

Der Projekt-Designer wird geöffnet.
Klicken Sie auf die Registerkarte Anwendung.
Geben Sie im Feld Standardnamespace (C#) bzw. im Feld Stammnamespace (Visual Basic) den Wert ServerExplorer.SharePointConnections.WebPartNode ein.

So konfigurieren Sie das Projekt WebPartCommands

Fügen Sie im Projekt WebPartCommands eine Codedatei mit dem Namen WebPartCommands hinzu.
Wählen Sie im Projektmappen-Explorer den Projektknoten WebPartCommands aus.
Klicken Sie im Menü Projekt auf Vorhandenes Element hinzufügen.
Wechseln Sie im Dialogfeld Vorhandenes Element hinzufügen zu dem Ordner, der die Codedateien für das Projekt "WebPartNodeExtension" enthält.
Wählen Sie die Codedateien WebPartNodeInfo und WebPartCommandIds aus.
Klicken Sie auf das Dropdownmenü für die Schaltfläche Hinzufügen, und wählen Sie Als Link hinzufügen aus.

Visual Studio fügt dem Projekt WebPartCommands die Codedateien als Links hinzu. Das bedeutet, dass sich die Codedateien im Projekt "WebPartNodeExtension" befinden, der Code aus den Dateien aber auch im Projekt "WebPartCommands" kompiliert wird.
Klicken Sie im Menü Projekt auf Verweis hinzufügen.
Halten Sie die Taste STRG gedrückt, und wählen Sie auf der Registerkarte .NET die folgenden Assemblys aus. Klicken Sie dann auf OK.
- Microsoft.SharePoint
- Microsoft.VisualStudio.SharePoint.Commands
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Knoten WebPartCommands, und wählen Sie Eigenschaften aus.

Der Projekt-Designer wird geöffnet.
Klicken Sie auf die Registerkarte Anwendung.
Geben Sie im Feld Standardnamespace (C#) bzw. im Feld Stammnamespace (Visual Basic) den Wert 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

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Knoten WebPartNodeExtension, und wählen Sie Eigenschaften aus.
Wählen Sie im Menü Projekt die Option Eigenschaften von WebPartNodeExtension aus.

Der Projekt-Designer wird geöffnet.
Klicken Sie auf die Registerkarte Ressourcen.
Klicken Sie auf Dieses Projekt enthält keine Standardressourcendatei. Klicken Sie hier, um eine zu erstellen.

Visual Studio erstellt eine Ressourcendatei und öffnet sie im Designer.
Klicken Sie am oberen Rand des Designers auf den Dropdownpfeil für die Schaltfläche Hinzufügen und dann auf Neues Symbol hinzufügen.
Geben Sie WebPartsNode als Namen für das neue Symbol ein, und klicken Sie auf Hinzufügen.

Das neue Symbol wird in der Bildbearbeitung geöffnet.
Bearbeiten Sie die 16x16-Version des Symbols so, dass Sie es leicht erkennen können.
Wählen Sie die 32x32-Version des Symbols aus.
Wählen Sie im Menü Bild die Option Bildtyp löschen aus.
Wiederholen Sie Schritt 5 bis 9, um den Projektressourcen ebenfalls ein Symbol hinzuzufügen. Nennen Sie dieses Symbol WebPart.
Wählen Sie im Projektmappen-Explorer unter dem Ordner Ressourcen für das Projekt WebPartNodeExtension die Datei WebPartsNode.ico aus.
Klicken Sie im Eigenschaftenfenster auf die Dropdownliste neben Buildvorgang, und wählen Sie Eingebettete Ressource aus.
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, z. B. wenn Sie einen neuen untergeordneten Knoten zu einem Knoten hinzufügen.

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

Doppelklicken Sie im Projekt "WebPartNodeExtension" auf die SiteNodeExtension-Codedatei.

Fügen Sie folgenden Code in die Datei ein.

Tipp

Nach dem Hinzufügen dieses Codes weist das Projekt mehrere Kompilierungsfehler auf. Diese Fehler werden durch Code behoben, den Sie 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. Dieser neue Knotentyp wird von Visual Studio verwendet, um untergeordnete Knoten unter dem Knoten Webpartkatalog anzuzeigen. Jeder dieser untergeordneten Knoten stellt ein einzelnes Webpart auf der SharePoint-Website dar.

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

Doppelklicken Sie im Projekt "WebPartNodeExtension" auf die WebPartNodeTypeProvder-Codedatei.

Fügen Sie folgenden Code in die Datei 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

Doppelklicken Sie im Projekt "WebPartNodeExtension" auf die WebPartNodeInfo-Codedatei.

Fügen Sie folgenden Code in die Datei 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

Doppelklicken Sie im Projekt "WebPartNodeExtension" auf die WebPartCommandIds-Codedatei.

Fügen Sie folgenden Code in die Datei 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 das SharePoint-Serverobjektmodell aufrufen, um Daten zu den Webparts auf der SharePoint-Website abzurufen. Jeder Befehl ist eine Methode, auf die das SharePointCommandAttribute angewendet wurde.

So definieren Sie die SharePoint-Befehle

Doppelklicken Sie im Projekt WebPartCommands auf die WebPartCommands-Codedatei.

Fügen Sie folgenden Code in die Datei 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 im Menü Erstellen auf Projektmappe erstellen.

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 im VSIX-Projekt enthaltene Datei "source.extension.vsixmanifest" ändern. Erstellen Sie anschließend das VSIX-Paket, indem Sie die Lösung erstellen.

So konfigurieren Sie das VSIX-Paket

Doppelklicken Sie im Projektmappen-Explorer unter dem Projekt "WebPartNode" auf die Datei source.extension.vsixmanifest.

Visual Studio öffnet die Datei im Manifest-Editor. Die Datei "source.extension.vsixmanifest" bildet die Grundlage für die Datei "extension.vsixmanifest", die für alle VSIX-Pakete erforderlich ist. Weitere Informationen zu dieser Datei finden Sie unter VSIX Extension Schema Reference.
Geben Sie im Feld Produktname den Namen Web Part Gallery Node for Server Explorer ein.
Geben Sie im Feld Autor den Namen Contoso ein.
Geben Sie im Feld Beschreibung folgenden Text ein: Adds a custom Web Part Gallery node to the SharePoint Connections node in Server Explorer. This extension uses a custom SharePoint command to call into the server object model.
Klicken Sie im Editor im Abschnitt Inhalt auf die Schaltfläche Inhalt hinzufügen.
Wählen Sie im Dialogfeld Inhalt hinzufügen im Listenfeldzum Auswählen eines Inhaltstyps die Option MEF-Komponente aus.

Tipp

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 (VSX Schema).
Aktivieren Sie unter Quelle auswählen das Optionsfeld Projekt, und wählen Sie im zugehörigen Listenfeld den Eintrag WebPartNodeExtension aus.
Klicken Sie auf OK.
Klicken Sie im Manifest-Editor erneut auf die Schaltfläche Inhalt hinzufügen.
Wählen Sie im Dialogfeld Inhalt hinzufügen im Listenfeld zum Auswählen eines Inhaltstyps die Option Benutzerdefinierter Erweiterungstyp aus.

Tipp

Dieser Wert entspricht dem CustomExtension-Element in der Datei "extension.vsixmanifest". Dieses Element gibt eine benutzerdefinierte Erweiterung an, die Sie in die Visual Studio-Erweiterung einschließen möchten. Weitere Informationen finden Sie unter CustomExtension Element (VSX Schema).
Geben Sie im Textfeld Typ den Text SharePoint.Commands.v4 ein.

Tipp

Dieser Wert entspricht dem Type-Attribut des CustomExtension-Elements in der Datei "extension.vsixmanifest". Der Wert Sharepoint.Commands.v4 muss für alle benutzerdefinierten Erweiterungsassemblys angegeben werden, die benutzerdefinierte SharePoint-Befehle enthalten.
Aktivieren Sie unter Quelle auswählen das Optionsfeld Projekt, und wählen Sie im zugehörigen Listenfeld den Eintrag WebPartCommands aus.
Klicken Sie auf OK.
Klicken Sie im Menü Erstellen auf Projektmappe erstellen. Stellen Sie sicher, dass die Projektmappe fehlerfrei kompiliert werden kann.
Öffnen Sie den Buildausgabeordner für das Projekt WebPartNode. Stellen Sie sicher, dass dieser Ordner jetzt die Datei WebPartNode.vsix enthält.

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

Testen der Erweiterung

Jetzt können Sie den neuen Knoten Webpartkatalog in Server-Explorer 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 Visual Studio erneut mit Administratorrechten, und öffnen Sie die Projektmappe "WebPartNode".
Öffnen Sie im Projekt "WebPartNodeExtension" die SiteNodeExtension-Codedatei, und fügen Sie in der ersten Codezeile in den NodeChildrenRequested- und CreateWebPartNodes-Methoden einen Haltepunkt hinzu.
Drücken Sie die Taste F5, um mit dem Debuggen zu beginnen.

Die Erweiterung wird unter "%UserProfile%\AppData\Local\Microsoft\VisualStudio\10.0Exp\Extensions\Contoso\Web Part Gallery Node Extension for Server Explorer\1.0" installiert, und eine experimentelle Instanz von Visual Studio wird gestartet. Sie testen das Projektelement in dieser Instanz von Visual Studio.

So testen Sie die Erweiterung

Klicken Sie in der experimentellen Instanz von Visual Studio im Menü Ansicht auf Server-Explorer.
Überprüfen Sie, ob die SharePoint-Website, die Sie für die Tests verwenden möchten, unter dem Knoten SharePoint-Verbindungen im Server-Explorer angezeigt wird. Führen Sie die folgenden Schritte aus, wenn sie nicht aufgelistet ist:
1. Klicken Sie mit der rechten Maustaste auf SharePoint-Verbindungen, und klicken Sie dann auf Verbindung hinzufügen.
2. Geben Sie im Dialogfeld SharePoint-Verbindung hinzufügen die URL für die SharePoint-Website ein, mit der Sie eine Verbindung herstellen möchten. Um die lokale SharePoint-Website auf dem Entwicklungscomputer anzugeben, geben Sie https://localhost ein.
3. Klicken Sie auf OK.
Erweitern Sie den Website-Verbindungsknoten (den Knoten, von dem die URL der Website angezeigt wird), und erweitern Sie anschließend einen untergeordneten Websiteknoten (z. B. Teamwebsite).
Überprüfen Sie, ob die Codeausführung in der anderen Instanz von Visual Studio an dem Haltepunkt unterbrochen wird, den Sie zuvor in der NodeChildrenRequested-Methode festgelegt haben. Drücken Sie F5, um mit dem Debuggen des Projekts fortzufahren.
Überprüfen Sie in der experimentellen Instanz von Visual Studio, ob ein neuer Knoten mit dem Namen Webpartkatalog unter dem Websiteknoten der obersten Ebene angezeigt wird. Erweitern Sie 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 CreateWebPartNodes-Methode festgelegt haben. Drücken Sie F5, um mit dem Debuggen des Projekts fortzufahren.
Überprüfen Sie in der experimentellen Instanz von Visual Studio, ob alle Webparts der verbundenen Website unter dem Knoten Webpartkatalog im Server-Explorer angezeigt werden.
Klicken Sie mit der rechten Maustaste auf eines der Webparts, und klicken Sie anschließend auf Eigenschaften.
Überprüfen Sie in der Visual Studio-Instanz, in der Sie das Debugging durchführen, ob alle Details zum Webpart im Eigenschaftenfenster 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 im Menü Extras auf Erweiterungs-Manager.

Das Dialogfeld Erweiterungs-Manager wird geöffnet.
Wählen Sie in der Liste der Erweiterungen Web Part Gallery Node Extension for Server Explorer aus, und klicken Sie anschließend auf Deinstallieren.
Klicken Sie im angezeigten Dialogfeld auf Ja, um zu bestätigen, dass Sie die Erweiterung deinstallieren möchten.
Klicken Sie auf 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

Last updated on 2011-08-10

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

Vorbereitungsmaßnahmen

Erstellen der Projekte

So erstellen Sie das VSIX-Projekt

So erstellen Sie das Erweiterungsprojekt

So erstellen Sie das SharePoint-Befehlsprojekt

Konfigurieren der Projekte

So konfigurieren Sie das Projekt "WebPartNodeExtension"

So konfigurieren Sie das Projekt WebPartCommands

Erstellen von Symbolen für die neuen Knoten

So erstellen Sie Symbole für die Knoten

Hinzufügen des Webpartkatalogknotens zum Server-Explorer

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

Definieren eines Knotentyps, der ein Webpart darstellt

So definieren Sie den Webpartknotentyp

Definieren der Webpart-Datenklasse

So definieren Sie die Webpart-Datenklasse

Definieren der IDs für den SharePoint-Befehl

So definieren Sie die Befehls-IDs

Erstellen der benutzerdefinierten SharePoint-Befehle

So definieren Sie die SharePoint-Befehle

Checkpoint

So erstellen Sie die Projektmappe

Erstellen eines VSIX-Pakets zum Bereitstellen der Erweiterung

So konfigurieren Sie das VSIX-Paket

Testen der Erweiterung

So debuggen Sie die Erweiterung

So testen Sie die Erweiterung

Deinstallieren der Erweiterung aus Visual Studio

So deinstallieren Sie die Erweiterung

Siehe auch

Aufgaben

Referenz

Weitere Ressourcen

Zusätzliche Ressourcen