O que há de novo no C # 10?

C # 10 foi lançado em novembro de 2021 junto com o Visual Studio 2022 e .NET 6. Ele adiciona vários novos recursos que o tornam mais fácil e conveniente de trabalhar. Aqui está um tour por algumas das adições mais úteis e como elas irão aprimorar seu fluxo de trabalho.

Namespaces com escopo de arquivo

Vamos começar com uma das mudanças mais simples, mas talvez as mais significativas. Agora você pode aplicar um namespace a um arquivo inteiro por meio de uma nova opção de sintaxe para o namespace palavra-chave. O código restante dentro do arquivo terá um namespace automaticamente, mesmo se não estiver indentado dentro de um namespace bloquear. Isso funciona de forma semelhante às declarações de namespace em PHP.

No C # 9, você precisava deste código para criar um namespace de classe:

namespace Demo {
 
    public class Example {
    }
 
}

Em C # 10, você pode usar o seguinte:

namespace Demo;
 
public class Example {
}

Isso economiza algum espaço horizontal em seu editor, cortando um nível de recuo. Se o arquivo precisa conter várias classes, você pode escrevê-los todos começando na coluna zero – o namespace declaração se aplica a todo o arquivo.

Usos Globais

Alguns namespaces são usados ​​amplamente em projetos. No entanto, você ainda precisa incluí-los manualmente em cada arquivo com um using demonstração.

C # 10 muda isso para oferecer suporte a um global using variante. Isso tornará o namespace referenciado acessível em todos os arquivos em seu projeto.

global using System;

Os usos globais podem ser adicionados a qualquer arquivo que será incluído em sua compilação. Eles suportam todos os recursos do padrão using declarações, incluindo o static palavra-chave e alias com =.

A adoção de usos globais reduzirá o número de linhas que você escreve, mas ainda é melhor reservá-los para namespaces comumente referenciados que apresentam pouca chance de colisões de nomenclatura. Esteja ciente de que confiar em um global using pode tornar seu código mais opaco, pois novos contribuidores podem não perceber imediatamente como um recurso com namespace foi incluído.

Um recurso que acompanha os usos globais são os usos implícitos. Isso cria automaticamente global using declarações apropriadas para o tipo de seu projeto. O recurso é ativado por padrão nos modelos de projeto .NET 6. Pode ser desativado com o ImplicitUsings configuração em seu .csproj Arquivo.

Estruturas aprimoradas

As estruturas receberam vários aprimoramentos que as aproximam das classes. Isso inclui construtores sem parâmetros, inicializadores de campo, suporte completo para with expressões e a opção de criar estruturas de registro:

public record Point(int X, int Y);

Este exemplo cria uma estrutura de registro “posicional” onde o X e Y os parâmetros do construtor tornam-se membros públicos implícitos. Você também pode definir manualmente os membros usando a sintaxe existente:

public record struct Point {
    public int X { get; init; }
    public int Y { get; init; }
}

Uma estrutura de registro deve ser usada em cenários onde você precisa encapsular alguns dados sem anexar comportamentos personalizados como métodos de classe. Uma estrutura de registro oferece verificações de igualdade de valor integradas e recursos como ToString(). Ele pode ser mutável ou imutável por meio do readonly palavra-chave.

Aprimoramentos de expressão lambda

C # 10 adiciona várias melhorias às expressões lambda, abrangendo seus tipos e sintaxe. O objetivo é tornar lambdas mais parecidos com métodos regulares e funções locais. Definir um agora será uma experiência mais familiar.

O conceito de um tipo “natural” foi introduzido. Isso permite que o compilador inferir o tipo de um lambda sem convertê-lo manualmente em um delegado ou expressão. Isso cria um código mais legível ao atribuir um lambda a uma variável:

// C# 9
Func<string, int> toInt = (string s) => int.Parse(s);
 
// C# 10
var toInt = (string s) => int.Parse(s)

O compilador irá inferir o tipo de toInt Como Func<string, int> e isso será exibido quando você visualizar o código no Visual Studio. As inferências usarão Func, Action, ou delegados sintetizados.

Os tipos naturais só funcionarão quando sua expressão lambda já estiver totalmente digitada. Se você omitir os tipos de parâmetro, o compilador não será capaz de criar uma definição de tipo compatível.

Uma mudança relacionada é o suporte para tipos de retorno explícitos. Como com uma função regular, o tipo de retorno vai antes da lista de parâmetros do lambda:

var toInt = int (string s) => int.Parse(s)

Por fim, lambdas agora podem receber atributos da mesma maneira que métodos e funções. Eles estão posicionados no início da expressão lambda, antes do tipo de retorno e da lista de parâmetros. Você pode usar atributos para anexar metadados extras aos seus lambdas para facilitar uma maior introspecção e análise de código.

var toInt = [DemoAttribute()] int (string s) => int.Parse(s)

Atribuições desconstruídas versáteis

As atribuições de desconstrução agora podem inicializar novas variáveis ​​e atribuir valores às existentes na mesma linha. Anteriormente, você precisava usar desconstruções separadas para essas operações.

Em C # 9, isso resultou em um código semelhante a este:

int x = 0;
int y = 0;
(x, y) = point;
 
(int z) = point;

Enquanto no C # 10, você pode fazer isso:

int x = 0;
int y = 0;
(x, y, int z) = point;

Agora x, y, e z serão todos inicializados com valores usando a atribuição de desconstrução única, reduzindo a repetição em seu código.

Outras Mudanças

A interpolação de strings foi aprimorada e agora também funciona com strings constantes. Você precisa garantir que todas as strings usadas para preencher os buracos do marcador durante a interpolação sejam, elas mesmas, valores constantes. De forma mais ampla, as otimizações do processo de interpolação podem reduzir o uso de memória e aumentar o desempenho por meio do uso de manipuladores dedicados.

Os padrões de propriedade foram simplificados para fornecer acesso mais legível às propriedades aninhadas. Agora você pode usar a sintaxe de ponto para acessar valores de propriedade aninhados, em vez de várias camadas de parênteses:

// C# 9
{ Train: {ArrivalTime: "10:00"} }
 
// C# 10
{ Train.ArrivalTime: "10:00" }

Em outros lugares, as otimizações do compilador significam que você se beneficiará de menos falsos positivos durante a atribuição definida e verificações de estado nulo. Vários problemas do C # 9 que dispararam avisos falsos em tempo de compilação foram resolvidos, resultando em verificações mais precisas e mais bem equipadas para ajudá-lo a depurar problemas que realmente importam. Os problemas estavam ligados ao uso de expressões coalescentes nulas e comparações de variáveis ​​com constantes booleanas.

Conclusão

C # 10 adiciona vários novos recursos que ajudarão a tornar o desenvolvimento mais direto. No entanto, muitos outros novos recursos, incluindo o field a palavra-chave e as propriedades necessárias foram adiadas para a próxima versão principal. Atributos genéricos e membros abstratos estáticos para interfaces aumentaram para 10, mas com a tag de visualização ainda anexada.

Você pode começar a usar o C # 10 hoje baixando o Visual Studio 2022. A linguagem também está disponível como parte do .NET 6 SDK autônomo que funciona no Windows, Mac e Linux.