Avançando na Correspondência de Padrões com `Span<char>` no C# 11
Tags: braziliandevs, tutorial, dotnet, csharp
Published: 2024-03-15 00:00:00

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

```csharp
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

```csharp
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

```csharp
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

```csharp
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.