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...