Creación de un sistema de proyecto básico, parte 1

Artículo
03/10/2023

En Visual Studio, los proyectos son los contenedores que los desarrolladores usan para organizar archivos de código fuente y otros recursos. Los proyectos aparecen como elementos secundarios de las soluciones en el Explorador de soluciones. Los proyectos permiten organizar, compilar, depurar e implementar código fuente y crear referencias a servicios web, bases de datos y otros recursos.

Los proyectos se definen en archivos de proyecto, por ejemplo, un archivo .csproj para un proyecto de Visual C#. Puede crear su propio tipo de proyecto que tenga su propia extensión de nombre de archivo de proyecto. Para obtener más información sobre los tipos de proyecto, vea Tipos de proyecto.

Nota:

Si necesita ampliar Visual Studio con un tipo de proyecto personalizado, se recomienda encarecidamente aprovechar el sistema de proyectos de Visual Studio (VSPS), que tiene una serie de ventajas sobre la creación de un sistema de proyecto desde cero:

Incorporación más sencilla. Incluso un sistema de proyecto básico requiere decenas de miles de líneas de código. El aprovechamiento de VSPS reduce el costo de incorporación a unos pocos clics antes de que esté listo para personalizarlo a sus necesidades.
Mantenimiento más sencillo. Al aprovechar VSPS, solo tiene que mantener sus propios escenarios. Manejamos el mantenimiento de toda la infraestructura del sistema del proyecto.

Si necesita tener como destino versiones de Visual Studio anteriores a Visual Studio 2013, no podrá aprovechar VSPS en una extensión de Visual Studio. Si es así, este tutorial es un buen lugar para empezar.

En este tutorial se muestra cómo crear un tipo de proyecto que tenga la extensión de nombre de archivo del proyecto .myproj. Este tutorial toma prestado del sistema de proyectos de Visual C# existente.

Nota:

Para obtener más ejemplos de proyectos de extensión, consulte ejemplos de VSSDK.

En este tutorial se enseña a realizar estas tareas:

Cree un tipo de proyecto básico.
Cree una plantilla de proyecto básica.
Registre la plantilla de proyecto con Visual Studio.
Cree una instancia de proyecto abriendo el cuadro de diálogo Nuevo proyecto y usando la plantilla.
Cree un generador de proyectos para el sistema del proyecto.
Cree un nodo de proyecto para el sistema del proyecto.
Agregue iconos personalizados para el sistema del proyecto.
Implemente la sustitución básica de parámetros de plantilla.

Requisitos previos

Descargue el código fuente de Managed Package Framework para proyectos. Extraiga el archivo en una ubicación a la que se pueda acceder a la solución que va a crear.

Creación de un tipo de proyecto básico

Cree un proyecto VSIX de C# denominado SimpleProject. (Archivo>nuevo>proyecto y, a continuación, Proyecto VSIX de Extensibilidad>de Visual C#).> Agregue una plantilla de elemento de proyecto paquete de Visual Studio (en el Explorador de soluciones, haga clic con el botón derecho en el nodo del proyecto y seleccione Agregar>nuevo elemento y, a continuación, vaya a Extensibilidad>del paquete de Visual Studio). Asigne al archivo el nombre SimpleProjectPackage.

Creación de una plantilla de proyecto básica

Ahora, puede modificar este VSPackage básico para implementar el nuevo tipo de proyecto .myproj . Para crear un proyecto basado en el tipo de proyecto .myproj , Visual Studio tiene que saber qué archivos, recursos y referencias se van a agregar al nuevo proyecto. Para proporcionar esta información, coloque los archivos de proyecto en una carpeta de plantilla de proyecto. Cuando un usuario usa el proyecto .myproj para crear un proyecto, los archivos se copian en el nuevo proyecto.

Para crear una plantilla de proyecto básica

Agregue tres carpetas al proyecto, una en la otra: Templates\Projects\SimpleProject. (En Explorador de soluciones, haga clic con el botón derecho en el nodo proyecto SimpleProject, seleccione Agregar y, a continuación, haga clic en Nueva carpeta. Asigne un nombre a las plantillas de carpeta. En la carpeta Plantillas, agregue una carpeta denominada Projects. En la carpeta Proyectos, agregue una carpeta denominada SimpleProject).
En la carpeta Templates\Projects\SimpleProject , agregue un archivo de imagen de mapa de bits para usarlo como el icono denominado SimpleProject.ico. Al hacer clic en Agregar, se abre el editor de iconos.
Haga que el icono sea distintivo. Este icono aparecerá en el cuadro de diálogo Nuevo proyecto más adelante en el tutorial.
Guarde el icono y cierre el editor de iconos.
En la carpeta Templates\Projects\SimpleProject , agregue un elemento Class denominado Program.cs.
Reemplace el código existente por las líneas siguientes.
```
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

Esta no es la forma final del código Program.cs ; los parámetros de reemplazo se tratarán en un paso posterior. Es posible que vea errores de compilación, pero siempre que BuildAction del archivo sea Content, debería poder compilar y ejecutar el proyecto de la forma habitual.
Guarde el archivo.
Copie el archivo AssemblyInfo.cs de la carpeta Propiedades en la carpeta Projects\SimpleProject .
En la carpeta Projects\SimpleProject , agregue un archivo XML denominado SimpleProject.myproj.

Nota:

La extensión de nombre de archivo para todos los proyectos de este tipo es .myproj. Si desea cambiarlo, debe cambiarlo en cualquier lugar en el que se menciona en el tutorial.

Reemplace el contenido existente por las líneas siguientes.

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

Guarde el archivo.
En la ventana Propiedades, establezca la acción de compilación de AssemblyInfo.cs, Program.cs, SimpleProject.ico y SimpleProject.myproj en Content y establezca sus propiedades Include en VSIX en True.

Esta plantilla de proyecto describe un proyecto básico de Visual C# que tiene una configuración de depuración y una configuración de versión. El proyecto incluye dos archivos de origen, AssemblyInfo.cs y Program.cs, y varias referencias de ensamblado. Cuando se crea un proyecto a partir de la plantilla, el valor de ProjectGuid se reemplaza automáticamente por un nuevo GUID.

En Explorador de soluciones, la carpeta Plantillas expandida debe aparecer de la siguiente manera:

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

Creación de un generador de proyectos básico

Debe indicar a Visual Studio la ubicación de la carpeta de plantilla de proyecto. Para ello, agregue un atributo a la clase VSPackage que implementa el generador de proyectos para que la ubicación de la plantilla se escriba en el registro del sistema cuando se compila VSPackage. Empiece por crear un generador de proyectos básico identificado por un GUID de generador de proyectos. Use el ProvideProjectFactoryAttribute atributo para conectar el generador de proyectos a la SimpleProjectPackage clase .

Para crear un generador de proyectos básico

Cree GUID para el generador de proyectos (en el menú Herramientas , haga clic en Crear GUID) o use el que se muestra en el ejemplo siguiente. Agregue los GUID a la SimpleProjectPackage clase cerca de la sección con el elemento ya definido PackageGuidString. Los GUID deben estar en forma GUID y en forma de cadena. El código resultante debe ser similar al ejemplo siguiente.

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

Agregue una clase a la carpeta SimpleProject superior denominada SimpleProjectFactory.cs.

Agregue lo siguiente mediante directivas:

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

Agregue un atributo GUID a la SimpleProjectFactory clase . El valor del atributo es el nuevo GUID del generador de proyectos.
```
[Guid(SimpleProjectPackage.SimpleProjectFactoryString)]
class SimpleProjectFactory
{
}
```
Ahora puede registrar la plantilla de proyecto.

Para registrar la plantilla de proyecto

En SimpleProjectPackage.cs, agregue un ProvideProjectFactoryAttribute atributo a la SimpleProjectPackage clase , como se indica a continuación.

[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

Vuelva a generar la solución y compruebe que se compila sin errores.

Al volver a generar, se registra la plantilla de proyecto.

Los parámetros defaultProjectExtension y possibleProjectExtensions se establecen en la extensión de nombre de archivo del proyecto (.myproj). El projectTemplatesDirectory parámetro se establece en la ruta de acceso relativa de la carpeta Plantillas . Durante la compilación, esta ruta de acceso se convertirá en una compilación completa y se agregará al registro para registrar el sistema del proyecto.

Prueba del registro de plantillas

El registro de plantillas indica a Visual Studio la ubicación de la carpeta de plantilla de proyecto para que Visual Studio pueda mostrar el nombre y el icono de la plantilla en el cuadro de diálogo Nuevo proyecto .

Para probar el registro de plantillas

Presione F5 para iniciar la depuración de una instancia experimental de Visual Studio.
En la instancia experimental, cree un nuevo proyecto del tipo de proyecto recién creado. En el cuadro de diálogo Nuevo proyecto , debería ver SimpleProject en Plantillas instaladas.

Ahora tiene un generador de proyectos registrado. Sin embargo, todavía no puede crear un proyecto. El paquete de proyecto y el generador de proyectos funcionan juntos para crear e inicializar un proyecto.

Adición del código de Managed Package Framework

Implemente la conexión entre el paquete del proyecto y el generador de proyectos.

Importe los archivos de código fuente para Managed Package Framework.
1. Descargue el proyecto SimpleProject (en Explorador de soluciones, seleccione el nodo del proyecto y, en el menú contextual, haga clic en Descargar proyecto) y abra el archivo de proyecto en el editor XML.
2. Agregue los siguientes bloques al archivo del proyecto (justo encima de los <bloques de importación> ). Establezca ProjectBasePath en la ubicación del archivo ProjectBase.files en el código de Managed Package Framework que acaba de descargar. Es posible que tenga que agregar una barra diagonal inversa al nombre de la ruta de acceso. Si no lo hace, es posible que el proyecto no encuentre el código fuente de Managed Package Framework.
```
<PropertyGroup>
     <ProjectBasePath>your path here\</ProjectBasePath>
     <RegisterWithCodebase>true</RegisterWithCodebase>
  </PropertyGroup>
  <Import Project="$(ProjectBasePath)\ProjectBase.Files" />
```
  Importante
  
  No olvide la barra diagonal inversa al final de la ruta de acceso.
3. Vuelva a cargar el proyecto .
4. Agregue referencias a los siguientes ensamblados:
  - Microsoft.VisualStudio.Designer.Interfaces (en <VSSDK install>\VisualStudioIntegration\Common\Assemblies\v2.0)
  - WindowsBase
  - Microsoft.Build.Tasks.v4.0

Para inicializar el generador del proyecto

En el archivo SimpleProjectPackage.cs , agregue la siguiente using directiva.
```
using Microsoft.VisualStudio.Project;
```
Derive la SimpleProjectPackage clase de Microsoft.VisualStudio.Package.ProjectPackage.
```
public sealed class SimpleProjectPackage : ProjectPackage
```
Registre el generador del proyecto. Agregue la siguiente línea al SimpleProjectPackage.Initialize método , justo después base.Initializede .
```
base.Initialize();
this.RegisterProjectFactory(new SimpleProjectFactory(this));
```

Implemente la propiedad ProductUserContextabstracta :

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

En SimpleProjectFactory.cs, agregue la siguiente using directiva después de las directivas existentes using .
```
using Microsoft.VisualStudio.Project;
```
Derive la SimpleProjectFactory clase de ProjectFactory.
```
class SimpleProjectFactory : ProjectFactory
```
Agregue el siguiente método ficticio a la SimpleProjectFactory clase . Implementará este método en una sección posterior.
```
protected override ProjectNode CreateProject()
{
    return null;
}
```
Agregue el siguiente campo y constructor a la SimpleProjectFactory clase . Esta SimpleProjectPackage referencia se almacena en caché en un campo privado para que se pueda usar en el establecimiento de un sitio de proveedor de servicios.
```
private SimpleProjectPackage package;

public SimpleProjectFactory(SimpleProjectPackage package)
    : base(package)
{
    this.package = package;
}
```
Vuelva a generar la solución y compruebe que se compila sin errores.

Prueba de la implementación del generador de proyectos

Pruebe si se llama al constructor para la implementación del generador de proyectos.

Para probar la implementación del generador de proyectos

En el archivo SimpleProjectFactory.cs , establezca un punto de interrupción en la siguiente línea del SimpleProjectFactory constructor.
```
this.package = package;
```
Presione F5 para iniciar una instancia experimental de Visual Studio.
En la instancia experimental, empiece a crear un nuevo proyecto. En el cuadro de diálogo Nuevo proyecto , seleccione el tipo de proyecto SimpleProject y, a continuación, haga clic en Aceptar. La ejecución se detiene en el punto de interrupción.
Borre el punto de interrupción y detenga la depuración. Puesto que aún no hemos creado un nodo de proyecto, el código de creación del proyecto sigue produciendo excepciones.

Extensión de la clase ProjectNode

Ahora puede implementar la SimpleProjectNode clase , que deriva de la ProjectNode clase . La ProjectNode clase base controla las siguientes tareas de creación del proyecto:

Copia el archivo de plantilla de proyecto SimpleProject.myproj en la nueva carpeta del proyecto. Se cambia el nombre de la copia según el nombre especificado en el cuadro de diálogo Nuevo proyecto . El ProjectGuid valor de la propiedad se reemplaza por un nuevo GUID.
Recorre los elementos de MSBuild del archivo de plantilla de proyecto, SimpleProject.myproj y busca Compile elementos. Para cada Compile archivo de destino, copia el archivo en la nueva carpeta del proyecto.

La clase derivada SimpleProjectNode controla estas tareas:
Habilita los iconos para los nodos de proyecto y archivo en Explorador de soluciones que se van a crear o seleccionar.
Permite especificar más sustituciones de parámetros de plantilla de proyecto.

Para ampliar la clase ProjectNode

Agregue una clase denominada SimpleProjectNode.cs.

Reemplace el código existente por el siguiente código.

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

Esta SimpleProjectNode implementación de clase tiene estos métodos invalidados:

ProjectGuid, que devuelve el GUID del generador de proyectos.
ProjectType, que devuelve el nombre localizado del tipo de proyecto.
AddFileFromTemplate, que copia los archivos seleccionados de la carpeta de plantilla en el proyecto de destino. Este método se implementa aún más en una sección posterior.

El SimpleProjectNode constructor, como el SimpleProjectFactory constructor, almacena en caché una SimpleProjectPackage referencia en un campo privado para su uso posterior.

Para conectar la SimpleProjectFactory clase a la SimpleProjectNode clase , debe crear una instancia de una nueva SimpleProjectNode en el SimpleProjectFactory.CreateProject método y almacenarla en caché en un campo privado para su uso posterior.

Para conectar la clase de generador de proyectos y la clase node

En el archivo SimpleProjectFactory.cs , agregue la siguiente using directiva:

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

Reemplace el SimpleProjectFactory.CreateProject método mediante el código siguiente.

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

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

Vuelva a generar la solución y compruebe que se compila sin errores.

Prueba de la clase ProjectNode

Pruebe el generador de proyectos para ver si crea una jerarquía de proyectos.

Para probar la clase ProjectNode

Presiona F5 para iniciar la depuración. En la instancia experimental, cree un nuevo SimpleProject.
Visual Studio debe llamar a la factoría de proyectos para crear un proyecto.
Cierre la instancia experimental de Visual Studio.

Icono agregar un nodo de proyecto personalizado

El icono del nodo del proyecto de la sección anterior es un icono predeterminado. Puede cambiarlo a un icono personalizado.

Para agregar un icono de nodo de proyecto personalizado

En la carpeta Recursos , agregue un archivo de mapa de bits denominado SimpleProjectNode.bmp.
En las ventanas Propiedades , reduzca el mapa de bits a 16 por 16 píxeles. Haga que el mapa de bits sea distintivo.
En la ventana Propiedades , cambie la acción Compilar del mapa de bits a Recurso incrustado.
En SimpleProjectNode.cs, agregue las siguientes using directivas:
```
using System.Drawing;
using System.Windows.Forms;
```

Agregue el siguiente campo estático y constructor a la SimpleProjectNode clase .

private static ImageList imageList;

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

Agregue la siguiente propiedad al principio de la SimpleProjectNode clase .

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

Reemplace el constructor de instancia por el código siguiente.
```
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 construcción estática, SimpleProjectNode recupera el mapa de bits del nodo del proyecto de los recursos del manifiesto de ensamblado y lo almacena en caché en un campo privado para su uso posterior. Observe la sintaxis de la ruta de acceso de la GetManifestResourceStream imagen. Para ver los nombres de los recursos de manifiesto insertados en un ensamblado, use el GetManifestResourceNames método . Cuando este método se aplica al SimpleProject ensamblado, los resultados deben ser los siguientes:

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 construcción de la instancia, la ProjectNode clase base carga Resources.imagelis.bmp, en la que se insertan mapas de bits de 16 x 16 x 16 de Resources\imagelis.bmp. Esta lista de mapas de bits está disponible para SimpleProjectNode como ImageHandler.ImageList. SimpleProjectNode anexa el mapa de bits del nodo del proyecto a la lista. El desplazamiento del mapa de bits del nodo del proyecto en la lista de imágenes se almacena en caché para su uso posterior como valor de la propiedad pública ImageIndex . Visual Studio usa esta propiedad para determinar qué mapa de bits se va a mostrar como el icono del nodo del proyecto.

Probar el icono de nodo de proyecto personalizado

Pruebe el generador de proyectos para ver si crea una jerarquía de proyectos que tiene el icono de nodo de proyecto personalizado.

Para probar el icono de nodo de proyecto personalizado

Inicie la depuración y, en la instancia experimental, cree un nuevo SimpleProject.
En el proyecto recién creado, observe que SimpleProjectNode.bmp se usa como icono del nodo del proyecto.
Abra el archivo Program.cs en el editor de código. Debería ver el código fuente similar al código siguiente.
```
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();
        }
    }
}
```
Observe que los parámetros de plantilla $nameSpace$ y $className$ no tienen nuevos valores. Aprenderá a implementar la sustitución de parámetros de plantilla en la sección siguiente.

Sustituir parámetros de plantilla

En una sección anterior, registró la plantilla de proyecto con Visual Studio mediante el ProvideProjectFactory atributo . El registro de la ruta de acceso de una carpeta de plantilla de esta manera le permite habilitar la sustitución de parámetros de plantilla básica mediante la invalidación y expansión de la ProjectNode.AddFileFromTemplate clase. Para obtener más información, vea Nueva generación de proyectos: En segundo plano, parte dos.

Ahora agregue código de reemplazo a la AddFileFromTemplate clase .

Para sustituir parámetros de plantilla

En el archivo SimpleProjectNode.cs , agregue la siguiente using directiva.
```
using System.IO;
```

Reemplace el AddFileFromTemplate método mediante el código siguiente.

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

Establezca un punto de interrupción en el método , justo después de la instrucción de asignación className .

Las instrucciones de asignación determinan valores razonables para un espacio de nombres y un nuevo nombre de clase. Las dos ProjectNode.FileTemplateProcessor.AddReplace llamadas al método reemplazan los valores de parámetro de plantilla correspondientes mediante estos nuevos valores.

Prueba de la sustitución de parámetros de plantilla

Ahora puede probar la sustitución de parámetros de plantilla.

Para probar la sustitución de parámetros de plantilla

Inicie la depuración y, en la instancia experimental, cree un nuevo SimpleProject.
La ejecución se detiene en el punto de interrupción del AddFileFromTemplate método .
Examine los valores de los nameSpace parámetros y className .
- nameSpace se asigna el valor del <elemento RootNamespace> en el archivo de plantilla de proyecto \Templates\Projects\SimpleProject\SimpleProject.myproj . En este caso, el valor es MyRootNamespace.
- className se asigna el valor del nombre de archivo de origen de clase, sin la extensión de nombre de archivo. En este caso, el primer archivo que se va a copiar en la carpeta de destino es AssemblyInfo.cs; por lo tanto, el valor de className es AssemblyInfo.
Quite el punto de interrupción y presione F5 para continuar la ejecución.

Visual Studio debería terminar de crear un proyecto.

Abra el archivo Program.cs en el editor de código. Debería ver el código fuente similar al código siguiente.

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

Observe que el espacio de nombres es ahora MyRootNamespace y el nombre de clase es ahora Program.

Inicie la depuración del proyecto. El nuevo proyecto debe compilar, ejecutar y mostrar "Hello VSX!!" en la ventana de la consola.

Felicidades. Ha implementado un sistema de proyecto administrado básico.

Compartir a través de