Sdílet prostřednictvím

Operátory přiřazení (referenční příručka C#)

Operátor = přiřazení přiřadí hodnotu jeho pravého operandu proměnné, vlastnosti nebo prvku indexeru zadaného jeho levým operandem. Výsledkem výrazu přiřazení je hodnota přiřazená k levému operandu. Typ pravého operandu musí být stejný jako typ levého operandu nebo na něj musí být implicitně převeden.

Operátor = přiřazení je pravě-asociativní, to je výraz ve tvaru.

a = b = c

Je hodnoceno jako

a = (b = c)

Následující příklad ukazuje použití operátoru přiřazení, kdy místní proměnná, vlastnost a prvek indexeru slouží jako levý operand:

List<double> numbers = [1.0, 2.0, 3.0];

Console.WriteLine(numbers.Capacity);
numbers.Capacity = 100;
Console.WriteLine(numbers.Capacity);
// Output:
// 4
// 100

int newFirstElement;
double originalFirstElement = numbers[0];
newFirstElement = 5;
numbers[0] = newFirstElement;
Console.WriteLine(originalFirstElement);
Console.WriteLine(numbers[0]);
// Output:
// 1
// 5

Levý operand přiřazení obdrží hodnotu pravého operandu. Pokud jsou operandy hodnotových typů, přiřazení zkopíruje obsah pravého operandu. Pokud jsou operandy typu odkazu, přiřazení zkopíruje odkaz na objekt.

Tato operace se nazývá přiřazení hodnoty: tato hodnota je přiřazena.

Od jazyka C# 14 může levá strana přiřazení hodnoty obsahovat výraz podmíněného člena s hodnotou null, například ?. nebo ?[]. Pokud je levá strana null, nevyhodnocuje se výraz na pravé straně.

přiřazení odkazu

Přiřazení= ref odkazu vytvoří z levého operandu alias pravého operandu, jak ukazuje následující příklad:

void Display(double[] s) => Console.WriteLine(string.Join(" ", s));

double[] arr = { 0.0, 0.0, 0.0 };
Display(arr);

ref double arrayElement = ref arr[0];
arrayElement = 3.0;
Display(arr);

arrayElement = ref arr[arr.Length - 1];
arrayElement = 5.0;
Display(arr);
// Output:
// 0 0 0
// 3 0 0
// 3 0 5

V předchozím příkladu je místní referenční proměnnáarrayElement inicializována jako alias prvního prvku pole. Potom se ref znovu přiřazuje, aby odkazoval na poslední prvek pole. Protože se jedná o alias, při aktualizaci jeho hodnoty pomocí běžného operátoru =přiřazení je také aktualizován odpovídající prvek pole.

Levým operandem ref přiřazení může být místní referenční proměnná,refpole a refparametr metody , outnebo in metoda. Oba operandy musí být stejného typu.

Přiřazení ref znamená, že referenční proměnná má jinou referenční hodnotu. Již neodkazuje na svůj předchozí referent. Použití ref = u parametru ref znamená, že parametr už nebude odkazovat na jeho argument. Všechny akce, které upravují stav objektu po opakovaném přiřazení reference, provádějí tyto změny novému objektu. Představte si například následující metodu:

private static void RefReassignAndModify(scoped ref string s)
{
    string sLocal = "Hello";
    Console.WriteLine(sLocal);  // Output: Hello

    s = ref sLocal;
    s = "World";
    Console.WriteLine(s);  // Output: World

Následující použití ukazuje, že přiřazení k parametru s není viditelné po volání metody, protože s bylo ref znovu přiřazeno, aby odkazovalo na sLocal před úpravou řetězce:

string msg = "Hi";
RefReassignAndModify(ref msg);
Console.WriteLine(msg); // Output: Hi!

Složené přiřazení

U binárního operátoru opje složený výraz přiřazení formuláře.

x op= y

Je ekvivalentní

x = x op y

Kromě toho, že x se vyhodnotí jenom jednou.

Aritmetické, logické Booleovy a bitové logické a posuvné operátory podporují složené přiřazení.

Přiřazení při souhlásání s hodnotou null

Operátor přiřazení s hodnotou null-coalescing můžete ??= použít k přiřazení hodnoty jeho pravého operandu k jeho levému operandu pouze v případě, že se operand vlevo vyhodnotí jako null. Další informace najdete v článku o operátorech ?? a ??=.

Přetížení operátoru

Uživatelem definovaný typ nemůže přetížit operátor přiřazení. Uživatelem definovaný typ však může definovat implicitní převod na jiný typ. Tímto způsobem lze hodnotu uživatelem definovaného typu přiřadit proměnné, vlastnosti nebo prvku indexeru jiného typu. Další informace naleznete v tématu Uživatelem definované operátory převodu.

Pokud uživatelem definovaný typ přetěžuje binární operátor op, op= operátor, pokud existuje, je také implicitně přetížen. Počínaje jazykem C# 14 může uživatelem definovaný typ explicitně přetížit operátory složeného přiřazení (op=), aby poskytoval efektivnější implementaci. Typ obvykle přetěžuje tyto operátory, protože hodnotu lze aktualizovat místo přidělení nové instance pro uložení výsledku binární operace. Pokud typ neposkytuje explicitní přetížení, kompilátor vygeneruje implicitní přetížení.

specifikace jazyka C#

Další informace najdete v části Operátory přiřazeníspecifikace jazyka C# a specifikace funkce definované uživatelem definovaného složeného přiřazení .

Viz také