C# 6.0 – novidades da linguagem – parte 1

Facebooktwittergoogle_plusredditpinterestlinkedinmail

Hoje vamos falar de algumas novidades da versão 6.0 do C#, que veio no framework 4.6 do .net e está disponível no Visual Studio 2015. O foco dessa versão foi trazer melhorias para a linguagem, para aumentar a produtividade, e permitir um código mais limpo. Então, vamos as novidades:

Auto-properties apenas com GET

Hoje, apenas conseguirmos criar auto-properties se elas tiverem GET e SET, dessa forma:

public double Versao { get; set; }

E se quisermos que Versao seja somente leitura, temos que declarar a propriedade da seguinte forma:

public double Versao 
{ 
	get
	{
		return 4.6;
	}	
}

Ou então, criamos um atributo somente leitura:

public readonly double Versao;

Na versão 6.0 do C#, podemos criar uma auto-property apenas com GET, dessa forma:

public double Versao { get; }

E podemos atribuir o valor à propriedade no construtor da classe:

public class Framework
{
	public double Versao { get; }
	
	public Framework()
	{
		this.Versao = 4.6;
	}
}

Estranho? Em um primeiro momento parece, pois a propriedade não tem SET, então como podemos atribuir um valor à ela dessa forma? É que por trás dos panos, o que o .net faz, é atribuir o valor 4.6 a um atributo somente leitura que está por trás da propriedade.

Initializers para auto-properties

Agora podemos inicializar uma auto-property com um valor padrão junto com sua declaração, o que antes não era possível. E podemos fazer isso tanto para propriedades que tenham apenas GET, como para as que possuem GET e SET. Confira abaixo alguns exemplos:

public string Nome { get; set; } = "C#";
public double Versao { get; } = 4.6;
public Desenvolvedor DesenvolvedorNinja { get; set; } = new Desenvolvedor();

Using estático

Imagine que você precisa fazer uma série de operações matemáticas, ou conversões, ou até mesmo imprimir várias mensagens no console. Pensando em cenários desse tipo, veja a classe abaixo:

using System;

namespace AutofacDemoWin
{
    public class Teste
    {
        public void Somar(string a, string b)
        {
            int x = Convert.ToInt32(a);
            int y = Convert.ToInt32(b);
            int r = x + y;
            Console.WriteLine("a: " + a);
            Console.WriteLine("b: " + b);
            Console.WriteLine("r: " + r.ToString());
        }
    }
}

Agora, ao invés de toda hora usarmos o nome da classe a cada utilização, podemos fazer da seguinte forma:

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

namespace AutofacDemoWin
{
    public class Teste
    {
        public void Somar(string a, string b)
        {
            int x = ToInt32(a);
            int y = ToInt32(b);
            int r = x + y;
            WriteLine("a: " + a);
            WriteLine("b: " + b);
            WriteLine("r: " + r.ToString());
        }
    }
}

Repare que não precisamos mais referenciar às classes Console e Convert, pois já fizemos isso na declaração do Using. Um ponto importante, é que esse recurso só funciona com classes estáticas. Outro detalhe importante, o using passa a ser feito diretamente para uma classe, e não para um namespace.

Interpolação de strings

Essa novidade é uma das que eu mais gostei. Vejamos o exemplo abaixo:

string.Format("a: {0}, b: {1}, r: {2}", a, b, r);

O código acima acaba sendo confuso, nós estamos numerando a posição de cada variável que queremos imprimir. Agora, não precisamos mais usar o Format, e podemos fazer isso dessa forma:

$"a: {a}, b: {b}, r: {r}";

Substituímos o Format pelo $, e não precisamos mais dos números, e usamos as variáveis diretamente. Bem mais prático e legível, não?

Facebooktwittergoogle_plusredditpinterestlinkedinmail
Com as palavras-chave

2 thoughts on “C# 6.0 – novidades da linguagem – parte 1

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *