Neste artigo, exploramos as principais novidades introduzidas no C#11, focando em melhorias de sintaxe e funcionalidades que facilitam o desenvolvimento.

Configuração de um Projeto Console com .NET 7.0

Para começar, crie um novo projeto de console usando o SDK do .NET 7.0. O arquivo de projeto pode ser estruturado da seguinte forma:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net7.0</TargetFramework>
    <RootNamespace>MeuProjetoConsole</RootNamespace>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
</Project>

Atributos Genéricos

No C#11, é possível criar atributos genéricos personalizados, o que permite reutilizar a lógica de anotação para diferentes tipos de dados. Por exemplo, defina um atributo genérico assim:

public class AtributoGenerico<T> : Attribute
{
    public T Valor { get; set; }

    public AtributoGenerico()
    {
    }

    public AtributoGenerico(T valorReal) : this()
    {
        Valor = valorReal;
    }
}

Este atributo pode ser aplicado em propriedades de classes, simplificando o uso de múltiplos tipos:

public class Usuario
{
    [AtributoGenerico<int>]
    public int IdUsuario { get; set; }

    [AtributoGenerico<string>("valorPadrao")]
    public string Nome { get; set; }
}

Validação de Nulos

No C#10, a validação de parâmetros nulos era realizada manualmente usando exceções. Por exemplo:

public Usuario ObterUsuario(string nome)
{
    ArgumentNullException.ThrowIfNull(nameof(nome));
    // Restante do código
}

O C#11 planejava introduzir uma sintaxe simplificada com dois operadores de exclamação, mas testes indicam que essa funcionalidade ainda não é suportada, resultando em erros de compilação.

Quebras de Linha em Strings com Interpolação

No C#11, o texto dentro das chaves {} em strings interpoladas pode abranger múltiplas linhas. Isso permite expressões C# complexas, como consultas LINQ ou padrões de correspondência, a serem escritas de forma mais legível.

Correspondência de Padrões em Listas

A correspondência de padrões em listas foi expandida no C#11, permitindo verificar sequências de elementos em arrays ou listas. Padrões como constantes, tipos e operações relacionais podem ser utilizados. Além disso, o padrão de descarte \_ corresponde a qualquer elemento único, e o padrão de intevralo .. correspodne a zero ou mais elementos.

Exemplos de uso:

var numeros = new[] { 1, 2, 3, 4, 5 };
if (numeros is [1, 2, 3, 4, 5] && numeros is [_, _, _, _, 5])
{
    Console.WriteLine("Padrão de lista correspondido");
}

O padrão \[\_, \_, \_, \_, 5\] verifica listas com cinco elementos, sendo o último igual a 5. O padrão de intervalo \[.., 5\] sipmlifica isso:

if (numeros is [.., 5])
{
    Console.WriteLine("Padrão de lista com intervalo correspondido");
}

Isso equivale a verificar se a lista tem pelo menos um elemento e o último é 5. Em expressões switch, a correspondência de padrões pode ser usada assim:

var amostra1 = new[] { 1, 2, 3, 4, 5 };
var amostra2 = new[] { 1, 3, 5 };
var amostra3 = new[] { 1 };
var amostra4 = new[] { 9 };
var amostra5 = new[] { 1, 6 };

string TestarPadrao(int[] colecao) => colecao switch
{
    [1, 2, 3, 4, 5] => "primeiro",
    [1, 3, .., 5] => "segundo",
    [1, _] => "terceiro",
    [1, ..] => "quarto",
    [..] => "quinto"
};

Console.WriteLine(TestarPadrao(amostra1)); // Saída: primeiro
Console.WriteLine(TestarPadrao(amostra2)); // Saída: segundo
Console.WriteLine(TestarPadrao(amostra3)); // Saída: quarto
Console.WriteLine(TestarPadrao(amostra4)); // Saída: quinto
Console.WriteLine(TestarPadrao(amostra5)); // Saída: terceiro

Strings Literais Brutas

As strings literais brutas são um novo formato no C#11 que permitem incluir texto arbitrário, incluindo espaços, quebras de linha e aspas, sem necessidade de caracteres de escape. Elas começam e terminam com pelo menos três aspas duplas """. Por exemplo:

var mensagem = """
    Esta é uma string literal bruta.
    Pode conter múltiplas linhas e "aspas" sem escape.
    """;

Isso facilita a escrita de strings complexas, como queries SQL ou JSON, diretamente no código.