C# - Novos recursos da versão 7.1

 Neste artigo vou apresentar 3 novos recursos da versão 7.1 da linguagem C#.

Não faz muito tempo que apresentei as novidades da versão 7.0 da linguagem e já temos uma nova versão 7.1 com mais novidades.(Na verdade já temos a versão 7.2). Essa versão marca uma nova forma de liberação de novas versões mais cadenciada.

A versão 7.1 do C# inclui a capacidade de configurar o compilador para corresponder a uma versão especificada da linguagem, e, isso permite que você separe a decisão de atualizar as ferramentas da decisão de atualizar as versões da linguagem.

Basicamente a versão 7.1 adiciona os seguintes recursos:

Selecionando a versão da linguagem

O compilador C# suporta a versão 7.1 a partir do Visual Studio 2017 versão 15.3 ou o .NET Core SDK 2.0. No entanto, os recursos 7.1 são desativados por padrão. Para habilitar os recursos da versão 7.1, você precisa alterar a configuração da versão da linguagem para o seu projeto.

Em seu projeto C#, no Visual Studio, clique com o botão direito do mouse sobre o nome do projeto no Solution Explorer e selecione Properties:



Clique na guia Build e a seguir clique no botão Advanced, e,  no menu suspenso em Language version selecione a versão específica ou C# latest major version(default) :

O último valor significa que você deseja usar a última versão menor na máquina atual. A versão C# 7.1 significa que você deseja usar o C# 7.1, mesmo depois que novas versões menores sejam lançadas.

1 - Asycn Main

O novo recurso Async Main permite que você utilize um await em seu método Main(). Anteriormente, você precisaria escrever o seguinte código :

        static int Main()
        {
            return MetodoAssincrono().GetAwaiter().GetResult();
        }

Agora você pode escrever :

        static async Task<int> Main()
        {
            return await MetodoAssincrono();
        }

E se o seu programa não retorna um código de saída você pode declarar um método que retorna Task : 

        static async Task Main()
        {
            await MetodoAssincrono();
        }

2 - Expressões literais default

As expressões literais padrão são um aprimoramento das expressões de valores padrão. Essas expressões inicializam uma variável para o valor padrão. 

Uma expressão de valor padrão produz o valor padrão para um tipo. As expressões de valores padrão são particularmente úteis em classes e métodos genéricos. Uma questão que surge com o uso de genéricos é como atribuir um valor padrão a um tipo parametrizado T quando você não conhece o seguinte antecipadamente:

1-) Se T é um tipo de referência ou um tipo de valor.
2-) Se T é um tipo de valor, seja um valor numérico ou uma estrutura definida pelo usuário.

Dada uma variável t de um tipo parametrizado T, a declaração t = null só é válida se T for um tipo de referência. A atribuição t = 0 funciona apenas para tipos de valores numéricos, mas não para estruturas.

A solução é usar uma expressão de valor padrão, que retorna null para tipos de referência (tipos de classe e tipos de interface) e zero para tipos de valores numéricos.

Para estruturas definidas pelo usuário, ele retorna a estrutura inicializada para o padrão de bits zero, que produz 0 ou null para cada membro, dependendo se esse membro é um valor ou tipo de referência. Para tipos de valor anuláveis, o padrão retorna um System.Nullable<T>, que é inicializado como qualquer estrutura.

A expressão padrão (T) não está limitada a classes e métodos genéricos. As expressões de valores padrão podem ser usadas com qualquer tipo gerenciado.

Assim qualquer uma das expressões a seguir é válida:

       var s = default(string);
       var d = default(dynamic);
       var i = default(int);
       var n = default(int?);    // n é um Nullable int onde HasValue é false.

Quando você cria um objeto Uri dessa forma, você obtém um benefício imediato ao manter a URI em uma string.

3 - Nomes de elementos de tuplas inferidos

Esse recurso é um pequeno aprimoramento do recurso de tuplas introduzido na versão 7.0 do C#.

Muitas vezes, quando você inicia uma tupla, as variáveis usadas para o lado direito da atribuição são as mesmas que os nomes que você gostaria para os elementos da tupla:

a- Antes da versão 7.1

      int count = 5;
    string label = "Cores usadas no mapa";
    var pair = (count: count, label: label);

b- Veja como fica na versão 7.1

     int count = 5;
    string label = "Cores usadas no mapa";
    var pair = (contagem, label);     // nomes de elementos são "count" e "label"

Agora o nome dos elementos de tupla podem ser deduzidos das variáveis usadas para inicializar a tupla no C# 7.1.

E estamos conversados...

(disse Jesus) "Eu sou o pão vivo que desceu do céu; se alguém comer deste pão, viverá para sempre; e o pão que eu der é a minha carne, que eu darei pela vida do mundo. "
 João 6:51

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