CKTIS / C#
Een oppervlakkige arraykopie sorteren met Comparison<T>
Maak met `Array.Clone()` een aparte array en sorteer die ter plekke met `Array.Sort` en een `Comparison<T>`-delegate. De kopie kan nog steeds objecten delen met het origineel.
Versie: C# 12 and .NET 8; later runtimes may add compatible features
Syntax
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 en .NET 8 maakt de instantiemethode System.Array.Clone() een nieuwe array van hetzelfde runtimetype. Het retourtype is object, dus gebruik voor een T[] de cast (T[])original.Clone(). De toewijzing copy = original maakt geen array: beide variabelen verwijzen dan naar dezelfde instantie.
De kopie is oppervlakkig: bij elementen van een waardetype wordt de waarde gekopieerd en bij elementen van een referentietype wordt de referentie gekopieerd, niet het object. Als je elementen in de kopie verplaatst of vervangt, blijven de posities in het origineel ongewijzigd. Een wijziging aan de toestand van een gedeeld object is wel zichtbaar via beide arrays.
De statische overload Array.Sort<T>(T[], Comparison<T>) sorteert de hele eendimensionale array met startindex nul ter plekke en retourneert void. Deze overload gebruikt een System.Comparison<T>-delegate, niet een IComparer<T>-object of de standaardvolgorde. Voor x en y plaatst een negatief resultaat x vóór y, betekent nul dat ze gelijkwaardig zijn voor de sortering en plaatst een positief resultaat x na y. Gebruik voor int-sleutels CompareTo in plaats van aftrekken, want dat kan overlopen.
Zorg voor een consistente, transitieve volgorde en retourneer nul als een element met zichzelf wordt vergeleken. De sortering is instabiel: elementen die als gelijk worden beoordeeld, kunnen van onderlinge volgorde veranderen. Als de array of de delegate null is, volgt een ArgumentNullException. Als het sorteren mislukt, ga er dan niet van uit dat de array ongewijzigd is gebleven.
Voorbeelden
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;
}Resultaat
original: B, A, C copy: A, B, C original: B, A*, C copy: A*, B, D
`byPriority` sorteert de kopie op oplopende `Priority`. De wijziging van `Name` bij `A` is in beide arrays zichtbaar, maar `C` vervangen door `D` heeft alleen effect op `copy`.
Gerelateerde lessen
- C# · Les 43 · Gemiddeld · Versie: 2