[.NET] C# 6.0 - Visual Studio 2015 CTP 6

C# 6.0 se incluye con Visual Studio 2015 y viene con varias novedades, en este post compartiré un resumen de las nuevas características de este lenguaje.

Sintaxis using static

En versiones previas de C#, cuando queríamos trabajar, por ejemplo, con la clase estática System.Console teníamos que definir using System y de esa manera tener la posibilidad de usar todas las clases que se encuentran en el espacio de nombres System (no había forma de usar solo la clase System.Console).

using System;

namespace CSharp6.CTP6
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.WriteLine("¡Hola XAML Development!");
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("¡Viva C# 6.0!");
        }
    }
}

Ahora con C# 6.0, tu puedes agregar using static para poder utilizar los métodos y propiedades de la única clase estática o el enumerado a la cual haces referencia:

using static System.Console;
using static System.ConsoleColor;

namespace CSharp6.CTP6
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            ForegroundColor = Cyan;
            WriteLine("¡Hola XAML Development!");
            ForegroundColor = Green;
            WriteLine("¡Viva C# 6.0!");
        }
    }
}

nameof

Muchas veces hemos usado literales de cadena para hacer referencia el nombre de una variable.

public static void Foo(string code)
{
     if (code== null) throw new Exception("code");
     //...
}

En C # 6.0, hay un nuevo operador llamado nameof que nos permitirá refactorizar nuestro código y deshacernos de muchos de esos literales de cadena. Ahora podremos tener un código más limpio y seguro cuando se trate de obtener el nombre de nuestras variables.

public static void Foo(string code)
{
     if (code== null) throw new Exception(nameof(code));
     //...
}

Filtros de Excepciones

Los filtros de excepciones no son nuevos en Visual Basic, pero sí en C#. La keyword when te permite especificar una condición para un bloque catch.

            try
            {
                throw new System.Exception("Error");
            }
            catch (System.Exception ex) when (ex.Message == "ReallyBadError")
            {
                // :(
            }
            catch (System.Exception ex) when (ex.Message == "Error")
            {
                WriteLine("Boom!");
            }

await desde un bloque catch y finally

Esta nueva característica no requiere mucha explicación. Que bueno que por fin este con nosotros ya que es muy útil.

        public static async void BoomAsync()
        {
            try
            {
                throw new Exception("Boom!");
            }
            catch
            {
                await Task.Delay(5000);
                WriteLine("Esperaste 5 segundos");
            }
            finally
            {
                await Task.Delay(3000);
                WriteLine("Esperaste 3 segundos");
            }
        }

Interpolación de cadenas

Ahora podemos poner expresiones directamente en la cadena literal para mostrar los valores de una manera sencilla. En C # 6.0 podemos especificar fácilmente varios formatos en nuestros valores.

            //C# < 6.0                
            string txt1 = "Hola" + "Mundo";
            string txt2 = string.Format("{0} {1}", "Hola", "Mundo");

            //C# >= 6.0   
            string txt3 = "Mundo";
            int habitantes = 8000;
            Console.WriteLine($"En el {txt3}. Hay aproximadamente {habitantes + 1} millones de habitantes. {DateTime.Now:dd-MM-yyyy}");

Operador de condicional nulo

¿Quien no se ha topado con un NullReferenceException?. Esta excepción que nos salta cuando olvidamos validar si es que un valor no es nulo antes de usarlo. Ahora gracias a C# 6.0 el trabajo con algunas de las validaciones será menos complicado. En el siguiente código, si nuestra variable es null la función devolverá null en vez de caerse.

        public static string NullConditional(object obj)
        {
            return obj?.ToString();
        }

Inicializadores de Diccionarios

No podemos negar que el siguiente formato para la creación de diccionarios es confuso :

            Dictionary<string, string> data = new Dictionary<string, string>()
            {
                { "Fruta", "Mandarina" },
                { "Disciplina", "Parkour" },
                { "Profesion", "Developer" }
            };

En C# 6.0 esto se extendió y ahora también se puede hacer de la siguiente manera, la cual es más fácil de entender:

            Dictionary<string, string> data = new Dictionary<string, string>()
            {
                ["Fruta"] = "Mandarina",
                ["Disciplina"] = "Parkour",
                ["Profesion"] = "Developer"
            };

Inicializadores Auto-Property

En el pasado teníamos que hacer lo siguiente para inicializar nuestras propiedades:

    public class Usuario
    {
        public Usuario()
        {
            this.Id = Guid.NewGuid();
        }

        public Guid Id { get; set; }

        public readonly int code = 3;

        public int Code
        {
            get { return code; }
        }
    }

Ahora es suficiente hacer lo siguiente:

    public class Usuario
    {
        public Guid Id { get; set; } = Guid.NewGuid();

        public int Code { get; } = 3;
    }

Conclusión

Desde que empezó su desarrollo, C# 6.0 ha ido tomando una mejor forma. Me agradan bastante las nuevas características, pero ahora debemos ser conscientes que cualquier cosa aquí esta sujeto a cambios, esto se puede deducir tomando en cuenta que tanto Visual Studio 2015 como C# 6.0 siguen en preview. Aconsejo mantenerse enganchado a los siguientes sitios:

http://msdn.microsoft.com/
http://channel9.msdn.com/