Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C#

Plytká kópia poľa a triedenie pomocou Comparison<T>

Pomocou `Array.Clone()` vytvorte samostatné pole a zoraďte ho na mieste metódou `Array.Sort` s delegátom `Comparison<T>`. Kópia môže s pôvodným poľom naďalej zdieľať objekty.

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

V C# 12 a .NET 8 vytvorí inštančná metóda System.Array.Clone() nové pole rovnakého typu za behu programu. Návratový typ je object, takže pre pole T[] použite pretypovanie (T[])original.Clone(). Priradenie copy = original pole nevytvorí: obe premenné odkazujú na tú istú inštanciu.

Kópia je plytká: prvky hodnotových typov sa kopírujú hodnotou a pri prvkoch referenčných typov sa kopírujú referencie, nie objekty. Zmena poradia alebo nahradenie prvku v kópii nemení pozície v pôvodnom poli. Zmena stavu zdieľaného objektu je však viditeľná cez obe polia.

Statické preťaženie Array.Sort<T>(T[], Comparison<T>) zoradí celé jednorozmerné pole indexované od nuly priamo na mieste a vráti void. Používa delegát System.Comparison<T>, nie objekt IComparer<T> ani predvolené poradie. Pre x a y záporný výsledok zaradí x pred y, nula znamená, že sú pri triedení rovnocenné, a kladný výsledok zaradí x za y. Pre kľúče typu int použite CompareTo namiesto odčítania, pri ktorom môže dôjsť k pretečeniu.

Zabezpečte konzistentné a tranzitívne usporiadanie a pri porovnaní prvku so sebou samým vráťte nulu. Triedenie je nestabilné: prvky vyhodnotené ako rovnocenné môžu zmeniť vzájomné poradie. Ak je pole alebo delegát null, vyvolá sa ArgumentNullException. Ak triedenie zlyhá, nepredpokladajte, že pole zostalo nezmenené.

Prí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ýsledok

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

`byPriority` zoradí kópiu vzostupne podľa `Priority`. Zmena `Name` v objekte `A` je viditeľná v oboch poliach, ale nahradenie `C` prvkom `D` ovplyvní iba `copy`.

Súvisiace lekcie

  • C# · Lekcia 43 · Stredne pokročilá · Verzia: 2

Zdroje