[Article] Visual Studio Code | Tips 1

Visual Studio Code se ha vuelto una de las herramientas de cabecera para muchos programadores. Desde su lanzamiento en el 2015, hasta estos días, ha tenido una evolución constante con grandes mejoras y muchas nuevas funcionalidades con cada nueva versión. A pesar de ser una herramienta bastante joven, ha escalado hasta el primer puesto entre los IDE de código fuente livianos del mercado. En esta serie de publicaciones vamos a ver algunos trucos, funcionalidades y plugins que podemos encontrar en esta fabulosa herramienta, como también, cómo nos ayudará a agilizar nuestra escritura de código, como también, optimizar nuestros tiempos..

Les dejo el link de descarga https://code.visualstudio.com/

Themes

Una de las funcionalidades que pocos conocen es la de los temas.  Visual Studio Code viene con varios temas para seleccionar que podemos elegir según a nuestro gusto. Para esto presionamos <F1> , tipeamos theme, presionamos <enter>, por último, seleccionaremos Preferences: Color Theme. Esto nos mostrará el listado de temas disponibles.

Podemos seleccionar el que más nos guste de la lista o bien agregar más temas si lo deseamos. Ingresamos nuevamente a la lista y elegimos la opción Install Additional Color Themes. Esto nos llevará a una lista descargable para seleccionar el que deseemos.

Iconos por tipo de archivo

Cada vez que creamos un archivo nuevo, Visual Studio Code, reconocerá la extensión y nos mostrará el icono relacionado con ese tipo de archivo. Posee una gran cantidad de iconos. Tenemos disponibles para casi todos  de los lenguajes más utilizados en el mercado.

Font Ligatures

Esta funcionalidad básicamente une algunos símbolos en un solo . Hace que la lectura de código sea más fácil del código y legible. Por ejemplo, si tenemos que escribir === será transformado a ☰. Parece ser más sencillo y natural de leer.  Otro ejemplo, si queremos hacer una arrow function, =>, sera cambiado por el símbolo ⇒.

Para tener disponible esta característica, lo primero que debemos hacer es descargar e instalar la fuente Fira Code. Les dejo el link para que lo descarguen.

https://github.com/tonsky/FiraCode#solution

Lo segundo que debemos hacer es agregar a la familia de fuentes la fuente Fira Code desde la configuración de VS Code. Presionamos <F1>, tepeamos User Setting, buscaremos en  la configuración a editar fontFamily y le agregamos Fira Code. Luego buscamos  fontLigatures y la activamos, esta funcionalidad viene desactivada por default.

Playground

Supongamos que queremos ver todos los features que posee Visual Studio Code. La manera de hacerlo es ingresando a la barra de comandos con <F1> y escribimos Playground. Seleccionamos Help: Interactive Playground. Esto nos mostrará todo el listado completo.

Panels

La funcionalidad de múltiples editores nos ayudará a tener varios archivos al mismo tiempo y poder visualizarlos de una forma simple. Por ejemplo, en angular, casi siempre tengo 2 archivos abiertos, el componente y la vista. Tenemos 2 maneras de dividirlo, la primera es por el icono que se encuentra arriba a la derecha. La segunda opción es por medio de Ctrl + \. Podemos dividir en la cantidad de columnas que deseemos.

Otra funcionalidad es la Grilla 2×2. Esta podemos activarla desde el menú View – Editor Layout – Grid (2×2). Nos dividirá la pantalla en 4 permitiendo visualizar 4 archivos al mismo tiempo.

Zen Mode

Trabajamos en pantalla completa!!!. Al activar ZenMode el Visual Studio Code ocultara todo, todas las barras y menús, se ampliará a todo nuestro screen permitiendo hacer foto 100% en lo que estamos trabajando.

Conclusión

Visual Studio Code se ha vuelto una poderosa herramienta para desarrolladores que podemos usar con la gran  mayoría de los lenguajes. En próximos post veremos más características de la herramienta.

[Article] Novedades de C# 8

Hoy vamos a ver algunas de las nuevas funcionalidad más interesantes que vendrán en C# 8. Para esto ver algunos ejemplos usaremos Visual Studio 2019 que se encuentra en su versión preview hasta el momento. También, deberemos instalar el SDK de .Net Core 3.0. Les dejo los links.

https://visualstudio.microsoft.com/es/vs/preview/

https://dotnet.microsoft.com/download/dotnet-core/3.0

Nullable reference types

Lo primero que vamos a ver son los  tipos nulos. Todos sabemos lo costoso que es cuando tenemos muchas excepciones que nos devuelve NulLReferenceException, más que todo, en un ambiente de producción.

Supongamos en siguiente caso: Tenemos un servicio que nos devuelve una lista de Personas.  Luego tenemos una metodo GetName, que nos devuelve e libro y el autor concatenados.

static string GetName(Person p)
    {
        return (p.MiddleName != null)
            ? $"{ p.FirstName } { p.MiddleName[0] }. { p.LastName })"
            : $"{ p.FirstName } { p.LastName })";
    }
}

public class Person
{
    public string FirstName { get; set; }
    public string? MiddleName { get; set; }
    public string LastName { get; set; }

    public Person(string first, string last)
    {
        FirstName = first;
        LastName = last;
    }
}

Si esta lista de personas nos devuelve una de sus propiedades, la segunda propiedad se encuentra en null, GetName(), fallará, debido a que se encuentra en null y devolverá la excepción System.NullRerefenceException.

Imaginemos si esto pasa todo el tiempo. Tratar de rastrear este tipo de excepciones a veces es difícil debido a que debemos suponer donde podría ocurrir. Aquí es donde esta nueva característica aparece para ayudarnos.

Lo primero que debemos hacer es activar esta característica de siguiente manera:

Una vez que se encuentra activa, veremos como el Visual Studio comienza a detectar los posibles null. En la siguiente imagen vemos como un campo, que debería ser parte del objeto, no está siendo declarado con Non-nullable.

Una vez que agregamos la declaración del parámetro, le asignamos el valor null, nos avisara que la variable declarada asociada no es nuleable como lo vemos en el siguiente código.

Por último, debemos arreglar nuestro método. Nos indica que es posible que uno de las propiedades posiblemente sea null en un momento en particular.

Entonces para solucionar esto podemos usar las siguientes líneas de código.

Esta funcionalidad no ayudará a prevenir muy eficientemente las situaciones donde es posible, que un error en el código, nos devuelva System.NullRerefenceException.

Async streams

Esta funcionalidad nos permite consumir o producir resultado asíncronos sencillamente sin la necesidad tener que devolver algo desde las llamadas. Veamos el siguiente código:

async Task GetBigResultAsync() { 
var result = await GetResultAsync(); if (result > 20) return result; else return -1; 
}

Supongamos que tenemos una lista, si estamos suscritos a un servicio o por ejemplo algún componente IoT no se reproducen tan fácilmente. Aquí es donde entra en juego la nueva Interfaz IAsyncEnumerable que es la versión asíncrona de IEnumerable. Esto nos permitirá que podamos agregar la palabra clave await a un foreach permitiendo recorrer los elementos a medida que van llegando

Ranges and indices

Ranges and indices es una funcionalidad que me gusta mucho. Supongamos nuevamente que tenemos un array o una collection, pero no deseamos recorrer desde el inicio hasta el final, sino solamente una parte. Actualmente deberíamos recorrer nuestro array omitiendo ciertas posición o bien hacer una subconsulta en linq devolviendo un nuevo resultado con el contenido deseado.

Para evitar esto podemos utilizar rango o índices. Veamos el siguiente código, vamos a decirle que solamente quiero recorrer desde 1 hasta 3.

foreach(var p in people[1..3]) yield return p;

Default implementations of interface members

Esta interesante característica nos ayudará a que la interfaces evolucionen más fácilmente. Supongamos que tenemos una interface que ya fue implementada. Si modificamos esa interfaz, seguramente, las implementaciones fallaran..

Para solucionar este inconveniente al modificar la interface podemos implementar, en la interface, un comportamiento por defecto:

interface ILogger
{
     void Log(LogLevel level, string message);
     void Log(Exception ex) => Log(LogLevel.Error, ex.ToString()); // New overload
}
class ConsoleLogger : ILogger
{
     public void Log(LogLevel level, string message) { … }
     // Log(Exception) gets default implementation
}

La clase ConsoleLogger no tiene implementado la sobrecarga del método Log, pero, al estar declarada en la interface como una implementación determinada no romperemos nuestras implementaciones antiguas.

Recursive patterns

C# 8 ahora nos permite tener patrones que contengan otros patrones. Por ejemplo:

IEnumerable GetEnrollees()
 {
     foreach (var p in People)
     {
         if (p is Student { Graduated: false, Name: string name }) yield return name;
     }
 }

En este código estamos verificando que p sea del tipo que se le asigna, si lo es, le asigna un valor de false a la propiedad y devolverá el name como nulo.

Switch expressions

¿Quién no ha sufrido la necesidad de en un switch validar todas combinaciones posibles? Como también, evaluar en ciertos casos un valor de un objeto. Para verlo en más detalle lo que estamos hablando les mostrare un código clásico:

  switch (p.FirstName, p.MiddleName, p.LastName)
            {
                case (string f, string m, string l):
                    return $"{ f } { m[0] }. { l }";
                case (string f, null, string l):
                    return $"{ f } { l }";
                case (string f, string m, null):
                    return $"{ f } { m }";
                case (string f, null, null):
                    return f ;
                case (null, string m, string l):
                    return $"Ms/Mr { m[0] }. { l }";
                case (null, null, string l):
                    return $"Ms/Mr { l }";
                case (null, string m, null):
                    return $"Ms/Mr { m }";
                case (null, null, null):
                    return "Someone";
            }

Verdaremante se hace muy difícil de leer. Ahora podemos, con C# 8, mediante Switch Expressions, hacerlo más legible y sencillo de la siguiente forma:

return (p.FirstName, p.MiddleName, p.LastName) switch
             {
                 (string f, string m, string l) =>  $"{ f } { m[0] }. { l }",
                 (string f, null, string l) =>  $"{ f } { l }",
                 (string f, string m, null) => $"{ f } { m }",
                 (string f, null, null) => f,
                 (null, string m, string l) => $"Ms/Mr { m[0] }. { l }",;
                 (null, null, string l) => $"Ms/Mr { l }",
                 (null, string m, null) =>  $"Ms/Mr { m }",
                 (null, null, null) => "Someone";
             }

Target-typed new-expressions

Se que van amar esta nueva funcionalidad. Anteriormente cuando declaramos una array de algún tipo de objeto y queríamos agregarle objetos nuevos debíamos hacerlo de esta manera:

Person[] people =
                {
                    new Person("Fernando", "A", "Sonego"),
                    new Person("Ricardo", "E", "Gomez"),
                    new Person("Alfredo", "X", "Rodriguez"),
                    new Person("Miguel", "A", "Gimenez")
                };

Ya no es necesario decirle que el objeto que vamos agregar en el array es del mismo tipo. Automáticamente se reconocerá y solamente debemos declararlo de la siguiente forma:

Person[] people =
                {
                    new ("Fernando", "A", "Sonego"),
                    new ("Ricardo", "E", "Gomez"),
                    new ("Alfredo", "X", "Rodriguez"),
                    new ("Miguel", "A", "Gimenez")
                };

Conclusiones

C# 8 nos trae nuevas y muy interesantes características que nos harán la vida un poco más fácil mientras estamos desarrollando. Además de estas habrá muchas más en el lanzamiento oficial.

Por ahora solo nos queda esperar el lanzamiento de Visual Studio 2019 junto ASP.Net Core 3.0. Mientras tanto podemos descargar las versiones preview e ir jugando para adoptarlas apenas sean oficiales.