Freigeben über

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

  • Artikel

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

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:

    • 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 Informationen Fenster Eigenschaften zum Webpart an, den der Knoten darstellt.

  • Erstellen eines Visual Studio-Erweiterungspakets (VSIX) zum Bereitstellen der Erweiterung.

  • Debuggen und Testen der Erweiterung.

HinweisHinweis

Die Erweiterung, die Sie in dieser exemplarischen Vorgehensweise erstellen, ähnelt der Erweiterung, die Sie in Exemplarische Vorgehensweise: Erweitern des Server-Explorers für die Anzeige von Webparts erstellen.In dieser exemplarischen Vorgehensweise das SharePoint-Serverobjektmodell, aber diese exemplarische Vorgehensweise verwendet, erfüllt die gleichen Aufgaben, indem es das Clientobjektmodell.

Vorbereitungsmaßnahmen

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

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 SharePoint.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

  1. Starten Sie Visual Studio.

  2. Wählen Sie in der Menüleiste Datei, Neu, Projekt aus.

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

    HinweisHinweis

    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.

  4. am oberen Rand des Dialogfelds wählen Sie .NET Framework 4.5 in der Liste der Versionen von .NET Framework aus.

    SharePoint-Toolerweiterungen benötigen Funktionen in dieser Version von .NET Framework.

  5. Wählen Sie die Vorlage aus. VSIX-Projekt

  6. Im Feld wählen Name-Typ WebPartNode und dann die Schaltfläche OK aus.

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

So erstellen Sie das Erweiterungsprojekt

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

    HinweisHinweis

    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.

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

  3. am oberen Rand des Dialogfelds wählen Sie .NET Framework 4.5 in der Liste der Versionen von .NET Framework aus.

  4. In der Liste der Projektvorlagen, wählen Sie Klassenbibliothek aus.

  5. Im Feld geben Sie NameWebPartNodeExtension ein und klicken Sie dann auf die Schaltfläche OK aus.

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

  6. Löschen Sie die Class1-Codedatei aus dem Projekt.

Konfigurieren des Erweiterungsprojekts

Bevor Sie Code schreiben, um die Erweiterung zu erstellen, müssen Sie Codedateien und Assemblyverweise zum Projekt hinzufügen, und Sie müssen den Standardnamespace aktualisieren.

So konfigurieren Sie das Projekt

  1. Im WebPartNodeExtension Projekt fügen Sie zwei Codedateien hinzu, die SiteNodeExtension und WebPartNodeTypeProvider benannt werden.

  2. Öffnen Sie das Kontextmenü für das Projekt "WebPartNodeExtension", und wählen Sie dann Verweis hinzufügen aus.

  3. Im Dialogfeld Verweis-Manager – WebPartNodeExtension wählen Sie den Knoten Framework aus, und wählen Sie dann die Kontrollkästchen für die System.ComponentModel.Compositions- und System.Windows.Forms aus.

  4. Wählen Sie den Knoten 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.Client

    • Microsoft.SharePoint.Client.Runtime

    • Microsoft.VisualStudio.SharePoint

  5. Öffnen Sie das Kontextmenü für das WebPartNodeExtension Projekt, und wählen Sie dann Eigenschaften aus.

    Der Projekt-Designer wird geöffnet.

  6. Wählen Sie die Registerkarte aus. Anwendung

  7. 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

  1. In Projekt-Designer für das Projekt "WebPartNodeExtension", wählen Sie die Registerkarte Ressourcen aus.

  2. Wählen Sie den Link , den dieses Projekt keine Standardressourcendatei enthält. Klicken Sie hier, um eine zu erstellen.

    Visual Studio erstellt eine Ressourcendatei und öffnet sie im Designer.

  3. am oberen Rand des Designers wählen Sie den Pfeil auf dem Ressource hinzufügen Menübefehl aus, und wählen Sie dann Neues Symbol hinzufügen aus.

  4. Geben Sie WebPartsNode für das neue Symbol ein, und wählen Sie dann die Schaltfläche Hinzufügen aus.

    Das neue Symbol wird in der Bildbearbeitung geöffnet.

  5. Bearbeiten Sie die 16x16-Version des Symbols, dass es einen Entwurf aufweist, den Sie leicht erkennen können.

  6. Öffnen Sie das Kontextmenü für die 32x32-Version des Symbols, und wählen Sie dann Bildtyp löschen aus.

  7. Wiederholen Sie die Schritte 3 bis 7, um den Projektressourcen ebenfalls ein Symbol hinzuzufügen, und benennen Sie dieses Symbol Webpart.

  8. In Projektmappen-Explorer im Ordner Ressourcen für das Projekt WebPartNodeExtension, wählen Sie WebPartsNode.ico aus.

  9. Im Fenster Eigenschaften öffnen Sie die Liste Buildvorgang, und wählen Sie dann Eingebettete Ressource aus.

  10. 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

  • Fügen Sie folgenden Code in die SiteNodeExtension Codedatei für das WebPartNodeExtension Projekt ein.

    HinweisHinweis

    Nachdem Sie diesen Code hinzufügen, weist das Projekt mehrere Compilerfehler.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.Visual Studio verwendet diesen neuen Knotentyp, 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

  • Fügen Sie folgenden Code in die WebPartNodeTypeProvider Codedatei für das WebPartNodeExtension Projekt 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 das WebPartNodeExtension Projekt, um sicherzustellen, dass es ohne Fehler kompiliert.

So erstellen Sie das Projekt

  • In Projektmappen-Explorer öffnen Sie das Kontextmenü für das WebPartNodeExtension Projekt, und wählen Sie dann Erstellen aus.

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

So konfigurieren Sie das VSIX-Paket

  1. In Projektmappen-ExplorerWebPartNode im Projekt, source.extension.vsixmanifest geöffnete Datei 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.

  2. Im Feld geben Sie ProduktnameWebpartkatalog-Knoten für Server-Explorer ein.

  3. Im Feld geben Sie AutorContoso ein.

  4. Im Feld geben Sie BeschreibungFügt einen benutzerdefinierten Webpartkatalogknoten dem Knoten SharePoint-Verbindungen im Server-Explorer hinzu ein.

  5. Klicken Sie auf der Registerkarte des Editors Objekte, wählen Sie die Schaltfläche Neu aus.

  6. Neue Anlage hinzufügen im Dialogfeld in der Liste Typ, wählen Sie Microsoft.VisualStudio.MefComponent aus.

    HinweisHinweis

    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.

  7. In der Liste wählen Sie QuelleEin Projekt in der aktuellen Projektmappe aus.

  8. In der Liste wählen Sie ProjektWebPartNodeExtension aus und wählen dann die Schaltfläche OK aus.

  9. Klicken Sie auf der Menüleiste wählen Sie Erstellen, Projektmappe erstellen aus, und überprüfen Sie, ob die Projektmappe fehlerfrei kompiliert.

  10. 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

Jetzt können Sie den neuen Knoten Webpartkatalog in Server-Explorer testen.Erstellen Sie zunächst, das Erweiterungsprojekt in einer experimentellen Instanz von Visual Studio debuggen.Verwenden Sie dann den neuen Knoten Webparts in der experimentellen Instanz von Visual Studio.

So debuggen Sie die Erweiterung

  1. Starten Sie Visual Studio erneut mit Administratorrechten, und öffnen Sie dann die WebPartNode Projektmappe.

  2. Öffnen Sie im Projekt "WebPartNodeExtension" die SiteNodeExtension Codedatei, und fügen Sie anschließend einen Haltepunkt startet den aus - NodeChildrenRequested und CreateWebPartNodes-Methoden hinzu.

  3. 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

  1. Klicken Sie in der experimentellen Instanz von Visual Studio, in der Menüleiste, wählen Sie Ansicht, Server-Explorer aus.

  2. Ü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.Wenn sie nicht aufgelistet ist, führen Sie folgende Schritte aus:

    1. Ö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 lokale SharePoint-Website auf dem Entwicklungscomputer anzugeben, geben Sie https://localhost ein.

  3. Erweitern Sie den Website-Verbindungsknoten (den die URL der Website angezeigt wird), und erweitern Sie dann einen untergeordneten Websiteknoten (beispielsweise, Teamwebsite).

  4. Ü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 NodeChildrenRequested-Methode und dann die F5-Taste auswählen, um fortfahren, um das Projekt zu debuggen.

  5. Klicken Sie in der experimentellen Instanz von Visual Studio, erweitern Sie den Knoten Webpartkatalog, der unter dem Websiteknoten der obersten Ebene angezeigt.

  6. Ü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.

  7. Ü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.

  8. Öffnen Sie das Kontextmenü für ein Webpart, und wählen Sie dann Eigenschaften aus.

  9. Im Fenster Eigenschaften überprüfen Sie, ob die Details zum Webpart angezeigt werden.

  10. In Server-Explorer öffnen Sie das Kontextmenü für dasselbe Webpart, und wählen Sie dann Meldung anzeigen aus.

    Klicken Sie im Meldungsfeld, das angezeigt wird, wählen Sie die Schaltfläche OK aus.

Deinstallieren der Erweiterung aus Visual Studio

Nachdem Sie beenden, die Erweiterung zu testen, deinstallieren Sie sie aus Visual Studio.

So deinstallieren Sie die Erweiterung

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

    Das Dialogfeld wird geöffnet. Erweiterungen und Updates

  2. In der Liste der Erweiterungen, wählen Sie Webpartkatalog-Knoten für Server-Explorer aus und wählen dann die Schaltfläche Deinstallieren aus.

  3. Im Dialogfeld, das angezeigt wird, wählen Sie die Schaltfläche Ja aus.

  4. Wählen Sie die Schaltfläche Jetzt neu starten, um die Deinstallation abzuschließen.

    Das Projektelement wird ebenfalls deinstalliert.

  5. 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

Aufgaben

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

Erstellen eines Symbols oder anderen Bilds (Bildbearbeitung für Symbole)

Referenz

Bildbearbeitung für Symbole

Konzepte

Aufrufe in die SharePoint-Objektmodelle

Weitere Ressourcen

Erweitern des SharePoint-Verbindungsknotens im Server-Explorer