Una sinfonía en C#

Un pequeño aporte a la comunidad de habla hispana.

Novedades de C#7: Literales binarios.

Ya hablamos hace un tiempo de las novedaes de C#7 que vendrán como parte de Visual Studio 2017, siguiendo con lo mismo vamos a ver una simple pero efectiva, los literales binarios.

Literales

Hasta hoy podíamos declarar literales de números enteros por ejemplo, así:

int[] numeros  = { 1, 2, 3, 4, 5, 6 };

Y esto está muy bien, tenemos enteros a la izquiera y a la derecha

Literales binarios

Aquí la novedad, con C#7 podemos declarar este mismo array pero con binarios, algo así:

int[] numeros  = { 0b1, 0b10, 0b11, 0b100, 0b101, 0b110 };

Nótese el prefijo 0b, con eso indicamos que se trata de binarios, si corremos la aplicación vemos que en definitiva tenemos el mismo resultado.

image

En definitiva terminamos declarando enteros.

Separadores

Una última cosa con respecto a los literales (sobre todo los binarios) en ocasiones puden convertirse en algo poco legible, como esto:

int[] numeros  = { 0b1000000000000 };

Bien, digamos que no es tan simple darse cuenta de cuántos ceros hay, por eso tenemos la posibilidad de hacer esto

int[] numeros  = { 0b10_0000_0000_000 };

Que es justo lo mismo, es decir, usamos un guión bajo como separador, de hecho podemos poner todos los que queramos

int[] numeros  = { 0b10_____0000_0000_000 };

Y funciona igual, no solo eso, sino que podemos usarlo en otro tipo de literales

int[] numeros  = { 4_096 };

Interesante, nos leemos.

Novedades de C#6: Exception filters

Otra de las novedades que nos trae C#6 son los Exception filters, básicamente es la capacidad de agregar una cláusula a un bloque catch que nos permite “filtrar” las excepciones que serán atrapadas por ese bloque basados en alguna condición, por ejemplo en el mensaje de la excepción, o alguna propiedad interna, veamos un ejemplo:

try
{
    throw new MyException(600);
}
//podemos filtrar las excepciones del mismo tipo a partir
//de una condición
catch (MyException ex) when (ex.Code == 400)
{
    Console.WriteLine("Bad Request");
}
catch (MyException ex) when (ex.Code == 401)
{
    Console.WriteLine("Unauthorized");
}
catch (MyException ex) when (ex.Code == 403)
{
    Console.WriteLine("Forbidden");
}
catch (MyException ex) when (ex.Code == 404)
{
    Console.WriteLine("Not Found");
}
//este catch atrapa las exception del cliente, entre 400 y 500
catch (MyException ex) when (ex.Code >= 400 && ex.Code < 500)
{
    Console.WriteLine("Client exception");
}
//en caso de no cumplirse ninguna de las otras condiciones
//siempre podemos tener un catch más general
catch (MyException)
{
    Console.WriteLine("Generic Exception");
}


¿Simple no? básicamente el tipo MyException representaría excepciones HTTP (no vamos a discutir si está bien hacerlo así, es un ejemplo) que tienen dentro el HTTP Status code correspondiente al error, entonces para mostrar un mensaje más simpático al cliente hacemos el fitro a partir de la propiedad Code del tipo MyException (este patrón de códigos se ve bastante en bases de datos), también tenemos una condición para las exceptiones entre 400 y 500 (las del cliente) en la cual únicamente caen aquellas no atrapadas por las condiciones anteriores más expecífica, por último tenemos un catch general para el tipo en donde caerán aquellos códigos cliente que no están más arriba.

Muy interesante, nos leemos.

[VIDEOS] Meetup de la comunidad NetBaires.

El pasado miércoles tuvo lugar una nueva reunión de la comunidad NetBaires, en este caso en las oficinas de Kinetica en CABA.

Hubo dos charlas cortas, la primera sobre principios de diseño SOLID con C#, tuve el honor de ser orador en ésta, hablamos sobre los principios y vimos una pequeña aplicación C# a la que le fuimos aplicando SOLID paso a paso.

Las segunda estuvo a cargo de Sebastián y fue sobre Xamarin, en este caso se habló de las preguntas más frecuentes del tema y un poco de experiencias personas.

La comunidad

Como dije, esto tuvo lugar en el marco de la comunidad NetBaires una interesante comunidad que se está armando y a la cual los invito a unirse por ahora a Slack (que es de NetLatam la comunidad “madre”).

Dejo algunos links.

Nos leemos.

[VIDEO] Tips de Typescript: Interpolación de strings

Al igual que en el paso he publicado videos sobre Azure para desarrolladores web en ese caso he agregado un nuevo video sobre Typescript, más específicamente acerca de la interpolación de string, el video está disponible en éste link, aprovecho para dejar un listado con todos los videos sobre Typescript que he publicado hasta el momento:

Seguramente seguiré haciendo más videos sobre Typescript, nos leemos.

Primeros pasos con .NET Core

.NET Core es una plataforma rápida, modular y multiplataforma para crear aplicaciones.

¿Multiplataforma?

Sí, NET Core corre en Windows, macOS y Linux utilizando no solo el mismo lenguaje sino que también las mismas librerías.

¿Rápida?

Según estos benchmarks, es 8 veces más rápido que Node.js y 3 veces más que Go.

¿Modular?

El modelo de desarrollo se basa en paquetes, una aplicación .NET Core sólo incluye aquellas partes de la plataforma que utiliza, a diferencia de hoy en .NET Framework.

¿Dónde puedo descargarlo?

El sitio de .NET Core es éste, desde ahí elegimos la versión que necesitamos según nuestro sistema operativo

¿Cómo sé si está correctamente instalado?

Simplemente vamos a la línea de comandos (la que corresponda al sistema operativo) y tipeamos

dotnet

Si todo está bien deberíamos ver esto:

image

¿En qué lenguaje programamos?

En C#, tal cual como lo hacemos en Visual Studio con un proyecto ,NET.

¿Necesito Visual Studio?

No, con .NET Core instalado es suficiente, podemos usar Visual Studio, o Visual Studio Code (que también es corre en macOS y Linux) o cualquier editor que querramos.

¿Cómo empezamos?

Bien, para crear la primer aplicación tenemos que crear un directorio donde residirá el código de la aplicación, una vez creamos y dentro de este directorio tenemos que inicializar la aplicacion tipeando el siguiente comando

dotnet new

Nota: Si usamos Visual Studio estos pasos son realizados por Visual Studio automáticamente.

Una vez hecho esto vemos que se crean dos archivos

image

Program.cs, el archivo de inicio de la aplicación,

using System;

namespace ConsoleApplication
{
    public class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

Sencillo, el típico archivo por defecto que imprime hello world, el otro archivo que fue creado en el directorio es project.json, veamos qué tiene adentro

{
  "version": "1.0.0-*",
  "buildOptions": {
    "debugType": "portable",
    "emitEntryPoint": true
  },
  "dependencies": {},
  "frameworks": {
    "netcoreapp1.0": {
      "dependencies": {
        "Microsoft.NETCore.App": {
          "type": "platform",
          "version": "1.0.0"
        }
      },
      "imports": "dnxcore50"
    }
  }
}

Este archivo tiene la información del proyecto, vemos que “dependencies” está vacío y tiene sentido, no hemos agregado dependencias, vemos que dentro de “frameworks” dice que utilizamos Microsoft.NETCore.App versión 1.0.0, sin embargo dentro del directorio no hay nada mas, lo que tenemos que hacer ahora es restaurar para ello tipeamos

dotnet restore

Después de hacer restore la aplicación está lista para correr pero antes nos damos cuenta que un nuevo archivo fue creador project.lock.json

image

El archivo project.lock.json no debe ser modificado a mano, ni debemos subirlo a nuestro control de versiones; durante el proceso de restore se calculan las dependencias del proyecto en el estado actual, esta tarea no es sencilla por lo tanto el archivo project.lock.json es creado como una forma de cache y actualizado cada vez que hacemos restore (deberemos hacer esto cuando agregemos o quitemos dependencias del proyecto).

Corriendo la aplicación por primera vez

Para correr la aplicación simplemente tipeamos

dotnet run

Y listo

image

Seguimos en la proxima, nos leemos.