CKTIS / C#
Cópia superficial e ordenação de arrays com Comparison<T>
Cria um array separado com `Array.Clone()` e ordena-o no próprio array com `Array.Sort` e um delegado `Comparison<T>`. A cópia pode continuar a partilhar objetos com o original.
Versão: C# 12 and .NET 8; later runtimes may add compatible features
Sintaxe
using System;
int[] original = [3, 1, 2];
int[] copy = (int[])original.Clone();
Comparison<int> comparison = (x, y) => x.CompareTo(y);
Array.Sort<int>(copy, comparison);
// API signatures (namespace System):
// Array: public virtual object Clone();
// Array: public static void Sort<T>(T[] array, Comparison<T> comparison);
// public delegate int Comparison<in T>(T x, T y);Em C# 12 e .NET 8, o método de instância System.Array.Clone() cria um novo array do mesmo tipo em tempo de execução. O tipo devolvido é object, pelo que, para um T[], deves usar (T[])original.Clone(). A atribuição copy = original não cria um array: as duas variáveis referem-se à mesma instância.
A cópia é superficial: os elementos de tipo valor são copiados por valor e, para os elementos de tipo referência, copiam-se as referências, não os objetos. Reordenar ou substituir elementos na cópia não altera as posições no original. Alterar o estado de um objeto partilhado é, no entanto, visível através de ambos os arrays.
A sobrecarga estática Array.Sort<T>(T[], Comparison<T>) ordena todo o array unidimensional, com índices a partir de zero, no próprio array e devolve void. Usa um delegado System.Comparison<T>, não um objeto IComparer<T> nem a ordem predefinida. Para x e y, um resultado negativo coloca x antes de y, zero indica equivalência para efeitos de ordenação e um resultado positivo coloca x depois de y. Para chaves int, usa CompareTo em vez de uma subtração, que pode causar um overflow.
Define uma ordem coerente e transitiva e devolve zero quando um elemento é comparado consigo próprio. A ordenação é instável: os elementos que a comparação considera iguais podem mudar de ordem relativa. Passar null como array ou delegado lança ArgumentNullException. Se a ordenação falhar, não assumas que o array ficou inalterado.
Exemplos
using System;
using System.Linq;
Item[] original = [new Item("B", 20), new Item("A", 10), new Item("C", 30)];
Item[] copy = (Item[])original.Clone();
Comparison<Item> byPriority = (x, y) => x.Priority.CompareTo(y.Priority);
Array.Sort(copy, byPriority);
Print("original", original);
Print("copy", copy);
copy[0].Name = "A*";
copy[2] = new Item("D", 40);
Print("original", original);
Print("copy", copy);
static void Print(string label, Item[] items) =>
Console.WriteLine($"{label}: {string.Join(", ", items.Select(item => item.Name))}");
sealed class Item(string name, int priority)
{
public string Name { get; set; } = name;
public int Priority { get; } = priority;
}Resultado
original: B, A, C copy: A, B, C original: B, A*, C copy: A*, B, D
`byPriority` ordena a cópia por `Priority` crescente. A alteração de `Name` de `A` é visível nos dois arrays, mas substituir `C` por `D` só afeta `copy`.
Lições relacionadas
- C# · Lição 43 · Intermédio · Versão: 2