Események

C# esetén egy osztály definiálhat eseményeket (event), amelyek arra jók, hogy az osztály saját belsÅ‘ állapotának megváltozásakor értesíteni tudjon más osztályokat. Ehhez a "megfigyelÅ‘" osztályoknak fel kell iratkozni a megfigyelt osztály eseményeire. Ezt a viselkedést MegfigyelÅ‘ programtervezési mintának nevezzük.¹

Az események valójában speciális delegate típusok, vagyis feliratkozni úgy tudunk rá, mint egy delegate-re. Van azonban pár különbség egy sima delegate és event között. Ezek:

• Esemény definiálható interfészben, míg delegate nem.
• Eseményt csak a deklaráló osztály tudja kiváltani, külsÅ‘leg nem elÅ‘idézhetÅ‘.
• Az esemény tulajdonság szerű. Rendelkezik add és remove metódusokkal, amelyekkel lekezelhetÅ‘, hogy feliratkozáskor és leiratkozáskor valójában mi történjen.

Nézzünk egy egyszerű példát, ami bemutatja az események használatát:

using System;

namespace PeldaEvent
{
    //kezelő delegate
    public delegate void SzamValtozott(int ujSzam);

    public class EventSource
    {
        private int _szam;

        public event SzamValtozott SzamMegvaltozott;

        public EventSource()
        {
            _szam = 0;
        }

        public void DoValami()
        {
            _szam += DateTime.Now.Second;
            //Esemény trigger
            //Előtte null check kell, hogy feliratkozó van-e!
            SzamMegvaltozott?.Invoke(_szam);
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            var eventSource = new EventSource();
            //Feliratkozás
            eventSource.SzamMegvaltozott += EventSource_SzamMegvaltozott;

            //3 trigger
            eventSource.DoValami();
            eventSource.DoValami();
            eventSource.DoValami();

            Console.ReadKey();

            //Leiratkozás
            eventSource.SzamMegvaltozott -= EventSource_SzamMegvaltozott;

        }

        private static void EventSource_SzamMegvaltozott(int ujSzam)
        {
            Console.WriteLine(ujSzam);
        }
    }
}

A program egy lehetséges kimenete:

16
32
48

Mint látható, események esetén szükséges egy delegate, ami az eseménykezelÅ‘ metódus definícióját írja le. Itt megjegyezném, hogy saját típusok alkalmazása helyett érdemes a keretrendszer EventHandler delegate típusát alkalmazni. Ennek elmulasztása komoly tervezési probléma, mivel a keretrendszerben minden esemény nagyjából ezt használja, így elvárható bármilyen komponenstÅ‘l, hogy a megszokott, jól bevált módszereket alkalmazza.

A beépített EventHandler delegate típus két paramétert definiál az eseményeknek: egy object típust, ami a feladóra mutató referencia és egy EventArgs típusú objektum, ami az eseménynek közvetít paramétereket. Ez egy alap osztály, ami alap esetben nem tartalmaz semmi hasznosat, viszont kiegészíthetÅ‘ és leszármaztatható további argumentumok tárolására.

Az alábbi példa az egyszerű EventHandler típusú esemény használatát mutatja be:

using System;

namespace PeldaEvent3
{
    public class EventSource
    {
        //Tulajdonság az állapot eléréséhez
        public int Szam { get; private set; }

        public event EventHandler SzamMegvaltozott;

        public EventSource()
        {
            Szam = 0;
        }

        public void DoValami()
        {
            Szam += DateTime.Now.Second;
            //Esemény trigger
            //Előtte null check kell, hogy feliratkozó van-e!
            //EventArgs.Empty-t adunk át, a null érték kerülendő!
            SzamMegvaltozott?.Invoke(this, EventArgs.Empty);
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            var eventSource = new EventSource();
            //Feliratkozás
            eventSource.SzamMegvaltozott += EventSource_SzamMegvaltozott;

            //3 trigger
            eventSource.DoValami();
            eventSource.DoValami();
            eventSource.DoValami();

            Console.ReadKey();

            //Leiratkozás
            eventSource.SzamMegvaltozott -= EventSource_SzamMegvaltozott;
        }

        private static void EventSource_SzamMegvaltozott(object sender, EventArgs e)
        {
            var felado = sender as EventSource;
            if (felado!=null)
            {
                //A feladótól kérdezzük le az értéket.
                //Itt az eventHandler csak értesít bennünket.
                Console.WriteLine(felado.Szam);
            }
        }
    }
}

A program egy lehetséges kimenete:

37
74
111

A C# 2.0-ás változatában bemutatkoztak a generikusok, így van generikus Event handler minta is. A .NET ajánlás azonban kompatibilitási okok miatt még mindig az lenne, hogy inkább az EventArgs osztályt származtassuk le és azzal közöljünk paramétereket publikusan közzétett események esetén, fÅ‘leg ha egy esemény esetén több paramétert át szeretnénk juttatni az eseménykezelÅ‘nek. Az alábbi példa a generikus megoldást mutatja be saját EventArgs segítségével.

using System;

namespace PeldaEvent2
{
    public class SzamEventArgs: EventArgs
    {
        public int Szam { get; }

        public SzamEventArgs(int szam)
        {
            Szam = szam;
        }
    }

    public class EventSource
    {
        private int _szam;

        public event EventHandler<SzamEventArgs> SzamMegvaltozott;

        public EventSource()
        {
            _szam = 0;
        }

        public void DoValami()
        {
            _szam += DateTime.Now.Second;
            //Esemény trigger
            //Előtte null check kell, hogy feliratkozó van-e!
            SzamMegvaltozott?.Invoke(this, new SzamEventArgs(_szam));
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            var eventSource = new EventSource();
            //Feliratkozás
            eventSource.SzamMegvaltozott += EventSource_SzamMegvaltozott;

            //3 trigger
            eventSource.DoValami();
            eventSource.DoValami();
            eventSource.DoValami();

            Console.ReadKey();

            //Leiratkozás
            eventSource.SzamMegvaltozott -= EventSource_SzamMegvaltozott;
        }

        private static void EventSource_SzamMegvaltozott(object sender, SzamEventArgs e)
        {
            Console.WriteLine(e.Szam);
        }
    }
}

A program egy lehetséges kimenete:

50
100
150

Mikor kell leiratkozni egy eseményről?

A delegate-ek használatánál elég jól ki lett hangsúlyozva, hogy ha nem jól csináljuk a dolgokat, akkor memória szivárgást kapunk. Ugyanez igaz eseményekre is. Azonban nem minden esetben kell leiratkoznunk, van, amikor ez nem okoz bajt.

Abban az esetben nincs baj, ha X osztály belső változóként hozza létre Y osztályt és feliratkozik Y osztály eseményeire, valamint Y osztály az X osztályon kívül nem látható.

Ebben az esetben X osztály megszűnésekor az egyetlen referencia Y osztályra az X, ami valójában Y létrehozója. A GC ezt érzékelni tudja és eltakarítja a referenciát, ami nem fog problémát okozni.

Egyedi feliratkozás és leiratkozás kezelés add és remove segítségével

Egyedi feliratkozás kezelés megvalósítására akkor van szükség, ha az osztályunknak szál biztosnak kell lennie, vagyis egy időben többen is feliratkozhatnak, illetve leiratkozhatnak az eseményről. Ennek megvalósításáról a több szálú programozás tárgyalásánál lesz szó.