Creare un sistema di progetto di base, parte 1

Articolo
10/10/2023

In Visual Studio i progetti sono i contenitori usati dagli sviluppatori per organizzare i file di codice sorgente e altri asset. I progetti vengono visualizzati come elementi figlio delle soluzioni nel Esplora soluzioni. I progetti consentono di organizzare, compilare, eseguire il debug e distribuire il codice sorgente e creare riferimenti a servizi Web, database e altre risorse.

I progetti vengono definiti nei file di progetto, ad esempio un file con estensione csproj per un progetto Visual C#. È possibile creare un tipo di progetto personalizzato con estensione di file di progetto personalizzata. Per altre informazioni sui tipi di progetto, vedere Tipi di progetto.

Nota

Se è necessario estendere Visual Studio con un tipo di progetto personalizzato, è consigliabile sfruttare il sistema di progetti di Visual Studio (VSPS) con numerosi vantaggi rispetto alla creazione di un sistema di progetto da zero:

Onboarding più semplice. Anche un sistema di progetto di base richiede decine di migliaia di righe di codice. L'uso di VSPS riduce i costi di onboarding a pochi clic prima di essere pronti per personalizzarlo in base alle proprie esigenze.
Manutenzione più semplice. Sfruttando VSPS, è sufficiente gestire scenari personalizzati. La manutenzione di tutte le infrastrutture del sistema di progetto viene gestita.

Se è necessario usare le versioni di Visual Studio precedenti a Visual Studio 2013, non sarà possibile usare VSPS in un'estensione di Visual Studio. In questo caso, questa procedura dettagliata è un buon posto per iniziare.

Questa procedura dettagliata illustra come creare un tipo di progetto con estensione myproj del file di progetto. Questa procedura dettagliata prende in prestito dal sistema di progetto Visual C# esistente.

Nota

Per altri esempi di progetti di estensione, vedere Esempi di VSSDK.

Questa procedura dettagliata illustra come eseguire queste attività:

Creare un tipo di progetto di base.
Creare un modello di progetto di base.
Registrare il modello di progetto con Visual Studio.
Creare un'istanza del progetto aprendo la finestra di dialogo Nuovo progetto e quindi usando il modello.
Creare una factory di progetto per il sistema di progetto.
Creare un nodo di progetto per il sistema di progetto.
Aggiungere icone personalizzate per il sistema di progetto.
Implementare la sostituzione dei parametri del modello di base.

Prerequisiti

Scaricare il codice sorgente per Managed Package Framework per i progetti. Estrarre il file in un percorso accessibile alla soluzione che si intende creare.

Creare un tipo di progetto di base

Creare un progetto VSIX C# denominato SimpleProject. (File>Nuovo>progetto e quindi progetto VSIX visual C#>Extensibility).> Aggiungere un modello di elemento di progetto pacchetto di Visual Studio (nel Esplora soluzioni fare clic con il pulsante destro del mouse sul nodo del progetto e scegliere Aggiungi>nuovo elemento, quindi passare a Extensibility>Visual Studio Package). Denominare il file SimpleProjectPackage.

Creazione di un modello di progetto di base

È ora possibile modificare questo VSPackage di base per implementare il nuovo tipo di progetto .myproj . Per creare un progetto basato sul tipo di progetto con estensione myproj , Visual Studio deve conoscere i file, le risorse e i riferimenti da aggiungere al nuovo progetto. Per fornire queste informazioni, inserire i file di progetto in una cartella del modello di progetto. Quando un utente usa il progetto con estensione myproj per creare un progetto, i file vengono copiati nel nuovo progetto.

Per creare un modello di progetto di base

Aggiungere tre cartelle al progetto, una sotto l'altra: Templates\Projects\SimpleProject. (In Esplora soluzioni fare clic con il pulsante destro del mouse sul nodo del progetto SimpleProject, scegliere Aggiungi e quindi fare clic su Nuova cartella. Denominare la cartella Modelli. Nella cartella Templates aggiungere una cartella denominata Projects. Nella cartella Projects aggiungere una cartella denominata SimpleProject.
Nella cartella Templates\Projects\SimpleProject aggiungere un file Bitmap Image da usare come icona denominata SimpleProject.ico. Quando si fa clic su Aggiungi, viene aperto l'editor di icone.
Rendere l'icona distintiva. Questa icona verrà visualizzata nella finestra di dialogo Nuovo progetto più avanti nella procedura dettagliata.
Salvare l'icona e chiudere l'editor di icone.
Nella cartella Templates\Projects\SimpleProject aggiungere un elemento di classe denominato Program.cs.
Sostituire il codice esistente con le righe seguenti.
```
using System;
using System.Collections.Generic;
using System.Text;

namespace $nameSpace$
{
    public class $className$
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello VSX!!!");
            Console.ReadKey();
        }
    }
}
```
Importante

Questo non è il formato finale del codice Program.cs . I parametri di sostituzione verranno trattati in un passaggio successivo. È possibile che vengano visualizzati errori di compilazione, ma purché buildAction del file sia Contenuto, sarà possibile compilare ed eseguire il progetto come di consueto.
Salvare il file.
Copiare il file AssemblyInfo.cs dalla cartella Proprietà alla cartella Projects\SimpleProject .
Nella cartella Projects\SimpleProject aggiungere un file XML denominato SimpleProject.myproj.

Nota

L'estensione del nome file per tutti i progetti di questo tipo è .myproj. Se si vuole modificarla, è necessario modificarla ovunque sia menzionata nella procedura dettagliata.

Sostituire il contenuto esistente con le righe seguenti.

<?xml version="1.0" encoding="utf-8" ?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectGuid></ProjectGuid>
    <OutputType>Exe</OutputType>
    <RootNamespace>MyRootNamespace</RootNamespace>
    <AssemblyName>MyAssemblyName</AssemblyName>
    <EnableUnmanagedDebugging>false</EnableUnmanagedDebugging>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
    <DebugSymbols>true</DebugSymbols>
    <OutputPath>bin\Debug\</OutputPath>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
    <DebugSymbols>false</DebugSymbols>
    <OutputPath>bin\Release\</OutputPath>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="mscorlib" />
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="AssemblyInfo.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Program.cs">
      <SubType>Code</SubType>
    </Compile>
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
</Project>

Salvare il file.
Nella finestra Proprietà impostare l'azione di compilazione di AssemblyInfo.cs, Program.cs, SimpleProject.ico e SimpleProject.myproj su Content e impostare le proprietà Include in VSIX su True.

Questo modello di progetto descrive un progetto Visual C# di base con una configurazione di debug e una configurazione release. Il progetto include due file di origine, AssemblyInfo.cs e Program.cs e diversi riferimenti agli assembly. Quando un progetto viene creato dal modello, il valore di ProjectGuid viene sostituito automaticamente da un nuovo GUID.

In Esplora soluzioni la cartella Modelli espansa dovrebbe essere visualizzata come segue:

Templates
   Projects
      SimpleProject
         AssemblyInfo.cs
         Program.cs
         SimpleProject.ico
         SimpleProject.myproj

Creare una factory di progetto di base

È necessario indicare a Visual Studio il percorso della cartella del modello di progetto. A tale scopo, aggiungere un attributo alla classe VSPackage che implementa la factory del progetto in modo che il percorso del modello venga scritto nel Registro di sistema al momento della compilazione del pacchetto VSPackage. Per iniziare, creare una factory di progetto di base identificata da un GUID della factory del progetto. Usare l'attributo ProvideProjectFactoryAttribute per connettere la factory del SimpleProjectPackage progetto alla classe .

Per creare una factory di progetto di base

Creare GUID per la factory del progetto (dal menu Strumenti fare clic su Crea GUID) oppure usare quello nell'esempio seguente. Aggiungere i GUID alla SimpleProjectPackage classe accanto alla sezione con l'oggetto già definito PackageGuidString. I GUID devono essere in formato GUID e stringa. Il codice risultante dovrebbe essere simile all'esempio seguente.

    public sealed class SimpleProjectPackage : Package
    {
        ...
        public const string SimpleProjectPkgString = "96bf4c26-d94e-43bf-a56a-f8500b52bfad";
        public const string SimpleProjectFactoryString = "471EC4BB-E47E-4229-A789-D1F5F83B52D4";

        public static readonly Guid guidSimpleProjectFactory = new Guid(SimpleProjectFactoryString);
    }

Aggiungere una classe alla cartella SimpleProject in alto denominata SimpleProjectFactory.cs.

Aggiungere le direttive using seguenti:

using System.Runtime.InteropServices;
using Microsoft.VisualStudio.Shell;

Aggiungere un attributo GUID alla SimpleProjectFactory classe . Il valore dell'attributo è il nuovo GUID della factory del progetto.
```
[Guid(SimpleProjectPackage.SimpleProjectFactoryString)]
class SimpleProjectFactory
{
}
```
È ora possibile registrare il modello di progetto.

Per registrare il modello di progetto

In SimpleProjectPackage.cs aggiungere un ProvideProjectFactoryAttribute attributo alla SimpleProjectPackage classe , come indicato di seguito.

[ProvideProjectFactory(    typeof(SimpleProjectFactory),     "Simple Project",
    "Simple Project Files (*.myproj);*.myproj", "myproj", "myproj",
    @"Templates\Projects\SimpleProject",     LanguageVsTemplate = "SimpleProject")]
[Guid(SimpleProjectPackage.PackageGuidString)]
public sealed class SimpleProjectPackage : Package

Ricompilare la soluzione e verificare che venga compilata senza errori.

La ricompilazione registra il modello di progetto.

I parametri defaultProjectExtension e possibleProjectExtensions sono impostati sull'estensione del file di progetto (con estensione myproj). Il projectTemplatesDirectory parametro è impostato sul percorso relativo della cartella Templates . Durante la compilazione, questo percorso verrà convertito in una compilazione completa e aggiunto al Registro di sistema per registrare il sistema di progetto.

Testare la registrazione del modello

La registrazione del modello indica a Visual Studio il percorso della cartella del modello di progetto in modo che Visual Studio possa visualizzare il nome e l'icona del modello nella finestra di dialogo Nuovo progetto .

Per testare la registrazione del modello

Premere F5 per avviare il debug di un'istanza sperimentale di Visual Studio.
Nell'istanza sperimentale creare un nuovo progetto del tipo di progetto appena creato. Nella finestra di dialogo Nuovo progetto verrà visualizzato SimpleProject in Modelli installati.

Ora si dispone di una factory di progetto registrata. Tuttavia, non può ancora creare un progetto. Il pacchetto di progetto e la factory del progetto interagiscono per creare e inizializzare un progetto.

Aggiungere il codice di Managed Package Framework

Implementare la connessione tra il pacchetto di progetto e la factory del progetto.

Importare i file del codice sorgente per Managed Package Framework.
1. Scaricare il progetto SimpleProject (in Esplora soluzioni, selezionare il nodo del progetto e scegliere Scarica progetto dal menu di scelta rapida) e aprire il file di progetto nell'editor XML.
2. Aggiungere i blocchi seguenti al file di progetto (appena sopra i <blocchi di importazione> ). Impostare ProjectBasePath sul percorso del file ProjectBase.files nel codice di Managed Package Framework appena scaricato. Potrebbe essere necessario aggiungere una barra rovesciata al nome percorso. In caso contrario, il progetto potrebbe non riuscire a trovare il codice sorgente di Managed Package Framework.
```
<PropertyGroup>
     <ProjectBasePath>your path here\</ProjectBasePath>
     <RegisterWithCodebase>true</RegisterWithCodebase>
  </PropertyGroup>
  <Import Project="$(ProjectBasePath)\ProjectBase.Files" />
```
  Importante
  
  Non dimenticare la barra rovesciata alla fine del percorso.
3. Ricaricare il progetto.
4. Aggiungere riferimenti agli assembly riportati di seguito:
  - Microsoft.VisualStudio.Designer.Interfaces (in <VSSDK install>\VisualStudioIntegration\Common\Assemblies\v2.0)
  - WindowsBase
  - Microsoft.Build.Tasks.v4.0

Per inizializzare la factory del progetto

Nel file SimpleProjectPackage.cs aggiungere la direttiva seguenteusing.
```
using Microsoft.VisualStudio.Project;
```
Derivare la SimpleProjectPackage classe da Microsoft.VisualStudio.Package.ProjectPackage.
```
public sealed class SimpleProjectPackage : ProjectPackage
```
Registrare la factory del progetto. Aggiungere la riga seguente al SimpleProjectPackage.Initialize metodo , subito dopo base.Initialize.
```
base.Initialize();
this.RegisterProjectFactory(new SimpleProjectFactory(this));
```

Implementare la proprietà ProductUserContextastratta :

public override string ProductUserContext
    {
        get { return ""; }
}

In SimpleProjectFactory.cs aggiungere la direttiva seguente using dopo le direttive esistenti using .
```
using Microsoft.VisualStudio.Project;
```
Derivare la SimpleProjectFactory classe da ProjectFactory.
```
class SimpleProjectFactory : ProjectFactory
```
Aggiungere il metodo fittizio seguente alla SimpleProjectFactory classe . Questo metodo verrà implementato in una sezione successiva.
```
protected override ProjectNode CreateProject()
{
    return null;
}
```
Aggiungere il campo e il costruttore seguenti alla SimpleProjectFactory classe . Questo SimpleProjectPackage riferimento viene memorizzato nella cache in un campo privato in modo che possa essere usato nell'impostazione di un sito del provider di servizi.
```
private SimpleProjectPackage package;

public SimpleProjectFactory(SimpleProjectPackage package)
    : base(package)
{
    this.package = package;
}
```
Ricompilare la soluzione e verificare che venga compilata senza errori.

Testare l'implementazione della factory del progetto

Verificare se viene chiamato il costruttore per l'implementazione della factory del progetto.

Per testare l'implementazione della factory del progetto

Nel file SimpleProjectFactory.cs impostare un punto di interruzione nella riga seguente nel SimpleProjectFactory costruttore.
```
this.package = package;
```
Premere F5 per avviare un'istanza sperimentale di Visual Studio.
Nell'istanza sperimentale iniziare a creare un nuovo progetto. Nella finestra di dialogo Nuovo progetto selezionare il tipo di progetto SimpleProject e quindi fare clic su OK. L'esecuzione verrà interrotta in corrispondenza del punto di interruzione.
Cancellare il punto di interruzione e arrestare il debug. Poiché non è ancora stato creato un nodo del progetto, il codice di creazione del progetto genera ancora eccezioni.

Estendere la classe ProjectNode

È ora possibile implementare la SimpleProjectNode classe , che deriva dalla ProjectNode classe . La ProjectNode classe base gestisce le attività seguenti di creazione del progetto:

Copia il file modello di progetto SimpleProject.myproj nella nuova cartella del progetto. La copia viene rinominata in base al nome immesso nella finestra di dialogo Nuovo progetto . Il valore della ProjectGuid proprietà viene sostituito da un nuovo GUID.
Attraversa gli elementi MSBuild del file modello di progetto SimpleProject.myproj e cerca Compile gli elementi. Per ogni Compile file di destinazione, copia il file nella nuova cartella del progetto.

La classe derivata SimpleProjectNode gestisce queste attività:
Abilita le icone per i nodi di progetto e file in Esplora soluzioni da creare o selezionare.
Consente di specificare altre sostituzioni dei parametri del modello di progetto.

Per estendere la classe ProjectNode

Aggiungere una classe denominata SimpleProjectNode.cs.

Sostituire il codice esistente con quello seguente.

using System;
using System.Collections.Generic;
using Microsoft.VisualStudio.Project;

namespace SimpleProject
{
    public class SimpleProjectNode : ProjectNode
    {
        private SimpleProjectPackage package;

        public SimpleProjectNode(SimpleProjectPackage package)
        {
            this.package = package;
        }
        public override Guid ProjectGuid
        {
            get { return SimpleProjectPackage.guidSimpleProjectFactory; }
        }
        public override string ProjectType
        {
            get { return "SimpleProjectType"; }
        }

        public override void AddFileFromTemplate(
            string source, string target)
        {
            this.FileTemplateProcessor.UntokenFile(source, target);
            this.FileTemplateProcessor.Reset();
        }
    }
}

Questa SimpleProjectNode implementazione della classe include questi metodi sottoposti a override:

ProjectGuid, che restituisce il GUID della factory del progetto.
ProjectType, che restituisce il nome localizzato del tipo di progetto.
AddFileFromTemplate, che copia i file selezionati dalla cartella modello al progetto di destinazione. Questo metodo viene ulteriormente implementato in una sezione successiva.

Il SimpleProjectNode costruttore, come il SimpleProjectFactory costruttore, memorizza nella cache un SimpleProjectPackage riferimento in un campo privato per un uso successivo.

Per connettere la SimpleProjectFactory classe alla SimpleProjectNode classe, è necessario creare un'istanza di un nuovo SimpleProjectNode nel SimpleProjectFactory.CreateProject metodo e memorizzarla nella cache in un campo privato per usarla in un secondo momento.

Per connettere la classe factory del progetto e la classe node

Nel file SimpleProjectFactory.cs aggiungere la direttiva seguenteusing:

using IOleServiceProvider =    Microsoft.VisualStudio.OLE.Interop.IServiceProvider;

Sostituire il SimpleProjectFactory.CreateProject metodo usando il codice seguente.

protected override ProjectNode CreateProject()
{
    SimpleProjectNode project = new SimpleProjectNode(this.package);

    project.SetSite((IOleServiceProvider)        ((IServiceProvider)this.package).GetService(            typeof(IOleServiceProvider)));
    return project;
}

Ricompilare la soluzione e verificare che venga compilata senza errori.

Testare la classe ProjectNode

Testare la factory del progetto per verificare se crea una gerarchia di progetti.

Per testare la classe ProjectNode

Premere F5 per avviare il debug. Nell'istanza sperimentale creare un nuovo SimpleProject.
Visual Studio deve chiamare la factory del progetto per creare un progetto.
Chiudere l'istanza sperimentale di Visual Studio.

Aggiungere un'icona del nodo del progetto personalizzato

L'icona del nodo del progetto nella sezione precedente è un'icona predefinita. È possibile modificarlo in un'icona personalizzata.

Per aggiungere un'icona del nodo del progetto personalizzato

Nella cartella Resources aggiungere un file bitmap denominato SimpleProjectNode.bmp.
Nelle finestre Proprietà ridurre la bitmap a 16 per 16 pixel. Rendi distintiva la bitmap.
Nella finestra Proprietà modificare l'azione Di compilazione della bitmap in Risorsa incorporata.
In SimpleProjectNode.cs aggiungere le direttive seguenti using :
```
using System.Drawing;
using System.Windows.Forms;
```

Aggiungere il campo statico e il costruttore seguenti alla SimpleProjectNode classe .

private static ImageList imageList;

static SimpleProjectNode()
{
    imageList =        Utilities.GetImageList(            typeof(SimpleProjectNode).Assembly.GetManifestResourceStream(                "SimpleProject.Resources.SimpleProjectNode.bmp"));
}

Aggiungere la proprietà seguente all'inizio della SimpleProjectNode classe .

internal static int imageIndex;
   public override int ImageIndex
   {
       get { return imageIndex; }
   }

Sostituire il costruttore dell'istanza con il codice seguente.
```
public SimpleProjectNode(SimpleProjectPackage package)
{
    this.package = package;

    imageIndex = this.ImageHandler.ImageList.Images.Count;

    foreach (Image img in imageList.Images)
    {
        this.ImageHandler.AddImage(img);
    }
}
```
Durante la costruzione statica, SimpleProjectNode recupera la bitmap del nodo del progetto dalle risorse del manifesto dell'assembly e la memorizza nella cache in un campo privato per usarla in un secondo momento. Si noti la sintassi del percorso dell'immagine GetManifestResourceStream . Per visualizzare i nomi delle risorse manifesto incorporate in un assembly, usare il GetManifestResourceNames metodo . Quando questo metodo viene applicato all'assembly SimpleProject , i risultati devono essere i seguenti:

SimpleProject.Resources.resources
VisualStudio.Project.resources
SimpleProject.VSPackage.resources
Resources.imagelis.bmp
Microsoft.VisualStudio.Project.DontShowAgainDialog.resources
Microsoft.VisualStudio.Project.SecurityWarningDialog.resources
SimpleProject.Resources.SimpleProjectNode.bmp

Durante la costruzione dell'istanza, la ProjectNode classe base carica Resources.imagelis.bmp, in cui sono incorporate comunemente usate 16 x 16 bitmap da Resources\imagelis.bmp. Questo elenco bitmap viene reso disponibile come SimpleProjectNode ImageHandler.ImageList. SimpleProjectNode aggiunge la bitmap del nodo del progetto all'elenco. L'offset della bitmap del nodo del progetto nell'elenco di immagini viene memorizzato nella cache per un uso successivo come valore della proprietà pubblica ImageIndex . Visual Studio usa questa proprietà per determinare quale bitmap visualizzare come icona del nodo del progetto.

Testare l'icona del nodo del progetto personalizzato

Testare la factory del progetto per verificare se crea una gerarchia di progetti con l'icona del nodo del progetto personalizzato.

Per testare l'icona del nodo del progetto personalizzato

Avviare il debug e nell'istanza sperimentale creare un nuovo SimpleProject.
Nel progetto appena creato si noti che SimpleProjectNode.bmp viene usato come icona del nodo del progetto.
Aprire Program.cs nell'editor di codice. Verrà visualizzato codice sorgente simile al codice seguente.
```
using System;
using System.Collections.Generic;
using System.Text;

namespace $nameSpace$
{
    public class $className$
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello VSX!!!");
            Console.ReadKey();
        }
    }
}
```
Si noti che i parametri del modello $nameSpace$ e $className$ non hanno nuovi valori. Si apprenderà come implementare la sostituzione dei parametri del modello nella sezione successiva.

Sostituire i parametri del modello

In una sezione precedente è stato registrato il modello di progetto con Visual Studio usando l'attributo ProvideProjectFactory . La registrazione del percorso di una cartella modello in questo modo consente di abilitare la sostituzione dei parametri del modello di base eseguendo l'override e espandendo la ProjectNode.AddFileFromTemplate classe. Per altre informazioni, vedere Nuova generazione di progetti: Sotto le quinte, parte 2.

Aggiungere ora il codice di sostituzione alla AddFileFromTemplate classe .

Per sostituire i parametri del modello

Nel file SimpleProjectNode.cs aggiungere la direttiva seguenteusing.
```
using System.IO;
```

Sostituire il AddFileFromTemplate metodo usando il codice seguente.

public override void AddFileFromTemplate(
    string source, string target)
{
    string nameSpace =
        this.FileTemplateProcessor.GetFileNamespace(target, this);
    string className = Path.GetFileNameWithoutExtension(target);

    this.FileTemplateProcessor.AddReplace("$nameSpace$", nameSpace);
    this.FileTemplateProcessor.AddReplace("$className$", className);

    this.FileTemplateProcessor.UntokenFile(source, target);
    this.FileTemplateProcessor.Reset();
}

Impostare un punto di interruzione nel metodo subito dopo l'istruzione className di assegnazione.

Le istruzioni di assegnazione determinano valori ragionevoli per uno spazio dei nomi e un nuovo nome di classe. Le due ProjectNode.FileTemplateProcessor.AddReplace chiamate al metodo sostituiscono i valori dei parametri del modello corrispondenti usando questi nuovi valori.

Testare la sostituzione dei parametri del modello

È ora possibile testare la sostituzione dei parametri del modello.

Per testare la sostituzione dei parametri del modello

Avviare il debug e nell'istanza sperimentale creare un nuovo SimpleProject.
L'esecuzione si arresta in corrispondenza del punto di interruzione nel AddFileFromTemplate metodo .
Esaminare i valori per i nameSpace parametri e className .
- nameSpace viene assegnato il valore dell'elemento <RootNamespace> nel file di modello di progetto \Templates\Projects\SimpleProject\SimpleProject.myproj . In questo caso il valore è MyRootNamespace.
- className viene assegnato il valore del nome del file di origine della classe, senza l'estensione del nome file. In questo caso, il primo file da copiare nella cartella di destinazione è AssemblyInfo.cs; pertanto, il valore di className è AssemblyInfo.
Rimuovere il punto di interruzione e premere F5 per continuare l'esecuzione.

Visual Studio dovrebbe completare la creazione di un progetto.

Aprire Program.cs nell'editor di codice. Verrà visualizzato codice sorgente simile al codice seguente.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyRootNamespace
{
    public class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello VSX!!!");
            Console.ReadKey();
        }
    }
}

Si noti che lo spazio dei nomi è ora MyRootNamespace e il nome della classe è ora Program.

Avviare il debug del progetto. Il nuovo progetto deve compilare, eseguire e visualizzare "Hello VSX!!" nella finestra della console.

Complimenti. È stato implementato un sistema di progetto gestito di base.

Condividi tramite