Si eres desarrollor de .NET (C#) y estas comenzando con Angular, Node, etc., Javascript al fin y al cabo. O, por el contrario, eres desarrollador de Javascript y estas comenzando con .NET (C#), quizás pueda interesarte este post. Sigue leyendo.
En el comienzo de mi recorrido por Angular y NodeJS hay algunas cosas del lenguaje Javascript que me han llamado mucho la atención, principalmente al tratar de comparalas con C#. Otro punto que me resulta un poco molesto (quizás debido a mi corta experiencia en Javascript), es el cambio constante entre ambos lenguajes. Esto me obliga a recurrir a Google para refrescar ciertas partes de las sintaxis.
En este post vamos a ver como a pesar de lo anterior, la sintaxis de ambos se parece y posiblemente sea únicamente una sensación mía. No pretendo profundizar en todos sus casos posibles, ni tampoco entrar en los pros y contras de cada una . La intención es simplemente compartir mi experiencia para tratar de acercar/acortar este camino.
Desestructuración/Deconstrucción
La desesctructuración, aparece en ECMAScript 6, y es la vía por la cual se pueden extraer valores de objetos y/o arrays en variables. En mi opinión, permite un código mas legible en muchos casos. Veamos el siguiente ejemplo de desestructuración de arrays.
const foo = ['one', 'two', 'three'];
const [red, yellow, green] = foo;
console.log(`${red}, ${yellow}, ${green}`);
Dado este código Javascript, ¿Cuál es el equivalente en C#? Pues, lo más parecido es la deconstrucción de arrays y objetos, que aparece a partir de la versión C# 7.0 (mediante el uso de tuplas). Por lo que tenemos un código equivalente como el siguiente:
var foo = ("one", "two", "three");
var (red, yellow, green) = foo;
Console.WriteLine($"{red}, {yellow}, {green}");
La primera sentencia, la obtenemos definiendo una tupla en lugar de un array. Si bien, para conseguir una sintaxis mas parecida haciendo uso de un array, necesitamos recurrir a la implementación de métodos «Deconstruct«.
public static class IEnumerableExtension
{
public static void Deconstruct(this IEnumerable seq,
out T first,
out IEnumerable rest)
{
first = seq.FirstOrDefault();
rest = seq.Skip(1);
}
public static void Deconstruct<T>(this IEnumerable<T> seq,
out T first,
out T second,
out IEnumerable<T> rest)
=> (first, (second, rest)) = seq;
public static void Deconstruct<T>(this IEnumerable<T> seq,
out T first,
out T second,
out T third,
out IEnumerable<T> rest)
=> (first, second, (third, rest)) = seq;
}
Una vez implementada la clase anterior, logramos la sintaxis esperada, y ya sí, haciendo uso de un array.
var foo = new[] { "one", "two", "three" };
var (red, yellow, green) = foo;
Console.WriteLine($"{red}, {yellow}, {green}");
Por otro lado, la desestructuración de objetos en Javascript podemos verla con este ejemplo:
const foo= {
id: 42,
is_verified: true
};
const {id, is_verified} = foo;
console.log(`${id} - ${is_verified}); // 42 - true
Para el caso de C#, (aunque podríamos usar tuplas directamente o incluso hacer uso de objetos anonímos), lo haremos, sin embargo, mediante un objeto tipado. Para ello implementaremos una clase Foo, con sus métodos «Deconstruct» pertinentes:
public class Foo
{
public int Id { get; set; }
public bool Is_Verified { get; set; }
public void Deconstruct(out int id) { id = Id; }
public void Deconstruct(out int id, out bool is_verified)
{
id = Id;
is_verified = Is_Verified; }
}
}
Así, podemos escribir nuevamente el ejemplo, con la sintaxis que buscamos:
var foo = new Foo
{
Id = 42,
Is_Verified = true
};
var (Id, Is_Verified) = foo;
Console.WriteLine($"{Id} - {Is_Verified}");
Por último, durante la desestructuración/deconstrucción, se pueden omitir algunos valores, en concreto, para nuestro ejemplo, omitiremos la propiedad «is_verified»/»Is_Verified»:
var { id } = foo;
console.log(`${id}`); // 42
En C# lo resolvemos haciendo uso del guión bajo («_»), que precisamente nos permitie optar por esta omisión o descarte:
var (Id, _) = foo;
Console.WriteLine($"{Id}");
Nota: Adicionalmente, como hemos visto en los ejemplos anteriores, y en particular para las sentencias «console.log(…) / Console.Writeline(…)«, la interpolación de cadenas, es otra característica muy interesante y util. ¡Tan parecidas en ambos lenguajes que tengo poco más que añadir 😀!
Como siempre, espero que esta entrada sea de utilidad.
Un saludo y happy Javascript & CSharp coding….
Juanlu, ElGuerre 