Tutorial: Crear un elemento de proyecto de columna de sitio con una plantilla de proyecto, parte 2

Después de definir un tipo personalizado de elemento de proyecto de SharePoint y asociarlo a una plantilla de proyecto en Visual Studio, es posible que desee proporcionar también un asistente para la plantilla.Puede usar el asistente con el fin de recopilar información de los usuarios cuando usan la plantilla para crear un nuevo proyecto que contiene el elemento de proyecto.La información que recopile puede usarse para inicializar el elemento de proyecto.

En este tutorial, agregará un asistente a la plantilla de proyecto de columnas de sitio que se muestra en Tutorial: Crear un elemento de proyecto de columna de sitio con una plantilla de proyecto, parte 1.Cuando un usuario crea un proyecto de columna de sitio, el asistente recopila información sobre la columna de sitio (como el tipo base y el grupo) y agrega esta información al archivo Elements.xml del nuevo proyecto.

En este tutorial se muestran las siguientes tareas:

• Crear un asistente para un tipo de elemento de proyecto de SharePoint personalizado asociado a una plantilla de proyecto.

• La definición de una interfaz de usuario de asistente personalizada similar a la de los asistentes integrados para los proyectos de SharePoint con Visual Studio.

• Crear dos comandos de SharePoint que se usan para llamar al sitio de SharePoint local mientras el asistente se está ejecutando.Los comandos de SharePoint son métodos que las extensiones de Visual Studio pueden usar para llamar a las API del modelo de objetos de servidor de SharePoint.Para obtener más información, vea Llamar a los modelos de objetos de SharePoint.

• Usar parámetros reemplazables para inicializar los archivos de proyecto de SharePoint con los datos recopilados en el asistente.

• Crear un nuevo archivo .snk en cada nueva instancia de proyecto de columnas de sitio.Este archivo se usa para firmar el resultado del proyecto a fin de que el ensamblado de la solución de SharePoint se pueda implementar en la memoria caché global de ensamblados.

• Depurar y probar el asistente.

[!NOTA]

Puede descargar un ejemplo que contiene los proyectos completos, el código y otros archivos para este tutorial en la siguiente ubicación: https://go.microsoft.com/fwlink/?LinkId=191369.

Requisitos previos

Para realizar este tutorial, debe crear primero la solución SiteColumnProjectItem con el tutorial Tutorial: Crear un elemento de proyecto de columna de sitio con una plantilla de proyecto, parte 1.

También necesitará los siguientes componentes en el equipo de desarrollo para completar este tutorial:

• Ediciones compatibles de Windows, SharePoint, y Visual Studio.Para obtener más información, vea Requisitos para desarrollar soluciones de SharePoint.

• Visual Studio SDK.En este tutorial se utiliza la plantilla Proyecto VSIX del SDK para crear un paquete VSIX e implementar el elemento.Para obtener más información, vea Extender la Herramientas de SharePoint en Visual Studio.

El conocimiento de los siguientes conceptos es útil, aunque no necesario, para completar el tutorial.

• Asistentes para plantillas de elementos y proyectos de Visual Studio.Para obtener más información, vea Cómo: Utilizar los asistentes con las plantillas de proyectos y la interfaz IWizard.

• Columnas de sitio de SharePoint.Para obtener más información, vea Columnas.

Descripción de los componentes del asistente

El asistente que se muestra en este tutorial contiene varios componentes.En la tabla siguiente se describen estos componentes.

Componente	Descripción
Implementación del asistente	Esta es una clase denominada SiteColumnProjectWizard, que implementa la interfaz IWizard.Esta interfaz define los métodos que Visual Studio llama cuando el asistente se inicia y finaliza y, a veces, mientras se ejecuta.
Interfaz de usuario del asistente	Se trata de una ventana basada en WPF, denominada WizardWindow.Esta ventana incluye dos controles de usuario, denominados Page1 y Page2.Estos controles de usuario representan las dos páginas del asistente. En este tutorial, el método RunStarted de la implementación del asistente muestra la interfaz de usuario del asistente.
Modelo de datos del asistente	Esta es una clase intermediaria denominada SiteColumnWizardModel, que proporciona una capa entre la interfaz de usuario del asistente y la implementación del asistente.En este ejemplo se usa esta clase para ayudar a abstraer la implementación del asistente y la interfaz de usuario del asistente entre sí; esta clase no es un componente necesario de todos los asistentes. En este tutorial, la implementación del asistente pasa un objeto SiteColumnWizardModel a la ventana del asistente cuando muestra la interfaz de usuario del asistente.La interfaz de usuario del asistente usa los métodos de este objeto para guardar los valores de los controles de la interfaz de usuario y para realizar tareas como comprobar que la dirección URL del sitio de entrada es válido.Una vez que el usuario finaliza el asistente, la implementación del asistente usa el objeto SiteColumnWizardModel para determinar el estado final de la interfaz de usuario.
Administrador de firma de proyectos	Esta es una clase auxiliar denominada ProjectSigningManager, que se usa en la implementación del asistente para crear un nuevo archivo key.snk en cada nueva instancia de proyecto.
Comandos de SharePoint	Estos son los métodos usados por el modelo de datos del asistente para llamar al sitio de SharePoint local mientras el asistente se está ejecutando.Dado que los comandos de SharePoint deben tener .NET Framework 3.5 como destino, se implementan en un ensamblado diferente al del resto del código del asistente.

Crear los proyectos

Para completar este tutorial, debe agregar varios proyectos a la solución SiteColumnProjectItem que creó en Tutorial: Crear un elemento de proyecto de columna de sitio con una plantilla de proyecto, parte 1.

• Un proyecto WPF.Implementará la interfaz IWizard y definirá la interfaz de usuario del asistente de este proyecto.

• Un proyecto de biblioteca de clases que define los comandos de SharePoint.Este proyecto debe tener como destino .NET Framework 3.5.

Comience el tutorial creando ambos proyectos.

Para crear el proyecto de WPF

1. En Visual Studio, abra la solución SiteColumnProjectItem.

2. En Explorador de soluciones, abra el menú contextual para el nodo de la solución SiteColumnProjectItem , elija Agregary, a continuación Nuevo proyecto.

   [!NOTA]

   En los proyectos de Visual Basic, el nodo de la solución solo aparece cuando se activa la casilla Mostrar solución siempre en el General, Projects and Solutions, Options Dialog Box.

3. En la parte superior del cuadro de diálogo Agregar nuevo proyecto , asegúrese de que .NET Framework 4,5 se elige en la lista de versiones de .NET Framework.

4. Expanda el nodo Visual c# o el nodo Visual Basic , y elegir el nodo Windows .

5. En la lista de plantillas de proyecto, elija Biblioteca de controles de usuario de WPF, asigne al proyecto ProjectTemplateWizard, y elija el botón Aceptar .

   Visual Studio agrega el proyecto ProjectTemplateWizard a la solución y abre el archivo predeterminado UserControl1.xaml.

6. Elimine el archivo UserControl1.xaml del proyecto.

Para crear el proyecto Comandos de SharePoint

1. En Explorador de soluciones, abra el menú contextual para el nodo de la solución SiteColumnProjectItem, elija Agregary, a continuación Nuevo proyecto.

2. En la parte superior del cuadro de diálogo Agregar nuevo proyecto , elija .NET Framework 3.5 en la lista de versiones de .NET Framework.

3. Expanda el nodo Visual c# o el nodo Visual Basic y, a continuación el nodo Windows .

4. Elija la plantilla de proyecto Biblioteca de clases , asigne al proyecto SharePointCommands, y elija el botón Aceptar .

   Visual Studio agrega el proyecto SharePointCommands a la solución y abre el archivo de código predeterminado Class1.

5. Elimine el archivo de código Class1 del proyecto.

Configurar los proyectos

Antes de crear el asistente, debe agregar algunos archivos de código y referencias a los proyectos.

Para configurar el proyecto de asistente

1. En Explorador de soluciones, abra el menú contextual para el nodo del proyecto ProjectTemplateWizard y, a continuación Propiedades.

2. En Diseñador de proyectos, elija la ficha Aplicación para un proyecto de Visual c# o la ficha Compilar para un proyecto de Visual Basic.

3. Asegúrese de que el marco de destino está establecido en .NET Framework 4,5, no .NET Framework client profile 4,5.

   Para obtener más información, vea Cómo: Usar como destino una versión de .NET Framework.

4. Abrir el menú contextual para el proyecto ProjectTemplateWizard , elija Agregary, a continuación Nuevo elemento.

5. Elija el elemento Ventana (WPF) , llame al elemento WizardWindow, y elija el botón Agregar .

6. Agregue dos elementos Control de usuario (WPF) al proyecto, y se llama Page1 y Page2.

7. Agregue cuatro archivos de código al proyecto, y déles los nombres siguientes:

   • SiteColumnProjectWizard

   • SiteColumnWizardModel

   • ProjectSigningManager

   • CommandIds

8. Abrir el menú contextual para el nodo del proyecto ProjectTemplateWizard y, a continuación Agregar referencia.

9. Expanda el nodo Ensamblados , elija el nodo Extensiones , y seleccione las casillas situadas junto a los siguientes ensamblados:

   • EnvDTE

   • 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. Elija el botón Aceptar para agregar ensamblados al proyecto.

11. En Explorador de soluciones, bajo la carpeta Referencias para el proyecto ProjectTemplateWizard , elija EnvDTE.

    [!NOTA]

    En los proyectos de Visual Basic, la carpeta Referencias solo aparece cuando está activada la casilla Mostrar solución siempre del General, Projects and Solutions, Options Dialog Box.

12. En la ventana Propiedades , cambie el valor de la propiedad Incrustar tipos de interoperabilidad a False.

13. Si está desarrollando un proyecto de Visual Basic, importe el espacio de nombres ProjectTemplateWizard del proyecto mediante Diseñador de proyectos.

    Para obtener más información, vea Cómo: Agregar o quitar espacios de nombres importados (Visual Basic).

Para configurar el proyecto ComandosSharePoint

1. En Explorador de soluciones, elija el nodo del proyecto SharePointCommands .

2. En la barra de menú, elija Proyecto, Agregar elemento existente.

3. En el cuadro de diálogo Agregar elemento existente , vaya a la carpeta que contiene los archivos de código del proyecto ProjectTemplateWizard, y elija el archivo de código CommandIds .

4. Elija la flecha situada junto al botón Agregar , y elija la opción Agregar como vínculo en el menú que aparece.

   Visual Studio agrega el archivo de código al proyecto SharePointCommands como vínculo.El archivo de código se encuentra en el proyecto ProjectTemplateWizard , pero el código del archivo también se compila en el proyecto SharePointCommands .

5. En el proyecto SharePointCommands , agregue otro archivo de código denominado Commands.

6. Elija el proyecto SharePointCommands y, a continuación, en la barra de menú, elija Proyecto, Agregar referencia.

7. Expanda el nodo Ensamblados , elija el nodo Extensiones , y seleccione las casillas situadas junto a los siguientes ensamblados:

   • Microsoft.SharePoint

   • Microsoft.VisualStudio.SharePoint.Commands

8. Elija el botón Aceptar para agregar ensamblados al proyecto.

Crear el modelo de asistente, el administrador de firma y los identificadores de comando de SharePoint

Agregue el código al proyecto de ProjectTemplateWizard para implementar los componentes siguientes en el ejemplo:

• Los identificadores de comando de SharePoint.Estas cadenas identifican los comandos de SharePoint que el asistente utiliza.Más adelante en este tutorial, agregará código al proyecto SharePointCommands de implementar los comandos.

• El modelo de datos del asistente.

• El administrador de firma del proyecto.

Para obtener más información sobre estos componentes, vea Descripción de los componentes del asistente.

Para definir los identificadores de comando de SharePoint

• En el proyecto ProjectTemplateWizard, abra el archivo de código CommandIds y, a continuación reemplaza todo el contenido de este archivo por el código siguiente.

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

Para crear el modelo de asistente

• Abra el archivo de código SiteColumnWizardModel, y reemplaza todo el contenido de este archivo por el código siguiente.

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

Para crear el administrador de firma de proyecto

• Abra el archivo de código ProjectSigningManager, y después reemplaza todo el contenido de este archivo por el código siguiente.

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

Crear la interfaz de usuario del asistente

Agregue XAML para definir la interfaz de usuario de la ventana del asistente y los dos controles de usuario que proporcionan la interfaz de usuario para las páginas del asistente, y agregue el código para definir el comportamiento de la ventana y los controles de usuario.El asistente que crea se parece al asistente integrado para los proyectos de SharePoint en Visual Studio.

[!NOTA]

En los siguientes pasos, el proyecto tendrá algunos errores de compilación después de agregar XAML o el código al proyecto.Estos errores desaparecerán al agregar código en pasos posteriores.

Para crear la interfaz de usuario de la ventana del asistente

1. En el proyecto ProjectTemplateWizard, abra el menú contextual para el archivo WizardWindow.xaml y, a continuación Abrir para abrir la ventana del diseñador.

2. En la vista XAML del diseñador, reemplace el código XAML actual por el siguiente.El XAML define una interfaz de usuario que incluye un título, un control Grid que contiene las páginas del asistente y los botones de navegación en la parte inferior de la ventana.

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

   [!NOTA]

   La ventana que se crea en este XAML se deriva de la clase base DialogWindow .Cuando se agrega un cuadro de diálogo WPF personalizado en Visual Studio, se recomienda deriva el cuadro de diálogo de esta clase para tener un estilo coherente con otros cuadros de diálogo de Visual Studio y para evitar los problemas modales de diálogo que pueden mostrarse de otra manera.Para obtener más información, vea Cómo: Crear y administrar los cuadros de diálogo.

3. Si está desarrollando un proyecto de Visual Basic, quite el espacio de nombres ProjectTemplateWizard class name WizardWindow en el atributo x:Class de elemento Window .Este elemento es la primera línea del XAML.Cuando lo haga, la primera línea debe tener el aspecto siguiente.

   <Window x:Class="WizardWindow"
   

4. Abra el archivo de código subyacente del archivo WizardWindow.xaml.

5. Reemplace el contenido de este archivo, excepto las declaraciones using en la parte superior del archivo, con el código siguiente.

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

Para crear la interfaz de usuario de la primera página del asistente

1. En el proyecto ProjectTemplateWizard, abra el menú contextual para el archivo Page1.xaml y, a continuación Abrir para abrir el control de usuario en el diseñador.

2. En la vista XAML del diseñador, reemplace el código XAML actual por el siguiente.El XAML define una interfaz de usuario que incluye un cuadro de texto donde los usuarios pueden escribir la dirección URL de los sitios locales que desean usar para depurar.La interfaz de usuario también incluye los botones de radio con los que los usuarios pueden especificar si el proyecto es de espacio aislado.

   <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. Si está desarrollando un proyecto de Visual Basic, quite el espacio de nombres ProjectTemplateWizard del nombre de clase Page1 del atributo x:Class del elemento UserControl.Esta es la primera línea del código XAML.Cuando termine, la primera línea tendrá el aspecto siguiente:

   <UserControl x:Class="Page1"
   

4. Reemplace el contenido del archivo Page1.xaml, excepto las declaraciones using en la parte superior del archivo, con el código siguiente.

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

Para crear la interfaz de usuario de la segunda página del asistente

1. En el proyecto ProjectTemplateWizard, abra el menú contextual para el archivo Page2.xaml y, a continuación Abrir.

   Se abre el control de usuario en el diseñador.

2. En la vista XAML, reemplace el código XAML actual por el siguiente.El XAML define una interfaz de usuario que incluye una lista desplegable para elegir el tipo base de la columna de sitio, un cuadro combinado para especificar un grupo integrado o personalizado en los que se muestra la columna de sitio en la galería y un cuadro de texto para especificar el nombre de la columna de sitio.

   <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. Si está desarrollando un proyecto de Visual Basic, quite el espacio de nombres ProjectTemplateWizard del nombre de clase Page2 del atributo x:Class del elemento UserControl.Esta es la primera línea del código XAML.Cuando termine, la primera línea tendrá el aspecto siguiente:

   <UserControl x:Class="Page2"
   

4. Reemplace el contenido del código- subyacente del archivo Page2.xaml, excepto las declaraciones using en la parte superior del archivo, con el código siguiente.

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

Implementar el asistente

Para definir la funcionalidad principal del asistente, implemente la interfaz IWizard.Esta interfaz define los métodos que Visual Studio llama cuando el asistente se inicia y finaliza y, a veces, mientras se ejecuta.

Para implementar el asistente

1. En el proyecto ProjectTemplateWizard, abra el archivo de código SiteColumnProjectWizard.

2. Reemplace todo el contenido de este archivo por el código siguiente:

   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()
           {
           }
       }
   }
   

Crear los comandos de SharePoint

Cree dos comandos personalizados que llamen al modelo de objetos de servidor de SharePoint.Un comando determina si la dirección URL del sitio que el usuario escribe en el asistente es válida.El otro comando obtiene todos los tipos de campo del sitio de SharePoint especificado para que los usuarios puedan seleccionar el que desean usar como base para la nueva columna de sitio.

Para definir los comandos de SharePoint

1. En el proyecto SharePointCommands, abra el archivo de código Commands.

2. Reemplace todo el contenido de este archivo por el código siguiente:

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

Punto de control

En este punto del tutorial, todo el código del asistente está en el proyecto.Compile el proyecto para asegurarse de que se compila sin errores.

Para compilar el proyecto

• En la barra de menú, elija Generar, Compilar solución.

Quitar el archivo key.snk de la plantilla de proyecto

En el Tutorial: Crear un elemento de proyecto de columna de sitio con una plantilla de proyecto, parte 1, la plantilla de proyecto creada contiene un archivo key.snk que se usa para firmar cada instancia del proyecto de columna de sitio.Este archivo key.snk ya no es necesario porque el asistente genera ahora un nuevo archivo key.snk para cada proyecto.Quite el archivo key.snk de la plantilla de proyecto y quite las referencias a este archivo.

Para quitar el archivo key.snk de la plantilla de proyecto

1. En Explorador de soluciones, bajo el nodo SiteColumnProjectTemplate , abra el menú contextual para el archivo key.snk y, a continuación Eliminar.

2. En el cuadro de diálogo de confirmación que aparece, elija el botón Aceptar .

3. Bajo el nodo SiteColumnProjectTemplate , abra el archivo SiteColumnProjectTemplate.vstemplate, y quita el siguiente elemento de.

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

4. Guarde y cierre el archivo.

5. Bajo el nodo SiteColumnProjectTemplate , abra el archivo ProjectTemplate.csproj o ProjectTemplate.vbproj y, a continuación quitará el siguiente elemento PropertyGroup de.

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

6. Quite el siguiente elemento None.

   <None Include="key.snk" />
   

7. Guarde y cierre el archivo.

Asociar el asistente a la plantilla de proyecto

Ahora que ha implementado el asistente, debe asociarlo a la plantilla de proyecto Columna de sitio.Hay tres procedimientos principales que debe completar para ello:

1. Firmar el ensamblado del asistente con un nombre seguro.

2. Obtener el token de clave pública del ensamblado del asistente.

3. Agregue una referencia al ensamblado del asistente en el archivo .vstemplate de la plantilla de proyecto de Columna de sitio.

Para firmar el ensamblado del asistente con un nombre seguro

1. En Explorador de soluciones, abra el menú contextual para el proyecto ProjectTemplateWizard y, a continuación Propiedades.

2. En la ficha Firma, active la casilla Firmar el ensamblado.

3. En la lista Elija un archivo de clave de nombre seguro , elija <New...>.

4. En el cuadro de diálogo Crear clave de nombre seguro , escriba un nombre para el nuevo archivo de clave, desactive la casilla Proteger mi archivo de clave mediante contraseña , y elija el botón Aceptar .

5. Abrir el menú contextual para el proyecto ProjectTemplateWizard y, a continuación Generar para crear el archivo de ProjectTemplateWizard.dll.

Para obtener el token de clave pública del ensamblado del asistente

1. En Menú Inicio, elija Todos los programas, elija Microsoft Visual Studio 2012, elija Visual Studio Tools, y elija Símbolo del sistema para desarrolladores de VS2012.

   Una ventana de símbolo del sistema de Visual Studio abre.

2. Ejecute el comando siguiente, reemplazando PathToWizardAssembly con la ruta de acceso completa al ensamblado ProjectTemplateWizard.dll compilado del proyecto ProjectTemplateWizard en el equipo de desarrollo:

   sn.exe -T PathToWizardAssembly
   

   El token de clave pública del ensamblado ProjectTemplateWizard.dll se escribe en la ventana del símbolo del sistema de Visual Studio.

3. Mantenga abierta la ventana del símbolo del sistema de Visual Studio.Necesitará el token de clave pública durante el procedimiento siguiente.

Para agregar una referencia al ensamblado del asistente del archivo .vstemplate

1. En el Explorador de soluciones, expanda el nodo del proyecto SiteColumnProjectTemplate y abra el archivo SiteColumnProjectTemplate.vstemplate.

2. Cuando se acerque el final del archivo, agregue el siguiente elemento WizardExtension entre las etiquetas </TemplateContent> y </VSTemplate>.Reemplace el valor de su token del atributo PublicKeyToken por el token de clave pública que obtuvo en el procedimiento anterior.

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

   Para obtener más información sobre el elemento WizardExtension, vea WizardExtension (Elemento, Plantillas de Visual Studio).

3. Guarde y cierre el archivo.

Agregar parámetros reemplazables al archivo Elements.xml de la plantilla de proyecto

Agregue varios parámetros reemplazables al archivo Elements.xml del proyecto SiteColumnProjectTemplate.Estos parámetros se inicializan en el método RunStarted de la clase SiteColumnProjectWizard que definió anteriormente.Cuando un usuario crea un proyecto de columna de sitio, Visual Studio reemplaza automáticamente estos parámetros en el archivo Elements.xml del nuevo proyecto por los valores especificados en el asistente.

Un parámetro reemplazable es un token que empieza y termina por el carácter del signo de dólar ($).Además de definir sus propios parámetros reemplazables, puede usar los parámetros integrados que se definen y se inicializan en el sistema de proyectos de SharePoint.Para obtener más información, vea Parámetros reemplazables.

Para agregar parámetros reemplazables al archivo Elements.xml

1. En el proyecto SiteColumnProjectTemplate, reemplace el contenido del archivo Elements.xml con el XML siguiente.

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

   El nuevo XML cambia los valores de los atributos Name, DisplayName, Type y Group por parámetros reemplazables personalizados.

2. Guarde y cierre el archivo.

Agregar el asistente al paquete VSIX

Para implementar el asistente con el paquete VSIX que contiene la plantilla de proyecto de columna de sitio, agregue las referencias del proyecto de asistente y del proyecto de comandos de SharePoint al archivo source.extension.vsixmanifest del proyecto VSIX.

Para agregar el asistente al paquete VSIX

1. En Explorador de soluciones, en el proyecto SiteColumnProjectItem , abra el menú contextual para el archivo source.extension.vsixmanifest y, a continuación Abrir.

   Visual Studio abre el archivo en el editor de manifiestos.

2. En la pestaña Activos de editor, elija el botón Nuevo .

   El cuadro de diálogo Agregar nuevo activo abra.

3. En la lista Tipo , elija Microsoft.VisualStudio.Assembly.

4. En la lista Origen , elija Un proyecto de la solución actual.

5. En la lista Proyecto , elija ProjectTemplateWizard, y elija el botón Aceptar .

6. En la pestaña Activos de editor, elija el botón Nuevo de nuevo.

   El cuadro de diálogo Agregar nuevo activo abra.

7. En la lista Tipo , entre en SharePoint.Commands.v4.

8. En la lista Origen , elija Un proyecto de la solución actual.

9. En la lista Proyecto , elija el proyecto SharePointCommands , y elija el botón Aceptar .

10. En la barra de menú, elija Generar, Compilar solución, y asegúrese de que la solución se compila sin errores.

Probar el asistente

Ahora está preparado para probar el asistente.Primero, empiece a depurar la solución SiteColumnProjectItem en la instancia experimental de Visual Studio.A continuación, pruebe el asistente para el proyecto de columna de sitio en la instancia experimental de Visual Studio.Por último, compile y ejecute el proyecto para comprobar que la columna de sitio funciona del modo esperado.

Para empezar a depurar la solución

1. Reinicie Visual Studio con credenciales administrativas, y vuelva a abrir la solución SiteColumnProjectItem.

2. En el proyecto ProjectTemplateWizard, abra el archivo de código SiteColumnProjectWizard, y después agregue un punto de interrupción a la primera línea de código en el método RunStarted .

3. En la barra de menú, elija Depurar, Excepciones.

4. En el cuadro de diálogo Excepciones , asegúrese de que las casillas Producida y No controlada por el usuario para Excepciones de Common Language Runtime están desactivadas, y elija el botón Aceptar .

5. Empiece a depurar eligiendo la clave F5 o, en la barra de menús, eligiendo Depurar, Iniciar depuración.

   Visual Studio instala la extensión en %UserProfile%\AppData\Local\Microsoft\VisualStudio\11.0Exp\Extensions\Contoso\Site Column\1.0 and starts an experimental instance of Visual Studio.Probará el elemento de proyecto en esta instancia de Visual Studio.

Para probar el asistente en Visual Studio

1. En la instancia experimental de Visual Studio, en la barra de menú, elija Archivo, Nuevo, Proyecto.

2. Expanda el nodo Visual c# o el nodo Visual Basic (dependiendo del lenguaje que la plantilla de proyecto admite), expanda el nodo SharePoint y, a continuación el nodo 2010 .

3. En la lista de plantillas de proyecto, elija Columna de sitio, asigne al proyecto SiteColumnWizardTest, y elija el botón Aceptar .

4. Compruebe que el código de la otra instancia de Visual Studio se detiene en el punto de interrupción que estableció anteriormente en el método RunStarted.

5. Continuar depurando el proyecto eligiendo la clave F5 o, en la barra de menús, eligiendo Depurar, Continuar.

6. En Asistente para la personalización de SharePoint, escriba la dirección URL del sitio que desea utilizar para depurar, y elija el botón Siguiente .

7. En la segunda página del Asistente para la personalización de SharePoint, realice las selecciones siguientes:

   • En la lista Tipo , elija Booleano.

   • En la lista Agrupar , elija Columnas sí/no personalizadas.

   • En el cuadro Nombre , entre en mi columna sí/no, y elija el botón Finalizar .

   En Explorador de soluciones, aparece un nuevo proyecto y contiene un elemento de proyecto denominado Field1, y Visual Studio abre el archivo Elements.xml del proyecto en el editor.

8. Compruebe que Elements.xml contiene los valores especificados en el asistente.

Para probar la columna de sitio de SharePoint

1. En la instancia experimental de Visual Studio, elija la tecla F5.

   La columna de sitio se empaqueta e implementa en el sitio de SharePoint que la propiedad URL del sitio project especifica.El explorador web se abre en la página predeterminada de este sitio.

   [!NOTA]

   Si aparece el cuadro de diálogo Depuración de scripts deshabilitada , elija el botón Sí para continuar depurando el proyecto.

2. En el menú Acciones del sitio , elija Configuración del sitio.

3. En la página Configuración del sitio, en Galerías, elija el vínculo Columnas de sitio .

4. En la lista de columnas de sitio, compruebe que un grupo Columnas sí/no personalizadas contiene una columna denominada Mi columna sí/no, y luego cierre el explorador web.

Limpiar el equipo de desarrollo

Después de probar el elemento de proyecto, quite la plantilla de proyecto de la instancia experimental de Visual Studio.

para limpiar el equipo de desarrollo

1. En la instancia experimental de Visual Studio, en la barra de menú, elija Herramientas, Extensiones y actualizaciones.

   El cuadro de diálogo Extensiones y actualizaciones abra.

2. En la lista de extensiones, elija Columna de sitio, y elija el botón Desinstalar .

3. En el cuadro de diálogo que aparece, elija el botón Sí para confirmar que desea desinstalar la extensión, y elija el botón Reiniciar ahora para completar la desinstalación.

4. Cierre la instancia experimental de Visual Studio y la instancia en la que la solución CustomActionProjectItem está abierto.

   Para obtener información sobre cómo implementar extensiones Visual Studio , vea Implementación de extensiones de Visual Studio.

Vea también

Tareas

Tutorial: Crear un elemento de proyecto de columna de sitio con una plantilla de proyecto, parte 1

Cómo: Utilizar los asistentes con las plantillas de proyectos

Referencia

Referencia de esquema de plantillas de Visual Studio

IWizard

Conceptos

Definir tipos de elementos de proyecto personalizados de SharePoint

Crear plantillas de elemento y plantillas de proyecto para los elementos de proyecto de SharePoint