El blog de Javier Torrecilla : Extensibilidad

[HowTo]Agregar Código al Código desde un Addin

Javier Torrecilla — Thu, 29 Dec 2011 09:07:00 GMT

Introducción

Antes de comenzar a hablar del propio titulo, vamos a hacer un índice de los artículos publicados en la serie de extensibilidad:

Parte 1: Agregar elementos a un menú de VS

Parte 2: Obtener los tipos de Proyecto de VS

Parte 3: Agregar Un Proyecto Nuevo

Parte 4: Agregar Ficheros a un Proyecto

Parte 5: Agregar Referencias

Parte 6: Eliminando Datos

En este artículo vamos a ver como agregar código o modificar el texto existente en el documento activo.

Código

        1: string addingText = GetText();

       2: int position = GetPosition();

       3: var fichero = (EnvDTE.Document)_applicationObject.Solution.DTE.ActiveDocument;

       4: var sel = (fichero.Selection as EnvDTE.TextSelection);

       5: sel.GotoLine(position);

       6: sel.Text = addingText ;

       7: sel.NewLine(1);

En el ejemplo utilizo un objeto de tipo TextSelection para agregar el texto en la posición que yo indique a través del conjunto de métodos disponibles.

Espero que os sea de utilidad Saludos

[HowTo]Eliminando Proyectos, ficheros y referencias…

Javier Torrecilla — Tue, 27 Dec 2011 10:29:10 GMT

Introducción

Continuando con la serie de extensibilidad de Visual Studio, en este artículo vamos a ver como eliminar algunas de las cosas que ya hemos visto como añadir a un proyecto / solución desde un addin en VS.

Código

Eliminar un Proyecto Existente

        1: var solution = (Solution2)_applicationObject.Solution;

       2: var project = GetProject(solution);

       3: solution.Remove(project);

       4:

Eliminar un Fichero Existente

       1: var solution = (Solution2)_applicationObject.Solution;

       2: var project = GetProject(solution);

       3: var file = GetFile(project);

       4: file.Remove();

Eliminar una Referencia Existente

       1: var solution = (Solution2)_applicationObject.Solution;

       2: var project = GetProject(solution);

       3: var reference = GetReference(project);

       4: reference.Remove();

Un saludo y espero que os sea de utilidad!!

[HowTo] Agregar Referencias a un proyecto

Javier Torrecilla — Tue, 27 Dec 2011 10:10:05 GMT

Introducción

Continuando con la serie de extensibilidad de Visual Studio, en este artículo vamos a ver como agregar una referencia a un proyecto existente.

Código

Partiendo de los código utilizados en ejemplos anteriores, vamos a agregar una nueva opción de menú y dentro del evento clic agregaremos el siguiente fragmento de código:

        1: string file = string.Empty;

       2:            using (OpenFileDialog opd = new OpenFileDialog())

       3:            {

       4:                opd.Filter = "DLL | (*.dll)";

       5:                if (opd.ShowDialog() == DialogResult.OK)

       6:                {

       7:                    file = opd.FileName;

       8:                    try

       9:                    {

      10:                        var solution = (Solution2)_applicationObject.Solution;

      11:                        var project = GetProject(solution);

      12:                        (project.Object as VSLangProj.VSProject).References.Add(file);

      13:                    }

      14:                    catch (Exception ex )

      15:                    {

      16:                        

      17:                        MessageBox.Show(String.Format("Sucedio un problema intentando agregar la DLL: {0}",ex.Message));

      18:                    }

      19:                    

      20:                }

      21:            }

En el método estamos haciendo una conversión del tipo Project(ENVDTE) a VSPRoject, y a continuación a través de la Colección References, agregamos la DLL indicada.

Un saludo y espero que os sea de utilidad.

[HowTo] Agregar Ficheros a un Proyecto Existente

Javier Torrecilla — Thu, 15 Dec 2011 11:18:00 GMT

Introducción

Siguiendo con la serie de post de extensibilidad que he estado escribiendo, vamos a ver en este artículo como agregar ficheros a un proyecto existente.

Agregar Ficheros

En este apartado vamos a ver como agregar ficheros nuevos o ficheros ya existentes.

Ficheros Nuevos

Al igual que existen plantillas predefinidas para proyectos, podemos encontrar plantillas de tipos de elementos agregables a un proyecto.

Para poder explorar el conjunto de plantillas existentes, dentro del directorio de instalación de Visual Studio, encontraremos la carpeta ItemTemplates, con los distintos lenguajes, instalados para poder consultar sus elementos.

var solution = (Solution2)_applicationObject.Solution;

var project = (Project)solution.Projects.Item(GetProject());

var template = solution.GetProjectItemTemplate("Class.zip", "CSharp");

var temp = project.ProjectItems.AddFromTemplate(template, "MyNewClass.cs");

El fragmento de código anterior está incluido en el evento click de una opción de menú de nuestro Addin.

El objeto Solution2 dispone del método GetProjectItemTemplate, que a través del nombre de la plantilla y el lenguaje a utilizar, nos va a permitir obtener el nombre de la plantilla para su importación.

A través del método AddFromTemplate de la colección ProjectItems del proyecto seleccionado, vamos a definir la plantilla obtenida y asignaremos el nombre de nuestro nuevo fichero.

Ficheros existentes

Existen dos formas de agregar un fichero existente a un proyecto:

- Como una copia

- De forma vinculada

1) Como una copia:

Se creará una copia del fichero deseado en la carpeta del proyecto y se agregará al mismo.

Para realizar este proceso bastaría con ejecutar el siguiente fragmento de código:

string file = string.Empty;

using (OpenFileDialog opd = new OpenFileDialog())

{

    if (opd.ShowDialog() == DialogResult.OK)

    {

        file = opd.FileName;

        var solution = (Solution2)_applicationObject.Solution;

        var project = (Project)solution.Projects.Item(GetProject());

        project.ProjectItems.AddFromFileCopy(file);

    }

}

A través del cuadro de Abrir Fichero (OpenFileDialog) vamos a elegir un fichero existente, y lo agregaremos como una copia al proyecto seleccionado a través del método AddFromFileCopy.

2) De forma vinculada:

La segunda forma de agregar un fichero existente a un proyecto es a través de un Vinculo. Visual Studio establecerá un vinculo al fichero existente sin copiarlo en el directorio del proyecto. Esto puede generar problemas si el fichero se mueve o se elimina, provocando que el enlace se pierda.

El código va a ser muy similar al anterior, con la salvedad que en lugar de utilizar el método AddFromFileCopy se va a utilizar el método AddFromFile.

string file = string.Empty;

using (OpenFileDialog opd = new OpenFileDialog())

{

    if (opd.ShowDialog() == DialogResult.OK)

    {

        file = opd.FileName;

        var solution = (Solution2)_applicationObject.Solution;

        var project = (Project)solution.Projects.Item(GetProject());

        project.ProjectItems.AddFromFile(file);

    }

}

Espero que os sea de utilidad.

Saludos

[HowTo] Agregar un Proyecto Nuevo a Visual Studio desde Código

Javier Torrecilla — Wed, 14 Dec 2011 15:36:00 GMT

Introducción

En un post anterior vimos como definir un nuevo elemento en el Menú contextual de la Solución dentro de Visual Studio, y en este otro Post, hemos visto como obtener las distintas plantillas de proyectos de Visual Studio según una determinada versión.

El objetivo del presente artículo, es indicar como agregar a una solución existente un Tipo de Proyecto dado, para ello partiendo del código de los dos artículos anteriores vamos a plantear una solución.

Agregando un nuevo Proyecto

Dentro del evento Click de nuestro elemento de Menú, vamos a agregar el siguiente bloque de código:

var solution = (Solution2)_applicationObject.Solution;

  

var newProjectName = String.Format("DLL{0}", solution.Projects.Count + 1);

var newProjectPath = String.Format(@"{0}\{1}",solution.FullName.Substring(0,solution.FullName.LastIndexOf(@"\")),newProjectName );

var templateName = "ClassLibrary.zip";

var template = solution.GetProjectTemplate(templateName , "CSharp");

solution.AddFromTemplate(template, newProjectPath , newProjectName );

En el ejemplo, construyo de manera genérica el nombre del nuevo Proyecto llamandolo DLL + un contador que será el número de proyectos existentes en mi solución más 1.

Vamos a definir la ruta donde se va a almacenar el nuevo proyecto, el cual estará almacenado dentro del directorio de nuestra solución incluyendo el nombre de nuestro proyecto.

A continuación, obtendremos el nombre de la plantilla a partir del método GetProjectTemplate del objeto Solution2 que hemos definido.

Y por último a través del método AddFromTemplate definiremos el nuevo proyecto y se agregará a nuestra solución.

Espero que os sea de utilidad.

Saludos

[HowTo]Obtener los Tipos de Proyecto de Visual Studio

Javier Torrecilla — Wed, 14 Dec 2011 10:16:00 GMT

Introducción

En mi anterior artículo explicaba la forma de agregar una nueva opción de menú a uno ya existente, dentro de un Addin para Visual Studio.

Siguiendo un poco con el tema de “extender” Visual Studio, vamos a ver como podemos obtener los distintos tipos de proyecto de una determinada versión de Visual Studio. (En el siguiente artículo, veremos como agregar un proyecto a una solución existente).

Código

Aunque he publicado el código en Code MSDN, me gustaría exponerlo aquí y explicarlo brevemente:

En primer lugar, será necesario que obtengamos el directorio donde se encuentra instalada la versión de Visual Studio que vamos a comprobar:

private  void GetVSFolder()

{

    string VSVersion = VSVersions.GetVSVersion(Version);

    string folder = String.Format("{0}{1}",RegistryPath,VSVersion);

    InstallationFolder = Registry.GetValue(folder, "InstallDir", "").ToString();

}

Dada una versión de Visual Studio, y la ruta de Registro de Windows “HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\”, vamos a obtener el valor de la clave “Install Dir”, y la asignaremos a una propiedad de nuestra clase.

Dentro del código vamos a tener un enumerador de las distintas versiones de VS y un diccionario (Dictionary<string,string>) con la pareja versión y Nombre largo. La versión es el valor que vamos a utilizar para poder obtener el directorio de Instalación.

La clase va a contener una Propiedad de tipo Lista de cadenas (List<string>) que va a contener las distintas agrupaciones para los proyectos (WEB, CSharp, VisualBasic…). Para obtener dichos valores:

private  void  GetProjectTypes()

        {

            if (String.IsNullOrWhiteSpace(InstallationFolder)) throw new Exception("El Directorio de Visual Studio no puede estar vacio.");

            ProjectType = new List<string>();

            foreach(var folder in System.IO.Directory.EnumerateDirectories(String.Format(@"{0}\ProjectTemplates",InstallationFolder)))

            {

                if (!ProjectType.Contains(folder)) ProjectType.Add(folder);

            }

  

        }

Para tratar las distintas plantillas, he definido una clase “ProjectTemplate”:

public class ProjectTemplate

   {

       public string TemplateName { get; set; }

       public string TemplatePath { get; set; }

       public string ProjectType { get; set; }

       public override string ToString()

       {

           return String.Format("{0} - {1}", ProjectType, TemplateName);

       }

   }

Y dentro de la clase una propiedad de tipo Lista (List<ProjectTemplate>), que rellenaremos de la siguiente manera:

private void GetProjectTemplates()

        {

            if (String.IsNullOrWhiteSpace(InstallationFolder)) throw new Exception("El Directorio de Visual Studio no puede estar vacio.");

            ProjectTemplates = new List<ProjectTemplate>();

            

            foreach (var file in System.IO.Directory.EnumerateFiles(String.Format(@"{0}\ProjectTemplates", InstallationFolder),"*"

                                                                        ,System.IO.SearchOption.AllDirectories))

            {

                var possition = file.IndexOf("ProjectTemplates")+17;

               ProjectTemplates.Add( new ProjectTemplate { 

                                            TemplatePath = file,

                                            TemplateName = file.Substring(file.LastIndexOf(@"\")+1),

                                            ProjectType = file.Substring(possition,file.IndexOf(@"\",possition)) 

                                        }

                                        ) ;

  

            }

        }

Para utilizar este proyecto, bastaría con agregar la referencia a un nuevo proyecto, y para poder probarlo:

VSInfo.VSInfo vs = new VSInfo.VSInfo(VSInfo.eVSVersions.VS2010);

           foreach (var template in vs.ProjectTemplates)

           {

              Console.WriteLine(template.ToString());

           }

Espero que os sea de utilidad.

Saludos

[How To] Agregar un elemento de menú a Visual Studio.

Javier Torrecilla — Mon, 12 Dec 2011 12:48:00 GMT

Introducción

En este post quiero explicar como agregar una nueva opción de menú propia a un menú de Visual Studio.

¿Por dónde empezar?

El primer paso para que podamos empezar a “extender” Visual Studio es realizar la descarga del último SDK disponible.

Una vez descargado e instalado, vamos a abrir Visual Studio, y generaremos un nuevo proyecto de tipo: Complemento de Visual Studio

Una vez pulsado Aceptar, va aparecer un asistente donde indicaremos el lenguaje que vamos a utilizar en nuestro AddIn, el nombre, donde se va a utilizar…

Una vez finalizado el asistente, vamos a ver el tema de agregar una nueva opción a un menú.

Un objeto predefinido en la clase de inicio del AddIn va a ser _applicationObject, que va a ser del tipo DTE2.

Vamos a definir un método donde vamos a implementar la lógica de agregación del menú:

private void CreateMyMenuOption(DTE2 _applicationObject)

        {

            if (_applicationObject == null) throw new ArgumentNullException("_applicationObject");;

            CommandBar oCommandBar = ((Microsoft.VisualStudio.CommandBars.CommandBars)_applicationObject.CommandBars)["Solution"];

  

            CommandBarButton myMenu = (CommandBarButton)oCommandBar.Controls.Add(MsoControlType.msoControlButton, 

                                     System.Reflection.Missing.Value, System.Reflection.Missing.Value, 1, true);

            myMenu.Caption = "Mi Menu";

            try

            {

                oSubMenuItemHandler = (CommandBarEvents)_applicationObject.Events.get_CommandBarEvents(myMenu);

                oSubMenuItemHandler.Click += new _dispCommandBarControlEvents_ClickEventHandler(oSubMenuItemHandler_Click);

            }

            catch (Exception ex)

            {

                ShowException(ex);

            }

        }

A través del objeto CommandBar, vamos a elegir el menú donde vamos a agregar la nueva opción que estamos creando.

Para obtener un listado de los menús disponible bastaría con recorrer la colección y obtener la propiedad Name:

   1: CommandBars commandBars = (CommandBars)_applicationObject.CommandBars;

Dentro del método defino un objeto del tipo CommandBarButton que agregaré a la colección de controles existentes en el menú seleccionado previamente.

En este objeto podremos definir un conjunto de propiedades como puede ser el Nombre que se visualizará, el ToolTip, la descripción…

Para asignarle un evento, vamos a utilizar una variable del tipo CommandBarEvents, y asignaremos su evento click:

CommandBarEvents oSubMenuItemHandler;

void oSubMenuItemHandler_Click(object CommandBarControl, ref bool Handled, ref bool CancelDefault)

        {

            MessageBox.Show("Me has pulsado!!!");

        }

El menú de destino de está prueba va a ser el menú contextual de “Soluciones”.

Para probar nuestro nuevo menú, bastará con que pulsemos F5. Al hacerlo, se va a abrir una nueva instancia de Visual Studio. Dentro generaremos un nuevo proyecto de tipo Solución en Blanco, al pulsar con el botón secundario sobre la nueva solución, aparecerá la nueva opción de menú que hemos definido de forma funcional.

Espero que os sea de utilidad.

Saludos!