Változók

A változó olyan, mint egy tároló rekesz, a programozók számára nélkülözhetetlen. C#-ban változókat így deklarálunk:

<adattípus> <név>;

Például:

string name;

Ez a legegyszerűbb verzió, de a változónak még nincs értéke. Értéket adhatunk neki később vagy akár a deklarációval egyszerre, így:

<data type> <name> = <value>;

Ha a változó nem lokális abban a metódusban, amelyben dolgozunk (pl.: osztály tagváltozó, azaz mező), akkor láthatóságot is adhatunk a változónak:

<láthatóság> <adattípus> <változónév> = <érték>;

Például:

private string name = "John Doe";

A láthatóság fogalma az osztályokhoz kapcsolódik, az osztályokról szóló fejezetben kerül részletesen tárgyalásra. Koncentráljunk most a változókra egy példával, amelyben fel is használjuk őket:

using System;

namespace ConsoleApplication1
{
    class Program
    {
    static void Main(string[] args)
    {
        string firstName = "John";
        string lastName = "Doe";

        Console.WriteLine("Name: " + firstName + " " + lastName);

        Console.WriteLine("Please enter a new first name:");
        firstName = Console.ReadLine();

        Console.WriteLine("New name: " + firstName + " " + lastName);

        Console.ReadLine();
    }
    }
}

Ebből már sok dolgot megmagyaráztunk korábban, ugorjunk rögtön az érdekes részhez. Először is, létrehozunk néhány string típusú változót. A string egyszerű szöveg, látható is, hiszen rögtön értéket is adunk a változóknak. Ezután kiírunk a konzolra egy sor szöveget, amelyben használjuk a két lokális változót. A stringet a + karakterek segítségével állítjuk össze a darabjaiból.

Ezután bekérünk a felhasználótól egy új keresztnevet, majd a ReadLine() metódus segítségével beolvassuk a felhasználói inputot a konzolról és beírjuk a firstName változóba. Miután a felhasználó lenyomja az enter gombot, az új keresztnév értékül lesz adva a lokális változónak, majd a következő sorban kiírjuk a nevet újra, hogy lehessen látni a változást. Ebben a programban használtuk a váltózót és annak legfontosabb tulajdonságát: értékét futás közben meg lehet változtatni.

Egy másik érdekes példa a matematikai számítások. Az előző kódokra építve itt egy kis számítás:

int number1, number2;

Console.WriteLine("Please enter a number:");
number1 = int.Parse(Console.ReadLine());

Console.WriteLine("Thank you. One more:");
number2 = int.Parse(Console.ReadLine());

Console.WriteLine("Adding the two numbers: " + (number1 + number2));

Console.ReadLine();

Tegyük bele a Main metódusunkba és próbáljuk ki. Az egyetlen új trükk az int.Parse metódus használata. Ez egyszerűen csak beolvas egy stringet és integer (egész szám - a ford.) típusú konvertálja konvertálja. Ahogy látszik, a program nem próbálja meg validálni a felhasználói inputot, így ha nem számot írunk be, kivétel keletkezik. Erről bővebben majd később.

Változok hatóköre

Eddig csak lokális változókat használtunk: olyanokat, amelyek ugyanabban a metódusban vannak definiálva, ahol használjuk őket. C#-ban egy adott metódusban definiált változót nem használhatunk egy másik metódusban, ezért is hívják lokális változónak. Ha ismersz más programozási nyelveket, akkor ismerheted a globális változó fogalmát, amelyeket több helyről is el lehet érni. A C# programozási nyelv azonban nem támogatja a globális változókat. Ehelyett egy mezőt lehet definiálni egy osztályban, amelyet az osztály minden metódusa tud használni. Íme egy példa:

using System;

namespace VariableScope
{
    class Program
    {
    private static string helloClass = "Hello, class!";

    static void Main(string[] args)
    {
        string helloLocal = "Hello, local!";
        Console.WriteLine(helloLocal);
        Console.WriteLine(Program.helloClass);
        DoStuff();
    }

    static void DoStuff()
    {
        Console.WriteLine("A message from DoStuff: " + Program.helloClass);
    }
    }
}

Vegyük észre, hogy a helloClass tag az osztály szintjén van definiálva, nem a metódusban. Ez lehetővé teszi, hogy mind a Main(), mind a DoStuffmetódusból hozzáférjünk. Ez nem igaz a helloLocal változóra, amelyet a Main() metódusban deklaráltunk, így csak ott használható.

A koncepciót, amely megkülönbözteti azt, hogy az egyes változók hol vannak deklarálva hatókörnek (scope) hívjuk. Ez segít abban, hogy a program ne legyen túlságosan átláthatatlan az olyan változók miatt, amelyeket túl sok helyről lehet megváltoztatni. Egy másik technika erre a láthatóság (jelen esetben a private kulcsszóval megvalósítva), amelyet majd az osztályokról szóló fejezetben tárgyalunk.

Összefoglalás

A változók lehetővé teszik, hogy különböző típusú adatokat, például szöveget, számokat vagy akár saját objektumokat tároljunk. Vannak lokális változók, amelyek csak abban a metódusban érhetőek el, amelyben deklarálva vannak és mezők, amelyek az osztály minden metódusából, sőt, akár az osztályon kívülről is elérhetőek, ha a láthatóság megengedi.