Eseményvezérelt programozás

A Wikipédiából, a szabad enciklopédiából
Ugrás a navigációhoz Ugrás a kereséshez

A számítógépes programozásban az eseményvezérelt programozás egy programozási paradigma, amiben a program futását az események határozzák meg, mint például a felhasználói műveletek (egérkattintás, billentyűleütés), az érzékelők kimenetei vagy más programok vagy szálak által küldött üzenetek. Az eseményvezérelt programozás a grafikus felhasználói felületek és más olyan alkalmazások (pl. JavaScript webes alkalmazások) domináns paradigmája, amelyek középpontjában a felhasználói bemenetre reagálva bizonyos műveletek végrehajtása áll. Szintén ez igaz az eszközillesztő programok programozására is. (Például a P az USB eszközillesztő csomagokban.[1])

Az eseményvezérelt programozásban általában van egy fő ciklus, ami figyeli az eseményeket, majd kivált egy visszahívási függvényt, amikor az események valamelyikét észleli. Beágyazott rendszerekben ugyanezt hardveres megszakításokkal lehet elérni a folyamatosan futó fő ciklus helyett. Az eseményvezérelt programokat bármilyen nyelven meg lehet írni, bár a feladat könnyebb olyan nyelveken, amelyek magas szintű absztrakciókat biztosítanak, mint például az await és a closure.

Eseménykezelők[szerkesztés]

Egy triviális eseménykezelő[szerkesztés]

Mivel az események ellenőrzésére szolgáló kód és a fő ciklus az alkalmazások között közös, ennek ellenére sok programozási keretrendszer gondoskodik ezek megvalósításáról és elvárja, hogy a felhasználó csak az eseménykezelők kódját adja meg. Ebben az egyszerű példában lehet egy OneKeyEnter() nevű eseménykezelő hívása, ami egy karakterláncot tartalmazó argumentumot tartalmaz, ami megfelel annak, amit a felhasználó az ENTER billentyű lenyomása előtt beírt. Két szám hozzáadásához az eseménykezelőn kívüli tárolást kell használni. Ez az implementáció az alábbiak szerint nézhet ki.

Globálisan deklaráljuk a K számlálót és a T egész számot

OneKeyEnter (karakter C) { 

C átalakítása N számmá

ha K nulla, tároljuk N-t T-ben és növeljük a K-t

ellenkező esetben adjuk hozzá N-t T-hez

írassuk ki az eredményt, majd a K-t állítsuk vissza nullára

}

Az előzmények nyomon követése triviális egy szekvenciális programban, mivel az eseménykezelők külső eseményekre válaszolva hajtódnak végre, az eseménykezelők megfelelő strukturálása, hogy bármilyen sorrendben történő hívás esetén helyesen működjenek, különleges figyelmet és tervezést igényel egy eseményvezérelt programozásban.

Eseménykezelők létrehozása[szerkesztés]

Az eseményvezérelt program fejlesztésének első lépése az eseménykezelő rutinoknak nevezett alprogramok vagy metódusok írása. Ezek a rutinok kezelik azokat az eseményeket, amelyekre a főprogram reagálni fog. Például egy GUI-programban a bal egérgombbal egy parancsgombra történő egyetlen kattintás kiválthat egy olyan rutint, amely megnyit egy másik ablakot, adatokat ment egy adatbázisba vagy kilép az alkalmazásból. Számos modern programozási környezet eseménysablonokat biztosít a programozó számára, így a programozó az eseménykód megírására fókuszálhat.

A második lépés az eseménykezelők eseményhez kötése, hogy az esemény bekövetkezésekor a megfelelő funkciót hívja meg a rendszer. A grafikus szerkesztők kombinálják az első két lépést: kattints duplán egy gombra, és a szerkesztő létrehoz egy (üres) eseménykezelőt, amely a felhasználó gombra kattintásához kapcsolódik, majd megnyit egy szövegablakot, hogy szerkeszthesse az eseménykezelőt.

Az eseményvezérelt program fejlesztésének harmadik lépése a fő ciklus megírása. Ez egy olyan függvény, ami ellenőrzi az események bekövetkezését, majd meghívja a megfelelő eseménykezelőt, hogy feldolgozza azt. A legtöbb eseményvezérelt programozási környezet már biztosítja ezt a fő ciklust, így az alkalmazás programozójának nem kell külön gondoskodnia róla. Az RPG az IBM korai programozási nyelve, amelynek az 1960-as évek tervezési koncepciója hasonló volt a fent tárgyalt eseményvezérelt programozáshoz, egy beépített fő I/O-ciklus (úgynevezett "programciklus") biztosított, ahol a számítások a ciklusban korábban beállított "indikátoroknak" (zászlóknak) megfelelően reagáltak

Kivételkezelők a PL/I-ben[szerkesztés]

A PL/I-ben, még ha a program nem is túlnyomórészt eseményvezérelt, előfordulhatnak bizonyos rendellenes események, mint például hardverhiba, túlcsordulás vagy "programellenőrzés", amelyek esetleg megakadályozzák a további feldolgozást. A kivételkezelőket "ON utasítások" biztosítják a (nem látható) hívókban, hogy tisztító rutinokat biztosítsanak az utólagos tisztításhoz a befejezés előtt, vagy hogy helyreállítási műveleteket végezzenek és visszatérjenek a megszakított eljáráshoz.

Általános felhasználások[szerkesztés]

A legtöbb létező GUI-fejlesztő eszköz és architektúra az eseményvezérelt programozásra támaszkodik.[2] A Java AWT keretrendszer minden UI-változást egyetlen szálon, az úgynevezett eseménykiosztó szálon dolgoz fel. Hasonlóképpen, a Java keretrendszer JavaFX-ben minden UI-frissítés a JavaFX Application Thread-en történik.[3]

Emellett az olyan rendszerek, mint a Node.js is eseményvezéreltek.[4]

Kritika[szerkesztés]

Az esemény-akció modellre támaszkodó programok tervezését kritikával illetik, és azt állítják, hogy az esemény-akció modell hibaérzékeny, nehezen bővíthető és túlságosan összetett alkalmazási kód létrehozására készteti a programozókat. A táblázatvezérelt állapotgépeket életképes alternatívaként támogatják.[5] Másrészt a táblázatvezérelt állapotgépek maguk is jelentős gyengeségekkel küzdenek, beleértve az állapotrobbanás jelenségét.[6] Erre megoldást jelent a Petri-hálók használata.

Verem nélküli környezet[szerkesztés]

A hardveres leíró nyelvekben eseményvezérelt megközelítést alkalmaznak. Egy környezetnek csak akkor van szüksége a CPU veremre, amikor aktívan feldolgoz egy eseményt, majd, ha ezzel végzett, a CPU továbbléphet más eseményvezérelt szálak feldolgozására. Ez rendkívül nagy számú szál kezelését teszi lehetővé. Ez lényegében egy véges állapotú gépi megközelítés.

Jegyzetek[szerkesztés]

  1. Vivek Gupta, Ethan Jackson, Shaz Qadeer and Sriram Rajamani (2012. november 1.). „P: Safe Asynchronous Event-Driven Programming”. Microsoft Research. (Hozzáférés ideje: 2017. február 20.)  
  2. Samek. „Who Moved My State?”, Dr. Dobb's, 2013. április 1. (Hozzáférés ideje: 2018. január 28.) 
  3. Fedortsova: Concurrency in JavaFX. JavaFX Documentation Home. Oracle, 2012. június 1. (Hozzáférés: 2018. január 4.) „The JavaFX scene graph, which represents the graphical user interface of a JavaFX application, is not thread-safe and can only be accessed and modified from the UI thread also known as the JavaFX Application thread.”
  4. Event-Driven Programming in Node.js.
  5. Samek: State Machines for Event-Driven Systems, 2009. március 11. (Hozzáférés: 2013. március 19.)
  6. Patrick Schaumont. A Practical Introduction to Hardware/Software Codesign (2012. november 27.). ISBN 978-1-4614-3737-6 

Fordítás[szerkesztés]

Ez a szócikk részben vagy egészben az Event-driven programming című angol Wikipédia-szócikk ezen változatának fordításán alapul. Az eredeti cikk szerkesztőit annak laptörténete sorolja fel. Ez a jelzés csupán a megfogalmazás eredetét jelzi, nem szolgál a cikkben szereplő információk forrásmegjelöléseként.

Kapcsolódó szócikkek[szerkesztés]

További információk[szerkesztés]