Sdílet prostřednictvím

Podrobné pokyny: Vytvoření položky projektu sloupec webu pomocí šablony projektu, část 2

  • Článek

Po definování vlastní typ projektu položky služby SharePoint a přidružit šablonu projektu v aplikaci Visual Studio, můžete také zadat šablony průvodce. Pomocí Průvodce shromažďovat informace od uživatelů při používání šablony vytvořit nový projekt, který obsahuje položku projektu. Informace, které shromažďujete, mohou sloužit k inicializaci položky projektu.

V tomto návodu bude průvodce přidat sloupec webu šablony projektu, který je znázorněn v Podrobné pokyny: Vytvoření položky projektu sloupec webu pomocí šablony projektu, část 1. Když uživatel vytvoří projekt sloupec webu, Průvodce shromažďuje informace o sloupec webu (například základní typ a skupiny) a přidá tyto informace do souboru Elements.xml v novém projektu.

Tento návod demonstruje následující úkoly:

  • Vytvoření průvodce pro vlastní typu zboží projektu SharePoint, který je spojen se šablonou projektu.

  • Definování vlastní Průvodce UI podobná vestavěných průvodců SharePoint projektů v Visual Studio 2010.

  • Vytvoření dvou SharePoint příkazy používané k volání do místního webu služby SharePoint je průvodce spuštěn. Příkazy služby SharePoint jsou metody, které lze rozšíření Visual Studio k volání rozhraní API v objektovém modelu serveru SharePoint. Další informace naleznete v tématu Volání do objektových modelů služby SharePoint.

  • Inicializace SharePoint souborů projektu pomocí Průvodce shromážděná data pomocí nahraditelné parametry.

  • Vytvoření nového souboru .snk pokaždé projektu nový sloupec webu. Tento soubor slouží k podepsání projektu výstupu tak, aby roztok sestavení služby SharePoint lze nasadit do globální mezipaměť sestavení (GAC).

  • Ladění a testování průvodce.

Poznámka

Stáhnout vzorek, který obsahuje dokončených projektů, kód a jiné soubory tohoto postupu z následujícího umístění: https://go.microsoft.com/fwlink/?LinkId=191369.

Požadavky

Chcete-li provést tento postup, musíte nejprve vytvořit řešení SiteColumnProjectItem vyplněním Podrobné pokyny: Vytvoření položky projektu sloupec webu pomocí šablony projektu, část 1.

Ve vývojovém počítači potřebujete také následující součásti pro dokončení tohoto návodu:

Znalost následujících konceptů je užitečná, ale není požadována k dokončení návodu:

Principy součásti Průvodce

Průvodce, který je znázorněn v tomto návodu obsahuje několik součástí. Následující tabulka popisuje tyto komponenty.

Součást

Popis

Průvodce implementací

Toto je třída s názvem SiteColumnProjectWizard, který implementuje IWizard rozhraní. Toto rozhraní definuje metody, které Visual Studio volá po spuštění průvodce a dokončení a v určitých časech během průvodce spuštěn.

Uživatelské rozhraní Průvodce

Je založena WPF okno, s názvem WizardWindow. Toto okno obsahuje dva ovládací prvky uživatele s názvem Page1 a Page2. Tyto ovládací prvky uživatele představují dvě stránky průvodce.

V tomto návodu RunStarted způsob provádění Průvodce zobrazí Průvodce uživatelského rozhraní.

Průvodce datový model

Jedná se o zprostředkující třídu s názvem SiteColumnWizardModel, který obsahuje vrstvu mezi Průvodce uživatelského rozhraní a implementace průvodce. V tomto příkladu je tato třída pomoci abstraktní provádění průvodce a uživatelské rozhraní Průvodce od sebe; Tato třída není povinnou součástí všech průvodců.

V tomto návodu průvodce implementací předává SiteColumnWizardModel objektu okna Průvodce zobrazí Průvodce uživatelského rozhraní. Uživatelské rozhraní Průvodce používá uložit hodnoty ovládacích prvků uživatelského rozhraní a provádět úkoly jako ověření platnou adresu URL webu vstupní metody tohoto objektu. Po dokončení Průvodce uživatele implementace Průvodce používá SiteColumnWizardModel objekt určit konečný stav uživatelského rozhraní.

Podpis vedoucího projektu

Jedná se o pomocnou třídu s názvem ProjectSigningManager, který je použit průvodce implementací pro vytvoření nového souboru key.snk na každý nový projekt instance.

Příkazy služby SharePoint

Tyto způsoby použité datový model průvodce k volání do místního webu služby SharePoint je průvodce spuštěn. Protože SharePoint příkazy musí zaměřit.NET Framework 3.5 tyto příkazy jsou implementovány v jiné než zbytek průvodce kódu sestavení.

Vytváření projektů

K dokončení tohoto postupu je třeba přidat několik projektů SiteColumnProjectItem řešení, které jste vytvořili v Podrobné pokyny: Vytvoření položky projektu sloupec webu pomocí šablony projektu, část 1:

  • Projekt WPF. Implementujete rozhraní IWizard a definujete uživatelské rozhraní průvodce v tomto projektu.

  • Projekt knihovny třídy definující příkazy služby SharePoint. Tento projekt musí zaměřit..NET Framework 3.5.

Začněte postup vytvořením projektů.

Pro vytvoření projektu WPF

  1. Otevřete v roztoku SiteColumnProjectItem Visual Studio.

  2. V Aplikaci Solution Explorer, klepněte pravým tlačítkem na uzel řešení, přejděte na Přidata klepněte na tlačítko Nový projekt.

    Poznámka

    Projekty jazyka Visual Basic v uzlu řešení zobrazeno, pouze pokud vždy zobrazit řešení políčko v Obecné, projekty a řešení, dialogové okno Možnosti.

  3. V Přidat nový projekt dialogovém okně pole, rozbalte položku Visual C# nebo Visual Basic uzly a klepněte na Windows.

  4. V poli se seznamem nahoře Přidat nový projekt dialogovém okně pole, ujistěte se, že .NET Framework 4 je zaškrtnuto.

  5. Zvolte šablonu projektu Uživatelská řídicí knihovna WPF.

  6. V název zadejte ProjectTemplateWizard.

  7. Klikněte na tlačítko OK.

    Visual StudioPřidá ProjectTemplateWizard projektu řešení.

  8. Odstraňte soubor UserControl1.xaml z projektu.

Vytvořte projekt příkazy služby SharePoint

  1. V Aplikaci Solution Explorer, klepněte pravým tlačítkem na uzel řešení, přejděte na Přidata klepněte na tlačítko Nový projekt.

  2. V Přidat nový projekt dialogovém okně pole, rozbalte položku Visual C# nebo Visual Basica klepněte na tlačítko Windows.

  3. Klepněte Knihovna tříd šablona projektu.

  4. V poli se seznamem v horní části dialogového okna zvolte Rozhraní .NET framework 3.5.

  5. V název zadejte SharePointCommands.

  6. Klikněte na tlačítko OK.

    Visual Studio, přidá SharePointCommands projektu řešení a otevře soubor výchozí kód Class1.

  7. Odstraňte soubor kódu Class1 z projektu.

Konfigurace projekty

Průvodce vytvoříte, musíte přidat některé soubory kód a odkazy na sestavení projektů.

Chcete-li nakonfigurovat projekt průvodce

  1. V Aplikaci Solution Explorer, klepněte pravým tlačítkem myši ProjectTemplateWizard projektu uzlu a potom klepněte na Vlastnosti.

  2. V Projektu Návrhář, změnit cílový rámec z.NET Framework 4 profilu klienta.NET Framework 4. V projektu Visual C#, můžete provést na aplikace karta; pro projekty jazyka Visual Basic lze provést na kompilace kartu. Další informace naleznete v tématu Postupy: Zaměření na specifickou verzi rozhraní .NET Framework nebo profil.

    Poznámka

    Ve výchozím nastavení se při vytvoření nového projektu tohoto cíle.NET Framework 4 cíle projektu profilu klienta. Tento postup vyžaduje úplné.NET Framework 4.

  3. V ProjectTemplateWizard projektu přidat nový Okno (WPF) položky projektu. Název položky WizardWindow.

  4. Přidejte dvě nové Uživatelský ovládací prvek (WPF) položky projektu. Název položky Stránka1 a postup strany Page2.

  5. Přidáte kód čtyři soubory s následujícími názvy:

    • SiteColumnProjectWizard

    • SiteColumnWizardModel

    • ProjectSigningManager

    • CommandIds

  6. V nabídce Projekt klepněte na příkaz Přidat odkaz.

  7. Na záložce .NET stiskněte klávesu CTRL klikněte na tlačítko následujících sestavení a potom klikněte na tlačítko OK:

    • EnvDTE

    • Microsoft.VisualStudio.technologie OLE.Spolupráce

    • Microsoft.VisualStudio.SharePoint

    • Microsoft.VisualStudio.Shell.10.0

    • Microsoft.VisualStudio.Shell.Interop.10.0

    • Microsoft.VisualStudio.TemplateWizardInterface

  8. V Aplikaci Solution Explorer, odkazy klepněte na složku projektu ProjectTemplateWizard EnvDTE.

    Poznámka

    Projekty jazyka Visual Basic, musíte klepnutím na Zobrazit všechny soubory tlačítka v Aplikaci Solution Explorer vidět odkazy složky.

  9. V Vlastnosti okna změnit Vložit Interop typy vlastnost False.

  10. Pokud vyvíjíte projekt aplikace Visual Basic, importovat ProjectTemplateWizard do projektu pomocí oboru názvů Návrháře projektu. Další informace naleznete v tématu Postupy: Přidat nebo odebrat importované obory názvů (Visual Basic).

Konfigurace SharePointCommands projektu

  1. V SharePointCommands projektu, přidejte kód souboru s názvem příkazy.

  2. V Aplikaci Solution Explorer, klepněte SharePointCommands projektu uzlu.

  3. V nabídce Projekt vyberte Přidat existující položku.

  4. V Přidat existující položku dialogové okno, vyhledejte složku obsahující soubory projektu ProjectTemplateWizard kód.

  5. Vyberte soubor CommandIds kód.

  6. Klepněte na rozevírací nabídku pro Přidat tlačítko a vyberte Přidat jako odkaz.

    Visual StudioPřidá kód soubor projektu SharePointCommands jako odkaz. To znamená, že kód je umístěn v ProjectTemplateWizard projektu, ale také kompilace kódu v souboru projektu SharePointCommands.

  7. V nabídce Projekt klepněte na příkaz Přidat odkaz.

  8. Na záložce .NET stiskněte klávesu CTRL a pak zvolte následující sestavení a potom klikněte na tlačítko OK:

    • Microsoft.SharePoint

    • Microsoft.VisualStudio.SharePoint.Commands

Vytvoření modelu Průvodce přihlášení správce a ID příkazu SharePoint

Přidejte kód projektu ProjectTemplateWizard ve vzorku implementovat následující součásti:

  • ID příkazu SharePoint. Jsou řetězce, které identifikují SharePoint příkazy používané průvodcem. Dále v tomto návodu přidáte kód projektu SharePointCommands provádět příkazy.

  • Průvodce datového modelu.

  • Podpis vedoucího projektu.

Další informace o těchto součástech naleznete Principy součásti Průvodce.

Definovat ID příkazu SharePoint

  1. Otevřete soubor CommandIds kód v projektu ProjectTemplateWizard.

  2. Následující kód nahradíte celý obsah tohoto souboru.

    Namespace Contoso.SharePoint.Commands
    Public Class CommandIds
        Public Const GetFieldTypes As String = "Contoso.Commands.GetFieldTypes"
        Public Const ValidateSite As String = "Contoso.Commands.ValidateSite"
    End Class
End Namespace

    namespace Contoso.SharePoint.Commands
{
    public static class CommandIds
    {
        public const string GetFieldTypes = "Contoso.Commands.GetFieldTypes";
        public const string ValidateSite = "Contoso.Commands.ValidateSite";
    }
}

Vytvoření modelu Průvodce

  1. Otevřete soubor SiteColumnWizardModel kód.

  2. Následující kód nahradíte celý obsah tohoto souboru.

    Imports EnvDTE
Imports Microsoft.VisualStudio.SharePoint
Imports Microsoft.VisualStudio
Imports Microsoft.VisualStudio.Shell
Imports Microsoft.VisualStudio.Shell.Interop
Imports IOleServiceProvider = Microsoft.VisualStudio.OLE.Interop.IServiceProvider

Public Class SiteColumnWizardModel
    Private dteObject As DTE
    Private projectServiceValue As ISharePointProjectService
    Private validatedUrls As New List(Of String)

    Friend Sub New(ByVal dteObject As DTE, ByVal requiresFarmPriveleges As Boolean)
        Me.dteObject = dteObject

        ' Initialize default values for wizard choices.
        IsSandboxed = Not requiresFarmPriveleges
        IsSecondPagePopulated = False
        FieldType = "Text"
        FieldGroup = "Custom Columns"
        FieldName = "My Custom Column"
        CurrentSiteUrl = GetLocalHostUrl()
    End Sub

#Region "Helper methods used by the wizard UI"

    ' Specifies whether the current site URL is valid. Uses the ValidateSite SharePoint command to do this.
    Friend Function ValidateCurrentUrl(ByVal errorMessage As String) As Boolean
        Dim isValid As Boolean = False
        errorMessage = String.Empty

        If validatedUrls.Contains(CurrentSiteUrl) Then
            isValid = True
        Else
            Dim uriToValidate As Uri = New Uri(CurrentSiteUrl, UriKind.Absolute)
            Dim vsThreadedWaitDialog As IVsThreadedWaitDialog2 = Nothing

            Try
                vsThreadedWaitDialog = ShowProgressDialog("Connect to SharePoint",
                    "Connecting to SharePoint site " + CurrentSiteUrl)
                isValid = Me.ProjectService.SharePointConnection.ExecuteCommand(Of Uri, Boolean)(
                    Contoso.SharePoint.Commands.CommandIds.ValidateSite, uriToValidate)
            Catch ex As Exception
                errorMessage = "An error occurred while validating the site. " + ex.Message
            Finally
                If isValid Then
                    validatedUrls.Add(CurrentSiteUrl)
                End If
                If vsThreadedWaitDialog IsNot Nothing Then
                    CloseProgressDialog(vsThreadedWaitDialog)
                End If
            End Try
        End If
        Return isValid
    End Function

    ' Gets the available field types from the SharePoint site. Uses the GetFieldTypes SharePoint command to do this.
    Friend Function GetFieldTypes() As ArrayList
        ' If we have not yet validated this site, do it now.
        Dim errorMessage As String = String.Empty
        If Not ValidateCurrentUrl(errorMessage) Then
            MessageBox.Show(String.Format("Cannot connect to the SharePoint site: {0}. {1}",
                CurrentSiteUrl, errorMessage), "SharePoint Connection Error")
            Return Nothing
        End If

        ' Site is valid, so go ahead and get the available field types.
        Dim siteUri As Uri = New Uri(CurrentSiteUrl, UriKind.Absolute)
        Dim vsThreadedWaitDialog As IVsThreadedWaitDialog2 = ShowProgressDialog(
            "Connect to SharePoint", "Connecting to SharePoint site " + CurrentSiteUrl)
        Dim fieldTypesArray As String() = Me.ProjectService.SharePointConnection.ExecuteCommand(Of Uri, String())(
            Contoso.SharePoint.Commands.CommandIds.GetFieldTypes, siteUri)

        If vsThreadedWaitDialog IsNot Nothing Then
            CloseProgressDialog(vsThreadedWaitDialog)
        End If

        Return New ArrayList(fieldTypesArray)
    End Function

    ' Returns the default column group names in SharePoint.
    Friend Function GetFieldGroups() As List(Of String)
        Dim groups As List(Of String) = New List(Of String)()
        groups.Add("Base Columns")
        groups.Add("Core Contact and Calendar Columns")
        groups.Add("Core Document Columns")
        groups.Add("Core Task and Issue Columns")
        groups.Add("Extended Columns")
        Return groups
    End Function
#End Region

#Region "Properties shared by the wizard implementation and the wizard UI"

    Friend ReadOnly Property ProjectService As ISharePointProjectService
        Get
            If projectServiceValue Is Nothing Then
                projectServiceValue = GetProjectService()
            End If
            Return projectServiceValue
        End Get
    End Property

    Friend Property IsSecondPagePopulated As Boolean
    Friend Property IsSandboxed As Boolean
    Friend Property FieldType As String
    Friend Property FieldGroup As String
    Friend Property FieldName As String
    Friend Property CurrentSiteUrl As String
#End Region

#Region "Private methods"

    Private Function GetLocalHostUrl() As String
        Const HttpScheme As String = "http"
        Dim builder As UriBuilder = New UriBuilder(HttpScheme, Environment.MachineName.ToLowerInvariant())
        Return builder.ToString()
    End Function

    Private Function GetProjectService() As ISharePointProjectService
        Dim serviceProvider As ServiceProvider = New ServiceProvider(CType(dteObject, IOleServiceProvider))
        Return CType(serviceProvider.GetService(GetType(ISharePointProjectService)), ISharePointProjectService)
    End Function

    Private Function ShowProgressDialog(ByVal caption As String, ByVal message As String) As IVsThreadedWaitDialog2
        Dim oleServiceProvider As IOleServiceProvider = CType(dteObject, IOleServiceProvider)
        Dim dialogFactory As IVsThreadedWaitDialogFactory = CType(New ServiceProvider(oleServiceProvider).GetService(
            GetType(SVsThreadedWaitDialogFactory)), IVsThreadedWaitDialogFactory)

        If dialogFactory Is Nothing Then
            Throw New InvalidOperationException("The IVsThreadedWaitDialogFactory object could not be retrieved.")
        End If

        Dim vsThreadedWaitDialog As IVsThreadedWaitDialog2 = Nothing
        ErrorHandler.ThrowOnFailure(dialogFactory.CreateInstance(vsThreadedWaitDialog))
        ErrorHandler.ThrowOnFailure(vsThreadedWaitDialog.StartWaitDialog(caption, message,
            Nothing, Nothing, String.Empty, 0, False, True))
        Return vsThreadedWaitDialog
    End Function

    Private Sub CloseProgressDialog(ByVal vsThreadedWaitDialog As IVsThreadedWaitDialog2)
        If vsThreadedWaitDialog Is Nothing Then
            Throw New ArgumentNullException("vsThreadedWaitDialog")
        End If
        Dim canceled As Integer
        ErrorHandler.ThrowOnFailure(vsThreadedWaitDialog.EndWaitDialog(canceled))
    End Sub
#End Region
End Class

    using System;
using System.Collections;
using System.Collections.Generic;
using System.Windows;
using EnvDTE;
using Microsoft.VisualStudio.SharePoint;
using Microsoft.VisualStudio;
using Microsoft.VisualStudio.Shell;
using Microsoft.VisualStudio.Shell.Interop;
using IOleServiceProvider = Microsoft.VisualStudio.OLE.Interop.IServiceProvider;

namespace ProjectTemplateWizard
{
    internal class SiteColumnWizardModel
    {
        private DTE dteObject;
        private ISharePointProjectService projectServiceValue;
        private List<string> validatedUrls = new List<string>();

        internal SiteColumnWizardModel(DTE dteObject, bool requiresFarmPriveleges)
        {
            this.dteObject = dteObject;

            // Initialize default values for wizard choices.
            IsSandboxed = !requiresFarmPriveleges;
            IsSecondPagePopulated = false;
            FieldType = "Text";
            FieldGroup = "Custom Columns";
            FieldName = "My Custom Column";
            CurrentSiteUrl = GetLocalHostUrl();
        }

        #region Helper methods used by the wizard UI

        // Specifies whether the current site URL is valid. Uses the ValidateSite SharePoint command to do this.
        internal bool ValidateCurrentUrl(out string errorMessage)
        {
            bool isValid = false;
            errorMessage = String.Empty;

            if (validatedUrls.Contains(CurrentSiteUrl))
            {
                isValid = true;
            }
            else
            {
                Uri uriToValidate = new Uri(CurrentSiteUrl, UriKind.Absolute);
                IVsThreadedWaitDialog2 vsThreadedWaitDialog = null;

                try
                {
                    vsThreadedWaitDialog = ShowProgressDialog("Connect to SharePoint",
                        "Connecting to SharePoint site " + CurrentSiteUrl);
                    isValid = this.ProjectService.SharePointConnection.ExecuteCommand<Uri, bool>(
                        Contoso.SharePoint.Commands.CommandIds.ValidateSite, uriToValidate);
                }
                catch (Exception ex)
                {
                    errorMessage = "An error occurred while validating the site. " + ex.Message;
                }
                finally
                {
                    if (isValid)
                    {
                        validatedUrls.Add(CurrentSiteUrl);
                    }

                    if (vsThreadedWaitDialog != null)
                    {
                        CloseProgressDialog(vsThreadedWaitDialog);
                    }
                }
            }

            return isValid;
        }

        // Gets the available field types from the SharePoint site. Uses the GetFieldTypes SharePoint command to do this.
        internal ArrayList GetFieldTypes()
        {
            // If we have not yet validated this site, do it now.
            string errorMessage;
            if (!ValidateCurrentUrl(out errorMessage))
            {
                MessageBox.Show(String.Format("Cannot connect to the SharePoint site: {0}. {1}",
                    CurrentSiteUrl, errorMessage), "SharePoint Connection Error");
                return null;
            }

            // Site is valid, so go ahead and get the available field types.
            Uri siteUri = new Uri(CurrentSiteUrl, UriKind.Absolute);
            IVsThreadedWaitDialog2 vsThreadedWaitDialog = ShowProgressDialog(
                "Connect to SharePoint", "Connecting to SharePoint site " + CurrentSiteUrl);
            string[] fieldTypesArray = this.ProjectService.SharePointConnection.ExecuteCommand<Uri, string[]>(
                    Contoso.SharePoint.Commands.CommandIds.GetFieldTypes, siteUri);

            if (vsThreadedWaitDialog != null)
            {
                CloseProgressDialog(vsThreadedWaitDialog);
            }

            return new ArrayList(fieldTypesArray);
        }

        // Returns the default column group names in SharePoint.
        internal List<string> GetFieldGroups()
        {
            List<string> groups = new List<string>();
            groups.Add("Base Columns");
            groups.Add("Core Contact and Calendar Columns");
            groups.Add("Core Document Columns");
            groups.Add("Core Task and Issue Columns");
            groups.Add("Extended Columns");
            return groups;
        }

        #endregion

        #region Properties shared by the wizard implementation and the wizard UI

        internal ISharePointProjectService ProjectService
        {
            get
            {
                if (projectServiceValue == null)
                {
                    projectServiceValue = GetProjectService();
                }
                return projectServiceValue;
            }
        }

        internal bool IsSecondPagePopulated { get; set; }
        internal bool IsSandboxed { get; set; }
        internal string FieldType { get; set; }
        internal string FieldGroup { get; set; }
        internal string FieldName { get; set; }
        internal string CurrentSiteUrl { get; set; }

        #endregion

        #region Private methods

        private string GetLocalHostUrl()
        {
            const string HttpScheme = "http";
            UriBuilder builder = new UriBuilder(HttpScheme, Environment.MachineName.ToLowerInvariant());
            return builder.ToString();
        }

        private ISharePointProjectService GetProjectService()
        {
            ServiceProvider serviceProvider = new ServiceProvider(dteObject as IOleServiceProvider);
            return serviceProvider.GetService(typeof(ISharePointProjectService)) as ISharePointProjectService;
        }

        private IVsThreadedWaitDialog2 ShowProgressDialog(string caption, string message)
        {
            IOleServiceProvider oleServiceProvider = dteObject as IOleServiceProvider;
            IVsThreadedWaitDialogFactory dialogFactory = new ServiceProvider(oleServiceProvider).GetService(
                typeof(SVsThreadedWaitDialogFactory)) as IVsThreadedWaitDialogFactory;

            if (dialogFactory == null)
            {
                throw new InvalidOperationException("The IVsThreadedWaitDialogFactory object could not be retrieved.");
            }

            IVsThreadedWaitDialog2 vsThreadedWaitDialog = null;
            ErrorHandler.ThrowOnFailure(dialogFactory.CreateInstance(out vsThreadedWaitDialog));
            ErrorHandler.ThrowOnFailure(vsThreadedWaitDialog.StartWaitDialog(caption, message,
                 null, null, String.Empty, 0, false, true));
            return vsThreadedWaitDialog;
        }

        private void CloseProgressDialog(IVsThreadedWaitDialog2 vsThreadedWaitDialog)
        {
            if (vsThreadedWaitDialog == null)
            {
                throw new ArgumentNullException("vsThreadedWaitDialog");
            }

            int canceled;
            ErrorHandler.ThrowOnFailure(vsThreadedWaitDialog.EndWaitDialog(out canceled));
        }

        #endregion
    }
}

Vytvořit podpis vedoucího projektu

  1. Otevřete soubor ProjectSigningManager kód.

  2. Následující kód nahradíte celý obsah tohoto souboru.

    Imports EnvDTE
Imports System
Imports System.IO
Imports System.Runtime.InteropServices

Friend Class ProjectSigningManager
    Private Const KEY_FILENAME As String = "key.snk"
    Private keyBuffer As Byte()
    Private strongNameGenerated As Boolean = False

#Region "Methods used by the project wizard"

    Friend Sub GenerateKeyFile()
        If Not strongNameGenerated Then
            keyBuffer = CreateNewKeyPair()
            strongNameGenerated = True
        End If
    End Sub

    Friend Sub AddKeyFile(ByVal project As Project)
        If strongNameGenerated Then
            AddKeyFileToProject(project)
        End If
    End Sub
#End Region

#Region "Private members"

    Private Function CreateNewKeyPair() As Byte()
        Dim buffer As IntPtr = IntPtr.Zero
        Dim bufferSize As UInteger
        Dim keyBuffer As Byte()

        Try
            If 0 = NativeMethods.StrongNameKeyGen(IntPtr.Zero, 0, buffer, bufferSize) Then
                Marshal.ThrowExceptionForHR(NativeMethods.StrongNameErrorInfo())
            End If
            If buffer = IntPtr.Zero Then
                Throw New InvalidOperationException("Cannot generate the strong name key.")
            End If

            ' Copy generated key to managed memory.
            keyBuffer = New Byte(bufferSize) {}
            Marshal.Copy(buffer, keyBuffer, 0, CInt(bufferSize))
        Finally
            ' Free native resources.
            NativeMethods.StrongNameFreeBuffer(buffer)
        End Try
        Return keyBuffer
    End Function

    Private Sub AddKeyFileToProject(ByVal project As Project)

        ' Save the key to a file.
        If keyBuffer IsNot Nothing Then
            Try
                Dim destinationDirectory As String = Path.GetDirectoryName(project.FullName)
                Dim keySavePath As String = Path.Combine(destinationDirectory, KEY_FILENAME)

                File.WriteAllBytes(keySavePath, keyBuffer)
                project.ProjectItems.AddFromFile(keySavePath)

                ' Add properties in the project to use the key for signing.
                Dim projProps As EnvDTE.Properties = project.Properties
                projProps.Item("SignAssembly").Value = True
                projProps.Item("AssemblyOriginatorKeyFile").Value = KEY_FILENAME
            Catch e As Exception
                Throw New Exception("Cannot add the strong name key to the project. " & e.Message, e)
            End Try
        End If
    End Sub

    Private Class NativeMethods
        <DllImport("mscoree.dll")>
        Friend Shared Function StrongNameFreeBuffer(ByVal pbMemory As IntPtr) As Integer
        End Function

        <DllImport("mscoree.dll", CharSet:=CharSet.Unicode, ExactSpelling:=True)>
        Friend Shared Function StrongNameKeyGen(ByVal wszKeyContainer As IntPtr, ByVal dwFlags As UInteger, _
            ByRef KeyBlob As IntPtr, ByRef KeyBlobSize As UInteger) As Integer
        End Function

        <DllImport("mscoree.dll", CharSet:=CharSet.Unicode)>
        Friend Shared Function StrongNameErrorInfo() As Integer
        End Function
    End Class
#End Region
End Class

    using EnvDTE;
using System;
using System.IO;
using System.Runtime.InteropServices;

namespace ProjectTemplateWizard
{
    internal class ProjectSigningManager
    {
        private const string KEY_FILENAME = "key.snk";
        private byte[] keyBuffer;
        private bool strongNameGenerated = false;

        #region Methods used by the project wizard

        internal void GenerateKeyFile()
        {
            if (!strongNameGenerated)
            {
                keyBuffer = CreateNewKeyPair();
                strongNameGenerated = true;
            }
        }

        internal void AddKeyFile(Project project)
        {
            if (strongNameGenerated)
            {
                AddKeyFileToProject(project);
            }
        }

        #endregion

        #region Private members

        private byte[] CreateNewKeyPair()
        {
            IntPtr buffer = IntPtr.Zero;
            uint bufferSize;
            byte[] keyBuffer;

            try
            {
                if (0 == NativeMethods.StrongNameKeyGen(IntPtr.Zero, 0, out buffer, out bufferSize))
                {
                    Marshal.ThrowExceptionForHR(NativeMethods.StrongNameErrorInfo());
                }

                if (buffer == IntPtr.Zero)
                {
                    throw new InvalidOperationException("Cannot generate the strong name key.");
                }

                // Copy generated key to managed memory.
                keyBuffer = new byte[bufferSize];
                Marshal.Copy(buffer, keyBuffer, 0, (int)bufferSize);
            }
            finally
            {
                // Free native resources.
                NativeMethods.StrongNameFreeBuffer(buffer);
            }

            return keyBuffer;
        }

        private void AddKeyFileToProject(Project project)
        {
            // Save the key to a file.
            if (keyBuffer != null)
            {
                try
                {
                    string destinationDirectory = Path.GetDirectoryName(project.FullName);
                    string keySavePath = Path.Combine(destinationDirectory, KEY_FILENAME);

                    File.WriteAllBytes(keySavePath, keyBuffer);
                    project.ProjectItems.AddFromFile(keySavePath);

                    // Add properties in the project to use the key for signing.
                    EnvDTE.Properties projProps = project.Properties;
                    projProps.Item("SignAssembly").Value = true;
                    projProps.Item("AssemblyOriginatorKeyFile").Value = KEY_FILENAME;
                }
                catch (Exception e)
                {
                    throw new Exception("Cannot add the strong name key to the project. " + e.Message, e);
                }
            }
        }

        private static class NativeMethods
        {
            [DllImport("mscoree.dll")]
            internal extern static int StrongNameFreeBuffer(IntPtr pbMemory);

            [DllImport("mscoree.dll", CharSet = CharSet.Unicode, ExactSpelling = true)]
            internal static extern int StrongNameKeyGen(IntPtr wszKeyContainer, uint dwFlags, out IntPtr KeyBlob, 
                out uint KeyBlobSize);

            [DllImport("mscoree.dll", CharSet = CharSet.Unicode)]
            internal static extern int StrongNameErrorInfo();
        }

        #endregion
    }
}

Vytvoření uživatelského rozhraní průvodce

Přidat XAML definovat uživatelské rozhraní okna průvodce a dva uživatelské ovládací prvky, které poskytují rozhraní stránky průvodce a přidat kód pro definování chování prvků okna a uživatele. Průvodce, který vytvoříte připomíná vestavěný Průvodce pro SharePoint projektů v Visual Studio 2010.

Poznámka

V následujících krocích projektu mají některé chyby kompilace po přidání XAML kód nebo projektu. Těmto chybám předejdete přidáním kódu v dalších krocích.

Vytvořit okno Průvodce UI

  1. V projektu ProjectTemplateWizard poklepejte na soubor WizardWindow.xaml v Návrháři otevřete okno.

  2. V zobrazení XAML návrháře nahraďte aktuální XAML následujícím XAML. Definuje XAML uživatelského rozhraní, který obsahuje záhlaví, Grid , který obsahuje Průvodce stránek a navigačních tlačítek v dolní části okna.

    <ui:DialogWindow x:Class="ProjectTemplateWizard.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 Height="28" HorizontalAlignment="Left" VerticalAlignment="Center" Margin="18,0,0,0" 
                   Name="headingLabel" FontWeight="ExtraBold" />
        </Grid>
        <Grid Grid.Row="1" Name="pageGrid" />
        <Rectangle Grid.Row="2" Name="separatorRectangle" Fill="White"  />
        <StackPanel Grid.Row="3" Name="navigationPanel" Orientation="Horizontal">
            <Button Content="&lt; _Previous" Margin="300,0,0,0"  Height="25" Name="previousButton" Width="85" 
                    IsEnabled="False" Click="previousButton_Click" />
            <Button Content="_Next >" Margin="10,0,0,0" Height="25" Name="nextButton" Width="85" Click="nextButton_Click" 
                    IsDefault="True" />
            <Button Content="_Finish" Margin="10,0,0,0" Height="25" Name="finishButton" Width="85" 
                    Click="finishButton_Click" />
            <Button Content="Cancel" Margin="10,0,0,0" Height="25" Name="cancelButton" Width="85" 
                    IsCancel="True" />
        </StackPanel>
    </Grid>
</ui:DialogWindow>

    Poznámka

    Okno vytvořený v tomto XAML je odvozen z DialogWindow základní třída Pokud přidáte vlastní dialogové okno WPF Visual Studio, doporučujeme odvozena od třídy mají konzistentní stylu s dialogových oknech Visual Studio a vyhnout se může jinak vyskytnout problémy modální dialogové okno dialogové okno. Další informace naleznete v tématu How to: Create and Manage Dialog Boxes.

  3. Pokud vyvíjíte projekt Visual Basic, odeberte obor názvů ProjectTemplateWizard z názvu třídy WizardWindow v atributu x:Class prvku Window. Toto je na prvním řádku XAML. Po dokončení by měl první řádek vypadat takto.

    <Window x:Class="WizardWindow"

  4. Otevřete soubor kódu pro soubor WizardWindow.xaml.

  5. Následující kód nahradíte celý obsah tohoto souboru.

    Public Class WizardWindow
    Private firstPage As Page1
    Private secondPage As Page2
    Private Const firstPageLabel As String = "Specify the site and security level for debugging"
    Private Const secondPageLabel As String = "Configure the site column"

    Friend Sub New(ByVal presentationModel As SiteColumnWizardModel)
        InitializeComponent()
        Me.PresentationModel = presentationModel
        firstPage = New Page1(Me)
        secondPage = New Page2(Me)
        secondPage.Visibility = Visibility.Hidden
    End Sub

    Friend Property PresentationModel As SiteColumnWizardModel

    Private Sub Window_Loaded(ByVal sender As Object, ByVal e As RoutedEventArgs)
        headingLabel.Content = firstPageLabel
        pageGrid.Children.Add(firstPage)
        pageGrid.Children.Add(secondPage)
    End Sub

    Private Sub nextButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)

        ' Initialize the second wizard page if this is the first time 
        ' it has been shown with the current site URL.
        If Not PresentationModel.IsSecondPagePopulated Then

            If Not ValidateUrl() Then
                Return
            End If

            ' Refresh the UI in the second page.
            secondPage.ClearControls()
            secondPage.PopulateSiteColumnOptions()

            ' Do not do this work again until the user changes the site URL.
            PresentationModel.IsSecondPagePopulated = True
        End If

        ' Display the second wizard page and update related controls.
        firstPage.Visibility = Visibility.Hidden
        secondPage.Visibility = Visibility.Visible
        previousButton.IsEnabled = True
        nextButton.IsEnabled = False
        nextButton.IsDefault = False
        finishButton.IsDefault = True
        headingLabel.Content = secondPageLabel
    End Sub

    ' Display the first wizard page again and update related controls.
    Private Sub previousButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
        secondPage.Visibility = Visibility.Hidden
        firstPage.Visibility = Visibility.Visible
        previousButton.IsEnabled = False
        finishButton.IsDefault = False
        nextButton.IsEnabled = True
        nextButton.IsDefault = True
        headingLabel.Content = firstPageLabel
    End Sub

    Private Sub finishButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
        If ValidateUrl() Then
            DialogResult = True
            Close()
        End If
    End Sub

    Private Function ValidateUrl() As Boolean
        Dim errorMessage As String = String.Empty
        If Not PresentationModel.ValidateCurrentUrl(errorMessage) Then
            MessageBox.Show(String.Format("Cannot connect to the SharePoint site: {0}. {1}",
                PresentationModel.CurrentSiteUrl, errorMessage),
                "SharePoint Connection Error")
            Return False
        End If
        Return True
    End Function
End Class

    using System;
using System.Windows;
using Microsoft.VisualStudio.PlatformUI;

namespace ProjectTemplateWizard
{
    public partial class WizardWindow : DialogWindow
    {
        private Page1 firstPage;
        private Page2 secondPage;
        private const string firstPageLabel = "Specify the site and security level for debugging";
        private const string secondPageLabel = "Configure the site column";

        internal WizardWindow(SiteColumnWizardModel presentationModel)
        {
            InitializeComponent();
            this.PresentationModel = presentationModel;
            firstPage = new Page1(this);
            secondPage = new Page2(this);
            secondPage.Visibility = Visibility.Hidden;
        }

        internal SiteColumnWizardModel PresentationModel { get; set; }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            headingLabel.Content = firstPageLabel;
            pageGrid.Children.Add(firstPage);
            pageGrid.Children.Add(secondPage);
        }

        private void nextButton_Click(object sender, RoutedEventArgs e)
        {
            // Initialize the second wizard page if this is the first time 
            // it has been shown with the current site URL.
            if (!PresentationModel.IsSecondPagePopulated)
            {
                if (!ValidateUrl())
                {
                    return;
                }

                // Refresh the UI in the second page.
                secondPage.ClearControls();
                secondPage.PopulateSiteColumnOptions();

                // Do not do this work again until the user changes the site URL.
                PresentationModel.IsSecondPagePopulated = true;
            }

            // Display the second wizard page and update related controls.
            firstPage.Visibility = Visibility.Hidden;
            secondPage.Visibility = Visibility.Visible;
            previousButton.IsEnabled = true;
            nextButton.IsEnabled = false;
            finishButton.IsDefault = true;
            headingLabel.Content = secondPageLabel;
        }

        // Display the first wizard page again and update related controls.
        private void previousButton_Click(object sender, RoutedEventArgs e)
        {
            secondPage.Visibility = Visibility.Hidden;
            firstPage.Visibility = Visibility.Visible;
            previousButton.IsEnabled = false;
            finishButton.IsDefault = false;
            nextButton.IsEnabled = true;
            nextButton.IsDefault = true;
            headingLabel.Content = firstPageLabel;
        }

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

        private bool ValidateUrl()
        {
            string errorMessage;
            if (!PresentationModel.ValidateCurrentUrl(out errorMessage))
            {
                MessageBox.Show(String.Format("Cannot connect to the SharePoint site: {0}. {1}",
                    PresentationModel.CurrentSiteUrl, errorMessage),
                    "SharePoint Connection Error");
                return false;
            }
            return true;
        }
    }
}

Vytvořte první stránku průvodce UI

  1. Poklepejte na soubor Page1.xaml v Návrháři otevřete uživatelský ovládací prvek.

  2. V zobrazení XAML návrháře nahraďte aktuální XAML následujícím XAML. Definuje XAML uživatelského rozhraní, který obsahuje textové pole, kde uživatelé mohou zadat URL místní sítě, který chtějí použít pro ladění a přepínací tlačítka pro určení, zda je projekt uzavřených apletů.

    <UserControl x:Class="ProjectTemplateWizard.Page1"
             xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="https://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="https://schemas.microsoft.com/expression/blend/2008" 
             mc:Ignorable="d" d:DesignHeight="364" d:DesignWidth="700" Loaded="UserControl_Loaded">
    <Grid Height="364" HorizontalAlignment="Left" Name="page1Grid" Width="700">
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="20*" />
            <ColumnDefinition Width="548*" />
            <ColumnDefinition Width="132*" />
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
        </Grid.RowDefinitions>
        <TextBox Grid.Row="1" Grid.Column="1" Margin="5,0,1,0" Height="23" Name="siteUrlTextBox" 
                 TextChanged="siteUrlTextBox_TextChanged" />
        <Label Grid.Row="0" Grid.Column="1" Margin="0,20,0,0" Name="siteLabel" FontWeight="Bold" 
               Target="{Binding ElementName=siteUrlTextBox}" 
               Content="What local _site do you want to use for debugging?" />
        <Button Grid.Row="1" Grid.Column="2" Content="_Validate" Height="25" Name="validateButton" 
                Width="88" Click="validateButton_Click" HorizontalAlignment="Left" 
                Margin="5,0,0,0" VerticalAlignment="Top" />
        <Label Grid.Row="2" Grid.Column="1" Margin="0,10,0,0" Content="What is the trust level for this SharePoint solution?" 
               Name="trustLabel" FontWeight="Bold" />
        <StackPanel Grid.Row="3" Grid.Column="1" Grid.ColumnSpan="2" Orientation="Vertical">
            <RadioButton Content="Deploy as a sand_boxed solution" Margin="5,0,0,0" Name="sandboxedSolutionRadioButton" 
                         FontWeight="Bold" Checked="sandboxedSolutionRadioButton_Checked" />
            <TextBlock TextWrapping="WrapWithOverflow" Margin="20,7,50,0">Clicking this option causes the solution to be 
                       deployed as a Sandboxed solution. Sandboxed solutions can be deployed by the site collection owner 
                       and are run in a secure, monitored process that has limited resource access.</TextBlock>
            <RadioButton Content="Deploy as a _farm solution" Margin="5,7,0,0" Name="farmSolutionRadioButton" FontWeight="Bold" 
                         Checked="farmSolutionRadioButton_Checked" />
            <TextBlock TextWrapping="WrapWithOverflow" Margin="20,7,50,0">Clicking this option means that users must have 
                       SharePoint administrator privileges to run or deploy the solution.</TextBlock>
        </StackPanel>
    </Grid>
</UserControl>

  3. Pokud vyvíjíte projekt Visual Basic, odeberte obor názvů ProjectTemplateWizard z názvu třídy Page1 v atributu x:Class prvku UserControl. Toto je na prvním řádku XAML. Po dokončení by měl první řádek vypadat takto.

    <UserControl x:Class="Page1"

  4. Otevřete soubor kódem na pozadí pro soubor Page1.xaml.

  5. Následující kód nahradíte celý obsah tohoto souboru.

    Public Class Page1
    Private mainWindow As WizardWindow

    Friend Sub New(ByVal mainWindow As WizardWindow)
        Me.mainWindow = mainWindow
        InitializeComponent()
    End Sub

    Private Sub UserControl_Loaded(ByVal sender As Object, ByVal e As RoutedEventArgs)
        If (mainWindow.PresentationModel.IsSandboxed) Then
            sandboxedSolutionRadioButton.IsChecked = True
        Else
            sandboxedSolutionRadioButton.IsEnabled = False
            farmSolutionRadioButton.IsChecked = True
        End If
        siteUrlTextBox.Text = mainWindow.PresentationModel.CurrentSiteUrl
    End Sub

    ' Validate that the URL exists on the development computer.
    Private Sub validateButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
        Dim errorMessage As String = String.Empty
        validateButton.IsEnabled = False

        If Not mainWindow.PresentationModel.ValidateCurrentUrl(errorMessage) Then
            MessageBox.Show(String.Format("Cannot connect to the SharePoint site: {0}. {1}",
                mainWindow.PresentationModel.CurrentSiteUrl, errorMessage),
                "SharePoint Connection Error")
        Else
            MessageBox.Show("Successfully connected to SharePoint site " +
                mainWindow.PresentationModel.CurrentSiteUrl, "Connection Successful")
        End If
        validateButton.IsEnabled = True
    End Sub

    ' Prevent users from finishing the wizard if the URL is not formatted correctly.
    Private Sub siteUrlTextBox_TextChanged(ByVal sender As Object, ByVal e As TextChangedEventArgs)
        Dim url As String = EnsureTrailingSlash(siteUrlTextBox.Text)

        ' Perform some basic error-checking on the URL here.
        If url.Length > 0 AndAlso Uri.IsWellFormedUriString(Uri.EscapeUriString(url), UriKind.Absolute) Then

            mainWindow.finishButton.IsEnabled = True
            mainWindow.nextButton.IsEnabled = True
            validateButton.IsEnabled = True
            mainWindow.PresentationModel.CurrentSiteUrl = url
            mainWindow.PresentationModel.IsSecondPagePopulated = False
        Else
            mainWindow.finishButton.IsEnabled = False
            mainWindow.nextButton.IsEnabled = False
            validateButton.IsEnabled = False
        End If
    End Sub

    Private Sub sandboxedSolutionRadioButton_Checked(ByVal sender As Object, ByVal e As RoutedEventArgs)
        mainWindow.PresentationModel.IsSandboxed = CBool(sandboxedSolutionRadioButton.IsChecked)
    End Sub

    Private Sub farmSolutionRadioButton_Checked(ByVal sender As Object, ByVal e As RoutedEventArgs)
        mainWindow.PresentationModel.IsSandboxed = CBool(sandboxedSolutionRadioButton.IsChecked)
    End Sub

    Private Function EnsureTrailingSlash(ByVal url As String)
        If Not String.IsNullOrEmpty(url) AndAlso url(url.Length - 1) <> "/" Then
            url += "/"
        End If
        Return url
    End Function
End Class

    using System;
using System.Windows;
using System.Windows.Controls;

namespace ProjectTemplateWizard
{
    public partial class Page1 : UserControl
    {
        private WizardWindow mainWindow;

        internal Page1(WizardWindow mainWindow)
        {
            this.mainWindow = mainWindow;
            InitializeComponent();
        }

        private void UserControl_Loaded(object sender, RoutedEventArgs e)
        {
            if (mainWindow.PresentationModel.IsSandboxed)
            {
                sandboxedSolutionRadioButton.IsChecked = true;
            }
            else
            {
                sandboxedSolutionRadioButton.IsEnabled = false;
                farmSolutionRadioButton.IsChecked = true;
            }

            siteUrlTextBox.Text = mainWindow.PresentationModel.CurrentSiteUrl;
        }

        // Validate that the URL exists on the development computer.
        private void validateButton_Click(object sender, RoutedEventArgs e)
        {
            string errorMessage;
            validateButton.IsEnabled = false;

            if (!mainWindow.PresentationModel.ValidateCurrentUrl(out errorMessage))
            {
                MessageBox.Show(String.Format("Cannot connect to the SharePoint site: {0}. {1}",
                    mainWindow.PresentationModel.CurrentSiteUrl, errorMessage),
                    "SharePoint Connection Error");
            }
            else
            {
                MessageBox.Show("Successfully connected to SharePoint site " +
                    mainWindow.PresentationModel.CurrentSiteUrl, "Connection Successful");
            }

            validateButton.IsEnabled = true;
        }

        // Prevent users from finishing the wizard if the URL is not formatted correctly.
        private void siteUrlTextBox_TextChanged(object sender, TextChangedEventArgs e)
        {
            string url = EnsureTrailingSlash(siteUrlTextBox.Text);

            // Perform some basic error-checking on the URL here.
            if ((url.Length > 0) && (Uri.IsWellFormedUriString(Uri.EscapeUriString(url), UriKind.Absolute)))
            {
                mainWindow.finishButton.IsEnabled = true;
                mainWindow.nextButton.IsEnabled = true;
                validateButton.IsEnabled = true;
                mainWindow.PresentationModel.CurrentSiteUrl = url;
                mainWindow.PresentationModel.IsSecondPagePopulated = false;
            }
            else
            {
                mainWindow.finishButton.IsEnabled = false;
                mainWindow.nextButton.IsEnabled = false;
                validateButton.IsEnabled = false;
            }
        }

        private void sandboxedSolutionRadioButton_Checked(object sender, RoutedEventArgs e)
        {
            mainWindow.PresentationModel.IsSandboxed = (bool)sandboxedSolutionRadioButton.IsChecked;
        }

        private void farmSolutionRadioButton_Checked(object sender, RoutedEventArgs e)
        {
            mainWindow.PresentationModel.IsSandboxed = (bool)sandboxedSolutionRadioButton.IsChecked;
        }

        private string EnsureTrailingSlash(string url)
        {
            if (!String.IsNullOrEmpty(url)
                && url[url.Length - 1] != '/')
            {
                url += '/';
            }
            return url;
        }
    }
}

Vytvoření druhé stránce průvodce UI

  1. Poklepejte na soubor Page2.xaml v Návrháři otevřete uživatelský ovládací prvek.

  2. V zobrazení XAML návrháře nahraďte aktuální XAML následujícím XAML. Definuje XAML uživatelského rozhraní, která obsahuje rozevírací seznam pro výběr základní typ sloupce webu, seznamem pro určení předdefinované nebo vlastní skupinu, do které chcete zobrazit sloupec webu v galerii a textové pole pro zadání názvu sloupce webu.

    <UserControl x:Class="ProjectTemplateWizard.Page2"
             xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="https://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="https://schemas.microsoft.com/expression/blend/2008" 
             mc:Ignorable="d" d:DesignHeight="364" d:DesignWidth="700" Loaded="UserControl_Loaded">
    <Grid Height="364" HorizontalAlignment="Left" Name="page2Grid" Width="700">
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="20*" />
            <ColumnDefinition Width="Auto" />
            <ColumnDefinition Width="450*" />
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
        </Grid.RowDefinitions>
        <Label Grid.Row="0" Grid.Column="1" Margin="0,20,0,0" Content="_Type:" Name="fieldTypeLabel" 
               FontWeight="Bold" Target="{Binding ElementName=fieldTypeComboBox}"/>
        <Label Grid.Row="1" Grid.Column="1" Margin="0,10,0,0" Content="_Group:" Name="groupLabel" 
               FontWeight="Bold" Target="{Binding ElementName=groupComboBox}"/>
        <Label Grid.Row="2" Grid.Column="1" Margin="0,10,0,0" Content="_Name:" Name="nameLabel" 
               FontWeight="Bold" Target="{Binding ElementName=nameTextBox}"/>
        <ComboBox Grid.Row="0" Grid.Column="2" HorizontalAlignment="Left" Margin="0,20,0,0" Height="23" 
                  Name="fieldTypeComboBox" Width="450" SelectionChanged="fieldTypeComboBox_SelectionChanged" />
        <ComboBox Grid.Row="1" Grid.Column="2" HorizontalAlignment="Left" Margin="0,10,0,0" Height="23" 
                  Name="groupComboBox" Width="450" IsEditable="True"  />
        <TextBox Grid.Row="2" Grid.Column="2" HorizontalAlignment="Left"  Margin="0,10,0,0" Height="23" 
                 Name="nameTextBox" Width="450" TextChanged="nameTextBox_TextChanged" />
    </Grid>
</UserControl>

  3. Pokud vyvíjíte projekt Visual Basic, odeberte obor názvů ProjectTemplateWizard z názvu třídy Page2 v atributu x:Class prvku UserControl. Toto je na prvním řádku XAML. Po dokončení by měl první řádek vypadat takto.

    <UserControl x:Class="Page2"

  4. Otevřete soubor kódem na pozadí pro soubor Page2.xaml.

  5. Následující kód nahradíte celý obsah tohoto souboru.

    Public Class Page2
    Private mainWindow As WizardWindow
    Private innerTextBoxForGroupComboBox As TextBox

    Friend Sub New(ByVal mainWindow As WizardWindow)
        Me.mainWindow = mainWindow
        InitializeComponent()
    End Sub

    Friend Sub ClearControls()
        fieldTypeComboBox.Items.Clear()
        groupComboBox.Items.Clear()
        nameTextBox.Clear()
    End Sub

    Friend Sub PopulateSiteColumnOptions()
        ' Add the available field type names to the combo box.
        Dim fieldTypes As System.Collections.ArrayList = mainWindow.PresentationModel.GetFieldTypes()
        If fieldTypes IsNot Nothing Then
            fieldTypes.Sort()
            For Each fieldValue As String In fieldTypes
                fieldTypeComboBox.Items.Add(fieldValue)
            Next
            fieldTypeComboBox.SelectedIndex = 0
        End If

        ' Add the default group names to the combo box.
        Dim fieldGroups As List(Of String) = mainWindow.PresentationModel.GetFieldGroups()
        For Each fieldGroupValue As String In fieldGroups
            groupComboBox.Items.Add(fieldGroupValue)
        Next
        groupComboBox.SelectedIndex = 0
    End Sub

    Private Sub UserControl_Loaded(ByVal sender As Object, ByVal e As RoutedEventArgs)
        ' Handle the TextChanged event of the underlying TextBox for the ComboBox. This enables us to determine 
        ' 1) when the user selects an item in the list and 2) when they type their own custom group name. 
        ' The ComboBox.SelectionChanged event is not raised when you type in an editable ComboboBox.
        innerTextBoxForGroupComboBox = CType(groupComboBox.Template.FindName(
            "PART_EditableTextBox", groupComboBox), TextBox)
        AddHandler innerTextBoxForGroupComboBox.TextChanged, AddressOf innerTextBoxForGroupComboBox_TextChanged
    End Sub

    Private Sub fieldTypeComboBox_SelectionChanged(ByVal sender As Object, ByVal e As SelectionChangedEventArgs)
        mainWindow.PresentationModel.FieldType = CStr(fieldTypeComboBox.SelectedItem)
    End Sub

    Private Sub innerTextBoxForGroupComboBox_TextChanged(ByVal sender As Object, ByVal e As TextChangedEventArgs)
        mainWindow.PresentationModel.FieldGroup = groupComboBox.Text
    End Sub

    Private Sub nameTextBox_TextChanged(ByVal sender As Object, ByVal e As TextChangedEventArgs)
        mainWindow.PresentationModel.FieldName = nameTextBox.Text
    End Sub
End Class

    using System.Windows;
using System.Windows.Controls;

namespace ProjectTemplateWizard
{
    public partial class Page2 : UserControl
    {
        private WizardWindow mainWindow;
        private TextBox innerTextBoxForGroupComboBox;

        internal Page2(WizardWindow mainWindow)
        {
            this.mainWindow = mainWindow;
            InitializeComponent();
        }

        internal void ClearControls()
        {
            fieldTypeComboBox.Items.Clear();
            groupComboBox.Items.Clear();
            nameTextBox.Clear();
        }

        internal void PopulateSiteColumnOptions()
        {
            // Add the available field type names to the combo box.
            System.Collections.ArrayList fieldTypes = mainWindow.PresentationModel.GetFieldTypes();
            if (fieldTypes != null)
            {
                fieldTypes.Sort();
                foreach (string fieldValue in fieldTypes)
                {
                    fieldTypeComboBox.Items.Add(fieldValue);
                }

                fieldTypeComboBox.SelectedIndex = 0;
            }

            // Add the default group names to the combo box.
            System.Collections.Generic.List<string> fieldGroups = mainWindow.PresentationModel.GetFieldGroups();
            foreach (string fieldGroupValue in fieldGroups)
            {
                groupComboBox.Items.Add(fieldGroupValue);
            }

            groupComboBox.SelectedIndex = 0;
        }

        private void UserControl_Loaded(object sender, RoutedEventArgs e)
        {
            // Handle the TextChanged event of the underlying TextBox for the ComboBox. This enables us to determine 
            // 1) when the user selects an item in the list and 2) when they type their own custom group name. 
            // The ComboBox.SelectionChanged event is not raised when you type in an editable ComboboBox.
            innerTextBoxForGroupComboBox = groupComboBox.Template.FindName(
                "PART_EditableTextBox", groupComboBox) as TextBox;
            innerTextBoxForGroupComboBox.TextChanged += innerTextBoxForGroupComboBox_TextChanged;
        }

        private void fieldTypeComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            mainWindow.PresentationModel.FieldType = (string)fieldTypeComboBox.SelectedItem;
        }

        void innerTextBoxForGroupComboBox_TextChanged(object sender, TextChangedEventArgs e)
        {
            mainWindow.PresentationModel.FieldGroup = groupComboBox.Text;
        }

        private void nameTextBox_TextChanged(object sender, TextChangedEventArgs e)
        {
            mainWindow.PresentationModel.FieldName = nameTextBox.Text;
        }
    }
}

Implementace průvodce

Definovat hlavní funkce průvodce implementací IWizard rozhraní. Toto rozhraní definuje metody, které Visual Studio volá po spuštění průvodce a dokončení a v určitých časech během průvodce spuštěn.

Chcete-li implementovat průvodce

  1. Otevřete soubor SiteColumnProjectWizard kód v projektu ProjectTemplateWizard.

  2. Následující kód nahradíte celý obsah tohoto souboru.

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

Public Class SiteColumnProjectWizard
    Implements IWizard

    Private wizardUI As WizardWindow
    Private dteObject As DTE
    Private presentationModel As SiteColumnWizardModel
    Private signingManager As ProjectSigningManager

    Public Sub New()
        signingManager = New ProjectSigningManager()
    End Sub

    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

        dteObject = CType(automationObject, DTE)
        presentationModel = New SiteColumnWizardModel(dteObject, False)

        If Not presentationModel.ProjectService.IsSharePointInstalled Then
            Dim errorString As String = "A SharePoint server is not installed on this computer. A SharePoint server " &
                "must be installed to work with SharePoint projects."
            System.Windows.MessageBox.Show(errorString, "SharePoint Not Installed", System.Windows.MessageBoxButton.OK,
                System.Windows.MessageBoxImage.Error)
            Throw New WizardCancelledException(errorString)
        End If

        wizardUI = New WizardWindow(presentationModel)
        Dim dialogCompleted? As Boolean = wizardUI.ShowModal()

        If (dialogCompleted = True) Then
            replacementsDictionary.Add("$selectedfieldtype$", presentationModel.FieldType)
            replacementsDictionary.Add("$selectedgrouptype$", presentationModel.FieldGroup)
            replacementsDictionary.Add("$fieldname$", presentationModel.FieldName)
            signingManager.GenerateKeyFile()
        Else
            Throw New WizardCancelledException()
        End If
    End Sub

    ' Populate the SiteUrl and IsSandboxedSolution properties in the new project, and add a new 
    ' key.snk file to the project.
    Public Sub ProjectFinishedGenerating(ByVal project As Project) _
        Implements IWizard.ProjectFinishedGenerating
        Dim sharePointProject As ISharePointProject = presentationModel.ProjectService.Convert(Of Project, ISharePointProject)(project)
        sharePointProject.SiteUrl = New Uri(presentationModel.CurrentSiteUrl, UriKind.Absolute)
        sharePointProject.IsSandboxedSolution = presentationModel.IsSandboxed
        signingManager.AddKeyFile(project)
    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 used in this example.
    Public Sub BeforeOpeningFile(ByVal projectItem As ProjectItem) _
        Implements IWizard.BeforeOpeningFile
    End Sub

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

    Public Sub RunFinished() Implements IWizard.RunFinished
    End Sub
End Class

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

namespace ProjectTemplateWizard
{
    public class SiteColumnProjectWizard : IWizard
    {
        private WizardWindow wizardUI;
        private DTE dteObject;
        private SiteColumnWizardModel presentationModel;
        private ProjectSigningManager signingManager;

        public SiteColumnProjectWizard()
        {
            signingManager = new ProjectSigningManager();
        }

        public void RunStarted(object automationObject, Dictionary<string, string> replacementsDictionary, 
            WizardRunKind runKind, object[] customParams)
        {
            dteObject = automationObject as DTE;
            presentationModel = new SiteColumnWizardModel(dteObject, false);

            if (!presentationModel.ProjectService.IsSharePointInstalled)
            {
                string errorString = "A SharePoint server is not installed on this computer. A SharePoint server " +
                    "must be installed to work with SharePoint projects.";
                System.Windows.MessageBox.Show(errorString, "SharePoint Not Installed", System.Windows.MessageBoxButton.OK,
                    System.Windows.MessageBoxImage.Error);
                throw new WizardCancelledException(errorString);
            }

            wizardUI = new WizardWindow(presentationModel);
            Nullable<bool> dialogCompleted = wizardUI.ShowModal();

            if (dialogCompleted == true)
            {
                replacementsDictionary.Add("$selectedfieldtype$", presentationModel.FieldType);
                replacementsDictionary.Add("$selectedgrouptype$", presentationModel.FieldGroup);
                replacementsDictionary.Add("$fieldname$", presentationModel.FieldName);
                signingManager.GenerateKeyFile();
            }
            else
            {
                throw new WizardCancelledException();
            }
        }

        // Populate the SiteUrl and IsSandboxedSolution properties in the new project, and add a new 
        // key.snk file to the project.
        public void ProjectFinishedGenerating(Project project)
        {
            ISharePointProject sharePointProject = presentationModel.ProjectService.Convert<Project, ISharePointProject>(project);
            sharePointProject.SiteUrl = new Uri(presentationModel.CurrentSiteUrl, UriKind.Absolute);
            sharePointProject.IsSandboxedSolution = presentationModel.IsSandboxed;
            signingManager.AddKeyFile(project);
        }

        // 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 used in this example.
        public void BeforeOpeningFile(ProjectItem projectItem)
        {
        }

        public void ProjectItemFinishedGenerating(ProjectItem projectItem)
        {
        }

        public void RunFinished()
        {
        }
    }
}

Vytváření příkazů služby SharePoint

Vytvořte dvě vlastní příkazy, které volání do objektového modelu serveru SharePoint. Jeden příkaz určuje, zda je platná adresa URL webu, uživatelem v průvodci. Tento příkaz získá všechny typy polí z určeného serveru SharePoint, takže uživatelé mohou vybrat používané jako základ pro jejich nový sloupec webu.

Definování příkazů služby SharePoint

  1. V SharePointCommands projektu, otevřete soubor příkazy kódu.

  2. Následující kód nahradíte celý obsah tohoto souboru.

    Imports Microsoft.SharePoint
Imports Microsoft.VisualStudio.SharePoint.Commands

Namespace Contoso.SharePoint.Commands

    Friend Class Commands

        <SharePointCommand(CommandIds.ValidateSite)> _
        Private Function ValidateSite(ByVal context As ISharePointCommandContext, ByVal url As Uri) As Boolean
            Using site As SPSite = New SPSite(url.AbsoluteUri)
                Dim webUrl As String = DetermineWebUrl(url.AbsolutePath, site.ServerRelativeUrl)
                If webUrl IsNot Nothing Then
                    Using web As SPWeb = site.OpenWeb(webUrl, True)
                        Return web.Exists
                    End Using
                End If
            End Using
            Return False
        End Function

        ' For simplicity, this command does not check to make sure the provided Uri is valid. 
        ' Use the ValidateSite command to verify that the Uri is valid first.
        <SharePointCommand(CommandIds.GetFieldTypes)> _
        Private Function GetFieldTypes(ByVal context As ISharePointCommandContext, ByVal url As Uri) As String()
            Dim columnDefinitions As List(Of String) = New List(Of String)()
            Using site As SPSite = New SPSite(url.AbsoluteUri)
                Dim webUrl As String = DetermineWebUrl(url.AbsolutePath, site.ServerRelativeUrl)
                Using web As SPWeb = site.OpenWeb(webUrl, True)
                    For Each columnDefinition As SPFieldTypeDefinition In web.FieldTypeDefinitionCollection
                        columnDefinitions.Add(columnDefinition.TypeName)
                    Next
                    ' SharePoint commands cannot serialize List<string>, so return an array.
                    Return columnDefinitions.ToArray()
                End Using
            End Using
        End Function

        Private Function DetermineWebUrl(ByVal serverRelativeInputUrl As String, ByVal serverRelativeSiteUrl As String) As String
            ' Make sure both URLs have a trailing slash.
            serverRelativeInputUrl = EnsureTrailingSlash(serverRelativeInputUrl)
            serverRelativeSiteUrl = EnsureTrailingSlash(serverRelativeSiteUrl)

            Dim webUrl As String = Nothing
            Dim isSubString As Boolean = serverRelativeInputUrl.StartsWith(serverRelativeSiteUrl, StringComparison.OrdinalIgnoreCase)

            If isSubString Then
                ' The Web URL cannot have escaped characters.
                webUrl = Uri.UnescapeDataString(serverRelativeInputUrl.Substring(serverRelativeSiteUrl.Length))
            End If
            Return webUrl
        End Function

        Private Function EnsureTrailingSlash(ByVal url As String)
            If Not String.IsNullOrEmpty(url) AndAlso url(url.Length - 1) <> "/" Then
                url += "/"
            End If
            Return url
        End Function
    End Class
End Namespace

    using System;
using System.Collections.Generic;
using Microsoft.SharePoint;
using Microsoft.VisualStudio.SharePoint.Commands;

namespace Contoso.SharePoint.Commands
{
    internal class Commands
    {
        [SharePointCommand(CommandIds.ValidateSite)]
        private bool ValidateSite(ISharePointCommandContext context, Uri url)
        {
            using (SPSite site = new SPSite(url.AbsoluteUri))
            {
                string webUrl = DetermineWebUrl(url.AbsolutePath, site.ServerRelativeUrl);
                if (webUrl != null)
                {
                    using (SPWeb web = site.OpenWeb(webUrl, true))
                    {
                        return web.Exists;
                    }
                }
            }

            return false;
        }

        // For simplicity, this command does not check to make sure the provided Uri is valid. 
        // Use the ValidateSite command to verify that the Uri is valid first.
        [SharePointCommand(CommandIds.GetFieldTypes)]
        private string[] GetFieldTypes(ISharePointCommandContext context, Uri url)
        {
            List<string> columnDefinitions = new List<string>();
            using (SPSite site = new SPSite(url.AbsoluteUri))
            {
                string webUrl = DetermineWebUrl(url.AbsolutePath, site.ServerRelativeUrl);
                using (SPWeb web = site.OpenWeb(webUrl, true))
                {
                    foreach (SPFieldTypeDefinition columnDefinition in web.FieldTypeDefinitionCollection)
                    {
                        columnDefinitions.Add(columnDefinition.TypeName);
                    }

                    // SharePoint commands cannot serialize List<string>, so return an array.
                    return columnDefinitions.ToArray();
                }
            }
        }

        private string DetermineWebUrl(string serverRelativeInputUrl, string serverRelativeSiteUrl)
        {
            // Make sure both URLs have a trailing slash.
            serverRelativeInputUrl = EnsureTrailingSlash(serverRelativeInputUrl);
            serverRelativeSiteUrl = EnsureTrailingSlash(serverRelativeSiteUrl);

            string webUrl = null;
            bool isSubString = serverRelativeInputUrl.StartsWith(serverRelativeSiteUrl, StringComparison.OrdinalIgnoreCase);

            if (isSubString)
            {
                // The Web URL cannot have escaped characters.
                webUrl = Uri.UnescapeDataString(serverRelativeInputUrl.Substring(serverRelativeSiteUrl.Length));
            }

            return webUrl;
        }

        private string EnsureTrailingSlash(string url)
        {
            if (!String.IsNullOrEmpty(url)
                && url[url.Length - 1] != '/')
            {
                url += '/';
            }
            return url;
        }
    }
}

Checkpoint

V tomto okamžiku v návodu, kód Průvodce je nyní v projektu. Sestavte projekt, abyste se ujistili, že se zkompiluje bez chyb.

Chcete-li sestavit projekt

  • V nabídce Sestavit zvolte Sestavit řešení.

Odebírání souboru key.snk z projektu šablony

V Podrobné pokyny: Vytvoření položky projektu sloupec webu pomocí šablony projektu, část 1, vytvořenou šablonu projektu obsahuje key.snk soubor, který je použit k podepsání projektu instance každý sloupec webu. Tento soubor key.snk již není nezbytné, protože Průvodce nyní vygeneruje nový soubor pro každý projekt key.snk. Odeberte soubor key.snk z projektu šablony a odkazy na tento soubor.

Odeberte soubor key.snk ze šablony projektu

  1. V Aplikaci Solution Explorerpod SiteColumnProjectTemplate uzel, klepněte pravým tlačítkem myši key.snk soubor a klepněte na tlačítko Odstranit. V okně zprávy s dotazem na potvrzení klepněte na tlačítko OK.

  2. Ve skupinovém rámečku SiteColumnProjectTemplate uzlu, otevřete soubor SiteColumnProjectTemplate.vstemplate.

  3. Následující prvek odeberte ze souboru.

    <ProjectItem ReplaceParameters="false" TargetFileName="key.snk">key.snk</ProjectItem>

  4. Soubor uložte a zavřete.

  5. Ve skupinovém rámečku SiteColumnProjectTemplate uzlu, otevřete soubor ProjectTemplate.csproj nebo ProjectTemplate.vbproj.

  6. Odebrat následující PropertyGroup prvku.

    <PropertyGroup>
  <SignAssembly>true</SignAssembly>
  <AssemblyOriginatorKeyFile>key.snk</AssemblyOriginatorKeyFile>
</PropertyGroup>

  7. Odebrat následující None prvku.

    <None Include="key.snk" />

  8. Soubor uložte a zavřete.

Přidružování průvodce šablonu projektu

Nyní, provádění průvodce Průvodce se musíte spojit Sloupec webu šablona projektu. Existují tři postupy, které musí provést dokončení:

  1. Podepište sestavení průvodce silným názvem.

  2. Získejte token veřejného klíče pro sestavení průvodce.

  3. Přidat odkaz na sestavení průvodce v souboru .vstemplate Sloupec webu šablona projektu.

Chcete-li podepsat sestavení průvodce silným názvem

  1. V Aplikaci Solution Explorer, klepněte pravým tlačítkem myši ProjectTemplateWizard uzlu projektu a na Vlastnosti.

  2. Klikněte na tlačítko záložky Podepisování.

  3. Označte zaškrtávací políčko Podepsání sestavení.

  4. V rozevíracím menu Zvolit soubor obsahující klíč se silným názvem zvolte Nový.

  5. V Vytvořit klíč silného názvu dialogovém okně pole, zadejte název pro nový soubor klíče a zrušte chránit klíč souboru s heslem políčko.

  6. Klikněte na tlačítko OK.

  7. V nabídce Sestavit zvolte Sestavit řešení.

Chcete-li získat token veřejného klíče pro sestavení průvodce

  1. Otevřete okno Příkazového řádku programu Visual Studio.

  2. Spusťte následující příkaz. Nahradit cestu k sestavení Průvodce s úplnou cestu k integrovanému ProjectTemplateWizard.dll sestavení projektu ProjectTemplateWizard ve vývojovém počítači.

    sn.exe -T path to wizard assembly

    Token veřejného klíče sestavení ProjectTemplateWizard.dll zapsána do okna příkazového řádku Visual Studio.

  3. Ponechejte otevřené okno příkazového řádku Visual Studio. Token veřejného klíče je nutný při další proceduře.

Chcete-li přidat odkaz na sestavení průvodce v souboru .vstemplate

  1. V Aplikaci Solution Explorer, rozbalte SiteColumnProjectTemplate projektu uzlu a otevřete soubor SiteColumnProjectTemplate.vstemplate.

  2. Poblíž konec souboru přidejte následující WizardExtension prvek mezi </TemplateContent> a </VSTemplate> značky. Nahradit tokenu hodnotu PublicKeyToken atributem token veřejného klíče v předchozím postupu.

    <WizardExtension>
  <Assembly>ProjectTemplateWizard, Version=1.0.0.0, Culture=neutral, PublicKeyToken=your token</Assembly>
  <FullClassName>ProjectTemplateWizard.SiteColumnProjectWizard</FullClassName>
</WizardExtension>

    Další informace o WizardExtension prvek, viz element WizardExtension (Visual Studio šablony).

  3. Soubor uložte a zavřete.

Přidání nahraditelných parametrů v souboru Elements.xml v šablona projektu

Přidáte několik nahraditelných parametrů v souboru Elements.xml v SiteColumnProjectTemplate projektu. Tyto parametry jsou inicializovány v metodě RunStarted v třídě SiteColumnProjectWizard, kterou jste definovali dříve. Při vytvoření sloupce webu projektu Visual Studio automaticky nahradí tyto parametry v souboru Elements.xml v novém projektu s hodnotami, které jsou specifikovány v průvodci.

Nahraditelný parametr je token, který začíná a končí znakem dolaru ($). K definování vlastních nahraditelných parametrů můžete použít předdefinované parametry, které jsou definovány a inicializovány systémem projektů služby SharePoint. Další informace naleznete v tématu Replaceable Parameters.

Chcete-li přidat nahraditelné parametry do souboru Elements.xml

  1. Otevřete soubor Elements.xml v SiteColumnProjectTemplate projektu.

  2. Nahraďte obsah tohoto souboru následujícím kódem XML.

    <?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="https://schemas.microsoft.com/sharepoint/">
  <Field ID="{$guid5$}" 
         Name="$fieldname$" 
         DisplayName="$fieldname$" 
         Type="$selectedfieldtype$" 
         Group="$selectedgrouptype$">
  </Field>
</Elements>

    Nové XML změní hodnoty Name, DisplayName, Type, a Group atributy vlastní nahraditelných parametrů.

  3. Soubor uložte a zavřete.

Přidání průvodce balíčku VSIX

Nasazení průvodce s VSIX balíček, který obsahuje sloupec webu šablonu projektu přidáte odkazy na projekt příkazy SharePoint a Průvodce projektu do souboru source.extension.vsixmanifest v VSIX projektu.

Chcete-li přidat průvodce do balíčku VSIX

  1. V Aplikaci Solution Explorer, poklepejte source.extension.vsixmanifest soubor SiteColumnProjectItem projektu.

    Visual Studio otevře soubor v editoru manifestu.

  2. V oddílu Obsah editoru klikněte na tlačítko Přidání obsahu.

  3. V dialogovém okně Přidat obsah v seznamu Volba typu obsahu zvolte Průvodce šablonou.

  4. Pod Vybrat zdroj, klepněte projektu rádiové tlačítko a vyberte ProjectTemplateWizard v seznamu vedle něj.

  5. Klikněte na tlačítko OK.

  6. V editoru manifestu znovu klikněte na tlačítko Přidání obsahu.

  7. V dialogovém okně Přidání obsahu v seznamu Zvolit typ obsahu zvolte Vlastní typ rozšíření.

    Poznámka

    Tato hodnota odpovídá CustomExtension prvku extension.vsixmanifest. Tento prvek určuje vlastní rozšíření, které chcete zahrnout v rozšíření Visual Studio. Další informace naleznete v tématu CustomExtension Element (VSX Schema).

  8. V textovém poli Typ napište SharePoint.Commands.v4.

    Poznámka

    Tato hodnota odpovídá Type atributu CustomExtension prvku extension.vsixmanifest. Hodnota Sharepoint.Commands.v4 je vyžadována pro všechny vlastní rozšíření sestavení obsahující vlastní příkazy služby SharePoint.

  9. Pod Vybrat zdroj, klepněte projektu rádiové tlačítko a vyberte SharePointCommands v seznamu vedle něj.

  10. Klikněte na tlačítko OK.

  11. V nabídce Build (Sestavit) klepněte na příkaz Build Solution (Sestavit řešení). Přesvědčte se, zda je řešení zkompilován bez chyb.

Průvodce testováním

Nyní jste připraveni k testování průvodce. Nejprve spustíte ladění SiteColumnProjectItem roztoku v experimentálních instance aplikace Visual Studio. Vyzkoušejte Průvodce pro projekt sloupec webu experimentální instance aplikace Visual Studio. Nakonec sestavit a spustit na projektu, zkontrolujte, zda sloupec webu funguje podle očekávání.

Spuštění ladění řešení

  1. Restartujte aplikaci Visual Studio s oprávněními správce a otevřete SiteColumnProjectItem roztoku.

  2. ProjectTemplateWizard projektu, otevřete soubor SiteColumnProjectWizard kód a zarážky na první řádek kódu v RunStarted metody.

  3. V nabídce Ladění klikněte na příkaz Výjimky.

  4. V dialogovém okně Výjimky se ujistěte, že zaškrtávací políčka Vyvolaná a Uživatelem neošetřená pro Výjimky modulu CLR jsou vymazána.

  5. Klepněte na tlačítko OK.

  6. Stiskněte F5 pro spuštění ladění.

    Visual Studio nainstaluje rozšíření %UserProfile%\AppData\Local\Microsoft\VisualStudio\10.0Exp\Extensions\Contoso\Site Column\1.0 a spustí experimentální instanci aplikace Visual Studio. Položku projektu budete testovat v této instanci aplikace Visual Studio.

Chcete-li otestovat průvodce v aplikaci Visual Studio

  1. V experimentální instanci Visual Studio v nabídce Soubor vyberte Nový a potom klikněte na Projekt.

  2. Rozbalte Visual C# nebo Visual Basic (v závislosti na jazyku podporuje šablona projektu), rozbalte položku SharePointa klepněte na tlačítko 2010.

  3. Klepněte v seznamu šablon projektů Sloupec webu.

  4. V název zadejte SiteColumnWizardTest.

  5. Klikněte na tlačítko OK.

  6. Ověření kódu v jiné instanci aplikace Visual Studio přestává reagovat na zarážky v dříve nastavené RunStarted metody. Stisknutím F5 pokračujte v ladění projektu.

  7. V SharePoint Průvodce přizpůsobením, zadejte adresu URL webu, který chcete použít k ladění a na Další.

  8. Na druhé stránce SharePoint Průvodce přizpůsobením, provést tyto volby:

    • Pro typu, vyberte Boolean v rozevíracím seznamu.

    • Pro skupiny, typ Vlastní sloupce Yes/No pole se seznamem.

    • Pro název, typ Tento sloupec Yes/No v textovém poli.

  9. Klepněte na tlačítko Dokončit.

    Nový projekt se objeví v Aplikaci Solution Explorer položky projektu s názvem pole1, a Visual Studio v editoru otevře soubor Elements.xml. Ověřte, zda Elements.xml obsahuje hodnoty, které jste zadali v průvodci.

Testování sloupec webu služby SharePoint

  1. V experimentální instanci aplikace Visual Studio stiskněte F5. Sloupec webu je zabalen a nasadit na web služby SharePoint, určený Adresa URL webu vlastnosti projektu. Webový prohlížeč otevře výchozí stránku tohoto webu.

    Poznámka

    Pokud Zakázáno ladění skriptu se zobrazí dialogové okno, klepněte na tlačítko Ano pokračovat v ladění projektu.

  2. V nabídce Akce webu klepněte na příkaz Nastavení webu.

  3. Pod galerií, klepněte na tlačítko sloupců webu.

  4. V seznamu sloupce webu, zkontrolujte, zda je Vlastní sloupce Yes/No skupinu, která obsahuje sloupec s názvem Tento sloupec Yes/No.

  5. Zavřete webový prohlížeč.

Čištění vývojového počítače

Po dokončení testování projektu položky odstraňte šablonu projektu z experimentálních instance aplikace Visual Studio.

Chcete-li vyčistit vývojový počítač

  1. V experimentální instanci Visual Studio v nabídce Nástroje klikněte na tlačítko Správce rozšíření.

    Otevře se okno Správce rozšíření.

  2. V seznamu přípon, klepněte na tlačítko Sloupec webua klepněte na tlačítko Odinstalace.

  3. V dialogovém okně, které se objeví, klikněte na tlačítko Ano pro potvrzení, že chcete odinstalovat rozšíření.

  4. Klikněte na Restartovat nyní pro dokonční odinstalace.

  5. Zavřete obě instance (instance experimentální a instance Visual Studio, která má otevřené řešení SiteColumnProjectItem) Visual Studio.

Viz také

Úkoly

Postupy: Použití Průvodců se šablonami projektů

Odkaz

Visual Studio šablona schéma Odkaz…

IWizard

Další zdroje

Podrobné pokyny: Vytvoření položky projektu sloupec webu pomocí šablony projektu, část 1

Definování vlastní typy položek projektu SharePoint

Vytváření položek projektu SharePoint položku šablony a šablony aplikace Project