Názorný postup: Vytvoření položky projektu sloupec webu pomocí šablony projektu, část 2

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

V tomto návodu přidáte průvodce do šablony projektu sloupec webu, která je znázorněna v Názorný postup: 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 jeho 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í typ položky projektu služby SharePoint, který je spojen se šablonou projektu.

• Definování vlastního průvodce uživatelské rozhraní, které nahrazuje vestavěné průvodce pro projekty SharePoint v aplikaci Visual Studio.

• Vytvoření dvou příkazy služby SharePoint , lze volat do místního webu služby SharePoint je spuštěn průvodce.Příkazy služby SharePoint jsou metody, které lze rozšíření aplikace 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.

• Použití nahraditelných parametrů inicializace soubory projektu SharePoint s daty, která shromažďujete v průvodci.

• Vytvoření nového souboru .snk pokaždé nový sloupec webu projektu.Tento soubor se používá k podepsání sestavení řešení SharePoint může být nasazena na globální mezipaměť sestavení (GAC) tak, aby výstup projektu.

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

[!POZNÁMKA]

Stáhnout vzorek, který obsahuje dokončené projekty, kód a další soubory v tomto návodu z následujícího umístění: https://go.microsoft.com/fwlink/?LinkId=191369.

Požadavky

Provést tento návod, musíte nejprve vytvořit řešení SiteColumnProjectItem provedením Názorný postup: 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:

• Podporované edice systému Windows, SharePoint a Visual Studio.Další informace naleznete v tématu Požadavky na vývoj řešení služby SharePoint.

• Visual Studio SDK.Tento návod používá šablonu Projekt VSIX v sadě SDK pro vytvoření balíčku VSIX k nasazení položky projektu.Další informace naleznete v tématu Rozšíření nástrojů SharePoint v aplikaci Visual Studio.

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

• Průvodci pro šablony projektu a položky v aplikaci Visual Studio.Další informace získáte v rozhraních Jak: pomocí průvodců s šablony projektů a IWizard.

• Sloupce webu služby SharePoint.Další informace naleznete v sloupce.

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	Description
Implementace průvodce	Toto je třída s názvem SiteColumnProjectWizard, která implementuje IWizard rozhraní.Toto rozhraní definuje metody, které volá Visual Studio při spuštění a dokončení a v určitých okamžicích během průvodce spustí průvodce.
Uživatelské rozhraní Průvodce	Toto je okno WPF založené, 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í uživatelské rozhraní průvodce.
Průvodce datový model	Toto je zprostředkovatelských třídu s názvem SiteColumnWizardModel, která poskytuje vrstvu mezi uživatelské rozhraní průvodce a Průvodce implementací.Tento příklad používá tuto třídu k pomoci abstraktní provádění průvodce a průvodce uživatelské rozhraní z druhé; Tato třída je povinnou součástí všech průvodců. V tomto návodu Průvodce implementací předává SiteColumnWizardModel objekt v okně Průvodce zobrazí uživatelské rozhraní průvodce.Uživatelské rozhraní Průvodce používá metody tohoto objektu uložit hodnoty ovládacích prvků uživatelského rozhraní a provádět úkoly jako ověření vstupní adresa URL platná.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žíván provádění průvodce vytvořit nový soubor key.snk v každé nové instance aplikace project.
Příkazy služby SharePoint	Jsou metody, které používá Průvodce datový model pro volání do místního webu služby SharePoint je spuštěn průvodce.Protože příkazů služby SharePoint se musí zaměřit 3.5 rozhraní.NET Framework, tyto příkazy jsou implementovány v jiném sestavení než zbývající kód průvodce.

Vytváření projektů

Chcete-li dokončit tento návod, potřebujete přidat několik projektů do SiteColumnProjectItem řešení, které jste vytvořili v Názorný postup: 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říd, který definuje 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. V Visual Studio, otevřete řešení SiteColumnProjectItem.

2. V Průzkumníku, otevřete místní nabídku pro SiteColumnProjectItem uzel řešení, zvolte Přidata pak zvolte Nový projekt.

   [!POZNÁMKA]

   V projektech Visual Basic se uzel řešení zobrazí pouze tehdy, když vždy zobrazit řešení políčko v General, Projects and Solutions, Options Dialog Box.

3. V horní části Přidat nový projekt dialogové okno pole, ujistěte se, že .NET Framework 4.5 je vybrán v seznamu verze rozhraní.NET Framework.

4. Rozbalte Visual C# uzel nebo jazyka Visual Basic uzel a zvolte Windows uzlu.

5. V seznamu šablon projektu zvolte Uživatelská řídicí knihovna WPF, název projektu ProjectTemplateWizarda pak zvolte OK tlačítko.

   Visual StudioPřidá ProjectTemplateWizard projekt do řešení a otevře soubor výchozího UserControl1.xaml.

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

Vytvoření projektu příkazů služby SharePoint

1. V Průzkumníku, otevřete místní nabídku pro uzel SiteColumnProjectItem řešení, zvolte Přidata pak zvolte Nový projekt.

2. V horní části Přidat nový projekt dialogovém okně zvolte 3.5 rozhraní.NET Framework v seznamu verze rozhraní.NET Framework.

3. Rozbalte Visual C# uzel nebo jazyka Visual Basic uzel a pak zvolte Windows uzlu.

4. Zvolte Knihovny tříd šablonu projektu, název projektu SharePointCommandsa pak zvolte OK tlačítko.

   Visual StudioPřidá SharePointCommands projekt do řešení a otevře soubor výchozího kódu Class1.

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

Konfigurace projektů

Před vytvořením průvodce, musíte přidat některé soubory kódu a odkazy na sestavení projektů.

Chcete-li nakonfigurovat projekt průvodce

1. V Průzkumníku, otevřete místní nabídku ProjectTemplateWizard uzel projektu a pak zvolte Vlastnosti.

2. V Návrháře projektu, zvolte aplikace kartu pro projekt Visual C# nebo kompilace kartu pro projekt Visual Basic.

3. Ujistěte se, zda je nastavena cílové rozhraní .NET Framework 4.5, není rozhraní .NET Framework 4.5 profilu klienta.

   Další informace naleznete v tématu Jak: cílové verzi.NET Framework.

4. Otevření místní nabídky ProjectTemplateWizard projektu, zvolte Přidata pak zvolte Nová položka.

5. Zvolte Okno (WPF) zboží, název zboží WizardWindowa pak zvolte Přidat tlačítko.

6. Přidat dva Uživatelský ovládací prvek WPF () položek do projektu a jejich Stránka1 a stránka.

7. Do projektu přidat čtyři soubory kódu a udělit jim následující názvy:

   • SiteColumnProjectWizard

   • SiteColumnWizardModel

   • ProjectSigningManager

   • CommandIds

8. Otevření místní nabídky ProjectTemplateWizard uzel projektu a pak zvolte Přidat odkaz.

9. Rozbalte sestavení uzel, zvolte rozšíření uzel a potom zaškrtněte políčka následující sestavení:

   • EnvDTE

   • Sestavení Microsoft.VisualStudio.OLE.Interop

   • Microsoft.VisualStudio.SharePoint

   • Microsoft.VisualStudio.Shell.11.0

   • Microsoft.VisualStudio.Shell.Interop.10.0

   • Microsoft.VisualStudio.Shell.Interop.11.0

   • Microsoft.VisualStudio.TemplateWizardInterface

10. Zvolte OK tlačítko Přidat sestavení do projektu.

11. V Průzkumníkupod odkazy složku ProjectTemplateWizard projektu, zvolte EnvDTE.

    [!POZNÁMKA]

    V projektech Visual Basic odkazy složky se zobrazí pouze tehdy, když vždy zobrazit řešení políčko v General, Projects and Solutions, Options Dialog Box.

12. V Vlastnosti okna, změňte hodnotu Embed Interop Types vlastnost False.

13. Pokud vyvíjíte projekt Visual Basic, importovat ProjectTemplateWizard do projektu pomocí názvů Návrháře projektu.

    Další informace naleznete v tématu Jak: Přidat nebo odebrat importovány obory názvů (Visual Basic).

Konfigurace projektu SharePointCommands

1. V Průzkumníku, zvolte SharePointCommands uzel projektu.

2. Na panelu nabídek zvolte projektu, Přidat existující položku.

3. V Přidat existující položku dialogové okno, vyhledejte složku obsahující soubory kódu projektu ProjectTemplateWizard a pak zvolte CommandIds soubor kódu.

4. Zvolte na šipku vedle Přidat tlačítko a poté zvolte Přidat jako odkaz možnost v zobrazené nabídce.

   Visual StudioPřidá do souboru kódu SharePointCommands projektu jako odkaz.Soubor kódu je umístěn v ProjectTemplateWizard projektu, ale kód v souboru je také zkompilovanou SharePointCommands projektu.

5. V SharePointCommands projektu, přidejte další soubor kódu s názvem příkazy.

6. Zvolte projekt SharePointCommands a v řádku nabídek zvolte projektu, Přidat odkaz.

7. Rozbalte sestavení uzel, zvolte rozšíření uzel a potom zaškrtněte políčka následující sestavení:

   • Microsoft.SharePoint

   • Microsoft.VisualStudio.SharePoint.Commands

8. Zvolte OK tlačítko Přidat sestavení do projektu.

Vytvoření modelu průvodce podepisování správce a ID příkazů služby SharePoint

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

• Identifikátory příkazů služby SharePoint.Tyto řetězce identifikují příkazy služby SharePoint, které průvodce používá.Dále v tomto návodu přidáte kód projektu SharePointCommands provádět příkazy.

• Průvodce datový model.

• Podpis vedoucího projektu.

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

Definovat ID příkazů služby SharePoint

• V ProjectTemplateWizard projektu otevřete soubor kódu CommandIds a celý obsah tohoto souboru nahraďte následující kód.

  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

• Otevřete soubor kódu SiteColumnWizardModel a nahradit celý obsah tohoto souboru následující kód.

  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ření podpisu vedoucího projektu

• Otevřete soubor kódu ProjectSigningManager a celý obsah tohoto souboru nahraďte následující kód.

  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řidejte XAML pro definování uživatelského rozhraní okna průvodce a dva uživatelské ovládací prvky, které poskytují uživatelské rozhraní stránky průvodce a přidejte kód pro definování chování okna a uživatelské ovládací prvky.Průvodce, který vytvoříte podobá vestavěné průvodce pro projekty SharePoint v aplikaci Visual Studio.

[!POZNÁMKA]

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

Vytvořit okno průvodce uživatelské rozhraní

1. V projektu ProjectTemplateWizard otevřete místní nabídku pro soubor WizardWindow.xaml a zvolte otevřete okno v návrháři.

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 nadpis, Grid , která obsahuje stránky průvodce 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.11.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]

   Okna, který je vytvořen v tomto jazyce XAML je odvozen z DialogWindow základní třídy.Při přidání vlastní dialogové okno WPF aplikace Visual Studio, doporučujeme odvození dialogovému oknu z této třídy mají jednotný styl s dialogových oknech Visual Studio a vyhnout se jinak může dojít k problémům modální dialogové okno.Další informace naleznete v tématu Jak: vytvoření a správa dialogová okna.

3. Pokud vyvíjíte projekt Visual Basic, odeberte ProjectTemplateWizard oboru názvů WizardWindow název třídy v x:Class atribut Window element.Tento prvek je v prvním řádku XAML.Po dokončení první řádek by měl vypadat jako následující příklad.

   <Window x:Class="WizardWindow"
   

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

5. S výjimkou nahradit obsah tohoto souboru using prohlášení v horní části souboru následujícím kódem.

   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 uživatelské rozhraní

1. V projektu ProjectTemplateWizard otevřete místní nabídku pro soubor Page1.xaml a pak zvolte otevřete otevřete uživatelského ovládacího prvku v návrháři.

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 kam mohou uživatelé zadat adresu URL místní servery, které se používají pro ladění.Uživatelské rozhraní obsahuje také přepínačů, které mohou uživatelé určit, zda je projekt v izolovaném prostoru.

   <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. S výjimkou nahradit obsah souboru Page1.xaml using prohlášení v horní části souboru následujícím kódem.

   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 uživatelské rozhraní

1. V projektu ProjectTemplateWizard otevřete místní nabídku pro soubor Page2.xaml a pak zvolte otevřete.

   Uživatelský ovládací prvek se otevře v návrháři.

2. V zobrazení jazyka XAML 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, pole se seznamem pro určení vestavěné nebo vlastní skupinu, do které chcete zobrazit sloupce 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. S výjimkou nahradit obsah souboru kódu pro soubor Page2.xaml using prohlášení v horní části souboru následujícím kódem.

   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

Definujte hlavní funkci Průvodce implementací IWizard rozhraní.Toto rozhraní definuje metody, které volá Visual Studio při spuštění a dokončení a v určitých okamžicích během průvodce spustí průvodce.

Chcete-li implementovat průvodce

1. V projektu ProjectTemplateWizard otevřete soubor kódu SiteColumnProjectWizard.

2. Nahradíte celý obsah tohoto souboru následující kód.

   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ření dvou vlastních příkazů, které volají do objektového modelu serveru SharePoint.Jeden příkaz určuje, zda je platná adresa URL webu, který uživatel zadal v průvodci.Ostatní příkaz získá všechny typy polí z určeného serveru SharePoint, takže uživatelé mohou vybrat, které z nich chcete použít jako základ pro jejich nový sloupec webu.

Chcete-li definovat příkazy služby SharePoint

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

2. Nahradíte celý obsah tohoto souboru následující kód.

   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 návodu je kód průvodce v projektu.Sestavte projekt, abyste se ujistili, že se zkompiluje bez chyb.

Chcete-li sestavit projekt

• Na panelu nabídek zvolte sestavení, Sestavit řešení.

Odebrání šablony projektu soubor key.snk

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

Odeberte soubor key.snk ze šablony projektu

1. V Průzkumníkupod SiteColumnProjectTemplate uzel, otevřete místní nabídku pro key.snk souboru a pak zvolte Odstranit.

2. V dialogovém okně potvrzení, zvolte OK tlačítko.

3. V části SiteColumnProjectTemplate uzel, otevřete soubor SiteColumnProjectTemplate.vstemplate a potom odeberte následující prvek z něj.

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

4. Soubor uložte a zavřete.

5. Pod SiteColumnProjectTemplate uzel, otevřete soubor ProjectTemplate.csproj nebo ProjectTemplate.vbproj a potom odeberte následující PropertyGroup element z něj.

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

6. Odeberte následující None prvku.

   <None Include="key.snk" />
   

7. Soubor uložte a zavřete.

Přidružení průvodce s šablonou projektu

Nyní, když máte implementovaného průvodce, musíte přidružit průvodce s Sloupec webu šablony projektu.Existují tři postupy, které je nutné provést postup:

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 šablony projektu.

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

1. V Průzkumníku, otevřete místní nabídku ProjectTemplateWizard projektu a pak zvolte Vlastnosti.

2. Na podepisování kartě vyberte podepsání sestavení políčko.

3. V Zvolit soubor obsahující klíč se silným názvem seznam, zvolte < nový... >.

4. V Vytvořit klíč silného názvu dialogové okno zadejte název pro nový soubor klíče, zrušte zaškrtnutí políčka chránit klíč souboru s heslem políčko a pak zvolte OK tlačítko.

5. Otevření místní nabídky pro ProjectTemplateWizard projektu a zvolte sestavení k vytvoření souboru ProjectTemplateWizard.dll.

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

1. Na Nabídky Start, zvolte Všechny programy, zvolte Microsoft Visual Studio 2012, zvolte Nástroje Visual Studioa pak zvolte Developer příkazového řádku pro VS2012.

   Otevře se okno Příkazový řádek Visual Studio.

2. Následující příkaz nahradí PathToWizardAssembly s úplnou cestu k sestavení vytvořené ProjectTemplateWizard.dll ProjectTemplateWizard projektu na vývojovém počítači:

   sn.exe -T PathToWizardAssembly
   

   Token veřejného klíče pro sestavení ProjectTemplateWizard.dll je zapsán 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 Průzkumníku, rozbalte SiteColumnProjectTemplate uzel projektu a otevřete soubor SiteColumnProjectTemplate.vstemplate.

2. Poblíž konec souboru přidejte následující WizardExtension mezi </TemplateContent> a </VSTemplate> značky.Nahradit tokenu hodnotu PublicKeyToken atribut s tokenem veřejného klíče, který jste získali v předchozí proceduře.

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

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

3. Soubor uložte a zavřete.

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

Přidejte několik nahraditelných parametrů do souboru Elements.xml v projektu SiteColumnProjectTemplate.Tyto parametry jsou inicializovány v metodě RunStarted v třídě SiteColumnProjectWizard, kterou jste definovali dříve.Když uživatel vytvoří sloupec webu projektu, Visual Studio automaticky nahradí tyto parametry v souboru Elements.xml v novém projektu s hodnotami, které jsou určeny 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 Nahraditelné parametry.

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

1. V projektu SiteColumnProjectTemplate nahradíte obsah souboru Elements.xml následujícím 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ích nahraditelných parametrů.

2. Soubor uložte a zavřete.

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

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

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

1. V Průzkumníkuv SiteColumnProjectItem projektu, otevřete místní nabídku pro source.extension.vsixmanifest souboru a pak zvolte otevřete.

   Visual Studio otevře soubor v editoru manifestu.

2. Na majetku kartě Editor, zvolte Nový tlačítko.

   Přidat nový majetek dialogové okno.

3. V typu seznam, zvolte Microsoft.VisualStudio.Assembly.

4. V zdroje seznam, zvolte projektu v aktuálním řešení.

5. V projektu seznam, zvolte ProjectTemplateWizarda pak zvolte OK tlačítko.

6. Na majetku kartě Editor, zvolte Nový znovu na tlačítko.

   Přidat nový majetek dialogové okno.

7. V typu seznam, zadejte SharePoint.Commands.v4.

8. V zdroje seznam, zvolte projektu v aktuálním řešení.

9. V projektu seznam, zvolte SharePointCommands projektu a poté vyberte OK tlačítko.

10. Na panelu nabídek zvolte sestavení, Sestavit řešenía ujistěte se, že řešení sestaví bez chyb.

Průvodce testováním

Nyní jste připraveni k testování průvodce.Nejprve spusťte ladění řešení SiteColumnProjectItem v experimentální instanci Visual Studio.Potom testujte průvodce pro sloupec webu projektu v experimentální instanci Visual Studio.Nakonec sestavte a spusťte projekt ověřit, že sloupce webu pracuje podle očekávání.

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

1. Restartujte aplikaci Visual Studio s pověřeními pro správu a otevřete řešení SiteColumnProjectItem.

2. V projektu ProjectTemplateWizard otevřete soubor kódu SiteColumnProjectWizard a potom přidejte zarážku do prvního řádku kódu v RunStarted metoda.

3. Na panelu nabídek zvolte ladění, výjimky.

4. V výjimky dialogové okno pole, ujistěte se, že vyvolaných a uživatelem neošetřená políčka pro Výjimky modulu CLR jsou vymazány a pak zvolte OK tlačítko.

5. Ladění pomocí příkazu Spustit F5 klíčů nebo v nabídce panelu Výběr ladění, Spuštění ladění.

   Visual Studio nainstaluje rozšíření do %UserProfile%\AppData\Local\Microsoft\VisualStudio\11.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 řádku nabídek zvolte soubor, Nový, projektu.

2. Rozbalte Visual C# uzel nebo jazyka Visual Basic rozbalte uzel (v závislosti na jazyk, který podporuje šablony projektu), SharePoint uzel a pak zvolte 2010 uzlu.

3. V seznamu šablon projektu zvolte Sloupec webu, název projektu SiteColumnWizardTesta pak zvolte OK tlačítko.

4. Ověřte, že se kód ve druhé instanci aplikace Visual Studio zastaví na zarážce, kterou jste nastavili výše v metodě RunStarted.

5. Pokračování v ladění projektu výběrem F5 klíčů nebo v nabídce panelu Výběr ladění, pokračovat.

6. V SharePoint Průvodce vlastním nastavením, zadejte adresu URL webu, který chcete použít pro ladění a pak zvolte Další tlačítko.

7. Na druhé stránce SharePoint Průvodce vlastním nastavením, proveďte následující výběry:

   • V typu seznam, zvolte Boolean.

   • V skupiny seznam, zvolte Sloupcích Logická vlastní.

   • V název zadejte sloupec Moje logická a pak zvolte Dokončit tlačítko.

   V Průzkumníku, zobrazí se nový projekt a obsahuje položky projektu s názvem pole1, a Visual Studio otevře soubor Elements.xml v editoru.

8. 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 Visual Studio vyberte klávesu F5.

   Sloupec webu je zabaleny a nasazeny do služby SharePoint Web, který Adresa URL webu určuje vlastnost projektu.Webový prohlížeč otevře výchozí stránku tohoto webu.

   [!POZNÁMKA]

   Pokud Ladění skriptů zakázáno dialogovém okně zvolte Ano tlačítko Pokračovat v ladění projektu.

2. Na Akce webu nabídce zvolte Nastavení webu.

3. Na stránce Nastavení webu v části Galerie, zvolte sloupce webu odkaz.

4. V seznamu sloupce webu, zkontrolujte, zda Sloupcích Logická vlastní skupina obsahuje sloupec s názvem Tento sloupec Logickáa pak zavřete webový prohlížeč.

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

Po dokončení testování položky projektu odeberte šablonu projektu v experimentální instanci Visual Studio.

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

1. V experimentální instanci Visual Studio v řádku nabídek zvolte Nástroje, aktualizace a rozšíření.

   Aktualizace a rozšíření dialogové okno.

2. V seznamu rozšíření zvolte Sloupec webua pak zvolte Odinstalace tlačítko.

3. V dialogovém okně, které se objeví, zvolte Ano potvrďte, že chcete odinstalovat rozšíření a pak zvolte tlačítko Restartovat nyní tlačítko dokončete odinstalaci.

4. Ukončete experimentální instanci aplikace Visual Studio a instanci Otevřete CustomActionProjectItem řešení.

   Informace o nasazení Visual Studio rozšíření, viz Zavedení rozšíření Visual Studio.

Viz také

Úkoly

Názorný postup: Vytvoření položky projektu sloupec webu pomocí šablony projektu, část 1

Jak: pomocí průvodců s šablony projektů

Referenční dokumentace

Reference schématu šablony Visual Studio

IWizard

Koncepty

Definování typů položek projektu SharePoint vlastní

Vytvoření položky šablony a šablony aplikace Project pro položky služby SharePoint projektu