Exemplarische Vorgehensweise: Erstellen eines Projektelements "Benutzerdefinierte Aktion" mit einer Elementvorlage, Teil 2

Artikel
08/10/2011

Nachdem Sie einen benutzerdefinierten Typ des SharePoint-Projektelements definiert und diesen einer Elementvorlage in Visual Studio zugeordnet haben, empfiehlt es sich, außerdem einen Assistenten für die Vorlage bereitzustellen. Mit dem Assistenten können Sie Informationen von Benutzern erfassen, wenn diese mit der Vorlage eine neue Instanz des Projektelements zu einem Projekt hinzufügen. Mit den gesammelten Informationen kann das Projektelement initialisiert werden.

In dieser exemplarischen Vorgehensweise fügen Sie dem Projektelement Benutzerdefinierte Aktion einen Assistenten hinzu. Das Projektelement wird in Exemplarische Vorgehensweise: Erstellen eines Projektelements "Benutzerdefinierte Aktion" mit einer Elementvorlage, Teil 1 veranschaulicht. Wenn ein Benutzer einem SharePoint-Projekt ein Projektelement Benutzerdefinierte Aktion hinzufügt, werden vom Assistenten Informationen zu der benutzerdefinierten Aktion gesammelt (z. B. der Speicherort und die aufgerufene URL, wenn darauf geklickt wird), und diese Informationen werden der Datei Elements.xml im neuen Projektelement hinzugefügt.

Diese exemplarische Vorgehensweise enthält die folgenden Aufgaben:

Erstellen eines Assistenten für einen benutzerdefinierten SharePoint-Projektelementtyp, dem eine Elementvorlage zugeordnet ist.
Definieren einer benutzerdefinierten Assistenten-Benutzeroberfläche, die der von integrierten Assistenten für SharePoint-Projektelemente in Visual Studio 2010 ähnelt
Initialisieren von SharePoint-Projektdateien mit im Assistenten gesammelten Daten mithilfe von ersetzbaren Parametern
Debuggen und Testen des Assistenten

Tipp

Ein Beispiel mit den abgeschlossenen Projekten, Code und weiteren Dateien für diese exemplarische Vorgehensweise können Sie unter folgender Adresse herunterladen: https://go.microsoft.com/fwlink/?LinkId=191369.

Vorbereitungsmaßnahmen

Um diese exemplarische Vorgehensweise ausführen zu können, müssen Sie zuerst die Projektmappe CustomActionProjectItem erstellen, indem Sie die Exemplarische Vorgehensweise: Erstellen eines Projektelements "Benutzerdefinierte Aktion" mit einer Elementvorlage, Teil 1 durcharbeiten.

Zum Durchführen dieser exemplarischen Vorgehensweise werden auf dem Entwicklungscomputer außerdem 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. Bei dieser exemplarischen Vorgehensweise wird mithilfe der Vorlage VSIX Project aus dem SDK ein VSIX-Paket zum Bereitstellen des Projektelements erstellt. Weitere Informationen finden Sie unter Erweitern der SharePoint-Tools in Visual Studio.

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

Assistenten für Projekt- und Elementvorlagen in Visual Studio. Weitere Informationen finden Sie unter Gewusst wie: Verwenden von Assistenten mit Projektvorlagen und der IWizard-Schnittstelle.
Benutzerdefinierte Aktionen in SharePoint. Weitere Informationen finden Sie im Thema zu benutzerdefinierten Aktionen (möglicherweise in englischer Sprache).

Erstellen des Assistentenprojekts

Um diese exemplarische Vorgehensweise ausführen zu können, müssen Sie der in Exemplarische Vorgehensweise: Erstellen eines Projektelements "Benutzerdefinierte Aktion" mit einer Elementvorlage, Teil 1 erstellten Projektmappe CustomActionProjectItem ein neues Projekt hinzufügen. In diesem Projekt implementieren Sie die IWizard-Schnittstelle, und Sie definieren die Assistenten-Benutzeroberfläche.

So erstellen Sie das Assistentenprojekt

Öffnen Sie die Projektmappe CustomActionProjectItem in Visual Studio.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektmappenknoten, klicken Sie auf Hinzufügen und anschließend 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 den Knoten Fenster.
Stellen Sie im Kombinationsfeld am oberen Rand des Dialogfelds Neues Projekt sicher, dass .NET Framework 4 ausgewählt ist.
Wählen Sie die Projektvorlage WPF-Benutzersteuerelementbibliothek aus.
Geben Sie im Feld Name die Zeichenfolge ItemTemplateWizard ein.
Klicken Sie auf OK.

Visual Studio fügt der Projektmappe das Projekt ItemTemplateWizard hinzu.
Löschen Sie das Element UserControl1 aus dem Projekt.

Konfigurieren des Assistentenprojekts

Bevor Sie den Assistenten erstellen, müssen Sie dem Projekt ein WPF-Fenster, eine Codedatei und Assemblyverweise hinzufügen.

So konfigurieren Sie ein Assistentenprojekt

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektknoten ItemTemplateWizard, und klicken Sie auf Eigenschaften.
Ändern Sie das Zielframework im Projekt-Designer von .NET Framework 4 Client Profile in .NET Framework 4. In Visual C#-Projekten können Sie dies auf der Registerkarte Anwendung tun, in Visual Basic auf der Registerkarte Kompilieren. Weitere Informationen finden Sie unter Gewusst wie: Ausrichten auf eine bestimmte .NET Framework-Version oder ein bestimmtes .NET Framework-Profil.

Tipp

Wenn Sie ein neues Projekt für .NET Framework 4 erstellen, verwendet das Projekt standardmäßig das Clientprofil als Ziel. Diese exemplarische Vorgehensweise erfordert die Vollversion von .NET Framework 4.
Fügen Sie im Projekt ItemTemplateWizard ein neues Element Fenster (WPF) hinzu. Weisen Sie dem neuen Element den Namen WizardWindow zu.
Fügen Sie zwei Codedateien mit den folgenden Namen hinzu:
- CustomActionWizard
- Zeichenfolgen
Klicken Sie im Menü Projekt auf Verweis hinzufügen.
Halten Sie auf der Registerkarte .NET die Taste STRG gedrückt, und klicken Sie auf die folgenden Assemblys. Klicken Sie anschließend auf OK:
- EnvDTE
- Microsoft.VisualStudio.Shell.10.0
- Microsoft.VisualStudio.TemplateWizardInterface
Klicken Sie im Projektmappen-Explorer unter dem Ordner Verweise für das Projekt ItemTemplateWizard auf EnvDTE.

Tipp

In Visual Basic-Projekten wird der Ordner Verweise nur angezeigt, wenn das Kontrollkästchen Projektmappe immer anzeigen in Allgemein, Projekte und Projektmappen, Dialogfeld "Optionen" aktiviert ist.
Ändern Sie im Fenster Eigenschaften den Wert der Eigenschaft Interoptypen einbetten in False.

Definieren der Standardspeicherort- und ID-Zeichenfolgen für benutzerdefinierte Aktionen

Jede benutzerdefinierte Aktion verfügt über einen Speicherort und eine ID, die im GroupID-Attribut und im Location-Attribut des CustomAction-Elements in der Datei Elements.xml angegeben werden. In diesem Schritt definieren Sie im Projekt ItemTemplateWizard einige gültige Zeichenfolgen für diese Attribute. Beim Durchführen dieser exemplarischen Vorgehensweise werden diese Zeichenfolgen in die Datei Elements.xml im Projektelement Benutzerdefinierte Aktion geschrieben, wenn Benutzer im Assistenten einen Speicherort und eine ID auswählen.

Zur Vereinfachung wird in diesem Beispiel nur eine Teilmenge der verfügbaren Standardspeicherorte und Standard-IDs unterstützt. Eine vollständige Liste finden Sie unter Default Custom Action Locations and IDs.

So definieren Sie die Standardspeicherort- und ID-Zeichenfolgen

Öffnen Sie im Projekt ItemTemplateWizard die Codedatei Strings.

Ersetzen Sie den Code in dieser Datei durch den folgenden Code:

' This sample only supports several custom action locations and their group IDs. 
Friend Class CustomActionLocations
    Friend Const ListEdit As String = "Microsoft.SharePoint.ListEdit"
    Friend Const StandardMenu As String = "Microsoft.SharePoint.StandardMenu"
End Class

Friend Class StandardMenuGroupIds
    Friend Const Actions As String = "ActionsMenu"
    Friend Const ActionsSurvey As String = "ActionsMenuForSurvey"
    Friend Const NewMenu As String = "NewMenu"
    Friend Const Settings As String = "SettingsMenu"
    Friend Const SettingsSurvey As String = "SettingsMenuForSurvey"
    Friend Const SiteActions As String = "SiteActions"
    Friend Const Upload As String = "UploadMenu"
    Friend Const ViewSelector As String = "ViewSelectorMenu"
End Class

Friend Class ListEditGroupIds
    Friend Const Communications As String = "Communications"
    Friend Const GeneralSettings As String = "GeneralSettings"
    Friend Const Permissions As String = "Permissions"
End Class

Friend Class DefaultTextBoxStrings
    Friend Const TitleText As String = "Replace this with your title"
    Friend Const DescriptionText As String = "Replace this with your description"
    Friend Const UrlText As String = "~site/Lists/Tasks/AllItems.aspx"
End Class

namespace ItemTemplateWizard
{
    // This sample only supports several custom action locations and their group IDs. 
    internal class CustomActionLocations
    {
        internal const string ListEdit = "Microsoft.SharePoint.ListEdit";
        internal const string StandardMenu = "Microsoft.SharePoint.StandardMenu";
    }

    internal class StandardMenuGroupIds
    {
        internal const string Actions = "ActionsMenu";
        internal const string ActionsSurvey = "ActionsMenuForSurvey";
        internal const string NewMenu = "NewMenu";
        internal const string Settings = "SettingsMenu";
        internal const string SettingsSurvey = "SettingsMenuForSurvey";
        internal const string SiteActions = "SiteActions";
        internal const string Upload = "UploadMenu";
        internal const string ViewSelector = "ViewSelectorMenu";
    }

    internal class ListEditGroupIds
    {
        internal const string Communications = "Communications";
        internal const string GeneralSettings = "GeneralSettings";
        internal const string Permissions = "Permissions";
    }

    internal class DefaultTextBoxStrings
    {
        internal const string TitleText = "Replace this with your title";
        internal const string DescriptionText = "Replace this with your description";
        internal const string UrlText = "~site/Lists/Tasks/AllItems.aspx";
    }
}

Erstellen der Assistenten-Benutzeroberfläche

Fügen Sie XAML hinzu, um die Benutzeroberfläche des Assistenten zu definieren, und fügen Sie Code hinzu, um einige Steuerelemente im Assistenten an die ID-Zeichenfolgen zu binden. Der Assistent, den Sie erstellen, ähnelt dem integrierten Assistenten für SharePoint-Projekte in Visual Studio 2010.

So erstellen Sie die Assistenten-Benutzeroberfläche

Doppelklicken Sie im Projekt ItemTemplateWizard auf die Datei WizardWindow.xaml, um das Fenster im Designer zu öffnen.

Ersetzen Sie in der XAML-Ansicht des Designers das aktuelle XAML durch das folgende XAML. Mit dem XAML wird eine Benutzeroberfläche einschließlich Überschrift, Steuerelementen zum Angeben des Verhaltens für eine benutzerdefinierte Aktion sowie Navigationsschaltflächen unten im Fenster definiert.

Tipp

Nachdem Sie dieses XML Ihrem Projekt hinzugefügt haben, weist dieses mehrere Fehler auf. Diese Fehler werden durch Code behoben, den Sie in späteren Schritten hinzufügen.

<ui:DialogWindow x:Class="ItemTemplateWizard.WizardWindow"
                 xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
                 xmlns:ui="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Shell.10.0"        
                 xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
                 Title="SharePoint Customization Wizard" Height="500" Width="700" ResizeMode="NoResize" 
                 Loaded="Window_Loaded" TextOptions.TextFormattingMode="Display">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="75*" />
            <RowDefinition Height="364*" />
            <RowDefinition Height="1*" />
            <RowDefinition Height="60*" />
        </Grid.RowDefinitions>
        <Grid Grid.Row="0" Name="headingGrid" Background="White">
            <Label Grid.Row="0" Content="Configure the Custom Action" Name="pageHeaderLabel" HorizontalAlignment="Left" 
                   VerticalAlignment="Center" Margin="18,0,0,0" FontWeight="ExtraBold" />
        </Grid>
        <Grid Grid.Row="1" Name="mainGrid">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="20*" />
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="400*" />
            </Grid.ColumnDefinitions>
            <Grid.RowDefinitions>
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
                <RowDefinition Height="Auto" />
            </Grid.RowDefinitions>
            <StackPanel Grid.Row="0" Grid.Column="1" Orientation="Vertical">
                <Label Margin="0,20,0,0" Content="Location:" Name="locationLabel" FontWeight="Bold" />
                <RadioButton Content="_List Edit" Margin="5,0,0,0" Name="listEditRadioButton" 
                             Checked="listEditRadioButton_Checked" FontWeight="Normal"  />
                <RadioButton Content="_Standard Menu" Margin="5,5,0,0" Name="standardMenuRadioButton" 
                             Checked="standardMenuRadioButton_Checked" FontWeight="Normal" />
            </StackPanel>
            <Label Grid.Row="1" Grid.Column="1" Margin="0,15,0,0" Content="_Group ID:" Name="groupIdLabel" 
                   FontWeight="Bold" Target="{Binding ElementName=idComboBox}" />
            <ComboBox Grid.Row="1" Grid.Column="2" HorizontalAlignment="Left" Margin="0,15,0,0" Height="23" 
                      Width="253" Name="idComboBox" IsEditable="False" IsSynchronizedWithCurrentItem="True" />
            <Label Grid.Row="2" Grid.Column="1" Margin="0,15,0,0" Content="_Title:" Name="titleLabel" 
                   FontWeight="Bold" Target="{Binding ElementName=titleTextBox}" />
            <TextBox Grid.Row="2" Grid.Column="2" HorizontalAlignment="Left" Margin="0,15,0,0" Height="23" 
                     Name="titleTextBox" Width="410" Text="" />
            <Label Grid.Row="3" Grid.Column="1" Margin="0,15,0,0" Content="_Description:" Name="descriptionLabel" 
                   FontWeight="Bold" Target="{Binding ElementName=descriptionTextBox}" />
            <TextBox Grid.Row="3" Grid.Column="2" HorizontalAlignment="Left" Margin="0,15,0,0" Height="23" 
                     Name="descriptionTextBox" Width="410" Text="" />
            <Label Grid.Row="4" Grid.Column="1" Margin="0,15,0,0" Content="_URL:" Height="28" Name="urlLabel" 
                   FontWeight="Bold" Target="{Binding ElementName=urlTextBox}" />
            <TextBox Grid.Row="4" Grid.Column="2" HorizontalAlignment="Left" Margin="0,15,0,0" Height="23" 
                     Name="urlTextBox" Width="410" Text="" />
        </Grid>
        <Rectangle Grid.Row="2" Name="separatorRectangle" Fill="White"  />
        <StackPanel Grid.Row="3" Name="navigationPanel" Orientation="Horizontal">
            <Button Content="_Finish" Margin="500,0,0,0" Height="25" Name="finishButton" Width="85" 
                    Click="finishButton_Click" IsDefault="True" />
            <Button Content="Cancel" Margin="10,0,0,0" Height="25" Name="cancelButton" Width="85" IsCancel="True" />
        </StackPanel>
    </Grid>
</ui:DialogWindow>

Tipp

Das Fenster, das im XAML erstellt wird, wird von der DialogWindow-Basisklasse abgeleitet. Wenn Sie Visual Studio ein benutzerdefiniertes WPF-Dialogfeld hinzufügen, wird empfohlen, das Dialogfeld von dieser Klasse abzuleiten, um ein einheitliches Aussehen mit anderen Dialogfeldern von Visual Studio sicherzustellen und Probleme mit modalen Dialogfeldern zu vermeiden, die andernfalls auftreten können. Weitere Informationen finden Sie unter How to: Create and Manage Dialog Boxes.

Wenn Sie ein Visual Basic-Projekt entwickeln, entfernen Sie den ItemTemplateWizard-Namespace aus dem WizardWindow-Klassennamen im x:Class-Attribut des Window-Elements. Dies erfolgt in der ersten Zeile des XAML. Anschließend sollte die erste Zeile wie folgt aussehen.
```
<Window x:Class="WizardWindow"
```
Öffnen Sie die CodeBehind-Datei für die Datei WizardWindow.xaml.

Ersetzen Sie den Code in dieser Datei durch den folgenden Code:

Public Class WizardWindow
    Private standardMenuGroups As List(Of String)
    Private listEditGroups As List(Of String)
    Private standardMenuGroupIdBinding As Binding
    Private listEditGroupIdBinding As Binding
    Private standardMenuGroupIdBindingView As ListCollectionView
    Private listEditGroupIdBindingView As ListCollectionView

    Private Sub Window_Loaded(ByVal sender As Object, ByVal e As RoutedEventArgs)
        standardMenuGroups = New List(Of String) From {
            StandardMenuGroupIds.Actions,
            StandardMenuGroupIds.ActionsSurvey,
            StandardMenuGroupIds.NewMenu,
            StandardMenuGroupIds.Settings,
            StandardMenuGroupIds.SettingsSurvey,
            StandardMenuGroupIds.SiteActions,
            StandardMenuGroupIds.Upload,
            StandardMenuGroupIds.ViewSelector}
        listEditGroups = New List(Of String) From {
            ListEditGroupIds.Communications,
            ListEditGroupIds.GeneralSettings,
            ListEditGroupIds.Permissions}

        standardMenuGroupIdBinding = New Binding()
        standardMenuGroupIdBinding.Source = standardMenuGroups
        listEditGroupIdBinding = New Binding()
        listEditGroupIdBinding.Source = listEditGroups

        standardMenuGroupIdBindingView = CType(CollectionViewSource.GetDefaultView(standardMenuGroups), ListCollectionView)
        listEditGroupIdBindingView = CType(CollectionViewSource.GetDefaultView(listEditGroups), ListCollectionView)

        standardMenuRadioButton.IsChecked = True
    End Sub

    Private Sub standardMenuRadioButton_Checked(ByVal sender As Object, ByVal e As RoutedEventArgs)
        BindingOperations.ClearBinding(idComboBox, ComboBox.ItemsSourceProperty)
        idComboBox.SetBinding(ComboBox.ItemsSourceProperty, standardMenuGroupIdBinding)
        standardMenuGroupIdBindingView.MoveCurrentToFirst()
    End Sub

    Private Sub listEditRadioButton_Checked(ByVal sender As Object, ByVal e As RoutedEventArgs)
        BindingOperations.ClearBinding(idComboBox, ComboBox.ItemsSourceProperty)
        idComboBox.SetBinding(ComboBox.ItemsSourceProperty, listEditGroupIdBinding)
        listEditGroupIdBindingView.MoveCurrentToFirst()
    End Sub

    Private Sub finishButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
        Me.DialogResult = True
        Me.Close()
    End Sub
End Class

using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using Microsoft.VisualStudio.PlatformUI;

namespace ItemTemplateWizard
{
    public partial class WizardWindow : DialogWindow
    {
        private List<string> standardMenuGroups;
        private List<string> listEditGroups;
        private Binding standardMenuGroupIdBinding;
        private Binding listEditGroupIdBinding;
        private ListCollectionView standardMenuGroupIdBindingView;
        private ListCollectionView listEditGroupIdBindingView;

        public WizardWindow()
        {
            InitializeComponent();
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            standardMenuGroups = new List<string>() { 
                StandardMenuGroupIds.Actions,
                StandardMenuGroupIds.ActionsSurvey,
                StandardMenuGroupIds.NewMenu, 
                StandardMenuGroupIds.Settings, 
                StandardMenuGroupIds.SettingsSurvey,
                StandardMenuGroupIds.SiteActions, 
                StandardMenuGroupIds.Upload, 
                StandardMenuGroupIds.ViewSelector };
            listEditGroups = new List<string>() { 
                ListEditGroupIds.Communications, 
                ListEditGroupIds.GeneralSettings,
                ListEditGroupIds.Permissions };

            standardMenuGroupIdBinding = new Binding();
            standardMenuGroupIdBinding.Source = standardMenuGroups;
            listEditGroupIdBinding = new Binding();
            listEditGroupIdBinding.Source = listEditGroups;

            standardMenuGroupIdBindingView = (ListCollectionView)CollectionViewSource.GetDefaultView(standardMenuGroups);
            listEditGroupIdBindingView = (ListCollectionView)CollectionViewSource.GetDefaultView(listEditGroups);

            standardMenuRadioButton.IsChecked = true;
        }

        private void standardMenuRadioButton_Checked(object sender, RoutedEventArgs e)
        {
            BindingOperations.ClearBinding(idComboBox, ComboBox.ItemsSourceProperty);
            idComboBox.SetBinding(ComboBox.ItemsSourceProperty, standardMenuGroupIdBinding);
            standardMenuGroupIdBindingView.MoveCurrentToFirst();
        }

        private void listEditRadioButton_Checked(object sender, RoutedEventArgs e)
        {
            BindingOperations.ClearBinding(idComboBox, ComboBox.ItemsSourceProperty);
            idComboBox.SetBinding(ComboBox.ItemsSourceProperty, listEditGroupIdBinding);
            listEditGroupIdBindingView.MoveCurrentToFirst();
        }

        private void finishButton_Click(object sender, RoutedEventArgs e)
        {
            this.DialogResult = true;
            this.Close();
        }
    }
}

Implementieren des Assistenten

Definieren Sie die Funktionen des Assistenten, indem Sie die IWizard-Schnittstelle implementieren.

So implementieren Sie den Assistenten

Öffnen Sie im Projekt ItemTemplateWizard die Codedatei CustomActionWizard.

Ersetzen Sie den Code in dieser Datei durch den folgenden Code:

Imports EnvDTE
Imports Microsoft.VisualStudio.TemplateWizard
Imports System
Imports System.Collections.Generic

Public Class CustomActionWizard
    Implements IWizard

    Private wizardPage As WizardWindow

#Region "IWizard Methods"

    Public Sub RunStarted(ByVal automationObject As Object, ByVal replacementsDictionary As Dictionary(Of String, String), _
        ByVal runKind As WizardRunKind, ByVal customParams() As Object) Implements IWizard.RunStarted
        wizardPage = New WizardWindow()
        Dim dialogCompleted? As Boolean = wizardPage.ShowModal()

        If (dialogCompleted = True) Then
            PopulateReplacementDictionary(replacementsDictionary)
        Else
            Throw New WizardCancelledException()
        End If
    End Sub

    ' Always return true; this IWizard implementation throws a WizardCancelledException
    ' that is handled by Visual Studio if the user cancels the wizard.
    Public Function ShouldAddProjectItem(ByVal filePath As String) As Boolean _
        Implements IWizard.ShouldAddProjectItem
        Return True
    End Function

    ' The following IWizard methods are not implemented in this example.
    Public Sub BeforeOpeningFile(ByVal projectItem As ProjectItem) _
        Implements IWizard.BeforeOpeningFile
    End Sub

    Public Sub ProjectFinishedGenerating(ByVal project As Project) _
        Implements IWizard.ProjectFinishedGenerating
    End Sub

    Public Sub ProjectItemFinishedGenerating(ByVal projectItem As ProjectItem) _
        Implements IWizard.ProjectItemFinishedGenerating
    End Sub

    Public Sub RunFinished() Implements IWizard.RunFinished
    End Sub

#End Region

    Private Sub PopulateReplacementDictionary(ByVal replacementsDictionary As Dictionary(Of String, String))

        ' Fill in the replacement values from the UI selections on the wizard page. These values are automatically inserted
        ' into the Elements.xml file for the custom action.
        Dim locationValue As String = If(wizardPage.standardMenuRadioButton.IsChecked,
                CustomActionLocations.StandardMenu, CustomActionLocations.ListEdit)
        replacementsDictionary.Add("$LocationValue$", locationValue)
        replacementsDictionary.Add("$GroupIdValue$", CType(wizardPage.idComboBox.SelectedItem, String))
        replacementsDictionary.Add("$IdValue$", Guid.NewGuid().ToString())

        Dim titleText As String = DefaultTextBoxStrings.TitleText
        If False = String.IsNullOrEmpty(wizardPage.titleTextBox.Text) Then
            titleText = wizardPage.titleTextBox.Text
        End If

        Dim descriptionText As String = DefaultTextBoxStrings.DescriptionText
        If False = String.IsNullOrEmpty(wizardPage.descriptionTextBox.Text) Then
            descriptionText = wizardPage.descriptionTextBox.Text
        End If

        Dim urlText As String = DefaultTextBoxStrings.UrlText
        If False = String.IsNullOrEmpty(wizardPage.urlTextBox.Text) Then
            urlText = wizardPage.urlTextBox.Text
        End If

        replacementsDictionary.Add("$TitleValue$", titleText)
        replacementsDictionary.Add("$DescriptionValue$", descriptionText)
        replacementsDictionary.Add("$UrlValue$", urlText)
    End Sub
End Class

using EnvDTE;
using Microsoft.VisualStudio.TemplateWizard;
using System;
using System.Collections.Generic;

namespace ItemTemplateWizard
{
    public class CustomActionWizard : IWizard
    {
        private WizardWindow wizardPage;

        public CustomActionWizard()
        {
        }

        #region IWizard Methods

        public void RunStarted(object automationObject, Dictionary<string, string> replacementsDictionary, 
            WizardRunKind runKind, object[] customParams)
        {
            wizardPage = new WizardWindow();
            Nullable<bool> dialogCompleted = wizardPage.ShowModal();

            if (dialogCompleted == true)
            {
                PopulateReplacementDictionary(replacementsDictionary);
            }
            else
            {
                throw new WizardCancelledException();
            }
        }

        // Always return true; this IWizard implementation throws a WizardCancelledException
        // that is handled by Visual Studio if the user cancels the wizard.
        public bool ShouldAddProjectItem(string filePath)
        {
            return true;
        }

        // The following IWizard methods are not implemented in this example.
        public void BeforeOpeningFile(ProjectItem projectItem)
        {
        }

        public void ProjectFinishedGenerating(Project project)
        {
        }

        public void ProjectItemFinishedGenerating(ProjectItem projectItem)
        {
        }

        public void RunFinished()
        {
        }

        #endregion

        private void PopulateReplacementDictionary(Dictionary<string, string> replacementsDictionary)
        {
            // Fill in the replacement values from the UI selections on the wizard page. These values are automatically inserted
            // into the Elements.xml file for the custom action.
            string locationValue = (bool)wizardPage.standardMenuRadioButton.IsChecked ?
                CustomActionLocations.StandardMenu : CustomActionLocations.ListEdit;
            replacementsDictionary.Add("$LocationValue$", locationValue);
            replacementsDictionary.Add("$GroupIdValue$", (string)wizardPage.idComboBox.SelectedItem);
            replacementsDictionary.Add("$IdValue$", Guid.NewGuid().ToString());

            string titleText = DefaultTextBoxStrings.TitleText;
            if (!String.IsNullOrEmpty(wizardPage.titleTextBox.Text))
            {
                titleText = wizardPage.titleTextBox.Text;
            }

            string descriptionText = DefaultTextBoxStrings.DescriptionText;
            if (!String.IsNullOrEmpty(wizardPage.descriptionTextBox.Text))
            {
                descriptionText = wizardPage.descriptionTextBox.Text;
            }

            string urlText = DefaultTextBoxStrings.UrlText;
            if (!String.IsNullOrEmpty(wizardPage.urlTextBox.Text))
            {
                urlText = wizardPage.urlTextBox.Text;
            }

            replacementsDictionary.Add("$TitleValue$", titleText);
            replacementsDictionary.Add("$DescriptionValue$", descriptionText);
            replacementsDictionary.Add("$UrlValue$", urlText);
        }
    }
}

Checkpoint

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

So erstellen Sie das Projekt

Klicken Sie im Menü Erstellen auf Projektmappe erstellen.

Zuordnen des Assistenten zur Elementvorlage

Nach der Implementierung des Assistenten muss dieser der Elementvorlage Benutzerdefinierte Aktion zugeordnet werden. Hierzu müssen drei Hauptschritte ausgeführt werden:

Signieren der Assistenten-Assembly mit einem starkem Namen
Abrufen des öffentlichen Schlüsseltokens der Assistenten-Assembly
Hinzufügen eines Verweises auf die Assistentenassembly in der Datei VSTEMPLATE für die Elementvorlage Benutzerdefinierte Aktion

So signieren Sie die Assistenten-Assembly mit einem starkem Namen

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektknoten ItemTemplateWizard, und klicken Sie auf Eigenschaften.
Klicken Sie auf die Registerkarte Signierung.
Aktivieren Sie das Kontrollkästchen Assembly signieren.
Wählen Sie in der Dropdownliste Schlüsseldatei mit starkem Namen auswählen die Option <Neu...> aus.
Geben Sie im Dialogfeld Schlüssel für einen starken Namen erstellen einen Namen ein, und deaktivieren Sie das Kontrollkästchen Schlüsseldatei mit Kennwort schützen.
Klicken Sie auf OK.
Klicken Sie im Menü Erstellen auf Projektmappe erstellen.

So rufen Sie das öffentliche Schlüsseltoken der Assistenten-Assembly ab

Öffnen Sie das Fenster Visual Studio-Eingabeaufforderung (2010).
Führen Sie den folgenden Befehl aus. Ersetzen Sie den Pfad zur Assistenten-Assembly durch den vollständigen Pfad zur erstellten Assembly ItemTemplateWizard.dll für das Projekt ItemTemplateWizard auf dem Entwicklungscomputer.
```
sn.exe -T path to wizard assembly
```
Das öffentliche Schlüsseltoken für die Assembly ItemTemplateWizard.dll wird in das Fenster der Visual Studio-Eingabeaufforderung geschrieben.
Lassen Sie das Fenster der Visual Studio-Eingabeaufforderung geöffnet. Sie benötigen das öffentliche Schlüsseltoken während der nächsten Prozedur.

So fügen Sie einen Verweis auf die Assistenten-Assembly in der VSTEMPLATE-Datei hinzu

Erweitern Sie im Projektmappen-Explorer den Projektknoten ItemTemplate, und öffnen Sie die Datei ItemTemplate.vstemplate.
Fügen Sie das folgende WizardExtension-Element zwischen dem </TemplateContent>-Tag und dem </VSTemplate>-Tag am Ende der Datei hinzu. Ersetzen Sie den Wert von Ihr Token im PublicKeyToken-Attribut durch das öffentliche Schlüsseltoken, das Sie in der vorherigen Prozedur abgerufen haben.
```
<WizardExtension>
  <Assembly>ItemTemplateWizard, Version=1.0.0.0, Culture=neutral, PublicKeyToken=your token</Assembly>
  <FullClassName>ItemTemplateWizard.CustomActionWizard</FullClassName>
</WizardExtension>
```
Weitere Informationen über das WizardExtension-Element finden Sie unter WizardExtension-Element (Visual Studio-Vorlagen).
Speichern und schließen Sie die Datei.

Hinzufügen von ersetzbaren Parametern zur Datei Elements.xml in der Elementvorlage

Fügen Sie der Datei Elements.xml im Projekt ItemTemplate-Projekt mehrere ersetzbare Parameter hinzu. Diese Parameter werden in der PopulateReplacementDictionary-Methode in der zuvor definierten CustomActionWizard-Klasse initialisiert. Wenn ein Benutzer einem Projekt ein Projektelement Benutzerdefinierte Aktion hinzufügt, werden diese Parameter von Visual Studio in der Datei Elements.xml im neuen Projektelement automatisch durch die Werte ersetzt, die im Assistenten angegeben wurden.

Ein ersetzbarer Parameter ist ein Token, das mit einem Dollarzeichen ($) beginnt und endet. Zusätzlich zu den selbst definierten ersetzbaren Parametern können Sie auch integrierte Parameter verwenden, die vom SharePoint-Projektsystem definiert und initialisiert werden. Weitere Informationen finden Sie unter Ersetzbare Parameter.

So fügen Sie der Datei Elements.xml ersetzbare Parameter hinzu

Öffnen Sie die Datei Elements.xml im Projekt ItemTemplate.

Ersetzen Sie den Inhalt dieser Datei durch folgendes XML.

<?xml version="1.0" encoding="utf-8" ?>
<Elements Id="$guid8$" xmlns="https://schemas.microsoft.com/sharepoint/">
  <CustomAction Id="$IdValue$"
                GroupId="$GroupIdValue$"
                Location="$LocationValue$"
                Sequence="1000"
                Title="$TitleValue$"
                Description="$DescriptionValue$" >
    <UrlAction Url="$UrlValue$"/>
  </CustomAction>
</Elements>

Durch das neue XML werden die Werte der Attribute Id, GroupId, Location, Description und Url in ersetzbare Parameter geändert.

Speichern und schließen Sie die Datei.

Hinzufügen des Assistenten zum VSIX-Paket

Wenn Sie den Assistenten mit dem VSIX-Paket bereitstellen möchten, das das Projektelement enthält, fügen Sie der Datei source.extension.vsixmanifest einen Verweis auf das Assistentenprojekt im VSIX-Projekt hinzu.

So fügen Sie den Assistenten dem VSIX-Paket hinzu

Doppelklicken Sie im Projektmappen-Explorer im Projekt "CustomActionProjectItem" auf die Datei source.extension.vsixmanifest.

Die Datei wird von Visual Studio im Manifest-Editor geöffnet.
Klicken Sie im Editor im Abschnitt Inhalt auf die Schaltfläche Inhalt hinzufügen.
Wählen Sie im Dialogfeld Inhalt hinzufügen im Listenfeld Inhaltstyp auswählen die Option Vorlagen-Assistent aus.
Aktivieren Sie unter Quelle auswählen das Optionsfeld Projekt, und wählen Sie im zugehörigen Listenfeld den Eintrag ItemTemplateWizard aus.
Klicken Sie auf OK.
Klicken Sie im Menü Erstellen auf Projektmappe erstellen. Stellen Sie sicher, dass die Projektmappe fehlerfrei kompiliert werden kann.

Testen des Assistenten

Sie können den Assistenten jetzt testen. Debuggen Sie die Projektmappe CustomActionProjectItem zunächst in der experimentellen Instanz von Visual Studio. Testen Sie anschließend den Assistenten für das Projektelement Benutzerdefinierte Aktion in einem SharePoint-Projekt in der experimentellen Instanz von Visual Studio. Erstellen und führen Sie zum Schluss das SharePoint-Projekt aus, um sicherzustellen, dass die benutzerdefinierte Aktion ordnungsgemäß funktioniert.

So debuggen Sie die Projektmappe

Starten Sie Visual Studio erneut mit Administratorrechten, und öffnen Sie die Projektmappe CustomActionProjectItem.
Öffnen Sie im Projekt ItemTemplateWizard die CustomActionWizard-Codedatei, und fügen Sie der ersten Codezeile in der RunStarted-Methode einen Haltepunkt hinzu.
Klicken Sie im Menü Debuggen auf Ausnahmen.
Stellen Sie im Dialogfeld Ausnahmen sicher, dass die Kontrollkästchen Ausgelöst und Vom Benutzercode unbehandelt für Common Language Runtime-Ausnahmen deaktiviert sind.
Klicken Sie auf OK.
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\Custom Action Project Item\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 den Assistenten in Visual Studio

Zeigen Sie in der experimentellen Instanz von Visual Studio im Menü Datei auf Neu, und klicken Sie dann auf Projekt.
Erweitern Sie Visual C# oder Visual Basic (entsprechend der von der Elementvorlage unterstützten Sprache), erweitern Sie SharePoint, und klicken Sie anschließend auf 2010.
Klicken Sie in der Liste der Projektvorlagen auf Leeres Projekt.
Geben Sie im Feld Name die Zeichenfolge CustomActionWizardTest ein.
Klicken Sie auf OK.
Geben Sie im Assistenten zum Anpassen von SharePoint die URL der Website ein, die Sie zum Debuggen verwenden möchten, und klicken Sie auf Fertig stellen.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektknoten, zeigen Sie auf Hinzufügen, und klicken Sie dann auf Neues Element.
Klicken Sie im Dialogfeld Neues Element hinzufügen unter dem Knoten SharePoint auf den Knoten 2010.
Klicken Sie in der Liste der Projektelemente auf Benutzerdefinierte Aktion, und klicken Sie anschließend auf Hinzufügen.
Überprüfen Sie, ob die Codeausführung in der anderen Instanz von Visual Studio an dem Haltepunkt unterbrochen wird, den Sie zuvor in der RunStarted-Methode festgelegt haben. Drücken Sie F5, um mit dem Debuggen des Projekts fortzufahren.
Wählen Sie im Assistenten folgende Optionen aus:
- Klicken Sie unter Speicherort auf Liste bearbeiten.
- Klicken Sie unter Gruppen-ID auf Kommunikation.
- Geben Sie SharePoint Developer Center als Titel ein.
- Geben Sie Öffnet die SharePoint Developer Center-Website als Beschreibung ein.
- Geben Sie https://msdn.microsoft.com/sharepoint/default.aspx als URL ein.
Klicken Sie auf Fertig stellen.

Visual Studio fügt dem Projekt ein neues Element mit dem Namen CustomAction1 hinzu und öffnet die Datei Elements.xml im Editor. Vergewissern Sie sich, dass Elements.xml die Werte enthält, die Sie im Assistenten angegeben haben.

So testen Sie die benutzerdefinierte Aktion in SharePoint

Drücken Sie in der experimentellen Instanz von Visual Studio die Taste F5. Die benutzerdefinierte Aktion wird verpackt und auf der SharePoint-Website bereitgestellt, die in der Website-URL-Eigenschaft des Projekts angegeben ist. Im Webbrowser wird die Standardseite dieser Website geöffnet.

Tipp

Wenn das Dialogfeld Skriptdebugging deaktiviert angezeigt wird, klicken Sie auf Ja, um mit dem Debuggen des Projekts fortzufahren.
Klicken Sie im Schnellstartbereich auf Aufgaben.
Klicken Sie auf dem Menüband auf die Registerkarte Liste.
Klicken Sie in der Gruppe Einstellungen auf Listeneinstellungen.
Überprüfen Sie unter der Überschrift Kommunikation am oberen Rand der Seite, ob ein Link mit dem Text SharePoint Developer Center angezeigt wird.
Klicken Sie auf den Link SharePoint Developer Center. Überprüfen Sie, ob der Browser die Website https://msdn.microsoft.com/sharepoint/default.aspx öffnet.
Schließen Sie den Webbrowser.

Bereinigen des Entwicklungscomputers

Nachdem Sie die Tests des Projektelements abgeschlossen haben, entfernen Sie die Projektelementvorlage aus der experimentellen Instanz von Visual Studio.

So bereinigen Sie den Entwicklungscomputer

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 Custom Action Project Item und dann 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 "CustomActionProjectItem" geöffnet ist).

Siehe auch

Exemplarische Vorgehensweise: Erstellen eines Projektelements "Benutzerdefinierte Aktion" mit einer Elementvorlage, Teil 2

Vorbereitungsmaßnahmen

Erstellen des Assistentenprojekts

So erstellen Sie das Assistentenprojekt

Konfigurieren des Assistentenprojekts

So konfigurieren Sie ein Assistentenprojekt

Definieren der Standardspeicherort- und ID-Zeichenfolgen für benutzerdefinierte Aktionen

So definieren Sie die Standardspeicherort- und ID-Zeichenfolgen

Erstellen der Assistenten-Benutzeroberfläche

So erstellen Sie die Assistenten-Benutzeroberfläche

Implementieren des Assistenten

So implementieren Sie den Assistenten

Checkpoint

So erstellen Sie das Projekt

Zuordnen des Assistenten zur Elementvorlage

So signieren Sie die Assistenten-Assembly mit einem starkem Namen

So rufen Sie das öffentliche Schlüsseltoken der Assistenten-Assembly ab

So fügen Sie einen Verweis auf die Assistenten-Assembly in der VSTEMPLATE-Datei hinzu

Hinzufügen von ersetzbaren Parametern zur Datei Elements.xml in der Elementvorlage

So fügen Sie der Datei Elements.xml ersetzbare Parameter hinzu

Hinzufügen des Assistenten zum VSIX-Paket

So fügen Sie den Assistenten dem VSIX-Paket hinzu

Testen des Assistenten

So debuggen Sie die Projektmappe

So testen Sie den Assistenten in Visual Studio

So testen Sie die benutzerdefinierte Aktion in SharePoint

Bereinigen des Entwicklungscomputers

So bereinigen Sie den Entwicklungscomputer

Siehe auch

Aufgaben

Referenz

Weitere Ressourcen

Zusätzliche Ressourcen