Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C#

Mělká kopie pole a řazení pomocí Comparison<T>

Pomocí `Array.Clone()` vytvořte samostatné pole a seřaďte ho na místě metodou `Array.Sort` s delegátem `Comparison<T>`. Kopie může s původním polem dál sdílet objekty.

Verze: C# 12 and .NET 8; later runtimes may add compatible features

Syntaxe

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);

V C# 12 a .NET 8 vytváří instanční metoda System.Array.Clone() nové pole stejného typu za běhu. Návratový typ je object, proto pro pole T[] použijte přetypování (T[])original.Clone(). Přiřazení copy = original nové pole nevytvoří: obě proměnné odkazují na stejnou instanci.

Kopie je mělká: prvky hodnotových typů se kopírují hodnotou a u prvků referenčních typů se kopírují odkazy, nikoli objekty. Změna pořadí nebo náhrada prvku v kopii nemění pozice v původním poli. Změna stavu sdíleného objektu je však viditelná přes obě pole.

Statické přetížení Array.Sort<T>(T[], Comparison<T>) řadí celé jednorozměrné pole indexované od nuly přímo na místě a vrací void. Používá delegát System.Comparison<T>, nikoli objekt IComparer<T> ani výchozí pořadí. Pro x a y záporný výsledek řadí x před y, nula znamená rovnocennost při řazení a kladný výsledek řadí x za y. Pro klíče typu int použijte CompareTo místo odčítání, při kterém může dojít k přetečení.

Zajistěte konzistentní a tranzitivní uspořádání a při porovnání prvku se sebou samým vracejte nulu. Řazení je nestabilní: prvky vyhodnocené jako rovnocenné mohou změnit vzájemné pořadí. Pokud je pole nebo delegát null, vyvolá se ArgumentNullException. Pokud řazení selže, nepředpokládejte, že pole zůstalo beze změny.

Příklady

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;
}

Výsledek

original: B, A, C
copy: A, B, C
original: B, A*, C
copy: A*, B, D

`byPriority` seřadí kopii vzestupně podle `Priority`. Změna `Name` u `A` se projeví v obou polích, ale nahrazení `C` prvkem `D` ovlivní pouze `copy`.

Související lekce

  • C# · Lekce 43 · Středně pokročilá · Verze: 2

Zdroje