CKTIS / C#
Copia superficiale e ordinamento di array con Comparison<T>
Crea un array separato con `Array.Clone()`, poi ordinalo sul posto con `Array.Sort` e un delegato `Comparison<T>`. La copia può ancora condividere gli oggetti con l’array originale.
Versione: C# 12 and .NET 8; later runtimes may add compatible features
Sintassi
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);In C# 12 e .NET 8, il metodo di istanza System.Array.Clone() crea un nuovo array dello stesso tipo a runtime. Il tipo restituito è object, quindi per un T[] usa (T[])original.Clone(). L’assegnazione copy = original non crea un array: entrambe le variabili fanno riferimento alla stessa istanza.
La copia è superficiale: gli elementi di tipo valore vengono copiati per valore, mentre per gli elementi di tipo riferimento vengono copiati i riferimenti, non gli oggetti. Riordinare o sostituire elementi nella copia non cambia le posizioni nell’originale. Una modifica allo stato di un oggetto condiviso, invece, è visibile tramite entrambi gli array.
L’overload statico Array.Sort<T>(T[], Comparison<T>) ordina sul posto l’intero array monodimensionale con indice iniziale zero e restituisce void. Usa un delegato System.Comparison<T>, non un oggetto IComparer<T> né l’ordine predefinito. Per x e y, un risultato negativo colloca x prima di y, zero indica che i due elementi sono equivalenti per l’ordinamento e un risultato positivo colloca x dopo y. Per chiavi int, usa CompareTo anziché una sottrazione, che può causare un overflow.
Definisci un ordine coerente e transitivo e restituisci zero quando un elemento è confrontato con se stesso. L’ordinamento è instabile: gli elementi equivalenti secondo il confronto possono cambiare ordine relativo. Passare null come array o delegato genera ArgumentNullException. Se l’ordinamento non riesce, non presumere che l’array sia rimasto invariato.
Esempi
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;
}Risultato
original: B, A, C copy: A, B, C original: B, A*, C copy: A*, B, D
`byPriority` ordina la copia per `Priority` crescente. La modifica di `Name` per `A` è visibile in entrambi gli array, ma la sostituzione di `C` con `D` riguarda solo `copy`.
Lezioni correlate
- C# · Lezione 43 · Intermedio · Versione: 2