Creare un sistema di progetto di base, parte 2

La prima procedura dettagliata di questa serie, Creare un sistema di progetto di base, parte 1, illustra come creare un sistema di progetto di base. Questa procedura dettagliata si basa sul sistema di progetto di base aggiungendo un modello di Visual Studio, una pagina delle proprietà e altre funzionalità. Prima di iniziare, è necessario completare la prima procedura dettagliata.

Questa procedura dettagliata illustra come creare un tipo di progetto con estensione myproj del file di progetto. Per completare la procedura dettagliata, non è necessario creare un linguaggio personalizzato perché la procedura dettagliata prende in prestito dal sistema di progetto Visual C# esistente.

Questa procedura dettagliata illustra come eseguire queste attività:

Creare un modello di Visual Studio.
Distribuire un modello di Visual Studio.
Creare un nodo figlio di tipo progetto nella finestra di dialogo Nuovo progetto .
Abilitare la sostituzione dei parametri nel modello di Visual Studio.
Creare una pagina delle proprietà del progetto.

Annotazioni

I passaggi di questa procedura dettagliata si basano su un progetto C#. Tuttavia, ad eccezione di specifiche come estensioni di file e codice, è possibile usare gli stessi passaggi per un progetto Visual Basic.

Creare un modello di Visual Studio

Creare un sistema di progetto di base, parte 1 illustra come creare un modello di progetto di base e aggiungerlo al sistema di progetto. Viene inoltre illustrato come registrare questo modello con Visual Studio usando l'attributo ProvideProjectFactoryAttribute , che scrive il percorso completo della cartella \Templates\Projects\SimpleProject\ nel Registro di sistema.

Usando un modello di Visual Studio (file con estensione vstemplate ) anziché un modello di progetto di base, è possibile controllare la modalità di visualizzazione del modello nella finestra di dialogo Nuovo progetto e la sostituzione dei parametri del modello. Un file con estensione vstemplate è un file XML che descrive come includere i file di origine quando viene creato un progetto usando il modello di sistema del progetto. Il sistema di progetto stesso viene compilato raccogliendo il file vstemplate e i file di origine in un file .zip e distribuiti copiando il file .zip in un percorso noto in Visual Studio. Questo processo viene illustrato in modo più dettagliato più avanti in questa procedura dettagliata.

In Visual Studio aprire la soluzione SimpleProject creata seguendo Creare un sistema di progetto di base, parte 1.
Nel file SimpleProjectPackage.cs trovare l'attributo ProvideProjectFactory. Sostituire il secondo parametro (il nome del progetto) con null e il quarto parametro (il percorso della cartella del modello di progetto) con ".\\NullPath", come indicato di seguito.
```
[ProvideProjectFactory(typeof(SimpleProjectFactory), null,
    "Simple Project Files (*.myproj);*.myproj", "myproj", "myproj",
    ".\\NullPath",
LanguageVsTemplate = "SimpleProject")]
```
Aggiungere un file XML denominato SimpleProject.vstemplate alla cartella \Templates\Projects\SimpleProject\ .

Sostituire il contenuto di SimpleProject.vstemplate con il codice seguente.

<VSTemplate Version="2.0.0" Type="Project"
    xmlns="http://schemas.microsoft.com/developer/vstemplate/2005">
  <TemplateData>
    <Name>SimpleProject Application</Name>
    <Description>
      A project for creating a SimpleProject application
    </Description>
    <Icon>SimpleProject.ico</Icon>
    <ProjectType>SimpleProject</ProjectType>
  </TemplateData>
  <TemplateContent>
    <Project File="SimpleProject.myproj" ReplaceParameters="true">
      <ProjectItem ReplaceParameters="true" OpenInEditor="true">
        Program.cs
      </ProjectItem>
      <ProjectItem ReplaceParameters="true" OpenInEditor="false">
        AssemblyInfo.cs
      </ProjectItem>
    </Project>
  </TemplateContent>
</VSTemplate>

Nella finestra Proprietà selezionare tutti e cinque i file nella cartella \Templates\Projects\SimpleProject\ e impostare Azione di compilazione su ZipProject.

La <sezione TemplateData> determina la posizione e l'aspetto del tipo di progetto SimpleProject nella finestra di dialogo Nuovo progetto , come indicato di seguito:

L'elemento <Name> denomina il modello di progetto come SimpleProject Application.
L'elemento <Description> contiene la descrizione visualizzata nella finestra di dialogo Nuovo progetto quando viene selezionato il modello di progetto.
L'elemento <Icon> specifica l'icona visualizzata insieme al tipo di progetto SimpleProject.
L'elemento <ProjectType> assegna un nome al tipo Project nella finestra di dialogo Nuovo progetto . Questo nome sostituisce il parametro del nome del progetto dell'attributo ProvideProjectFactory.

Annotazioni

L'elemento <ProjectType> deve corrispondere all'argomento LanguageVsTemplate dell'attributo ProvideProjectFactory nel file SimpleProjectPackage.cs.

La <sezione TemplateContent> descrive questi file generati quando viene creato un nuovo progetto:
SimpleProject.myproj
Program.cs
AssemblyInfo.cs

Tutti e tre i file sono ReplaceParameters impostati su true, che abilita la sostituzione dei parametri. Il file Program.cs è OpenInEditor impostato su true, che determina l'apertura del file nell'editor di codice quando viene creato un progetto.

Per altre informazioni sugli elementi nello schema modello di Visual Studio, vedere le informazioni di riferimento sullo schema del modello di Visual Studio.

Annotazioni

Se un progetto ha più di un modello di Visual Studio, ogni modello si trova in una cartella separata. Ogni file in tale cartella deve avere l'azione di compilazione impostata su ZipProject.

Aggiunta di un file con estensione vsct minimo

Visual Studio deve essere eseguito in modalità di installazione per riconoscere un modello di Visual Studio nuovo o modificato. Per la modalità di installazione è necessario che sia presente un file vsct . Pertanto, è necessario aggiungere un file con estensione vsct minimo al progetto.

Aggiungere un file XML denominato SimpleProject.vsct al progetto SimpleProject.

Sostituire il contenuto del file SimpleProject.vsct con il codice seguente.

<?xml version="1.0" encoding="utf-8" ?>
<CommandTable
  xmlns="http://schemas.microsoft.com/VisualStudio/2005-10-18/CommandTable">
</CommandTable>

Impostare l'azione di compilazione di questo file su VSCTCompile. È possibile eseguire questa operazione solo nel file con estensione csproj , non nella finestra Proprietà . Assicurarsi che il Build Action di questo file sia impostato su None a questo punto.
1. Fare clic con il pulsante destro del mouse sul nodo SimpleProject e quindi scegliere Modifica SimpleProject.csproj.
2. Nel file con estensione csproj individuare l'elemento SimpleProject.vsct .
```
<None Include="SimpleProject.vsct" />
```
3. Modificare l'azione di compilazione in VSCTCompile.
```
<VSCTCompile Include="SimpleProject.vsct" />
```
4. il file di progetto e chiudere l'editor.
5. Salvare il nodo SimpleProject e quindi in Esplora soluzioni selezionare Ricarica progetto.

Esaminare i passaggi di compilazione del modello di Visual Studio

Il sistema di compilazione del progetto VSPackage esegue in genere Visual Studio in modalità di installazione quando il file vstemplate viene modificato o il progetto che contiene il file vstemplate viene ricompilato. È possibile seguire questa procedura impostando il livello di dettaglio di MSBuild su Normale o superiore.

Nel riquadro Opzioni strumenti> espandere la sezioneTutte le impostazioni>Progetti e soluzioni>Compila ed esegui.
Impostare l'opzione dettaglio output compilazione progetto MSBuild su Normale.

Nella finestra di dialogo Strumenti>Opzioni, espandere la sezione Progetti e Soluzioni>Compilazione ed Esecuzione.
Imposta l'opzione dettaglio output compilazione progetto MSBuild su Normale e seleziona OK.

Ricompilare il progetto SimpleProject.

Il passaggio di compilazione per creare il file di progetto .zip dovrebbe essere simile all'esempio seguente.

ZipProjects:
1>  Zipping ProjectTemplates
1>  Zipping <path>\SimpleProject\SimpleProject\obj\Debug\SimpleProject.zip...
1>  Copying file from "<path>\SimpleProject\SimpleProject\obj\Debug\SimpleProject.zip" to "<%LOCALAPPDATA%>\Microsoft\VisualStudio\14.0Exp\ProjectTemplates\\\\SimpleProject.zip".
1>  Copying file from "<path>\SimpleProject\SimpleProject\obj\Debug\SimpleProject.zip" to "bin\Debug\\ProjectTemplates\\\\SimpleProject.zip".
1>  SimpleProject -> <path>\SimpleProject\SimpleProject\bin\Debug\ProjectTemplates\SimpleProject.zip
1>ZipItems:
1>  Zipping ItemTemplates
1>  SimpleProject ->

Distribuire un modello di Visual Studio

I modelli di Visual Studio non contengono informazioni sul percorso. Di conseguenza, il modello .zip file deve essere distribuito in un percorso noto a Visual Studio. Il percorso della cartella ProjectTemplates è in < genere%LOCALAPPDATA%>\Microsoft\VisualStudio\14.0Exp\ProjectTemplates.

Per distribuire la factory del progetto, il programma di installazione deve disporre dei privilegi di amministratore. Distribuisce i modelli nel nodo di installazione di Visual Studio: ...\Microsoft Visual Studio 14.0\Common7\IDE\ProjectTemplates.

Testare un modello di Visual Studio

Testare la factory del progetto per verificare se crea una gerarchia di progetti usando il modello di Visual Studio.

Reimpostare l'istanza sperimentale di Visual Studio SDK.

In Windows 7: nel menu Start individuare la cartella Microsoft Visual Studio/Microsoft Visual Studio SDK/Tools e quindi selezionare Reimposta l'istanza sperimentale di Microsoft Visual Studio.

Nelle versioni successive di Windows: nella schermata Start digitare Reimposta Istanza sperimentale della versione< di Microsoft Visual Studio>.
Viene visualizzata una finestra del prompt dei comandi. Quando vengono visualizzate le parole Premere un tasto qualsiasi per continuare, selezionare INVIO. Al termine della finestra, aprire Visual Studio.
Ricompilare il progetto SimpleProject e avviare il debug. Viene visualizzata l'istanza sperimentale.
Nell'istanza sperimentale creare un progetto SimpleProject. Nella finestra di dialogo Nuovo progetto selezionare SimpleProject.
Verrà visualizzata una nuova istanza di SimpleProject.

Creare un nodo figlio del tipo di progetto

È possibile aggiungere un nodo figlio a un nodo del tipo di progetto nella finestra di dialogo Nuovo progetto . Ad esempio, per il tipo di progetto SimpleProject, è possibile avere nodi figlio per applicazioni console, applicazioni finestra, applicazioni Web e così via.

I nodi figlio vengono creati modificando il file di progetto e aggiungendo bambini <OutputSubPath> agli elementi <ZipProject>. Quando un modello viene copiato durante la compilazione o la distribuzione, ogni nodo figlio diventa una sottocartella della cartella dei modelli di progetto.

Questa sezione illustra come creare un nodo figlio console per il tipo di progetto SimpleProject.

Rinominare la cartella \Templates\Projects\SimpleProject\ in \Templates\Projects\ConsoleApp\.
Nella finestra Proprietà selezionare tutti e cinque i file nella cartella \Templates\Projects\ConsoleApp\ e assicurarsi che l'azione di compilazione sia impostata su ZipProject.
Nel file SimpleProject.vstemplate aggiungere la riga seguente alla fine della <sezione TemplateData> , subito prima del tag di chiusura.
```
<NumberOfParentCategoriesToRollUp>1</NumberOfParentCategoriesToRollUp>
```
In questo modo il modello Applicazione console viene visualizzato sia nel nodo figlio console che nel nodo padre SimpleProject, ovvero un livello superiore al nodo figlio.
Salvare il file SimpleProject.vstemplate .
Nel file con estensione csproj aggiungere <OutputSubPath> a ognuno degli elementi ZipProject. Scaricare il progetto, come in precedenza, e modificare il file di progetto.

Individuare gli <elementi ZipProject> . Per ogni <elemento ZipProject> , aggiungere un <elemento OutputSubPath> e assegnargli il valore Console. The ZipProject

<ZipProject Include="Templates\Projects\ConsoleApp\AssemblyInfo.cs">
  <OutputSubPath>Console</OutputSubPath>
</ZipProject>
<ZipProject Include="Templates\Projects\ConsoleApp\Program.cs">
  <OutputSubPath>Console</OutputSubPath>
</ZipProject>
<ZipProject Include="Templates\Projects\ConsoleApp\SimpleProject.myproj">
  <OutputSubPath>Console</OutputSubPath>
</ZipProject>
<ZipProject Include="Templates\Projects\ConsoleApp\SimpleProject.vstemplate">
  <OutputSubPath>Console</OutputSubPath>
</ZipProject>
<ZipProject Include="Templates\Projects\ConsoleApp\SimpleProject.ico">
  <OutputSubPath>Console</OutputSubPath>
</ZipProject>

Aggiungere questo <PropertyGroup> al file di progetto:

<PropertyGroup>
  <VsTemplateLanguage>SimpleProject</VsTemplateLanguage>
</PropertyGroup>

Salvare il file di progetto e ricaricare il progetto.

Testare il nodo figlio del progetto

Testare il file di progetto modificato per verificare se il nodo figlio console viene visualizzato nella finestra di dialogo Nuovo progetto .

Eseguire lo strumento Reimposta Istanza di Sperimentazione di Microsoft Visual Studio.
Ricompilare il progetto SimpleProject e avviare il debug. Verrà visualizzata l'istanza sperimentale
Nella finestra di dialogo Nuovo progetto selezionare il nodo SimpleProject . Il modello applicazione console dovrebbe essere visualizzato nel riquadro Modelli .
Espandere il nodo SimpleProject . Verrà visualizzato il nodo figlio della console . Il modello Applicazione SimpleProject continua a essere visualizzato nel riquadro Modelli .
Selezionare annullare e interrompere il debug.

Sostituire i parametri del modello di progetto

La creazione di un sistema di progetto di base, parte 1 ha illustrato come sovrascrivere il ProjectNode.AddFileFromTemplate metodo per eseguire una semplice sostituzione dei parametri del modello. Questa sezione illustra come usare i parametri del modello di Visual Studio più sofisticati.

Quando si crea un progetto usando un modello di Visual Studio nella finestra di dialogo Nuovo progetto , i parametri del modello vengono sostituiti con stringhe per personalizzare il progetto. Un parametro di modello è un token speciale che inizia e termina con un segno di dollaro, ad esempio $time$. I due parametri seguenti sono particolarmente utili per abilitare la personalizzazione nei progetti basati sul modello:

$GUID[1-10]$ viene sostituito da un nuovo GUID. È possibile specificare fino a 10 GUID univoci, ad esempio $guid 1$.
$safeprojectname$ è il nome fornito da un utente nella finestra di dialogo Nuovo progetto , modificato per rimuovere tutti i caratteri e gli spazi non sicuri.

Per un elenco completo dei parametri del modello, vedere Parametri del modello.

Per sostituire i parametri del modello di progetto

Nel file SimpleProjectNode.cs rimuovere il AddFileFromTemplate metodo .
Nel file \Templates\Projects\ConsoleApp\SimpleProject.myproj individuare la proprietà RootNamespace< e modificarne il >valore in $safeprojectname$.
```
<RootNamespace>$safeprojectname$</RootNamespace>
```

Nel file \Templates\Projects\SimpleProject\Program.cs sostituire il contenuto del file con il codice seguente:

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;    // Guid

namespace $safeprojectname$
{
    [Guid("$guid1$")]
    public class $safeprojectname$
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello VSX!!!");
            Console.ReadKey();
        }
    }
}

Ricompilare il progetto SimpleProject e avviare il debug. Verrà visualizzata l'istanza sperimentale.
Creare una nuova applicazione Console SimpleProject. Nel riquadro Tipi di progetto selezionare SimpleProject. In Modelli installati in Visual Studio selezionare Applicazione console.

Nel progetto appena creato aprire Program.cs. Dovrebbe essere simile al seguente (i valori GUID nel file differiscono):

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;    // Guid

namespace Console_Application1
{
    [Guid("00000000-0000-0000-00000000-00000000)"]
    public class Console_Application1
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello VSX!!!");
            Console.ReadKey();
        }
    }
}

Creare una pagina delle proprietà del progetto

È possibile creare una pagina delle proprietà per il tipo di progetto in modo che gli utenti possano visualizzare e modificare le proprietà nei progetti basati sul modello. Questa sezione illustra come creare una pagina delle proprietà indipendente dalla configurazione. Questa pagina delle proprietà di base usa una griglia delle proprietà per visualizzare le proprietà pubbliche esposte nella classe della pagina delle proprietà.

Deriva la tua classe di pagina delle proprietà dalla classe base SettingsPage. La griglia delle proprietà fornita dalla classe riconosce la SettingsPage maggior parte dei tipi di dati primitivi e sa come visualizzarle. Inoltre, la SettingsPage classe sa come rendere persistenti i valori delle proprietà nel file di progetto.

La pagina delle proprietà creata in questa sezione consente di modificare e salvare queste proprietà del progetto:

AssemblyName
TipoDiOutput
RootNamespace.

Nel file SimpleProjectPackage.cs aggiungere questo ProvideObject attributo alla SimpleProjectPackage classe :
```
[ProvideObject(typeof(GeneralPropertyPage))]
public sealed class SimpleProjectPackage : ProjectPackage
```
In questo modo viene registrata la classe GeneralPropertyPage della pagina delle proprietà con COM.

Nel file SimpleProjectNode.cs aggiungere questi due metodi sottoposti a override alla SimpleProjectNode classe :

protected override Guid[] GetConfigurationIndependentPropertyPages()
{
    Guid[] result = new Guid[1];
    result[0] = typeof(GeneralPropertyPage).GUID;
    return result;
}
protected override Guid[] GetPriorityProjectDesignerPages()
{
    Guid[] result = new Guid[1];
    result[0] = typeof(GeneralPropertyPage).GUID;
    return result;
}

Entrambi questi metodi restituiscono una matrice di GUID della pagina delle proprietà. Il GUID GeneralPropertyPage è l'unico elemento della matrice, pertanto la finestra di dialogo Pagine delle proprietà mostra una sola pagina.

Aggiungere un file di classe denominato GeneralPropertyPage.cs al progetto SimpleProject.

Sostituire il contenuto di questo file usando il codice seguente:

using System;
using System.Runtime.InteropServices;
using Microsoft.VisualStudio;
using Microsoft.VisualStudio.Project;
using System.ComponentModel;

namespace SimpleProject
{
    [ComVisible(true)]
    [Guid("6BC7046B-B110-40d8-9F23-34263D8D2936")]
    public class GeneralPropertyPage : SettingsPage
    {
        private string assemblyName;
        private OutputType outputType;
        private string defaultNamespace;

        public GeneralPropertyPage()
        {
            this.Name = "General";
        }

        [Category("AssemblyName")]
        [DisplayName("AssemblyName")]
        [Description("The output file holding assembly metadata.")]
        public string AssemblyName
        {
            get { return this.assemblyName; }
        }
        [Category("Application")]
        [DisplayName("OutputType")]
        [Description("The type of application to build.")]
        public OutputType OutputType
        {
            get { return this.outputType; }
            set { this.outputType = value; this.IsDirty = true; }
        }
        [Category("Application")]
        [DisplayName("DefaultNamespace")]
        [Description("Specifies the default namespace for added items.")]
        public string DefaultNamespace
        {
            get { return this.defaultNamespace; }
            set { this.defaultNamespace = value; this.IsDirty = true; }
        }

        protected override void BindProperties()
        {
            this.assemblyName = this.ProjectMgr.GetProjectProperty("AssemblyName", true);
            this.defaultNamespace = this.ProjectMgr.GetProjectProperty("RootNamespace", false);

            string outputType = this.ProjectMgr.GetProjectProperty("OutputType", false);
            this.outputType = (OutputType)Enum.Parse(typeof(OutputType), outputType);
        }

        protected override int ApplyChanges()
        {
            this.ProjectMgr.SetProjectProperty("AssemblyName", this.assemblyName);
            this.ProjectMgr.SetProjectProperty("OutputType", this.outputType.ToString());
            this.ProjectMgr.SetProjectProperty("RootNamespace", this.defaultNamespace);
            this.IsDirty = false;

            return VSConstants.S_OK;
        }
    }
}

La GeneralPropertyPage classe espone le tre proprietà pubbliche AssemblyName, OutputType e RootNamespace. Poiché AssemblyName non dispone di un metodo impostato, viene visualizzato come proprietà di sola lettura. OutputType è una costante enumerata, quindi viene visualizzata come elenco a discesa.

La SettingsPage classe base fornisce ProjectMgr per rendere persistenti le proprietà. Il BindProperties metodo usa ProjectMgr per recuperare i valori delle proprietà persistenti e impostare le proprietà corrispondenti. Il ApplyChanges metodo usa ProjectMgr per ottenere i valori delle proprietà e renderli persistenti nel file di progetto. Il metodo set di proprietà imposta su IsDirty true per indicare che le proprietà devono essere mantenute. La persistenza si verifica quando si salva il progetto o la soluzione.

Ricompilare la soluzione SimpleProject e avviare il debug. Verrà visualizzata l'istanza sperimentale.
Nell'istanza sperimentale creare una nuova applicazione SimpleProject.
Visual Studio chiama la factory del progetto per creare un progetto usando il modello di Visual Studio. Il nuovo file Program.cs viene aperto nell'editor di codice.
Fare clic con il pulsante destro del mouse sul nodo del progetto in Esplora soluzioni e quindi scegliere Proprietà. Viene visualizzata la finestra di dialogo Pagine delle proprietà .

Testare la pagina delle proprietà del progetto

Ora puoi verificare se puoi modificare i valori delle proprietà.

Nella finestra di dialogo Pagine delle proprietà MyConsoleApplication impostare DefaultNamespace su MyApplication.
Selezionare la proprietà OutputType e quindi selezionare Libreria di classi.
Selezionare Applica e quindi OK.
Riaprire la finestra di dialogo Pagine delle proprietà e verificare che le modifiche siano state mantenute.
Chiudere l'istanza sperimentale di Visual Studio.
Riaprire l'istanza sperimentale.
Riaprire la finestra di dialogo Pagine delle proprietà e verificare che le modifiche siano state mantenute.
Chiudere l'istanza sperimentale di Visual Studio.

Last updated on 2025-12-12

Condividi tramite