Una sinfonía en C#

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

Xamarin Dev Days Buenos Aires 2016

El viernes 2 de Diciembre he tenído el honor de participar en #XamarinDevDays en Buenos Aires tanto como organizador como speaker, el evento tuvo lugar en las oficinas de Microsoft de Argentina en Buenos Aires desde las 9hs hasta las 16hs.

Gracias!

Lo primero que quiero decir es gracias a quienes me dieron la oportunidad de organizar este evento Jayme, Diana y a los que ayudaron desde Microsoft Argentina Soledad y Carolina, sin ellas hubiera sido imposible; todo el tiempo que duró la organización así como durante el evento cada una de ellas dio una gran mano.

A todos los asistentes por tomarse todo un día para compartir con nosotros.

También quiero agradecer a los speakers, además de mí estuvieron Alex Pestchanker y Sebastián Pérez, ambos dieron excelentes charlas.

El evento

El evento contó con tres charlas y un Hand on lab después del almuerzo en el cual los asistentes desarrolaban su primera aplicación con Xamarin Forms conectada a Azure y todo salió más que bien.

Lo más importante de todo fue la convocatoria, éramos más de 40 personas que llegaron bien temprano y de ellos más de 30 estuvieron hasta el final y simpre mostrando un gran interés en el tema y muy buena predisposición.

Dejo algunas fotos del evento.

XamarinDevDays-5XamarinDevDays-7XamarinDevDays-18XamarinDevDays-8XamarinDevDays-15XamarinDevDays-34

Quiero agradecer especialmente a Meri y Ale por ayudarnos con la promoción, para los que no vieron hicimos un par de videos:

Nos leemos.

C# 6: ¿Qué son los operadores “explicit” e “implicit”?

En ocasiones nos encontramos con la necesidad de convertir entre dos tipos que no son directamente equivalentes, por ejemplo un tipo Usuario a un int, pero tal vez sea un caso válido para nosotros (sin llegar a tanto como en el ejemplo), imaginemos que tenemos un tipo Moneda, así:

public class Moneda
{
    public decimal Valor { get; set; }
    public string Simbolo { get; set; }

}

Y queremos hacer una instancia de, por ejemplo, una moneda del tipo “$”, bueno, no nos queda mucho más que hacer esto:

var a = new Moneda();
a.Simbolo = "$";

Lo cual está bien (incluso podríamos hacerlo en una línea) pero bueno, en este caso no estamos directamente convitiendo el “$” en una instancia de moneda con ese símbolo sino que estamos creando una moneda y después cambiando ese valor.

Conviertiendo entre tipos no compatibles

Bien, existe una forma de hacerlo en C#, en realidad dos formas, explícita o implícita. y son operadores, vamos a ver un ejemplo:

public class Moneda
{
    public decimal Valor { get; set; }
    public string Simbolo { get; set; }

    //permite convertir implícitamente, es decir Moneda a = "$"
    public static implicit operator Moneda(string s)
    {
        return new Moneda { Simbolo = s };
    }

    //permite convertir explícitamente, es decir Moneda a = (Moneda) 1;
    public static explicit operator Moneda(decimal i)
    {
        return new Moneda { Valor = i };
    }
}

Y como indica el código, el operador implicit permite hacer una conversión directa, en este caso igualar un tipo objeto Moneda contra un string, el explícito nos pide indicar explícitamente la conversión agregando el tipo entre paréntesis. La implementación no es una que la construcción de un objeto Moneda.

var a = new Moneda();

//conversión implícita
a = "$";

//conversión explícita
a = (Moneda) 1;

Cool, si miramos el IL vemos que lo que hace el compilador es hacer llamadas a los métodos de conversión cuando se intenta hacer la asignación

IL_0000: nop
IL_0001: newobj instance void ConsoleApplication1.Moneda::.ctor()
IL_0006: stloc.0
IL_0007: ldstr "$"
IL_000c: call class ConsoleApplication1.Moneda ConsoleApplication1.Moneda::op_Implicit(string)
IL_0011: stloc.0
IL_0012: ldsfld valuetype [mscorlib]System.Decimal [mscorlib]System.Decimal::One
IL_0017: call class ConsoleApplication1.Moneda ConsoleApplication1.Moneda::op_Explicit(valuetype [mscorlib]System.Decimal)
IL_001c: stloc.0
IL_001d: ret

Como vemos en las líneas 000c y 0017 se llama a los método op_Implicit y op_Explicit que hacen las conversiones.

Nos leemos.

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.