Megosztás a következőn keresztül:

Hozzárendelési operátorok (C#-referencia)

A hozzárendelési operátor = hozzárendeli a jobb oldali operandus értékét egy változóhoz, egy tulajdonsághoz vagy egy indexelő elemhez, amelyet a bal oldali operandus adott. A hozzárendelési kifejezés eredménye a bal oldali operandushoz rendelt érték. A jobb oldali operandus típusának meg kell egyeznie a bal oldali operandus típusával, vagy implicit módon átalakíthatónak kell lennie hozzá.

A hozzárendelési operátor = jobb asszociatív, vagyis az űrlap kifejezése

a = b = c

A kiértékelés a következőképpen történik:

a = (b = c)

Az alábbi példa a hozzárendelési operátor használatát mutatja be egy helyi változóval, egy tulajdonsággal és egy indexelő elemet tartalmazó bal oldali operandussal:

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

A feladat bal oldali operandusa megkapja a jobb oldali operandus értékét . Ha az operandusok értéktípusokból állnak, a hozzárendelés átmásolja a jobb oldali operandus tartalmát. Ha az operandusok referenciatípusok, a hozzárendelés átmásolja az objektumra mutató hivatkozást.

Ezt a műveletet érték-hozzárendelésnek nevezzük: az érték hozzárendelése.

A C# 14-től kezdődően az érték-hozzárendelés bal oldala tartalmazhat null feltételes tagkifejezést, például ?. vagy ?[]. Ha a bal oldali érték null, a jobb oldali kifejezés nem lesz kiértékelve.

ref hozzárendelés

A Ref-hozzárendelés= ref a bal oldali operandusát a jobb oldali operandus aliasává teszi, ahogy az alábbi példa is mutatja:

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

Az előző példában a helyi referenciaváltozóarrayElement az első tömbelem aliasaként van inicializálva. Ezután ref hozzá van rendelve, hogy az utolsó tömbelemre hivatkozzon. Aliasként, amikor az értékét egy szokásos hozzárendelési operátorral =frissíti, a megfelelő tömbelem is frissül.

A hozzárendelés bal oldali operandusa ref lehet helyi referenciaváltozó,refmező és ref, outvagy in metódusparaméter. Mindkét operandusnak azonos típusúnak kell lennie.

A ref hozzárendelés azt jelenti, hogy egy referenciaváltozó más hivatkozással rendelkezik. Már nem a korábbi hivatkozására hivatkozik. Ha ref =-et használ egy ref paraméteren, az azt jelenti, hogy a paraméter már nem hivatkozik az argumentumára. Minden olyan művelet, amely módosítja az objektum állapotát az újbóli hozzárendelés után, végrehajtja ezeket a módosításokat az új elemen. Vegyük például a következő módszert:

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

Az alábbi használat azt mutatja, hogy a paraméter s-hoz történő hozzárendelés nem látható a metódushívás után, mert sref újra hozzárendelve lett, hogy sLocal-ra hivatkozzon, mielőtt a sztringet módosították.

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

Összetett hozzárendelés

Bináris operátor opesetén az űrlap összetett hozzárendelési kifejezése

x op= y

Egyenértékű azzal, hogy

x = x op y

Kivéve, hogy a x csak egyszer lesz kiértékelve.

Az aritmetikai, Boolean logikai és bitenkénti logikai és shift operátorok mind támogatják az összetett hozzárendelést.

Null-egyesítő hozzárendelés

A null egyesítési hozzárendelési operátorral ??= csak akkor rendelheti hozzá a jobb oldali operandus értékét a bal oldali operandushoz, ha a bal oldali operandus null-nek értékelődik ki. További információkért tekintse meg az ?? operátorokról szóló ??= cikket.

Operátorok túlterhelése

A felhasználó által definiált típus nem terhelheti túl a hozzárendelési operátort. A felhasználó által definiált típus azonban definiálhat implicit átalakítást egy másik típusra. Így a felhasználó által definiált típus értéke hozzárendelhető egy másik típusú változóhoz, tulajdonsághoz vagy indexelő elemhez. További információ: Felhasználó által definiált konverziós operátorok.

Ha egy felhasználó által definiált típus túlterhel egy bináris operátort op, akkor az op= operátor is implicit módon túlterhelődik. A C# 14-től kezdve a felhasználó által definiált típus explicit módon túlterhelheti az összetett hozzárendelési operátorokat (op=) a hatékonyabb végrehajtás érdekében. Egy típus általában túlterheli ezeket az operátorokat, mert az érték frissíthető a helyén, ahelyett, hogy egy új példányt helyeznek ki a bináris művelet eredményének tárolására. Ha egy típus nem biztosít explicit túlterhelést, a fordító implicit túlterhelést hoz létre.

C# nyelvspecifikáció

További információ: A C# nyelv specifikációjánakHozzárendelési operátorok szakasza és a felhasználó által definiált összetett hozzárendelési funkció specifikációja.

Lásd még

  • Last updated on