A mellékelt program Form-ján elhelyezett TabControl kontrol füleire kattintva láthatunk egy-egy példát a kulcsszavak használattára. A params kulcsszó használatát modellezendő, egy összeadást hajtunk végre a ComboBox-ban elhelyezett operandusokon, az ’Összeadás’ feliratú gombra kattintás után.
A volatile kulcsszó használatát egy szálat indító műveletben próbálhatjuk ki, ahol a szál folyamatosan növeli egy privát tagváltozó értékét, miközben a főszálban elérjük a változót és értékével műveletet végzünk, szintén egy összeadást.
Params kulcsszó
A params kulcsszó használatával feloldható a függvényhívások azon korlátja, hogy csak ismert számú paraméter adható át a függvényeknek. Természetesen itt azonos típusú, csak ismeretlen számú bemenő paraméterről van szó.
A Params kulcsszó használatával argumentumként adjuk át a paramétereket egy tömbben, melynek deklarációja a következő:
params datatype[] argumentum név;
Megjegyzendő, hogy az argumentum egy egy-dimenziós tömb kell legyen, és az utolsó argumentumként kell szerepeljen a függvényhez rendelt argumentum listában. A params argumentumhoz aztán egy tömbként férhetünk hozzá.
A példában létrehoztunk egy Sum nevű összeadó tagfüggvényt, melynek paraméterként adjuk át az összeadandó számokat egy tömbben, melyeket a ComboBox kontrolból olvasunk ki.
int Sum(params int[] operands)
{
int result = 0;
foreach(int i in operands)
{
result = result + i;
}
return result;
}
Az ’Összeadás’ gombra kattintva a Sum metódust a következőképpen hívjuk:
resultText.Text = Sum(ops).ToString();
A Params kulcsszó használata miatt a hívás ekvivalens a következő sorral is, melyben három szám összeadása szerepel:
A fordító nem jelez hibát, holott normális esetben a szignatúra nem illeszkedik a deklarált függvény változathoz.
Volatile kulcsszó
A programban volatile kulcsszóval deklaráltunk egy változót, mellyel gondoskodtunk arról, hogy a processzor különösen kezelje változónkat IO műveletek elvégzésekor.
private volatile int thValue;
A volatile kulcsszó használatával kikényszeríthetjük a processzortól, hogy egy ezzel a kulcsszóval deklarált változó olvasása a változó memóriaterületéről történjen még akkor is, ha előzőleg értéke egy gyors processzor regiszterbe volt betöltve.
Írási művelet esetében ez egyszerűen azt jelenti, hogy a változó értékének módosításakor a módosított érték azonnal kiírásra kerül a memóriába még akkor is, ha később az írás megfelelőbb és gyorsabb lenne, illetve még mielőtt más olvasó művelet hozzáférne a memóriaterülethez. Ezzel biztosítva azt, hogy a memóriaterületet megcímezve mindig az aktuális érték kerüljön kiolvasásra.
A volatile prefix felfogható úgy, mintha a megjelölt változó a CPU egy regisztere lenne.
A volatile kulcsszó használatának tehát optimalizáló hatásai vannak, mintsem látható eredményei. Jól jöhetnek ezek akkor, ha valamilyen időigényes munka elvégzéséhez szálakat indítunk, és ezek a szálak változók értékeit módosítják, melyek aktuális értékeire a főszálban szükség van.
A mellékelt programban indítunk egy szálat, mely folyamatosan növeli a thValue változó értékét, miközben a változót a főszálban felhasználjuk egy összeadásban. A szál deklarációja és indítása:
th = new Thread(new ThreadStart(this.ThreadFunction));
th.Start();
startButton.Enabled = false;
A szálfüggvény a következő, melyben a meghívott WriteNumber metódus írja a számot egy TextBox-ba:
public void ThreadFunction()
{
try
{
MethodInvoker mi = new MethodInvoker(WriteNumber);
while (true)
{
BeginInvoke(mi);
Thread.Sleep(1000);
}
}
catch
{
}
}
A főszálban pedig használjuk a változót:
int result = Sum(thValue,100,100);
...