A grafikus programok eseményvezéreltek (0.2 lecke): nem egy előre megírt sorrendben futnak végig, hanem várnak, és reagálnak arra, ami történik: egy kattintásra, egy billentyűre, egy beírt szövegre, egy lejáró időzítőre. Az esemény (event) egy jelzés: „ez történt”. Az eseménykezelő (event handler) pedig az a metódus, amely a jelzésre reagál.

Hasonlat: a csengő (a Button) nem tudja, ki van otthon és mit csináljon. Annyit tud, hogy megszólal, és akik előfizettek rá (a lakók), azok reagálnak: az egyik ajtót nyit, a másik nem figyel. A csengő a kibocsátó (publisher), a lakók a feliratkozók (subscribers). A kibocsátó nem ismeri a feliratkozókat, ezért egy csengőhöz bármennyi (akár nulla) lakó tartozhat.

Jósolj!

Egy gombnak nincs eseménykezelője (senki nem iratkozott fel a Click eseményére). Mi történik, ha rákattintasz? Hibát kapsz?

Az eseménykezelő metódusnak pontosan meghatározott szerkezete van. Ha duplán kattintasz egy gombra a tervezőben, a Visual Studio ezt generálja:

private void btnKoszon_Click(object sender, EventArgs e)
{
    MessageBox.Show("Szia!");
}

Hol köti össze a Visual Studio az eseményt és a metódust?

A kapcsolatot nem a metódus neve hozza létre, hanem egy sor a Form1.Designer.cs fájlban, az InitializeComponent metódusban (0.5 lecke). Ezt a Designer kezeli, ezért ne szerkeszd kézzel, de érdemes megnézni:

// btnKoszon
this.btnKoszon.Name = "btnKoszon";
this.btnKoszon.Text = "Köszön";
this.btnKoszon.Click += new System.EventHandler(this.btnKoszon_Click);

Az utolsó sor a lényeg: a btnKoszon Click eseményére feliratkozik a btnKoszon_Click metódus. A += a feliratkozás jele, az EventHandler pedig a delegált típusa, amelyet a következő szakaszban nézünk meg.

Jósolj!

Átírod a btnKoszon_Click metódus nevét btnKoszon_Kattint-ra a Form1.cs fájlban (a Designer.cs-t nem módosítod). Lefordul-e a program? Hogy hívják ezt a hibát?

A delegált (delegate) egy típus, amelynek értéke egy metódus. Úgy működik, mint egy mutató vagy névjegykártya: nem a metódus kódját tartalmazza, hanem hivatkozik rá, és a delegáltat hívva a hivatkozott metódus fut le. A delegált típus megadja, milyen szerkezetű metódusra hivatkozhat (paraméterek és visszatérési típus):

// delegált típus: két egész számot kap, egész számot ad vissza
delegate int Muvelet(int a, int b);

private int Osszead(int a, int b) { return a + b; }
private int Szoroz(int a, int b) { return a * b; }

private void btnProba_Click(object sender, EventArgs e)
{
    Muvelet m = Osszead;           // a delegált az Osszead metódusra hivatkozik
    MessageBox.Show(m(3, 4).ToString());   // 7

    m = Szoroz;                  // most a Szoroz metódusra
    MessageBox.Show(m(3, 4).ToString());   // 12
}

Az EventHandler egy delegált

A Windows Forms események típusa is delegált. Az EventHandler definíciója a .NET-ben:

public delegate void EventHandler(object sender, EventArgs e);

Ebből következik az eseménykezelő szerkezete: olyan metódus, amely object és EventArgs paramétert kap, és nem ad vissza értéket (void). A Click esemény tehát EventHandler típusú delegáltak gyűjteménye: az eseményre feliratkozó metódusokat tárolja, és az esemény bekövetkeztekor mindet meghívja.

Beépített delegált típusok: Action és Func

Nem kell mindig saját delegált típust írnod. Az Action olyan metódusra hivatkozik, amely nem ad vissza értéket (Action<int>: egy int paraméter), a Func<int, int, int> két int paramétert kap, és int értéket ad vissza (az utolsó típus a visszatérési érték). A fenti Muvelet helyett Func<int, int, int> is használható.

Jósolj!

A Muvelet m = Osszead; sort átírod Muvelet m = Osszead(3, 4); alakra. Lefordul-e? Miért nem ugyanaz a két sor?

A tervezőn kívül kódból is feliratkozhatsz egy eseményre, a += operátorral, és leiratkozhatsz a -= operátorral. Erre akkor van szükség, ha a vezérlőt kódból hozod létre, vagy az eseménykezelő csak bizonyos ideig kell:

private void Form1_Load(object sender, EventArgs e)
{
    btnProba.Click += Proba_Click;       // feliratkozás
}

private void Proba_Click(object sender, EventArgs e)
{
    MessageBox.Show("Proba");
}

private void btnLeiratkozik_Click(object sender, EventArgs e)
{
    btnProba.Click -= Proba_Click;       // leiratkozás: a Proba_Click többé nem fut le
}

Több feliratkozó: a „multicast”

Egy eseményre több metódus is feliratkozhat. Ezek a feliratkozás sorrendjében futnak le:

btnProba.Click += Elso;
btnProba.Click += Masodik;
btnProba.Click += Elso;   // ugyanaz a metódus kétszer is feliratkozhat!

// egy kattintás: Elso, Masodik, Elso

Lambda kifejezés: névtelen eseménykezelő

Rövid, egyszeri eseménykezelőhöz nem kell külön metódust írni: a lambda kifejezés (=> jellel) névtelen metódust ad:

// (paraméterek) => { utasítások }
btnProba.Click += (s, ev) =>
{
    MessageBox.Show("Lambda kezelő");
};

// ha egyetlen utasítás, rövidebben:
btnProba.MouseEnter += (s, ev) => btnProba.BackColor = Color.LightYellow;
btnProba.MouseLeave += (s, ev) => btnProba.BackColor = SystemColors.Control;

Jósolj!

Egy gomb Click eseményére kétszer is feliratkozol ugyanazzal a metódussal: egyszer a tervezőben (Events nézet), egyszer a Form1_Load-ban (+=). Hányszor fut le a metódus egy kattintásra?

Az események nemcsak a vezérlőknek vannak: a saját osztályaidnak is lehet eseménye. Ez azt jelenti, hogy az osztály „jelez” valamit, és nem kell ismernie, ki figyel rá. Készítsünk egy számlálót, amely jelez, ha eléri a határértéket. Először az osztály:

public class Szamlalo
{
    private int ertek = 0;

    public int Hatar { get; set; } = 5;

    public int Ertek
    {
        get { return ertek; }
    }

    // az esemény deklarációja
    public event EventHandler ElerteAHatart;

    public void Novel()
    {
        ertek = ertek + 1;

        if (ertek >= Hatar)
        {
            // az esemény kiváltása: ha van feliratkozó, meghívja
            ElerteAHatart?.Invoke(this, EventArgs.Empty);
        }
    }

    public void Nulloz()
    {
        ertek = 0;
    }
}

És a használata az ablakban:

private Szamlalo szamlalo = new Szamlalo();

private void Form1_Load(object sender, EventArgs e)
{
    szamlalo.ElerteAHatart += Szamlalo_ElerteAHatart;   // feliratkozás a saját eseményre
}

private void Szamlalo_ElerteAHatart(object sender, EventArgs e)
{
    lblUzenet.Text = "Elérted a határt!";
}

private void btnNovel_Click(object sender, EventArgs e)
{
    szamlalo.Novel();
    lblErtek.Text = szamlalo.Ertek.ToString();
}

Jósolj!

Az Hatar értéke 5. Hányadik Novel() hívásnál jelenik meg az üzenet, és megjelenik-e újra a 6. hívásnál? Mit tennél, hogy az üzenet csak egyszer jelenjen meg?

Mi a baj, és hogyan javítod?

Gondold végig az okot, és csak utána nyisd le a megoldást.

1. A metódus nem fordul le átnevezés után

// CS1061: A „Form1” nem tartalmaz „btnMent_Click” nevű definíciót

2. A metódus kétszer fut le

Egy kattintásra az üzenet kétszer jelenik meg.

3. Nem tudsz leiratkozni a lambdáról

btnProba.Click += (s, e) => MessageBox.Show("Hello");
btnProba.Click -= (s, e) => MessageBox.Show("Hello");   // nem működik!

4. NullReferenceException az esemény kiváltásakor

ElerteAHatart(this, EventArgs.Empty);   // hiba, ha nincs feliratkozó

5. Rossz szerkezetű metódus

private void Kezelo()   // hiányoznak a paraméterek
{
}

btnProba.Click += Kezelo;
// CS0123: A „Kezelo” egyetlen túlterhelése sem felel meg a delegált „EventHandler” típusnak

6. Az esemény nem fut le

A metódus megvan, de a gombnyomásra semmi sem történik.

Három önálló gyakorlófeladat

Egyszerre csak egyet csinálj: tervezd meg, írd meg, futtasd, ellenőrizd, és csak utána nyisd ki a megoldást.

private void A(object s, EventArgs e) { lstSor.Items.Add("A"); }
private void B(object s, EventArgs e) { lstSor.Items.Add("B"); }
private void C(object s, EventArgs e) { lstSor.Items.Add("C"); }

private void Form1_Load(object sender, EventArgs e)
{
    btnProba.Click += A;
    btnProba.Click += B;
    btnProba.Click += C;
}

private void Form1_Load(object sender, EventArgs e)
{
    btnBeallit.Click += ElsoKattintas;
}

private void ElsoKattintas(object sender, EventArgs e)
{
    MessageBox.Show("Az első kattintás!");
    btnBeallit.Click -= ElsoKattintas;
}

// Szamlalo.cs
public class SzamlaloEventArgs : EventArgs
{
    public int Ertek { get; set; }
}

public event EventHandler<SzamlaloEventArgs> ElerteAHatart;

// a kiváltás:
ElerteAHatart?.Invoke(this, new SzamlaloEventArgs { Ertek = ertek });

// Form1.cs
private void Szamlalo_ElerteAHatart(object sender, SzamlaloEventArgs e)
{
    lblUzenet.Text = "Elérted a határt: " + e.Ertek;
}

Három szinten gyakorolhatsz: alap, közepes és kihívás. Csak a próbálkozás után nyisd le a megoldást.

Alap szint

private void lblFelirat_MouseEnter(object sender, EventArgs e)
{
    lblFelirat.ForeColor = Color.Red;
}

// kódból: lblFelirat.MouseEnter += lblFelirat_MouseEnter;

Közepes szint

private void Form1_Load(object sender, EventArgs e)
{
    Button gomb = new Button();
    gomb.Text = "Kattints rám";
    gomb.Location = new Point(20, 20);
    gomb.Size = new Size(150, 40);

    gomb.Click += (s, ev) => MessageBox.Show("Megnyomtál!");

    this.Controls.Add(gomb);
}

for (int i = 1; i <= 5; i++)
{
    int szam = i;   // helyi másolat minden körben

    Button gomb = new Button();
    gomb.Text = szam.ToString();
    gomb.Location = new Point(20 + (szam - 1) * 60, 20);
    gomb.Size = new Size(50, 40);

    gomb.Click += (s, ev) => MessageBox.Show("A " + szam + ". gomb");

    this.Controls.Add(gomb);
}

Kihívás szint

public class ArEventArgs : EventArgs
{
    public decimal Regi { get; set; }
    public decimal Uj { get; set; }
}

public class Termek
{
    private decimal ar;

    public string Nev { get; set; } = "";

    public decimal Ar
    {
        get { return ar; }
        set
        {
            if (value == ar)
            {
                return;
            }

            decimal regi = ar;
            ar = value;
            ArValtozott?.Invoke(this, new ArEventArgs { Regi = regi, Uj = ar });
        }
    }

    public event EventHandler<ArEventArgs> ArValtozott;
}

// Form1.cs
private Termek termek = new Termek { Nev = "Kenyér" };

private void Form1_Load(object sender, EventArgs e)
{
    termek.ArValtozott += (s, ev) => lblValtozas.Text = $"{termek.Nev}: {ev.Regi} Ft → {ev.Uj} Ft";
}

private void btnBeallit_Click(object sender, EventArgs e)
{
    termek.Ar = nudAr.Value;
}

Gyors önellenőrzés

Válaszolj fejben, és csak utána nyisd le a választ.