Propriedades e Métodos Essenciais de Arrays

Imagine que um array é como um trem de carga. Cada vagão do trem pode carregar um contêiner (um elemento do array), e todos os vagões são numerados, começando do zero. As operações que podemos fazer nesse trem nos ajudam a gerenciá-lo de forma eficiente.

Vamos explorar algumas das propriedades e métodos mais comuns que você usará ao trabalhar com arrays, usando nossa analogia do trem.

`Length` (Propriedade)

O Length não é um método, mas sim uma propriedade. Pense nele como o relatório do chefe da estação que diz exatamente quantos vagões o seu trem possui. Ele não faz nada, apenas informa um fato sobre o array: seu tamanho total.

// Our array is a "train" with 5 "wagons"
int[] numbers = new int[5];

// The Length property tells us the total capacity of our train.
Console.WriteLine($"The train has {numbers.Length} wagons."); // Outputs: The train has 5 wagons.

`Clone()` (Método)

O método Clone() constrói um trem novo, idêntico ao original. Ele cria um novo array com exatamente o mesmo tamanho e com os mesmos elementos do array original.

No entanto, há um detalhe extremamente importante: Clone() cria uma cópia superficial (shallow copy). Para uma explicação detalhada, veja o exemplo no final da seção.

// An array of value types (integers)
int[] originalTrain = { 10, 20, 30 };

// Clone the train
int[] clonedTrain = (int[])originalTrain.Clone();

// Change a wagon in the cloned train
clonedTrain[0] = 100;

// The original train remains unchanged because int is a value type
Console.WriteLine($"Original train first wagon: {originalTrain[0]}"); // Outputs: 10

`CopyTo()` (Método)

O método CopyTo() é como mover a carga de alguns vagões do seu trem para outro trem que já está na estação. Ele não cria um novo array, mas copia elementos do array de origem para um array de destino que já existe.

// The source train with 3 wagons
int[] sourceTrain = { 1, 2, 3 };

// The destination train, bigger and initially empty
int[] destinationTrain = new int[5]; // { 0, 0, 0, 0, 0 }

// Copy all wagons from the source train to the destination train,
// starting at the second position (index 1) of the destination.
sourceTrain.CopyTo(destinationTrain, 1);

// Final state of destinationTrain: { 0, 1, 2, 3, 0 }
Console.WriteLine(string.Join(", ", destinationTrain));

`IndexOf()` (Método Estático)

Precisa saber em qual vagão está uma carga específica? Array.IndexOf() faz isso. Ele percorre o trem e te diz o número do primeiro vagão (o índice) onde a carga foi encontrada. Se a carga não existir no trem, ele retorna -1.

string[] cargoTrain = { "Apples", "Oranges", "Bananas", "Oranges" };

// Find the wagon number for "Bananas"
int bananaWagon = Array.IndexOf(cargoTrain, "Bananas"); // Returns 2

// "Oranges" appears twice, but IndexOf returns the first one it finds.
int orangeWagon = Array.IndexOf(cargoTrain, "Oranges"); // Returns 1

// "Grapes" are not in the train
int grapeWagon = Array.IndexOf(cargoTrain, "Grapes"); // Returns -1

Console.WriteLine($"Bananas are in wagon: {bananaWagon}");

`Sort()` (Método Estático)

Este método organiza os vagões do seu trem. Se a carga for numérica, ele os ordena do menor para o maior. Se for texto, em ordem alfabética. É importante saber que Array.Sort() modifica o array original.

int[] messyTrain = { 5, 1, 4, 2, 3 };

// Sort the train
Array.Sort(messyTrain);

// The messyTrain is now ordered: { 1, 2, 3, 4, 5 }
Console.WriteLine(string.Join(", ", messyTrain));

`Reverse()` (Método Estático)

Array.Reverse() inverte a ordem de todos os vagões do trem. O último vira o primeiro, o penúltimo vira o segundo, e assim por diante. Assim como o Sort, ele modifica o array original.

string[] train = { "First", "Middle", "Last" };

// Reverse the train
Array.Reverse(train);

// The train is now in reversed order: { "Last", "Middle", "First" }
Console.WriteLine(string.Join(", ", train));

`Clear()` (Método Estático)

Este método não remove os vagões, mas esvazia seu conteúdo, restaurando-os para o valor padrão (0 para números, null para objetos, false para booleanos). Você especifica em qual vagão começar a limpeza e quantos vagões limpar.

int[] trainToClean = { 1, 2, 3, 4, 5 };

// Clean 2 wagons, starting from the second wagon (index 1)
Array.Clear(trainToClean, 1, 2);

// The train's cargo is now: { 1, 0, 0, 4, 5 }
Console.WriteLine(string.Join(", ", trainToClean));

`Resize()` (Método Estático)

E se você precisar de um trem mais longo ou mais curto? Arrays em C# têm um tamanho fixo, mas Array.Resize() nos ajuda a contornar isso.

Atenção: ele não "estica" o array original. Ele cria um novo array com o tamanho desejado, copia os elementos do array antigo para o novo e, em seguida, faz sua variável de array apontar para este novo array.

int[] trainToResize = { 1, 2, 3 };

// Resize the train to have 5 wagons
// The 'ref' keyword is necessary here
Array.Resize(ref trainToResize, 5);

// The train now has 5 wagons. The new ones have the default value (0).
// Content: { 1, 2, 3, 0, 0 }
Console.WriteLine($"New train length: {trainToResize.Length}");
Console.WriteLine(string.Join(", ", trainToResize));

Referências

Para aprofundar seus conhecimentos, consulte a documentação oficial da Microsoft, que é a fonte mais confiável de informação.

Classe System.Array: A página principal da classe Array, com uma lista de todas as suas propriedades e métodos.
Guia de Programação de Arrays (C#): Um guia completo sobre como declarar, inicializar e usar arrays em C#.

18 August 2025

Propriedades e Métodos Essenciais de Arrays

Length (Propriedade)

Clone() (Método)

CopyTo() (Método)

IndexOf() (Método Estático)

Sort() (Método Estático)

Reverse() (Método Estático)

Clear() (Método Estático)

Resize() (Método Estático)