Creación de fragmentos de código en C# - Personalización de Visual Studio para mayor eficacia

Por qué son importantes los fragmentos de código

Tim comienza compartiendo cómo utiliza con frecuencia fragmentos de código para insertar cosas como autopropiedades, constructores y bucles foreach. Demuestra cómo escribir cw y pulsar Tab dos veces inserta Console.WriteLine(), colocando el cursor entre paréntesis, un truco esencial para la salida de contenido de cadena.

Pero, como señala, no todos los métodos útiles tienen un fragmento incorporado. Por ejemplo, a Console.ReadLine() le falta una. ¿La respuesta de Tim? Cree el suyo propio.

Cómo crear un proyecto de demostración en Visual Studio

Para hacer una demostración en contexto, Tim crea una aplicación web ASP.NET Core en Visual Studio. Aunque el tipo de proyecto no es crítico, tener archivos C# y HTML con los que trabajar le permite mostrar ejemplos de ambos lenguajes.

Este es un recordatorio clave: los fragmentos no se limitan a C#, sino que pueden aplicarse a varios lenguajes compatibles con Visual Studio, como HTML, XAML y otros.

Snippets integrados y el poder de los atajos

Tim muestra algunos fragmentos existentes:

• cw + Tab Tab → Console.WriteLine()

• ctor + Tab Tab → Constructor

• prop + Tab Tab → Propiedad autoimplementada (por ejemplo, public string Test { get; set; })

• propfull → Crea una propiedad con un campo de respaldo

Estos atajos están diseñados para eliminar repeticiones y aumentar el rendimiento. Basta con especificar un tipo, como string o int, y un nombre, y dejar que el resto se autogenere.

Estos fragmentos incorporados también pueden demostrar la interpolación, los modificadores de acceso como public y los elementos definidos por el sistema, garantizando que el código siga una estructura coherente.

Crear su propio snippet en VS Code

En lugar de utilizar una herramienta generadora de fragmentos, Tim opta por Visual Studio Code por su sencillez y el resaltado de sintaxis XML.

Crea un archivo llamado readline.snippet y muestra la estructura XML esencial:

<CodeSnippets>
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>Console.ReadLine</Title>
      <Shortcut>cr</Shortcut>
      <Description>Creates Console.ReadLine()</Description>
      <Author>Tim Corey</Author>
    </Header>
    <Snippet>
      <Code Language="csharp"><!-- [CDATA[
Console.ReadLine();
]]></Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

<CodeSnippets>
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>Console.ReadLine</Title>
      <Shortcut>cr</Shortcut>
      <Description>Creates Console.ReadLine()</Description>
      <Author>Tim Corey</Author>
    </Header>
    <Snippet>
      <Code Language="csharp"><!-- [CDATA[
Console.ReadLine();
]]></Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Este es un fragmento básico, usando <!-- [CDATA[]]> para envolver el código C# sin procesar. El atajo cr ahora activa la inserción del método Console.ReadLine() con dos pulsaciones de Tabulador.

Tim señala que el formato se hereda del entorno Visual Studio del usuario, lo que significa que la sangría y el espaciado coincidirán con su configuración.

Importación de fragmentos de código a Visual Studio

Tim explica cómo importar un archivo .snippet mediante Herramientas > Administrador de fragmentos de código. Selecciona la ubicación de Mis fragmentos de código, asegurándote de que el fragmento aparezca cuando sea necesario.

Una vez importado, tecleando cr + Tab Tab se inserta la línea Console.ReadLine(), lista para asignar su valor a una variable o utilizarla dentro de un bloque de manejo de excepciones.

Cabeceras de documentación reutilizables

A continuación, Tim muestra un fragmento de documentación, una necesidad frecuente en proyectos empresariales o equipos de colaboración. Crea un fragmento con el atajo docme que genere un bloque de comentarios:

/// Title:
/// Author:
/// Date:
/// Purpose:

/// Title:
/// Author:
/// Date:
/// Purpose:

Es ideal para el seguimiento de cambios, autoría y contexto de archivos. Mientras que herramientas como Git gestionan el control de versiones, las cabeceras ofrecen referencias visuales rápidas, especialmente en equipos grandes.

Recortes HTML: Ejemplo de formulario Bootstrap

Los fragmentos no son sólo para código C#. Tim muestra cómo utilizarlas en HTML, lo que resulta perfecto para crear formularios, elementos de entrada y colecciones de etiquetas estructuradas.

Copia un ejemplo de formulario Bootstrap y envuélvelo en el mismo formato de fragmento XML, cambiando el idioma a html. Después de la importación, al teclear el atajo sampleform se inserta una estructura HTML ya preparada, lo que evita tener que hacer repetidas referencias a URL externas o copiar textos repetitivos.

Snippet avanzado con marcadores de posición y variables

Aquí es donde las cosas se ponen más avanzadas y más potentes. Tim crea un fragmento que recupera un valor de configuración:

_config.GetValue<string>("values:myTest");

_config.GetValue<string>("values:myTest");

Muestra cómo utilizar marcadores de posición tanto para el tipo (string, int, bool) como para la ruta (values:myTest), de modo que el desarrollador solo tenga que rellenar lo que sea diferente.

En el XML, utiliza:

<Declarations>
  <Literal>
    <id>ValType</id>
    <Default>string</Default>
    <ToolTip>Data type of the value</ToolTip>
  </Literal>
  <Literal>
    <id>Path</id>
    <Default>values:myTest</Default>
    <ToolTip>Config path</ToolTip>
  </Literal>
</Declarations>

<Declarations>
  <Literal>
    <id>ValType</id>
    <Default>string</Default>
    <ToolTip>Data type of the value</ToolTip>
  </Literal>
  <Literal>
    <id>Path</id>
    <Default>values:myTest</Default>
    <ToolTip>Config path</ToolTip>
  </Literal>
</Declarations>

En el cuerpo del fragmento:

_config.GetValue<$ValType$>("$Path$")

_config.GetValue<$ValType$>("$Path$")

El uso de variables y declaraciones permite generar código flexible, expresivo y conciso. Es ideal para tareas como la recuperación de parámetros de seguridad, el acceso a diccionarios o la lectura de valores anidados de archivos JSON.

Por qué los fragmentos de código mejoran el rendimiento

Tim concluye explicando que los fragmentos de código no son sólo una cuestión de velocidad, sino que promueven prácticas coherentes, reducen los errores y mejoran la legibilidad del código en todo el equipo. Con el tiempo, incluso el ahorro de unos segundos por fragmento puede traducirse en horas ahorradas.

Destaca que los fragmentos ayudan con:

• Inicialización de tareas comunes

• Manejo estandarizado de excepciones con try-catch-finally

• Creación de plantillas de clases completas

• Trabajar con bloques finally, bloques catch estructurados y anulaciones de métodos

Pensamientos finales: La ventaja del desarrollador

Tanto si está creando sistemas complejos como aplicaciones sencillas, los fragmentos de código pueden ayudarle a escribir código C o C# de forma más rápida y coherente. Permiten:

• Eliminar repeticiones

• Centrarse en la lógica empresarial

• Mantener una base de código limpia, interpolada y bien documentada

Como sugiere Tim en su completo vídeo, explora tus propios hábitos de codificación. Descubre dónde escribes las mismas cosas una y otra vez. A continuación, decídete por un enfoque: crear un fragmento.

Pronto se dará cuenta de que ha transformado su flujo de trabajo, haciendo que el desarrollo sea más eficiente, organizado y agradable.

Ideas de fragmentos rápidos para empezar

• tryfinally - Generar bloques try + finally

• logerror - Insertar lógica de registro con Log.Error()

• propnotify - Propiedad con INotifyPropertyChanged

• filecheck - If File.Exists(path) con lógica en línea

• foreachdict - Recorrer un diccionario<TKey, TValue>

Consejo de Tim: No te limites a copiar y pegar de otro archivo: haz un fragmento y no vuelvas a escribirlo nunca más.