Archivo de la categoría: Novedades

Visual Studio 2017: Nuevo formato de instalación

Muchos de nosotros hemos solicitado que la instalación e incluso el IDE de Microsoft fuera reducido y además, modular. Esto, en esta versión, ha sucedido y ahora tenemos una instalación que ocupará más o menos a nuestra elección al igual que el propio entorno. Para que os hagáis una idea, la instalación mínima de VS, ocupa 10 veces menos que las anteriores versiones.

Actualmente tenemos una experiencia de instalación mejorada pudiendo seleccionar en todo momento lo que queremos instalar y lo que no, evidentemente, modificable a posterior. Además, nuestra instalación será mucho más rápida que las anteriores versiones.

Al ejecutar el instalador de la nueva versión de VS nos aparecerá una ventana, clasificada por Workloads, dónde pondremos seleccionar que queremos instalar:

Visual Studio

Además de los Workloads, podemos seleccionar componentes individuales de cada uno de los entornos de trabajo e instalar componentes individuales que necesitemos o, por lo contrarios, que no nos sirvan en nuestro entorno de desarrollo.

VS Installation

Tan fácil cómo seleccionar que queremos instalar, su ruta y el alias (nickname) de la instalación. A parte de estas novedades, el alias en sí es otra de las novedades que nos trae Microsoft. ¡Ahora podemos instalar diferentes entornos de desarrollo con sus componentes usando el alias! Es decir, podemos tener una instalación para “web”, “mobile”, “cloud”, etc… y tener los diferentes sandboxs de desarrollo de forma independiente. Por último, y no menos importante, podemos instalar idiomas adicionales al IDE

Si quieres empezar a trabajar con él, aquí lo puedes descargar aunque recuerda que está cómo RC.

Happy new version!! :)

.NET Standard como unificación de .NET Framework, .NET Core & Xamarin

Microsoft está haciendo un gran trabajo para abrirse y exponer sus dotes tecnológicas a través de Frameworks abiertos, modulares y cross-platform con el fin de reutilizar el código al máximo.

En las primeras versiones de .NET Core, ASP.NET Core, Entity Core, etc… teníamos marcos de trabajo independientes, con un entorno aislado al .NET tradicional a diferencia de ahora.

Para huir de este entorno aislado, es dónde .NET Standard Library cómo eje de unión, entra en acción. Esta librería es una especificación de las APIs del framework que está destinada a estar disponible en todos los runtimes de .NET. ECMA355 establece una uniformidad para el comportamiento del runtime a diferencia de las antiguas .NET Base Class (BCL).

Esta librería nos permite trabajar con una API unificada para todas las plataformas de dotnet abstrayéndonos de cual es la plataforma y, además, nos permite que podamos desarrollar librerías portables sin políticas de compilación.

¡Vamos a ver esto un poco más gráfico! Así es cómo quedará el stack,.NET Tomorrow

Para nosotros, cómo técnicos, significa que tan solo tendremos que tener un knowledge de una única biblioteca. Las bibliotecas nuevas cómo .NET Core o el recién incorporado en Microsoft, Xamarin, podrán ser ejecutadas sobre esta librería sin tener que preocuparnos que  librería debemos consumir.

Para resumir este primer post nos tenemos que quedar con dos importantes mensajes; consistencia y cross-plarform en todos los desarrollos realizados con esta nueva librería.

Un saludo!!! :)

Novedades en C# 6.0 (II)

En mi anterior entrada hacia un anticipo de las novedades que ofrece la nueva versión de C#. Todas las novedades, recaen en una evolución hacia la simplicidad y mejora de la escritura del propio lenguaje.

Operador condición NULL

¿Cuantas veces has visto en tu aplicación un NullReferenceException por no controlar correctamente un posible valor null? Seguramente en diferentes ocasiones. En esta nueva versión se nos propone una forma simple y limpia de hacer esta validación.
Observemos cómo hacíamos la validación hasta el momento,

public string Truncate(string value, int length)
{
  string result = value;
  if (value != null)
    result = value.Substring(0, Math.Min(value.Length, length));
  return result;
}

Si no hacemos la validación del value a null, el método Substring nos devolvería una excepción NullReferenceException. Vamos a hacer exactamente lo mismo, pero con la nueva sintaxis de código,

public string Truncate(string value, int length)
{          
  return value?.Substring(0, Math.Min(value.Length, length));
}

Cómo podemos observar, nos simplifica la validación y la expresa de forma natural para que nos sea más simple y ágil tener en cuenta este tipo de validaciones que tantos quebraderos de cabeza nos dan cuándo las olvidamos.
Debemos tener en cuenta que el operador ? va a devolver siempre un tipo nullable, es decir, que si el tipo de devolución es int deberemos expresar el tipo cómo int? para que pueda aceptar el valor después de la validación con el operador o bien un null.
De hecho, si no indicamos esto, el IDE no nos dejará compilar indicando que el error es de conversión de tipos int? a int.

Mejoras en al gestión de excepciones

Tenemos dos mejoras muy importantes, la primera de ellas es el uso de operaciones async/await dentro de los bloques de excepciones y la segunda es el filtrado de excepciones.

try
{
  WebRequest webRequest = WebRequest.Create("http://contoso.com");
  WebResponse response = await webRequest.GetResponseAsync();
}
catch (WebException exception)
{
  await WriteErrorToDb(exception);
}

De forma totalmente asíncrona escribiríamos la traza en en nuestro log y seguiremos ejecutando el código mejorando así el performance de nuestra aplicación. Haciendo uso del mismo bloque de código podemos, ahora, filtrar por el tipo de excepción y actuar en consecuencia. Veamos el ejemplo,

try
{
  WebRequest webRequest = WebRequest.Create("http://contoso.com");
  WebResponse response = await webRequest.GetResponseAsync();
}
catch (WebException exception)
 when (exception.Status == WebExceptionStatus.Timeout)
  {
     await SendEmail(exception);
  }

Inicialización de diccionarios

Esta característica nos permite inicializar con valores por defecto nuestros diccionarios con mucho menos código que antes,

Dictionary<string, string> airportCode = new Dictionary<string, string>()
{
["BCN"] = "Barcelona",
["LER"] = "Lleida",
["SVQ"] = "Sevilla"
};

Constructores primarios

Esta es una fantástica feature para nuestro código, aunque a mi personalmente, me gusta más tener los constructores correctamente ubicados en regiones dentro de mi clase aunque debo reconocer que ubicar el constructor a nivel de clase es práctico y nos da, de un solo vistazo, que información precisa la clase para funcionar debidamente.

public class BasketItem(int unit, int productId, double price)
{
public string Unit{ get; set; } = unit;
public string ProductId { get; set; } = productId;
public string Price { get; set; } = price;
}

Espero disfrutéis de estas novedades y sobretodo, que las apliquéis 😉 ¡vuestro código lo agradecerá!

Novedades en C# 6.0 (I)

En mi anterior entrada, dónde hacia una introducción a Roslyn, ya citaba que no solo del compilador se trataba si no que tendríamos mejoras para que nuestro código sea mas compacto, legible y este mejor organizado.

El concepto de code smell lo podremos aplicar aquí y podremos ver cómo C# en su versión 6.0 nos ayuda mucho en ello con pequeñas pero significativas mejoras. Cómo hay varias y en bastantes quiero profundizar en detalle, he preparado una serie de entradas diferentes y en esta,me he centrado en aquellas que son más mundanas pero no por ello menos importantes.

Inicializar las propiedades

En todas nuestras clases tenemos propiedades y estas, en ocasiones, deben ser inicializadas. Con esta nueva versión, esto se puede hacer directamente al momento de declarar la propiedad y asignar su valor.

public class Employee
{
   public string First { get; set; } = "Francesc";
   public string Last { get; set; } = "Jaumot";
}

Propiedades de solo lectura

Relacionada con la anterior, podemos hacer exactamente lo mismo aunque nuestra propiedad sea solo de lectura, es decir, solo con get y sin set.

public class Employee
{
   public string First { get; } = "Francesc";
   public string Last { get; } = "Jaumot";
}

Por debajo, esto, es implícitamente declarado cómo readonly y esta se puede inicializar en el constructor de la siguiente manera,

public class Employee
{
   public string Name{ get; };

   public Employee(string first, string last)
   {
       Name = first + " " + last;
   }
}

Mejora en el uso de clases estáticas

¿Cuantas veces hemos visto Console.WriteLine(“”); o bien Math.Sqrt(2); entre muchas otras? En esta versión tan solo deberemos ocuparnos de hacer el correspondiente using y poder usar el método de dentro de la clase estática de una forma más simple.

using System.Console;
using static System.Math;

class Program
{
    static void Main(string[] args)
    {
        WriteLine(Sqrt(2));
    }
}

Interpolación en el string

Personalmente, la que más me gusta. Muchas veces deberemos devolver un string formateado, por ejemplo en una pantalla modal que nos muestre el nombre del cliente, o bien un nombre desde recursos en función del tipo de error, etc..Hasta ahora, debíamos hacer,

String.Format("¿Está seguro de eliminar el cliente {0} y número {1}?",obj.NombreCompleto, obj.IdentificadorCliente);

Ahora esto se ha simplificado y en casos dónde tengamos que concatenar varias cadenas el código, nos quedará limpio y ordenado.

return s = $"¿Está seguro de eliminar el cliente {obj.NombreCompleto} y número {obj.IdentificadorCliente}?";

Nombre del operador o clase

Este me encanta, sobretodo para los mensajes de error. Anteriormente teníamos el código así,

if (paramValue == null) throw new ArgumentNullException("paramValue");

Actualmente, lo veremos así,

if (paramValue == null) throw new ArgumentNullException(nameof(paramValue));

El operador nameof es en tiempo de compilación y no penaliza en rendimiento, ademas que nos servirá y mucho, para los que usamos INotifyPropertyChanged en MVVM.
Si alguna vez tenemos que hacer una refactorización, esto nos serviría muchísimo pues el nameof se verá afectado y dentro de la cadena, a no ser que uses alguna herramienta adicional, no aplicaría.

Recordar que algunas de estas mejoras pueden cambiar en su versión final, pero tenéis mi compromiso de que actualizaré el post a medida que tengamos más información 😉

Saludos y a por el siguiente!

Novedades de Visual Studio 2013 (II)

En mi anterior entrada ya explique algunas de las novedades del nuevo IDE de Microsoft. Con este IDE, tenemos la incorporación de .NET Framework 4.5.1 que incorpora mejoras relacionadas con el trabajo del código fuente y que veremos detalladas a continuación,

Editar y continuar: anteriormente ya podíamos editar el código fuente de nuestro software mientras hacíamos debug y ver que pasaba según la modificación realizada. Con la evolución de los ordenadores a 64 bits y siendo la gran mayoría de ellos de 64 bits, esta opción la mayoría no la pudo ni probar debido a que únicamente estaba habilitado para 32 bits desde el 2005.
En esta versión, por demanda popular con más de 2600 votos, esto funciona para 32 bits y 64 bits para WPF, Windows Phone, aplicaciones de la tienda y ASP.NET.
De esta forma podemos modificar el código fuente sin detener el debug y ver que sucede después.

Devolución de valores en los métodos: Para ver el valor retornado de un método anteriormente debíamos declarar una variable del tipo devuelto y poner un punto de interrupción para ver que sucedía. Ahora esto no es necesario gracias a que desde la ventana de inmediato y de autos podemos ver el valor devuelto de nuestro método mediante $ReturnValue.

ReturnValue

Async debugging: Depurar tareas asíncronas, hilos… siempre ha sido complicado debido a que todo era asíncrono y los hilos principales seguían su ejecución. Los hilos en background podían producir excepciones complicadas de detectar o de trazar.
En esta versión, tal y cómo nos muestra la imagen comparativa, nos es mucho mas fácil de debugar las tareas asíncronas con las nuevas herramientas del IDE. Nos permite ver al completo la Stack de trazas síncronas y asíncronas además de un panel especifico para las tareas en background.

AsyncDebug

Y esto es todo de momento para esta entrada 😉
Un saludo y happy IDE!!