C# 6.0 – Cinco novos recursos que é bom conhecer

Desde o seu lançamento, a linguagem C# tem evoluído a passos largos e, assim, seu uso por desenvolvedores de diversas áreas tem crescido.

A linguagem possui tantos recursos que muitas vezes usamos somente os mais comuns em nossa tarefa diária. Neste artigo, eu vou mostrar 5 recursos que a linguagem C# tem disponível que talvez você não conheça, mas que existem a partir da versão 6.0 da linguagem C#.

Todos os exemplos mostrados neste artigo foram testados no Visual Studio Community 2015 usando a versão 4.6 do .NET Framework.

Nota: para criar um projeto do tipo console no Visual Studio faça o seguinte:

• Abra o VS Community 2015  e clique em New Project;
• A seguir selecione Visual C# -> Console Application;
• Informe o nome  do projeto e clique no botão OK.

Recursos usados:

• Visual Studio Community 2015

• Linguagem C# 6.0

1. Expression-bodied Function

Quantas vezes você teve que escrever um método de apenas uma linha de código?

Agora, com C# 6, você pode simplesmente criar um membro expression bodied contendo somente a expressão, sem usar as chaves {} ou ter um retorno explícito.

Antes, você só podia usar expressões lambdas em corpo de métodos que compunham uma classe. Agora, com as expressions bodied, é possível implementar métodos e propriedades somente de leitura a partir de expressões lambdas.

Para deixar claro o recurso, abaixo temos o código comparando a forma anterior e a forma usando expression-bodied:

C# 5.0

 public class Item
    {
        public int Quantidade { get; set; }
        public double Preco { get; set; }
        public double Total
        {
            get
            {
                return Quantidade * Preco;
            }
        }
    }

C# 6.0

public class Item
    {
        public int Quantidade { get; set; }
        public double Preco { get; set; }
        public double Total => Quantidade * Preco;
    }

Exemplo de utilização:

 class Program
 {
        static void Main(string[] args)
        {
            Item item = new Item();
            item.Preco = 5.00;
            item.Quantidade = 15;
            Console.WriteLine(String.Format(
                "*** Item de Venda ***\n" +
                "Quantidade: {0}\nPreco: {1}\nValor Total: {2}",
                item.Quantidade, item.Preco, item.Total));
            Console.ReadKey();
        }
 }

Os membros de função das expression-bodied permitem que as propriedades, métodos, operadores e outros membros de função tenham corpos como expressões lambda (=>) ao invés de blocos de instrução, reduzindo assim a quantidade de código e dando uma visão mais claras sobre as expressões.

2. Operador Null Condicional

Nas versões anteriores da C#, você sempre tinha que escrever código para checar explicitamente a condição NULL antes de poder usar um objeto ou suas propriedades.

Da mesma forma que os tipos anuláveis (nullabe types), os operadores null-conditional podem ser usados para obter o mesmo resultado, bastando apenas usar o sinal ? depois da instância e antes de chamar a propriedade.

Dessa forma, a produtividade aumenta e a possibilidade de erros diminui.

Antes você fazia assim:

using System;
namespace OperadorNullCondicional
{
    class Program
    {
        static void Main(string[] args)
        {
            Funcionario funci = new Funcionario()
            {
                Nome = "Macoratti",
                Endereco = new Endereco()
                {
                    Residencial = "Rua Projetada, 100",
                    Trabalho = "Rua Peru, 300"
                }
            };
            if (funci != null && funci.Endereco != null)
            {
                Console.WriteLine((funci.Nome) + "  " + (funci.Endereco.Residencial ?? "Sem endereço"));
            }
            Console.ReadLine();
        }
    }
    public class Funcionario
    {
        public string Nome { get; set; }
        public Endereco Endereco { get; set; }
    }
    public class Endereco
    {
        public string Residencial { get; set; }
        public string Trabalho { get; set; }
    }
}

Agora, usando o recurso do operador Null Condicional(?) podemos fazer assim:

using static System.Console;
namespace OperadorNullCondicional
{
    class Program
    {
        static void Main(string[] args)
        {
            Funcionario funci = new Funcionario()
            {
                Nome = "Macoratti",
                Endereco = new Endereco()
                {
                    Residencial = "Rua Projetada, 100",
                    Trabalho = "Rua Peru, 300"
                }
            };
            WriteLine((funci?.Nome) + "  " + (funci?.Endereco?.Residencial ?? "Sem endereço"));
            ReadLine();
        }
    }
    public class Funcionario
    {
        public string Nome { get; set; }
        public Endereco Endereco { get; set; }
    }
    public class Endereco
    {
        public string Residencial { get; set; }
        public string Trabalho { get; set; }
    }
}

Assim, o operador verifica se a instância é null antes de chamar o método ou propriedade.

3. Inicializando auto propriedades e propriedades somente leitura a partir do construtor

Com C# 6.0, você pode inicializar as propriedades e propriedades somente de leitura a partir do construtor diretamente:

using static System.Console;
using System;
namespace InicialiarPropriedadesConstrutor
{
    class Program
    {
        static void Main(string[] args)
        {
            Aluno aluno = new Aluno();
            WriteLine("Nome " + aluno.Nome);
            WriteLine("Sobrenome " + aluno.SobreNome);
            WriteLine("Idade " + aluno.Idade);
            WriteLine("Registro " + aluno.DataRegistro);
            ReadLine();
        }
    }
    public class Aluno
    {
        public string Nome { get; set; } = "Jose Carlos";
        public string SobreNome { get; set; } = "Macoratti";
        public int Idade = 45;
        public DateTime DataRegistro { get; } = DateTime.Now;
    }
}

Resultado:

Menos código a digitar, menos erros a cometer.

4. Usando expressões lambdas para definir propriedades Get

Da mesma forma que usamos as expressões lambdas nas expression-bodied, a C# 6.0 permite que você utilize expressões lambdas para implementar o valor get de propriedades somente-leitura.

Sempre que uma expressão lambda for encontrada, o compilador C# a identifica como uma propriedade contendo somente o método get e não como um campo.

using static System.Console;
using System.Linq;
namespace ExpressaoLambda_Get
{
    class Program
    {
        static void Main(string[] args)
        {
            Aluno aluno = new Aluno();
            WriteLine("Nome Completo " + aluno.NomeCompleto);
            WriteLine("Nome Reverso " + aluno.NomeReverso);
            ReadLine();
        }
    }
    public class Aluno
    { 
        public string Nome { get; set; } = "Jose Carlos";
        public string SobreNome { get; set; } = "Macoratti";
        public string NomeCompleto => new string((Nome + " " + SobreNome).ToArray());
        public string NomeReverso => new string(NomeReverso.Reverse().ToArray());
    }
}

Resultado:

Simplificando a codificação.

5. Usando diretivas com classes estáticas

Você já deve saber que pode importar um namespace ou espaços de nomes usando a cláusula using. Isso nos dá a capacidade de usar um tipo citando apenas o seu nome no código e sem a necessidade de qualificá-lo totalmente usando o seu namespace completo.

Agora, na C# 6, podemos ir um passo além, e importar os membros estáticos de uma classe para o nosso namespace. Isto significa que podemos usar os membros estáticos de uma classe diretamente, sem necessidade de qualificá-los com o seu espaço para nome ou nome do tipo.

A sintaxe é ‘using static’ seguido do tipo cujos métodos estáticos desejamos importar.

Assim, esse recurso permite que todos os membros estáticos acessíveis de um tipo sejam importados, tornando-os disponíveis sem ter que utilizar o namespace completo no código.

Nota: eu já usei esse recurso nos exemplos anteriores.

Exemplo de uso:

using static System.Console;
using static System.Math;
using static System.DayOfWeek;
using static System.Linq.Enumerable;
namespace Using_Static
{
    class Program
    {
        static void Main(string[] args)
        {
            var numeros = Range(1, 10).ToArray();
            WriteLine("A raiz quadrada de 4 é : " + Sqrt(4));
            WriteLine(" 3 * 3 + 4 * 4  = " + Sqrt(3 * 3 + 4 * 4));
            WriteLine("Sexta-Feira " + Friday + "Segunda-feira : " + Monday);
            foreach (int num in numeros)
            {
                WriteLine(num);
            }
            ReadLine();
        }
    }
}

Resultado:

Essas são apenas algumas das novidades da C# 6.0. Aguarde, em breve, outro artigo com mais novidades.

Pegue o projeto completo aqui: CSharp_6.zip