Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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

Fonti