Exemplarische Vorgehensweise: Aufrufe in das SharePoint-Clientobjektmodell innerhalb einer Server-Explorererweiterung

Artikel
08/10/2011

Diese exemplarische Vorgehensweise veranschaulicht, wie das SharePoint-Clientobjektmodell in einer Erweiterung für den Knoten SharePoint-Verbindungen im Server-Explorer aufgerufen wird. Weitere Informationen zur Verwendung des SharePoint-Clientobjektmodells finden Sie unter Aufrufe in die SharePoint-Objektmodelle.

Diese exemplarische Vorgehensweise enthält die folgenden Aufgaben:

Erstellen einer Visual Studio-Erweiterung, die den Knoten SharePoint-Verbindungen im 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.
Erstellen eines Visual Studio-Erweiterungspakets (VSIX) zum Bereitstellen der Erweiterung.
Debuggen und Testen der Erweiterung.

Tipp

Die Erweiterung, die Sie in dieser exemplarischen Vorgehensweise erstellen, ähnelt der Erweiterung in Exemplarische Vorgehensweise: Erweitern des Server-Explorers für die Anzeige von Webparts. Bei der zuvor erwähnten Vorgehensweise wird jedoch das SharePoint-Serverobjektmodell verwendet. Die folgende exemplarische Vorgehensweise verwendet für dieselben Aufgaben das Clientobjektmodell.

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 der Erweiterung 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-Clientobjektmodells. Weitere Informationen finden Sie im Thema zum verwalteten Clientobjektmodell (möglicherweise in englischer Sprache).
Webparts in Microsoft SharePoint Services. 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 zwei Projekte erstellen:

Ein VSIX-Projekt für die Erstellung des VSIX-Pakets zum Bereitstellen der Server-Explorer-Erweiterung.
Ein Klassenbibliotheksprojekt, das die Server-Explorer-Erweiterung implementiert.

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 klicken Sie dann auf Erweiterungen.

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. Für SharePoint-Tools-Erweiterungen werden Funktionen aus dieser .NET Framework-Version benötigt.
Klicken Sie auf die Vorlage VSIX Project.
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.

Konfigurieren des Erweiterungsprojekts

Bevor Sie Code zum Erstellen der Erweiterung schreiben, müssen Sie Codedateien und Assemblyverweise zum Projekt hinzufügen und den Standardnamespace aktualisieren.

So konfigurieren Sie das Projekt

Fügen Sie im Projekt WebPartNodeExtension zwei Codedateien mit den folgenden Namen hinzu:
- SiteNodeExtension
- WebPartNodeTypeProvider
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.Client
- Microsoft.SharePoint.Client.Runtime
- Microsoft.VisualStudio.SharePoint
- System.ComponentModel.Composition
- System.Windows.Forms
Wählen Sie im Menü Projekt die Option Eigenschaften von WebPartNodeExtension 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 Projekt-Designer für das Projekt "WebPartNodeExtension" 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.
Klicken Sie auf die 32x32-Version des Symbols.
Klicken Sie im Menü Bild auf Bildtyp löschen.
Wiederholen Sie Schritt 3 bis 7, 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.SharePoint.Client
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: Indicates that this class extends SharePoint site nodes in Server Explorer.
    ' SiteNodeExtension class: Represents an extension of SharePoint site nodes in Server Explorer.
    <Export(GetType(IExplorerNodeTypeExtension))> _
    <ExplorerNodeType(ExplorerNodeTypes.SiteNode)> _
    Friend Class SiteNodeExtension
        Implements IExplorerNodeTypeExtension

        Private siteUrl As System.Uri = Nothing

        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)

            ' Get the site URL so that it can be used later to access the site
            ' by using the SharePoint client object model.
            siteUrl = e.Node.Context.SiteUrl

            ' 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 individual Web Part nodes under the new Web Part Gallery node.
        Private Sub CreateWebPartNodes(ByVal parentNode As IExplorerNode)

            ' Use the SharePoint client object model to get items from the Web Part gallery.
            Dim Context As ClientContext = New ClientContext(siteUrl.AbsoluteUri)
            Dim WebPartsGallery As List = Context.Web.GetCatalog(CType(ListTemplateType.WebPartCatalog, Integer))
            Dim WebParts As ListItemCollection = WebPartsGallery.GetItems(New CamlQuery())

            ' Request the FieldValuesAsText property values with the Web Part items.
            Context.Load(WebParts, Function(listItems) listItems.Include(Function(i) i.FieldValuesAsText))
            Context.ExecuteQuery()

            If WebParts IsNot Nothing Then
                For Each WebPart As ListItem 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(ListItem), WebPart)

                    ' Create the new node for the current Web Part item.
                    parentNode.ChildNodes.Add(WebPartNodeTypeProvider.WebPartNodeTypeId, _
                        WebPart.FieldValuesAsText.FieldValues("Title"), Annotations)
                Next
            End If
        End Sub
    End Class
End Namespace

using System.Collections.Generic;
using System.ComponentModel.Composition;
using Microsoft.SharePoint.Client;
using Microsoft.VisualStudio.SharePoint;
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
    {
        private System.Uri siteUrl = null;

        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)
        {
            // Get the site URL so that it can be used later to access the site
            // by using the SharePoint client object model.
            siteUrl = e.Node.Context.SiteUrl;

            // 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 individual Web Part nodes under the new Web Part Gallery node.
        private void CreateWebPartNodes(IExplorerNode parentNode)
        {
            // Use the SharePoint client object model to get items from the Web Part gallery.
            ClientContext context = new ClientContext(siteUrl.AbsoluteUri);
            List webPartsGallery = context.Web.GetCatalog((int)ListTemplateType.WebPartCatalog);
            ListItemCollection webParts = webPartsGallery.GetItems(new CamlQuery());

            // Request the FieldValuesAsText property values with the Web Part items.
            context.Load(webParts, listItems => listItems.Include(i => i.FieldValuesAsText));
            context.ExecuteQuery();

            if (webParts != null)
            {
                foreach (ListItem 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(ListItem), webPart } 
                    };

                    // Create the new node for the current Web Part item.
                    parentNode.ChildNodes.Add(WebPartNodeTypeProvider.WebPartNodeTypeId,
                        webPart.FieldValuesAsText.FieldValues["Title"], 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 WebPartNodeTypeProvider-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.SharePoint.Client
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
            AddHandler typeDefinition.NodeMenuItemsRequested, AddressOf NodeMenuItemsRequested
        End Sub

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

            Dim webPart = e.Node.Annotations.GetValue(Of ListItem)()
            Dim propertySource = e.Node.Context.CreatePropertySourceObject( _
                webPart.FieldValuesAsText.FieldValues)
            e.PropertySources.Add(propertySource)
        End Sub

        Private Sub NodeMenuItemsRequested(ByVal Sender As Object, _
            ByVal e As ExplorerNodeMenuItemsRequestedEventArgs)
            Dim WebPartNodeMenuItem As IMenuItem = e.MenuItems.Add("Display Message")
            AddHandler WebPartNodeMenuItem.Click, AddressOf MenuItemClick
        End Sub

        Private Sub MenuItemClick(ByVal Sender As Object, ByVal e As MenuItemEventArgs)
            Dim ParentNode As IExplorerNode = TryCast(e.Owner, IExplorerNode)
            If ParentNode IsNot Nothing Then
                Dim webPart = ParentNode.Annotations.GetValue(Of ListItem)()
                MessageBox.Show("You clicked the context menu for the following Web part: " & _
                    webPart.FieldValuesAsText.FieldValues("Title") + ".", "Web Part Menu Command")
            End If
        End Sub
    End Class
End Namespace

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.ComponentModel.Composition;
using Microsoft.SharePoint.Client;
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;
            typeDefinition.NodeMenuItemsRequested += NodeMenuItemsRequested;
        }

        // Retrieves properties that are displayed in the Properties window when
        // a Web Part node is selected.
        private void NodePropertiesRequested(object sender,
            ExplorerNodePropertiesRequestedEventArgs e)
        {
            var webPart = e.Node.Annotations.GetValue<ListItem>();
            object propertySource = e.Node.Context.CreatePropertySourceObject(
                webPart.FieldValuesAsText.FieldValues);
            e.PropertySources.Add(propertySource);
        }

        private void NodeMenuItemsRequested(
            object sender, ExplorerNodeMenuItemsRequestedEventArgs e)
        {
            e.MenuItems.Add("Display Message").Click += MenuItemClick;
        }

        private void MenuItemClick(object sender, MenuItemEventArgs e)
        {
            IExplorerNode parentNode = e.Owner as IExplorerNode;

            if (parentNode != null)
            {
                var webPart = parentNode.Annotations.GetValue<ListItem>();
                MessageBox.Show("You clicked the context menu for the following Web part: " +
                    webPart.FieldValuesAsText.FieldValues["Title"] + ".", "Web Part Menu Command");
            }
        }
    }
}

Checkpoint

Ab diesem Punkt in der exemplarischen Vorgehensweise wurde der gesamte für den Knoten Webpartkatalog benötigte Code in das Projekt eingefügt. Erstellen Sie die Projektmappe, um sicherzustellen, dass das Projekt ohne Fehler kompiliert wird.

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 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 im Knoten "WebPartNode".

Die Datei wird von Visual Studio im Manifest-Editor geöffnet. 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.
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 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 das Erweiterungsprojekt 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 den ersten Codezeilen 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).
Vergewissern Sie sich, dass 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, ob die Details zum Webpart im Fenster Eigenschaften angezeigt werden.
Klicken Sie im Server-Explorer mit der rechten Maustaste erneut auf dasselbe Webpart, und klicken Sie dann auf Meldung anzeigen.

Vergewissern Sie sich, dass ein Meldungsfeld angezeigt wird. Klicken Sie im Meldungsfeld auf OK.

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.
Klicken Sie in der Liste der Erweiterungen auf Web Part Gallery Node Extension for Server Explorer, 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. Das Projektelement wird ebenfalls deinstalliert.
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