¿Que traerá de nuevo C# 6.0?

Para este artículo hemos compilado para ti las principales novedades que traerá bajo el brazo el lenguaje de C# 6.0. Esperamos que estas sean un alivio para los programadores de dicho lenguaje que sepáis cómo aplicarlas en vuestros futuros proyectos. Sin más dilación os dejo con lo nuevo que traera C# 6.0

Mejoras en las auto-propiedades

Podrás inicializar las propiedades de la misma manera que inicializas las variables, campos...

public class Employee
{
public string FirstName { get; set; } = "Jorge";
public string LastName { get; set; } = "Lopez";
}

Parámetros en clases y structs

Podrás pasar parámetros a las clases/structs de la misma manera que lo haces con los métodos y funciones.

public class Employee(string firstName, string lastName)
{
public string FirstName { get; set; } = firstName;
public string LastName { get; set; } = lastName;
}

También puedes agregar la lógica en parámetros como:

public class Employee(string firstName, string lastName)
{
{
if (Equals(firstName,null))
{throw new ArgumentNullException("firstName");}
if (Equals(lastName,null))
{throw new ArgumentNullException("lastName");}
}
public string FirstName { get; } = firstName;
public string LastName { get; } = lastName;
}

Uso de clases estáticas

En C# 6.0, Microsoft anunció que nuestro CS Compiler tendrá un nuevo comportamiento que nos permitirá llamar a todos los métodos estáticos de clases estáticas sin el nombre de las clases.

Código en C# 5.0

static void Main(string[] args)
{
    Console.WriteLine("Introduce el primer numero :");
    int num1 = Convert.ToInt32(Console.ReadLine());
    Console.WriteLine("Introduce el segundo numero :");
    int num2 = Convert.ToInt32(Console.ReadLine());
    Console.WriteLine("Multiplicacion : {0}", (num1 * num2));
    Console.ReadLine();
}

Código en C# 6.0

using static System.Console;
using static System.Convert;

public class UsingStaticTest
{
static void Main(string[] args) 
        { 
            WriteLine("Introduce el primer numero:"); 
            int num1 = ToInt32(ReadLine()); 
            WriteLine("Introduce el segundo numero:"); 
            int num2 = ToInt32(ReadLine()); 
            WriteLine("Multiplicacion : {0}", (num1 * num2)); 
            ReadLine(); 
        } 
}

Filtros de excepción

Con esta nueva función, podrás agregar condicionantes para que el bloque catch decida qué bloque catch se debe ejecutarse basándose en la condición.

try
{
throw new Exception("Jorge");
}
catch (Exception ex) if (ex.Message == "Jorge")
{
// esto se ejecutará porque los mensajes de excepcion coinciden
}
catch (Exception ex) if (ex.Message == "Lopez")
{
// esto no se ejecutará porque los mensajes de excepcion no coinciden
}

Operadores condicionales que comprueban nulos

El operador condicional que comprueba nulos es un nuevo concepto en C# 6.0 que comprueba automáticamente referencias nulas. En la versión anterior de C#, 5.0, si accedemos a cualquier propiedad de una clase, primero tendríamos que comprobamos si el objeto de la clase es nulo o no es nulo, para después leer la propiedad. Pero en C# 6.0, podemos hacer lo mismo con el operador "?".

Código en C# 5.0

namespace ConditionalTest
{  
    class Program  
    {  
       static void Main()  
        {  
            Employee emp = new Employee(){ 
            FullName = "Jorge Lopez",  
            EmpAddress = new Address()  
            {  
                ResidenceAddress = "Vasco da Gama, 4",  
                OfficeAddress = "Cervantes, 36"  
            }
          } 
            if(emp!= null && emp.EmpAddress!=null)     
            {
             WriteLine((emp.FullName) + "  " + (emp.EmpAddress.ResidenceAddress??"No Address")); 
            } 
            ReadLine();  
        }  
    }  
    class Employee  
    {  
        public string FullName { get; set; }  
        public Address EmpAddress { get; set; }  
    }  
    class Address  
    {  
        public string ResidenceAddress { get; set; }  
        public string OfficeAddress { get; set; }  
    }  
}   

Código en C# 6.0

namespace ConditionalTest
{  
    class Program  
    {  
       static void Main()  
        {  
            Employee emp = new Employee(){  
            FullName = "Jorge Lopez", 
            EmpAddress = new Address()  
            {  
                HomeAddress = "Vasco da Gama, 4",  
                OfficeAddress = "Cervantes, 36"  
            }
            }            
            WriteLine((emp?.FullName) + "  " + (emp?.EmpAddress?.ResidenceAddress??"No Address")); 
            ReadLine();  
        }  
    }  
    class Employee  
    {  
        public string FullName { get; set; }  
        public Address EmpAddress { get; set; }  
    }  
    class Address  
    {  
        public string ResidenceAddress { get; set; }  
        public string OfficeAddress { get; set; }  
    }  
}   

Inicialización de índices

C# 6.0 introduce una nueva sintaxis para inicializar índices. Fíjate en los corchetes del próximo ejemplo:

Código en C# 5.0

var persons = new Dictionary<int, string> {
{ 3, "Jorge" },
{ 4, "Lopez" },
{ 6, "Guapo" }
};

Código en C# 6.0

var persons = new Dictionary<int, string> {
[3] = "Jorge",
[4] = "Lopez",
[6] = "Guapo"
};

El símbolo $

C# introduce una nueva manera de inicializar y acceder a los índices

var persons = new Dictionary<string, string>()
{
$first = "Jorge"
};

/en C# 5.0 
persons["first"] = "Jorge";

// en C# 6.0
persons.$first = "Jorge";

Interpolación de cadenas

Se ha mejorado la sintaxis cuando se incluyen variables dentro de cadenas, ahora podemos escapar una cadena para colocar variables sin usar el dichoso String.format.

string FullName = String.Format("{0} {1}",FirstName,LastName);

En C# 6.0 se añade la interpolación de cadenas (usando el caracter $ para formatear string) que provee al formato del string con la fuente del valor del parámetro en sí.

string FullName = $"{FirstName} {LastName}";

La expresión nameof

Antes de C# 6.0, cuando necesitábamos utilizar una propiedad, una función o un nombre de data member en un mensaje como un string, teníamos que utilizar el nombre como modificable en "name" en la cadena y en el futuro, si mi propiedad o los nombres de los métodos se modificaban, teníamos que cambiar todos los mensajes en cualquier formulario y en cada página.

Para resolver este problema, C# 6.0 introduce nameof como una nueva palabra clave que devolverá un string literal del nombre de la propiedad o del método.

Código en C# 5.0

namespace NameOfTest
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Employee emp = new Employee();  
            WriteLine("{0} : {1}", "EmpCode", emp.EmpCode);  
            WriteLine("{0} : {1}", "EmpName", emp.EmpName);            
            ReadLine();  
        }  
    }  
    class Employee  
    {  
        public int EmpCode{ get; set; } = 101;  
        public string EmpName { get; set; } = "Jorge"; 
       
    }  
}   

Código en C# 6.0

namespace NameOfTest
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Employee emp = new Employee();  
            WriteLine("{0} : {1}", nameof(Employee.EmpCode), emp.EmpCode);  
            WriteLine("{0} : {1}", nameof(Employee.EmpName), emp.EmpName);            
            ReadLine();  
        }  
    }  
    class Employee  
    {  
        public int EmpCode{ get; set; } = 101;  
        public string EmpName { get; set; } = "Jorge"; 
       
    }  
}   

Y hasta aquí las nuevas mejores de C# 6.0. Como programadores de este lenguaje supongo que las estaréis esperando con ganas al igual que nosotros. ¿Qué le pides tú a este nuevo lenguaje? Indícanoslo en los comentarios...

COMPARTE ESTE ARTÍCULO

ENVIAR A UN AMIGO
COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN GOOGLE +
ARTÍCULO ANTERIOR

¡SÉ EL PRIMERO EN COMENTAR!
Conéctate o Regístrate para dejar tu comentario.