c# - tutorial - visual studio community

Extensión de Visual Studio Text Editor

Question

Estoy tratando de comenzar con las extensiones de Visual Studio (2010) y estoy teniendo dificultades para encontrar los materiales adecuados. Tengo el SDK, pero las muestras incluidas parecen ser cosas como adornos, ventanas e íconos.

Estoy tratando de hacer una extensión que funcione directamente con el editor de texto (para alfabetizar todos los nombres de mis métodos en una clase, o hacer que todos los nombres constantes sean mayúsculas, por ejemplo) pero no puedo encontrar una demostración para este tipo de funcionalidad , o incluso un tutorial.

¿Alguien sabe dónde puedo encontrar este tipo de cosas?

Answer 1

Tenía exactamente la misma pregunta y ahora he navegado por la web varias horas hasta que pude entender y explicar cómo debería comenzar con una extensión de este tipo.

En mi siguiente ejemplo crearemos una extensión pequeña y tonta que siempre agregará "Hola" al comienzo de un archivo de código cuando se haya realizado una edición. Es muy básico, pero debería darle una idea de cómo continuar desarrollando esta cosa.

Tenga cuidado: tiene que analizar los archivos de código completamente por su cuenta: Visual Studio no le da ninguna información sobre dónde están las clases, los métodos o lo que sea y qué contienen. Ese es el mayor obstáculo que se debe tomar al hacer una herramienta de formato de código y no se tratará en esta respuesta. [*]

Para aquellos que saltaron a esta respuesta, asegúrese de descargar e instalar primero el Visual Studio SDK o no encontrará el tipo de proyecto mencionado en el paso uno.

Creando el proyecto

1. Comience por crear un nuevo proyecto del tipo "Visual C #> Extensibilidad> Proyecto VSIX" (solo visible si seleccionó .NET Framework 4 como el marco de destino). Tenga en cuenta que es posible que deba seleccionar el tipo de proyecto "Clasificador de editor" en lugar del tipo "Proyecto VSIX" para que funcione. Comenta abajo.

2. Después de que se haya creado el proyecto, se abrirá el archivo "source.extension.vsixmanifest", que le brinda la posibilidad de configurar el nombre del producto, el autor, la versión, la descripción, el icono, etc. Creo que este paso es bastante autoexplicativo, puede cerrar la pestaña ahora y restaurarla más tarde abriendo el archivo vsixmanifest.

Crear una clase de escucha para recibir notificaciones sobre creaciones de instancias de editor de texto

A continuación, debemos escuchar cada vez que se haya creado un editor de texto en Visual Studio y vincularlo con nuestra herramienta de formato de código. Un editor de texto en VS2010 es una instancia de IWpfTextView .

1. Agregue una nueva clase a nuestro proyecto y TextViewCreationListener nombre TextViewCreationListener . Esta clase tiene que implementar la interfaz Microsoft.VisualStudio.Text.Editor.IWpfTextViewCreationListener . Debe agregar una referencia a Microsoft.VisualStudio.Text.UI.Wpf a su proyecto. La DLL del ensamblado se encuentra en su directorio de Visual Studio SDK en VisualStudioIntegration / Common / Assemblies / v4.0 .

2. Tienes que implementar el método TextViewCreated de la interfaz. Este método tiene un parámetro que especifica la instancia del editor de texto que se ha creado. Crearemos una nueva clase de formato de código a la que esta instancia pasará más adelante.

3. Necesitamos hacer que la clase TextViewCreationListener visible para Visual Studio especificando el atributo [Export(typeof(IWpfTextViewCreationListener))] . Agregue una referencia a System.ComponentModel.Composition a su proyecto para el atributo Export .

4. Además, debemos especificar con qué tipos de archivos el formateador de código debe estar vinculado al editor de texto. Solo nos gusta formatear archivos de código y no archivos de texto sin formato, por lo que agregamos el atributo [ContentType("code")] a la clase de oyente. Para ello, debe agregar una referencia a Microsoft.VisualStudio.CoreUtility a su proyecto.

5. Además, solo queremos cambiar el código editable y no los colores o adornos que lo rodean (como se ve en los proyectos de ejemplo), así que agregamos el atributo [TextViewRole(PredefinedTextViewRoles.Editable)] a la clase. De nuevo, necesita una nueva referencia, esta vez para Microsoft.VisualStudio.Text.UI .

6. Marque la clase como interna sellada. Al menos esa es mi recomendación. Ahora su clase debería verse similar a esto:

   [ContentType("code")]
   [Export(typeof(IWpfTextViewCreationListener))]
   [TextViewRole(PredefinedTextViewRoles.Editable)]
   internal sealed class TextViewCreationListener : IWpfTextViewCreationListener
   {
       public void TextViewCreated(IWpfTextView textView)
       {
       }
   }

Crear una clase para formatear el código

A continuación, necesitamos una clase que maneje la lógica de formateo de códigos, los métodos de clasificación, etc. Nuevamente, en este ejemplo, simplemente agregará "Hola" al inicio del archivo cada vez que se realice una edición.

1. Agregue una nueva clase llamada Formatter a su proyecto.

2. Agregue un constructor que tome un argumento IWpfTextView . Recuerde que queríamos pasar la instancia del editor creado a esta clase de formato en el método TextViewCreated de nuestra clase de oyente (simplemente agregue el new Formatter(textView); al método allí).

3. Guarde la instancia pasada en una variable miembro. Será útil al formatear el código más tarde (por ejemplo, para recuperar la posición de intercalación). También PostChanged eventos Changed y PostChanged de la propiedad TextBuffer de la instancia del editor:

   public Formatter(IWpfTextView view)
   {
       _view = view;
       _view.TextBuffer.Changed += new EventHandler<TextContentChangedEventArgs>(TextBuffer_Changed);
       _view.TextBuffer.PostChanged += new EventHandler(TextBuffer_PostChanged);
   }

4. El evento Changed se invoca cada vez que se realiza una edición (por ejemplo, escribir un carácter, pegar código o cambios programáticos). Debido a que también reacciona a los cambios programáticos, utilizo un bool para determinar si nuestra extensión o el usuario / cualquier otra cosa está cambiando el código en este momento y llamo a mi FormatCode() personalizado FormatCode() solo si nuestra extensión no se está editando. De lo contrario, llamarás recursivamente a este método que bloqueará Visual Studio:

   private void TextBuffer_Changed(object sender, TextContentChangedEventArgs e)
   {
       if (!_isChangingText)
       {
           _isChangingText = true;
           FormatCode(e);
       }
   }

5. Tenemos que restablecer esta variable de miembro bool en el controlador de eventos PostChanged nuevamente a false .

6. Pasemos los argumentos del evento Changed a nuestro método personalizado FormatCode porque contienen lo que ha cambiado entre la última edición y ahora. Esas ediciones se almacenan en la matriz e.Changes del tipo INormalizedTextChangeCollection (es decir, el enlace al final de mi publicación para obtener más información sobre este tipo). Analizamos todas esas ediciones y llamamos a nuestro método personalizado HandleChange con el nuevo texto que ha producido esta edición.

   private void FormatCode(TextContentChangedEventArgs e)
   {
       if (e.Changes != null)
       {
           for (int i = 0; i < e.Changes.Count; i++)
           {
               HandleChange(e.Changes[0].NewText);
           }
       }
   }

7. En el método HandleChange , podríamos escanear las palabras clave para manejarlas de una manera específica (recuerde, usted debe analizar cualquier código en usted mismo), pero aquí agregamos tontamente "Hola" al comienzo del archivo para fines de prueba. Por ejemplo, tenemos que cambiar el TextBuffer de nuestra instancia de editor. Para hacerlo, necesitamos crear un objeto ITextEdit con el que podamos manipular el texto y aplicar sus cambios posteriormente. El código es bastante autoexplicativo:

   private void HandleChange(string newText)
   {
       ITextEdit edit = _view.TextBuffer.CreateEdit();
       edit.Insert(0, "Hello");
       edit.Apply();
   }

Al compilar este complemento, se inicia una sección experimental de Visual Studio con solo nuestra extensión cargada. Crea un nuevo archivo C # y comienza a escribir para ver los resultados.

Espero que esto te brinde algunas ideas sobre cómo continuar en este tema. Tengo que explorarlo yo mismo ahora.

Recomiendo mucho la documentación del modelo de texto del editor en MSDN para obtener pistas sobre cómo puede hacer esto y aquello. http://msdn.microsoft.com/en-us/library/dd885240.aspx#textmodel

Notas a pie de página

[*] Tenga en cuenta que Visual Studio 2015 o posterior vienen con la plataforma de compilación Rosyln, que de hecho ya analiza los archivos C # y VB.NET por usted (y probablemente otros idiomas preinstalados también) y expone su estructura sintáctica jerárquica, pero estoy no es un experto en este tema aún para dar una respuesta sobre cómo usar estos nuevos servicios. El progreso básico de iniciar una extensión de editor sigue siendo el mismo que se describe en esta respuesta de todos modos. Tenga en cuenta que, si usa estos servicios, se volverá dependiente de Visual Studio 2015+ y la extensión no funcionará en versiones anteriores.

Answer 2

solo eche un vistazo al sitio "Comenzando con las extensiones del Editor" en MSDN http://msdn.microsoft.com/en-us/library/dd885122.aspx

Thorsten