Readonly kulcsszó

A C# korábbi változatai esetén a readonly kulcsszó csak tagváltozók esetén volt használható. Az így megjelölt tagváltozók csak a konstruktorban kaphatnak értéket és utána nem módosítható az értékük.

C# 8.0 óta azonban metódus elÅ‘tt is alkalmazható a readonly kulcsszó, de csak struktúrák esetén. A readonly módosítóval megjelölt metódus nem módosíthatja az struktúra tagváltozóinak értékét. Ha erre mégis sor kerülne, akkor fordítási hibába ütközünk.

Felmerülhet a kérdés, hogy ez miért jó vagy miért hasznos? Az objektum orientált paradigma nem választja szét az adatokat és a hozzájuk kapcsolódó metódusokat, ezért ha egy külső gyártó struktúráját alkalmazzuk, akkor nem feltétlen tudjuk megmondani, hogy a metódus hívása az struktúra belső állapotát módosítja-e vagy sem. Ez a bizonytalanság problémákat tud okozni, ami a kód olvashatóságát és karbantarthatóságát nehezíti.

Ezen problémák elhárításában nagymértékben segít, ha tudjuk, vagy jelölve van valamilyen módon, hogy az adott metódus nem módosít állapotot. Nézzünk egy példát:

public struct Point 
{
    public double X { get; set; }
    public double Y { get; set; }
    public double Tavolsag => Math.Sqrt(X * X + Y * Y);

    public readonly override string ToString()
    {
        //fordítási hiba
        //Y = 22;
        return $"({X}, {Y}) Távolsága az Origótól: {Tavolsag}";
    }
}

A fenti struktúra definícióban a ToString() metódust megjelöltük a readonly kulcsszóval, mivel a ToString() hívás esetén a józan észnek ellent mondana, ha az állapottal babrálnánk.

A readonly elÅ‘nye, hogy a struktúra létrehozója a tervezési szándékot is közli. Ezért egy késÅ‘bbi módosító esetleg elgondolkozik, hogy talán okkal lett a metódus readonly és nem kellene benne egy állapot módosítást eszközölni.

Ref readonly

A C# 12 egyik újdonsága a ref és a readonly kulcsszó kombinálhatósága. Ez egy csak olvasható, referencia alapú értékátadást teszt lehetÅ‘vé. Ennek kapcsán felmerülhet a kérdés, hogy ennek mi értelme van?

Ez a funkció akkor nyer értelmet, ha van egy metódusunk, amit sokszor kell meghívnunk és ez a metódus érték típusokat vár paraméterként. Ebben az esetben a metódus minden egyes hívásakor egy másolat keletkezik az argumentumokról. Ennek a másolásnak az időköltsége nem elhanyagolható már mondjuk milliós hívási szám esetén. Ha referencia szerint adjuk át a változókat, akkor a másolás költsége megspórolható, de cserébe veszélyes szituációt idézünk elő, mert a metóduson belül módosíthatjuk a hívó értéket.

Ezen változtat a ref readonly kombinációja: referencia alapú átadást tudunk vele csinálni, de a metóduson belül nem módosíthatók a kapott paraméterek:

static class Pelda
{
    public static int Sum(ref readonly int a, ref readonly int b)
    {
        //fordítási hiba lenne:
        //a = 22;
        return a + b;
    }
}