💻 Exemplos: Capítulo 04: Estruturas Repetitivas, Foreach e o Poder do Span

Especialização em Sistemas com C# • Demonstrações Práticas Compiláveis

🎯 Objetivo dos Exemplos

Demonstrar a evolução da iteração e manipulação contígua de memória em C#: loops tradicionais, foreach otimizado e a aplicação da estrutura de alta performance Span<T> / ReadOnlySpan<T> combinada com stackalloc para processamento numérico com alocação zero no Heap gerenciado (Zero-Allocation).

1. Código Fonte Completo (Program.cs)

/**
 * @file Program.cs
 * @brief Laços iterativos, Span<T>, ReadOnlySpan<T> e stackalloc em C# 12.
 */

using System;

Console.WriteLine("=== CAPÍTULO 04: LAÇOS MODERNOS E SPAN<T> ===");

// 1. Alocação Pura na Stack com stackalloc e Span<T> (Zero Alocação no Heap / GC Zero)
Span<int> bufferSinais = stackalloc int[8];

// Preenchimento sequencial direto na Stack
for (int i = 0; i < bufferSinais.Length; i++)
{
    bufferSinais[i] = (i + 1) * 10;
}

Console.WriteLine($"Buffer alocado na Stack com {bufferSinais.Length} inteiros.");

// 2. Fatiamento de Memória Sem Alocar Novo Array (Slice O(1))
Span<int> janelaCentral = bufferSinais.Slice(start: 2, length: 4);

Console.Write("Elementos da Janela Central (Slice 2..5): ");
foreach (int valor in janelaCentral)
{
    Console.Write($"{valor} ");
}
Console.WriteLine();

// Modificar a fatia reflete diretamente no buffer original!
janelaCentral[0] = 999;
Console.WriteLine($"Buffer original no indice 2 apos mutacao na fatia: {bufferSinais[2]}");

// 3. Processamento de Strings Sem Alocação com ReadOnlySpan<char>
string linhaLog = "2026-09-28|KERNEL_SECURITY_ALERT|PID_1042";

// Parsing com Spans não instancia novas strings no Heap!
ReadOnlySpan<char> spanTexto = linhaLog.AsSpan();

int primeiraBarra = spanTexto.IndexOf('|');
int segundaBarra = spanTexto.LastIndexOf('|');

ReadOnlySpan<char> timestamp = spanTexto.Slice(0, primeiraBarra);
ReadOnlySpan<char> severidade = spanTexto.Slice(primeiraBarra + 1, segundaBarra - primeiraBarra - 1);
ReadOnlySpan<char> processo = spanTexto.Slice(segundaBarra + 1);

Console.WriteLine("\n--- Parsing Zero-Allocation via ReadOnlySpan<char> ---");
Console.WriteLine($"Timestamp:  [{timestamp}]");
Console.WriteLine($"Severidade: [{severidade}]");
Console.WriteLine($"Processo:   [{processo}]");

// 4. Somatório e Estatísticas Eficientes
static double CalcularMedia(ReadOnlySpan<int> valores)
{
    if (valores.IsEmpty) return 0.0;
    long soma = 0;
    foreach (int v in valores)
    {
        soma += v;
    }
    return (double)soma / valores.Length;
}

Console.WriteLine($"Media calculada das amostras: {CalcularMedia(bufferSinais):F2}");

2. Instruções de Compilação e Execução

dotnet new console -n AppSpans -f net8.0
cd AppSpans
dotnet run

3. Saída Esperada no Terminal

=== CAPÍTULO 04: LAÇOS MODERNOS E SPAN<T> ===
Buffer alocado na Stack com 8 inteiros.
Elementos da Janela Central (Slice 2..5): 30 40 50 60 
Buffer original no indice 2 apos mutacao na fatia: 999

--- Parsing Zero-Allocation via ReadOnlySpan<char> ---
Timestamp:  [2026-09-28]
Severidade: [KERNEL_SECURITY_ALERT]
Processo:   [PID_1042]
Media calculada das amostras: 153.62