Procedura dettagliata: estensione di Esplora server per visualizzare web part

Articolo
02/18/2013

In Visual Studio, è possibile utilizzare il nodo Connessioni di SharePointEsplora server per visualizzare i componenti dei siti di SharePoint.Tuttavia, Esplora server non vengono visualizzati alcuni componenti per impostazione predefinita.In questa procedura dettagliata, estese Esplora server in modo da visualizzare la raccolta Web part in ogni sito di SharePoint connesso.

In questa procedura dettagliata vengono illustrate le attività seguenti:

Creazione di un'estensione di Visual Studio che estende Esplora server nei modi seguenti:
- L'estensione aggiunge un nodo Raccolta web part sotto ogni nodo del sito di SharePoint in Esplora server.In questo nuovo nodo sono contenuti nodi figlio che rappresentano ogni web part nella relativa raccolta sul sito.
- L'estensione definisce un nuovo tipo di nodo che rappresenta un'istanza di Web part.Questo nuovo tipo di nodo è la base dei nodi figlio sotto il nuovo nodo Raccolta web part.Il nuovo tipo di nodo di web part visualizza le informazioni nella finestra Proprietà relativa alla web part che rappresenta.Il tipo di nodo include anche un elemento di menu di scelta rapida personalizzato che è possibile utilizzare come punto iniziale per eseguire altre attività correlate alla Web part.
Creazione di due comandi di SharePoint personalizzati che l'assembly di estensioni chiama.I comandi di SharePoint sono metodi che possono essere chiamati dagli assembly di estensioni per utilizzare le API nel modello a oggetti del server di SharePoint.In questa procedura dettagliata verranno creati comandi per recuperare informazioni sulla web part dal sito locale di SharePoint nel computer di sviluppo.Per ulteriori informazioni, vedere Chiamate ai modelli a oggetti di SharePoint.
Compilazione di un pacchetto Visual Studio Extension (VSIX) per distribuire l'estensione.
Debug e test dell'estensione.

[!NOTA]

Per una versione alternativa di questa procedura dettagliata che utilizza il modello a oggetti del client di SharePoint anziché il modello a oggetti del server, vedere Procedura dettagliata: chiamata al modello a oggetti del client di SharePoint in un'estensione di Esplora server.

Prerequisiti

Per completare la procedura dettagliata, nel computer di sviluppo devono essere presenti i componenti elencati di seguito:

Edizioni supportate di Windows, SharePoint e Visual Studio.Per ulteriori informazioni, vedere Requisiti per lo sviluppo di soluzioni SharePoint.
Visual Studio SDK.In questa procedura dettagliata viene utilizzato il modello VSIX Project di SDK per creare un pacchetto VSIX e distribuire l'elemento di progetto.Per ulteriori informazioni, vedere Estensione degli strumenti di SharePoint in Visual Studio.

Per completare la procedura dettagliata è consigliabile conoscere i concetti riportati di seguito:

Utilizzo del modello a oggetti del server di SharePoint.Per ulteriori informazioni, vedere l'articolo relativo all'utilizzo del modello a oggetti lato server di SharePoint Foundation (la pagina potrebbe essere in inglese).
Web part nelle soluzioni SharePoint.Per ulteriori informazioni, vedere l'articolo relativo alla panoramica delle web part (la pagina potrebbe essere in inglese).

Creazione dei progetti

Per completare questa procedura dettagliata, è necessario creare tre progetti:

Un progetto VSIX per creare il pacchetto VSIX allo scopo di distribuire l'estensione.
Un progetto Libreria di classi che implementa l'estensione.Questo progetto deve essere destinato a .NET Framework 4,5.
Un progetto Libreria di classi che definisce i comandi di SharePoint personalizzati.Questo progetto deve essere destinato a .NET Framework 3.5.

Iniziare la procedura dettagliata creando i progetti.

Per creare il progetto VSIX

Avviare Visual Studio.
Sulla barra dei menu, scegliere Il file, Nuova, Project.
Nella finestra di dialogo Nuovo progetto, espandere i nodi Visual Basic o Visual C# quindi selezionare il nodo Extensibility.

[!NOTA]

Il nodo Extensibility è disponibile solo se si installa Visual Studio SDK.Per ulteriori informazioni, vedere la sezione precedente relativa ai prerequisiti.
Nella parte superiore della finestra di dialogo, scegliere .NET Framework 4.5 nell'elenco delle versioni di.NET Framework.
Scegliere il modello Progetto VSIX, denominare il progetto WebPartNodequindi scegliere il pulsante OK.

Visual Studio aggiunge il progetto WebPartNode a Esplora soluzioni.

Per creare il progetto di estensione

In Esplora soluzioni, aprire il menu di scelta rapida del nodo della soluzione, scegliere Aggiungiquindi scegliere Nuovo progetto.

[!NOTA]

Nei progetti di Visual Basic, il nodo della soluzione viene visualizzato in Esplora soluzioni solo quando la casella di controllo Mostra sempre soluzione viene selezionata in General, Projects and Solutions, Options Dialog Box.
Nella finestra di dialogo Nuovo progetto, espandere il nodo Visual C# o il nodo Visual Basic quindi il nodo Finestre di scelta.
Nella parte superiore della finestra di dialogo, scegliere .NET Framework 4.5 nell'elenco delle versioni di.NET Framework.
Nell'elenco di modelli di progetto, scegliere Libreria di classi, denominare il progetto WebPartNodeExtensionquindi scegliere il pulsante OK.

In Visual Studio il progetto WebPartNodeExtension viene aggiunto alla soluzione e viene aperto il file di codice predefinito Class1.
Eliminare il file di codice Class1 dal progetto.

Per creare il progetto di comandi di SharePoint

In Esplora soluzioni, aprire il menu di scelta rapida del nodo della soluzione, scegliere Aggiungiquindi scegliere Nuovo progetto.

[!NOTA]

Nei progetti di Visual Basic, il nodo della soluzione viene visualizzato in Esplora soluzioni solo quando la casella di controllo Mostra sempre soluzione viene selezionata in General, Projects and Solutions, Options Dialog Box.
Nella finestra di dialogo Nuovo progetto, espandere il nodo Visual C# o il nodo Visual Basic quindi selezionare il nodo Finestre.
Nella parte superiore della finestra di dialogo, scegliere .NET Framework 3.5 nell'elenco delle versioni di.NET Framework.
Nell'elenco di modelli di progetto, scegliere Libreria di classi, denominare il progetto WebPartCommandsquindi scegliere il pulsante OK.

Visual Studio aggiunge il progetto WebPartCommands alla soluzione e apre il file di codice predefinito Class1.
Eliminare il file di codice Class1 dal progetto.

Configurazione dei progetti

Prima di scrivere codice per creare l'estensione, è necessario aggiungere file di codice e i riferimenti ad assembly e configurare le impostazioni del progetto.

Per configurare il progetto WebPartNodeExtension

Nel progetto WebPartNodeExtension, aggiungere quattro file di codice con i nomi seguenti:
- SiteNodeExtension
- WebPartNodeTypeProvider
- WebPartNodeInfo
- WebPartCommandIds
Aprire il menu di scelta rapida del progetto WebPartNodeExtension quindi scegliere Aggiungi riferimento.
Nella finestra di dialogo Gestione riferimenti – WebPartNodeExtension, scegliere la scheda Framework quindi selezionare la casella di controllo per ognuno degli assembly seguenti:
- System.ComponentModel.Composition
- System.Windows.Forms
Scegliere la scheda Estensioni, selezionare la casella di controllo per un assembly Microsoft.VisualStudio.SharePoint quindi scegliere il pulsante OK.
In Esplora soluzioni, aprire il menu di scelta rapida del nodo del progetto WebPartNodeExtension quindi scegliere Proprietà.

Verrà aperta la finestra Progettazione progetti.
Scegliere la scheda Application.
Nella casella Spazio dei nomi predefinito (C#) o casella Spazio dei nomi radice (Visual Basic), immettere ServerExplorer.SharePointConnections.WebPartNode.

Per configurare il progetto WebPartCommands

Nel progetto WebPartCommands, aggiungere un file di codice denominato WebPartCommands.
In Esplora soluzioni, aprire il menu di scelta rapida del nodo del progetto WebPartCommands, scegliere Aggiungiquindi scegliere Elemento esistente.
Nella finestra di dialogo Aggiungi elemento esistente, individuare la cartella che contiene file di codice per il progetto WebPartNodeExtension quindi i file di codice WebPartNodeInfo e WebPartCommandIds.
Scegliere la freccia accanto al pulsante Aggiungi quindi scegliere Aggiungi come collegamento dal menu visualizzato.

Visual Studio aggiunge i file di codice al progetto WebPartCommands come collegamenti.Di conseguenza, i file di codice si trovano nel progetto WebPartNodeExtension, ma il codice nei file è compilato anche nel progetto WebPartCommands.
Aprire nuovamente il menu di scelta rapida del progetto WebPartCommands e scegliere Aggiungi riferimento.
Nella finestra di dialogo Gestione riferimenti – WebPartCommands, scegliere la scheda Estensioni, selezionare la casella di controllo per ognuno degli assembly e quindi scegliere il pulsante OK :
- Microsoft.SharePoint
- Microsoft.VisualStudio.SharePoint.Commands
In Esplora soluzioni, aprire nuovamente il menu di scelta rapida del progetto WebPartCommands quindi scegliere Proprietà.

Verrà aperta la finestra Progettazione progetti.
Scegliere la scheda di Application.
Nella casella Spazio dei nomi predefinito (C#) o casella Spazio dei nomi radice (Visual Basic), immettere ServerExplorer.SharePointConnections.WebPartNode.

Creazione di icone per i nuovi nodi

Creare due icone per l'estensione Esplora server: una per il nuovo nodo Raccolta web part e un'altra per ogni nodo di web part figlio presente sotto il nodo Raccolta web part.Più avanti nella procedura dettagliata si scriverà codice che associa queste icone ai nodi.

Per creare icone per i nodi

In Esplora soluzioni, aprire il menu di scelta rapida del progetto WebPartNodeExtension quindi scegliere Proprietà.
Verrà aperta la finestra Progettazione progetti.
Scegliere la scheda Risorse e quindi scegliere Questo progetto non contiene un file di risorse predefinito. Fare clic qui per creare un collegamento.

Visual Studio crea un file di risorse che viene aperto nella finestra di progettazione.
Nella parte superiore della finestra di progettazione, scegliere la freccia accanto al comando di menu Aggiungi risorsa quindi scegliere Aggiungi nuova icona dal menu visualizzato.
Nella finestra di dialogo Aggiungi nuova risorsa, denominare la nuova icona WebPartsNodequindi scegliere il pulsante Aggiungi.

La nuova icona viene aperta in Editor immagini.
Modificare la versione 16x16 dell'icona in modo che la relativa progettazione sia facilmente riconoscibile.
Aprire il menu di scelta rapida per la versione 32x32 dell'icona e scegliere Elimina tipo di immagine.
Ripetere i passaggi da 5 a 8 per aggiungere una seconda icona alle risorse del progetto e denominare questa icona Web part.
In Esplora soluzioni, nella cartella Risorse per il progetto WebPartNodeExtension, aprire il menu di scelta rapida per WebPartsNode.ico.
Nella finestra Proprietà, scegliere la freccia accanto a Operazione di compilazionequindi scegliere Risorsa incorporata nel menu visualizzato.
Ripetere gli ultimi due passaggi per WebPart.ico.

Aggiunta del nodo Raccolta web part a Esplora server

Creare una classe che aggiunge il nuovo nodo Raccolta web part a ogni nodo del sito di SharePoint.Per aggiungere il nuovo nodo, la classe implementa l'interfaccia IExplorerNodeTypeExtension.Implementare questa interfaccia tutte le volte che si desidera estendere il comportamento di un nodo esistente in Esplora server, ad esempio aggiungendo il nodo figlio a un nodo.

Per aggiungere il nodo Raccolta web part a Esplora server

Nel progetto WebPartNodeExtension, aprire il file di codice SiteNodeExtension e quindi incollare il codice seguente in.

[!NOTA]

Dopo aver aggiunto questo codice, il progetto presenterà alcuni errori di compilazione, ma verranno risolti quando si aggiunge codice nei passaggi successivi.

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

Definizione di un tipo di nodo che rappresenta una web part

Creare una classe che definisce un nuovo tipo di nodo che rappresenta una web part.Visual Studio utilizza questo nuovo tipo di nodo per visualizzare i nodi figlio sotto il nodo Raccolta web part.Ogni nodo figlio rappresenta una singola Web part sul sito di SharePoint.

Per definire il nuovo tipo di nodo, la classe implementa l'interfaccia IExplorerNodeTypeProvider.Implementare questa interfaccia tutte le volte che si desidera definire un nuovo tipo di nodo in Esplora server.

Per definire il tipo di nodo di web part

Nel progetto WebPartNodeExtension, aprire il file di codice Webpartnodetypeprovider quindi incollare il codice seguente in.

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

Definizione della classe di dati della web part

Definire una classe che contiene i dati relativi a una singola web part sul sito di SharePoint.Più avanti in questa procedura dettagliata, verrà creato un comando di SharePoint personalizzato che recupera i dati di ogni Web part sul sito e li assegna alle istanze di questa classe.

Per definire la classe di dati della web part

Nel progetto WebPartNodeExtension, aprire il file di codice WebPartNodeInfo e quindi incollare il codice seguente in.

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

Definizione degli ID per i comandi di SharePoint

Definire diverse stringhe che identificano i comandi personalizzati di SharePointche verranno implementati più avanti nella procedura dettagliata.

Per definire gli ID dei comandi

Nel progetto WebPartNodeExtension, aprire il file di codice WebPartCommandIds quindi incollare il codice seguente in.

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

Creazione di comandi personalizzati di SharePoint

Creare controlli personalizzati che effettuano chiamate nel modello a oggetti del server di SharePoint per recuperare i dati relativi alle Web part sul sito di SharePoint.Ogni comando è un metodo che dispone di un oggetto SharePointCommandAttribute applicato.

Per definire i comandi di SharePoint

Nel progetto WebPartCommands, aprire il file di codice WebPartCommands quindi incollare il codice seguente in.

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

Verifica

In questa fase della procedura dettagliata, tutto il codice per il nodo Raccolta web part e i comandi di SharePoint si trovano nei progetti.Compilare la soluzione per assicurarsi che entrambi i progetti vengano compilati senza errori.

Per compilare la soluzione

Sulla barra dei menu, scegliere Compilazione, Compila soluzione.

Attenzione
In questa fase, il progetto WebPartNode può avere un errore di compilazione dal file manifesto VSIX non dispone di un valore dell'autore.L'errore andrà tramite quando si aggiunge un valore nei passaggi successivi.

Creazione di un pacchetto VSIX per distribuire l'estensione

Per distribuire l'estensione, utilizzare il progetto VSIX nella soluzione per creare un pacchetto VSIX.Innanzitutto, configurare il pacchetto VSIX modificando il file source.extension.vsixmanifest nel progetto VSIX.Successivamente, creare il pacchetto VSIX compilando la soluzione.

Per configurare il pacchetto VSIX

In Esplora soluzioni, doppio clic sul file, aprire il file source.extension.vsixmanifest nell'editor del manifesto.

Il file source.extension.vsixmanifest è la base del file extension.vsixmanifest che tutti i pacchetti VSIX richiedono.Per ulteriori informazioni su questo file, vedere Informazioni di riferimento sullo schema dell'estensione VSIX.
Nella casella Nome prodotto, immettere Nodo raccolta web part per Esplora server.
Nella casella Autore, immettere Contoso.
Nella casella Descrizione, immettere Aggiungere un nodo personalizzato della raccolta Web part al nodo Connessioni di SharePoint in Esplora server. This extension uses a custom SharePoint command to call into the server object model.
Scegliere la scheda Asset dell'editor e quindi scegliere il pulsante Nuova.

La finestra di dialogo Aggiungi nuovo asset visualizzato.
Nell'elenco Tipo, scegliere Microsoft.VisualStudio.MefComponent.

[!NOTA]

Questo valore corrisponde all'elemento MefComponent del file extension.vsixmanifest.Questo elemento specifica il nome di un assembly dell'estensione nel pacchetto VSIX.Per ulteriori informazioni, vedere MEFComponent Element.
Nell'elenco Alimentazione, scegliere Progetto nella soluzione corrente.
Nell'elenco Project, scegliere WebPartNodeExtension quindi scegliere il pulsante OK.
Nell'editor del manifesto, scegliere nuovamente il pulsante Nuova.

La finestra di dialogo Aggiungi nuovo asset visualizzato.
Nella casella Tipo, immettere SharePoint.Commands.v4.

[!NOTA]

Questo elemento specifica un'estensione personalizzata che si desidera includere nell'estensione di Visual Studio.Per ulteriori informazioni, vedere Elemento di risorsa (schema VSX).
Nell'elenco Alimentazione, selezionare la voce di elenco Progetto nella soluzione corrente.
Nell'elenco Project, scegliere WebPartCommandsquindi scegliere il pulsante OK.
Sulla barra dei menu, scegliere Compilazione, Compila soluzionequindi assicurarsi che la soluzione venga compilato senza errori.
Verificare che la cartella di output di compilazione per il progetto WebPartNode adesso contenga il file WebPartNode.vsix.

Per impostazione predefinita, la cartella dell'output di compilazione è ..\bin\Debug sotto la cartella che contiene il file di progetto.

Test dell'estensione

È ora possibile testare il nuovo nodo Raccolta web part in Esplora server.Innanzitutto, avviare il debug dell'estensione in un'istanza sperimentale di Visual Studio.Successivamente, utilizzare il nuovo nodo Web part nell'istanza sperimentale di Visual Studio.

Per avviare il debug dell'estensione

Riavviare Visual Studio con credenziali amministrative e aprire la soluzione WebPartNode.
Nel progetto WebPartNodeExtension, aprire il file di codice SiteNodeExtension e aggiungere un punto di interruzione alla prima riga di codice nei metodi CreateWebPartNodes e NodeChildrenRequested.
Scegliere il tasto F5 per avviare il debug.

In Visual Studio i file di estensione vengono installati in %UserProfile% \ AppData \ local \ Microsoft \ VisualStudio \ 11.0Exp \ extensions \ Contoso \ estensione del nodo raccolta Web part a Esplora server \ 1,0 e viene avviata un'istanza sperimentale di Visual Studio.L'elemento del progetto verrà testato in questa istanza di Visual Studio.

Per testare l'estensione

Nell'istanza sperimentale Visual Studio, sulla barra dei menu, scegliere Visualizza, Esplora server.
Eseguire i passaggi seguenti se il sito di SharePoint che si desidera utilizzare per il test non viene visualizzato nel nodo Connessioni di SharePoint in Esplora server:
1. In Esplora server, aprire il menu di scelta rapida per Connessioni di SharePointquindi scegliere Aggiungi connessione.
2. Nella finestra di dialogo Aggiungi connessione SharePoint, immettere l'url per il sito di SharePoint a cui si desidera connettersi e quindi scegliere il pulsante OK.
  
  Per specificare il sito di SharePoint nel computer di sviluppo, immettere https://localhost.
Espandere il nodo della connessione al sito (in cui è visualizzato l'url del sito) e quindi espandere il nodo del sito figlio (ad esempio, Sito team).
Verificare che il codice nell'altra istanza Visual Studio si interrompe al punto di interruzione impostato precedentemente nel metodo NodeChildrenRequested quindi si sceglie F5 per continuare a eseguire il debug del progetto.
Nell'istanza sperimentale di Visual Studio, verificare che un nuovo nodo denominato Raccolta web part sotto il nodo del sito principale e quindi espandere il nodo Raccolta web part.
Verificare che il codice nell'altra istanza di Visual Studio si interrompe al punto di interruzione impostato precedentemente nel metodo CreateWebPartNodes quindi scegliere il tasto F5 per continuare a eseguire il debug del progetto.
Nell'istanza sperimentale di Visual Studio, verificare che tutte le Web part sul sito connesso vengano visualizzati nel nodo Raccolta web part in Esplora server.
In Esplora server, aprire il menu di scelta rapida per una Web part e quindi scegliere Proprietà.
Nell'istanza Visual Studio che si sta eseguendo il debug, verificare che i dettagli relativi alla Web part vengano visualizzati nella finestra Proprietà.

Disinstallazione dell'estensione da Visual Studio

Dopo aver completato il test dell'estensione, disinstallare quest'ultima da Visual Studio.

Per disinstallare l'estensione

Nell'istanza sperimentale Visual Studio, sulla barra dei menu, scegliere Strumenti, Estensioni e aggiornamenti.

La finestra di dialogo Estensioni e aggiornamenti viene aperto.
Nell'elenco di estensioni selezionare, Estensione nodo raccolta web part per Esplora serverquindi scegliere il pulsante Disinstalla.
Nella finestra di dialogo, scegliere il pulsante Sì per confermare che si desidera disinstallare l'estensione e quindi scegliere il pulsante Riavvia ora per completare la disinstallazione.
Chiudere entrambe le istanze di Visual Studio (l'istanza sperimentale e l'istanza di Visual Studio in cui la soluzione WebPartNode è aperta).

Vedere anche

Condividi tramite