C# 6.0 - Cinco Novos recursos que é bom conhecer
 Neste artigo vou mostrar 5 recursos existente na linguagem C# (a partir da versão 6.0) que talvez você não conheça, mas existem, e podem fazer a diferença quando você precisar do recurso.

Desde o seu lançamento a linguagem C# tem evoluído a passos largos e assim têm crescido em utilização por desenvolvedores de diversas áreas.

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:

Recursos usados :

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

Antes você somente 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 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:

 

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

 
C# 5.0 C# 6.0

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

Disse Jesus: "Na verdade, na verdade vos digo que quem ouve a minha palavra, e crê naquele que me enviou, tem a vida eterna, e não entrará em condenação, mas passou da morte para a vida"
João 5:24

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Referências:

José Carlos Macoratti