Avançando na Correspondência de Padrões com `Span<char>` no C# 11

Continuando nossa exploração pelas inovações do C# 11, chegamos a uma funcionalidade que promete enriquecer significativamente a maneira como manipulamos e comparamos strings: a capacidade de realizar correspondência de padrões usando Span<char> com strings constantes. Esse aprimoramento é particularmente relevante para cenários de alta performance e manipulação de strings em nível mais baixo, onde a eficiência é crítica.

Expandindo a Correspondência de Padrões

O C# tem evoluído constantemente suas capacidades de correspondência de padrões, tornando o código não apenas mais expressivo, mas também mais conciso. Com o C# 11, essa evolução continua ao permitir comparações diretas entre Span<char> e strings constantes, uma adição que simplifica a manipulação de strings, especialmente em contextos onde a alocação de memória precisa ser minimizada.

Exemplo 1: Verificação Simples de Igualdade

ReadOnlySpan<char> span = "test".AsSpan();
if (span.SequenceEqual("test"))
{
    Console.WriteLine("As strings são iguais.");
}

Neste exemplo, span.SequenceEqual("test") permite uma comparação direta e eficiente entre um Span<char> e uma string literal, facilitando a verificação de igualdade sem a necessidade de conversões ou alocações adicionais.

Exemplo 2: Uso em Métodos de Extensão

public static bool ComecaCom(this ReadOnlySpan<char> span, ReadOnlySpan<char> prefixo)
{
    return span.StartsWith(prefixo);
}

ReadOnlySpan<char> span = "exemplo".AsSpan();
if (span.ComecaCom("ex"))
{
    Console.WriteLine("O span começa com 'ex'.");
}

Este exemplo demonstra como a correspondência de padrões com Span<char> pode ser integrada em métodos de extensão, proporcionando uma maneira elegante e eficiente de estender a funcionalidade de comparação de strings.

Exemplo 3: Busca de Padrões em Texto

ReadOnlySpan<char> texto = "Procurando por padrões no C# 11".AsSpan();
ReadOnlySpan<char> padrao = "padrões".AsSpan();

if (texto.Contains(padrao))
{
    Console.WriteLine("Padrão encontrado!");
}

Aqui, a busca por um padrão dentro de um texto é realizada de maneira eficiente, usando a representação de Span<char> tanto para o texto quanto para o padrão de busca, ilustrando a utilidade do recurso em algoritmos de busca e manipulação de texto.

Exemplo 4: Comparação Sensível a Caso

ReadOnlySpan<char> entrada = "Caso Sensível".AsSpan();
if (entrada.Equals("CASO SENSÍVEL", StringComparison.OrdinalIgnoreCase))
{
    Console.WriteLine("Igualdade sensível a caso.");
}

Este exemplo mostra como realizar comparações de strings que são sensíveis a maiúsculas e minúsculas, aproveitando as sobrecargas de métodos existentes que aceitam Span<char>, garantindo que a lógica de comparação seja tanto precisa quanto eficiente.

Conclusão

A introdução da correspondência de padrões com Span<char> em uma string constante no C# 11 é um exemplo claro da contínua evolução da linguagem em direção à maior eficiência e expressividade. Este recurso abre novas portas para a manipulação de strings em cenários de alta performance, onde a redução de alocações de memória é crucial.

À medida que exploramos mais profundamente as funcionalidades do C# 11, torna-se evidente o foco em fornecer aos desenvolvedores as ferramentas necessárias para escrever código mais limpo, seguro e eficiente. Fique atento para mais artigos desta série, onde revelaremos outras inovações empolgantes que o C# 11 traz para a mesa de desenvolvimento.