Mik azok a modulok és pontosan mire valók? A modul tartalmazza a programkódot. Sőt érdemes megjegyezni, hogy a 7.7-es platformmal ellentétben, ahol a kód mind az űrlapelemek tulajdonságaiban, mind az elrendezési táblák celláiban elhelyezhető, a 8.x platformon minden kódsort el kell helyezni. valamilyen modulban. Általában egy modul három részből áll - egy szakasz a változók leírására, egy szakasz az eljárások és funkciók leírására, valamint egy szakasz a fő program számára. Ez a struktúra néhány kivételtől eltekintve szinte minden platformmodulra jellemző. Egyes moduloknak nincs változó deklarációs szakasza és fő programrésze. Például a Session Module és bármely általános modul.

A modulok végrehajtási környezete általában kliens és szerver kontextusra oszlik. Emellett egyes modulok mind kliens, mind szerver oldalon lefordíthatók. Néhányuk pedig tisztán szerveroldali vagy ügyféloldali. Így:

Alkalmazási modul

A modult úgy tervezték, hogy megragadja az alkalmazás indításának (a konfiguráció betöltésének) és annak befejezésének pillanatait. És a megfelelő eseményekben megszervezheti az ellenőrzési eljárásokat. Például az alkalmazás indításakor frissítsen bármilyen konfigurációs referenciaadatot, a munka végén kérdezze meg, hogy érdemes-e egyáltalán elhagyni, esetleg még nem ért véget a munkanap. Ezenkívül lehallgatja az eseményeket külső berendezésekről, például kereskedelmi vagy pénzügyi eszközökről. Érdemes megjegyezni, hogy az alkalmazásmodul csak interaktív indítás esetén fogja el a leírt eseményeket. Azok. amikor maga a programablak létrejön. Ez nem történik meg, ha az alkalmazás módban indul el com kapcsolatokat.

A 8.2-es platformon két különböző alkalmazásmodul található. Ezek a Közös alkalmazás modul és a Felügyelt alkalmazás modul. Különböző kliensek indításakor aktiválódnak. A felügyelt alkalmazásmodul így aktiválódik, amikor a webes ügyfél, a vékony kliens és a vastag kliens felügyelt alkalmazás módban indul. A normál alkalmazásmodul pedig akkor indul el, amikor a vastag kliens normál alkalmazási módban elindul.

Az összes rész elhelyezhető az alkalmazás modulban - a változók, eljárások és funkciók leírása, valamint a fő program leírása. Az alkalmazás modult a kliens oldalon állítják össze, így ez erősen korlátoz minket sokféle adat elérhetőségében. Kibővítheti egy alkalmazásmodul környezetét a megosztott modulok metódusaival, amelyeknél be van állítva a Call Server tulajdonság. Minden exportálásként megjelölt változó és metódus elérhető lesz bármely ügyféloldali konfigurációs modulban. Bármilyen csábító is, nem szabad itt közzétenni nagyszámú mód. Minél több kódot tartalmaz, annál hosszabb a fordítási idő, és ennek következtében az alkalmazás indítási ideje is, ami nagyon bosszantó a felhasználók számára.

Ahogy fentebb említettük, az alkalmazásmodul kezeli az alkalmazás kezdő és záró eseményeit. Ezen események mindegyikének kezeléséhez az alkalmazásmodulban van néhány kezelő: Előtte ... és Mikor ... A különbség köztük az, hogy amikor a kezelőben található kód végrehajtásra kerül, a művelet még nem történt meg. megtörtént, és megtagadhatjuk annak végrehajtását. Erre való az Elutasítás opció. Az On-kezelőkben a művelet már megtörtént, és nem tagadhatjuk meg az alkalmazás elindítását vagy kilépését.

Külső csatlakozó modul

A modul célja hasonló az alkalmazási modul céljához. Kezeli az alkalmazás kezdő- és végpontját. A külső csatlakozási modul akkor aktiválódik, amikor az alkalmazást com-connection módban indítják. Maga a külső csatlakozási folyamat nem interaktív folyamat. Ebben az üzemmódban a program a információs bázisés az alkalmazás ablaka nem nyílik meg, ami bizonyos korlátozásokat támaszt az interaktív munkára szánt módszerek használatában. Ebben a módban nem használhat párbeszédablak-hívásokat, figyelmeztető üzeneteket stb. Egyszerűen nem fognak működni.

Az alkalmazásmodulhoz hasonlóan itt is elérhetők a változókat, metódusokat és a főprogramot leíró szakaszok. Deklarálhat exportváltozókat és metódusokat is. A különbség az, hogy com-connection módban az infobázissal minden munka a szerver oldalon történik, így a külső kapcsolati modul kizárólag a szerveren kerül fordításra. Ennek megfelelően a gyakori ügyfélmodulok exportváltozói és metódusai nem érhetők el benne.

munkamenet modul

Ez egy rendkívül speciális modul, és kizárólag a munkamenet-paraméterek inicializálására szolgál. Miért kellett ehhez saját modult készíteni? Ennek az az oka, hogy az inicializálási folyamat megkövetelheti bizonyos kódok végrehajtását, emellett az alkalmazás különböző kliensek alatt is elindítható (ami különböző alkalmazásmodulok vagy külső csatlakozási modulok végrehajtását vonja maga után), és a munkamenet paramétereit kötelező bármely indítási módban inicializálható. Ezért szükség volt egy további modulra, amely bármely alkalmazásindítási módban végrehajtódik.

A szekciómodulban egyetlen "SetSessionParameters" esemény található, amely a legelsőként aktiválódik, még az alkalmazásmodul BeforeSystemStart eseménye előtt. Nincs benne változó deklarációs rész és fő programrész. És az exportálási módszereket sem lehet deklarálni. A modul a szerver oldalon van lefordítva.

Kerülje el azt a kísértést, hogy ez a modul az alkalmazás minden indításakor lefusson, és olyan kódot helyezzen el benne, amely nem kapcsolódik közvetlenül a munkamenet-paraméterek inicializálásához. Ez annak köszönhető, hogy a SetSessionParameters kezelő a rendszer működése közben többször is meghívható. Például ez történik, amikor nem inicializált paraméterekhez férünk hozzá. És bár el lehet fogni ennek az eseménynek az első indításának pillanatát (a RequiredParameters Undefined típusú), azonban meg kell jegyezni, hogy ez a modul privilegizált módban van fordítva, pl. nem szabályozza a hozzáférési jogokat. És a második pont, még mindig nem lehetünk száz százalékig biztosak abban, hogy a rendszer elindul. Hirtelen az alkalmazásmodul meghibásodik, és megpróbálunk valamilyen műveletet végrehajtani az adatbázissal.

Általános modulok

A modulok célja néhány általános algoritmus leírása, amelyeket más konfigurációs modulok hívnak meg. Az általános modul nem tartalmaz változó deklarációs részt és fő programrészt. Ebben deklarálhatunk export metódusokat, amelyek hozzáférhetőségi kontextusát a fordítási jelzők határozzák meg. Tekintettel arra, hogy a változó deklaráció szakasza nem érhető el, nem lehet globális változókat definiálni megosztott modulokban. Ehhez a visszatérési érték gyorsítótárazású közös modulok vagy egy alkalmazásmodul funkcióit kell használni. Nem szabad megfeledkezni arról, hogy még ha a közös modul újrahasználati tulajdonsága „A munkamenet időtartamára” értékre van állítva, ebben az esetben a gyorsítótárazott értékek élettartama nem haladja meg a 20 percet attól a pillanattól számítva. utoljára elérve.
A megosztott modul viselkedése a beállított paraméterektől függ (globális vagy nem, különféle fordítási jelzők, elérhető-e szerverhívás stb.). Ebben a cikkben nem veszünk figyelembe mindenféle beállítást, valamint a viselkedési jellemzőket és buktatókat, amelyek akkor merülnek fel, ha a tulajdonságjelzőket indokolatlanul állítják be. Ez egy külön cikk témája. Maradjunk csak néhány ponton, amelyeket be kell tartani a zászlók beállításakor:

• Jó hüvelykujjszabály, hogy ne használjuk mindenhol a „Globális” zászlót. Ez csökkenti az alkalmazás indítási idejét, valamint javítja a kód olvashatóságát (persze, ha a közös modulnak teljesen értelmes neve van).
• Nem tanácsos egynél több fordításjelzőt használni. Nincs olyan sok metódus, amit különböző kontextusokban kell végrehajtani, és ha mégis szükség van ilyen módszerekre, akkor külön közös modult lehet hozzájuk rendelni.
• A "Call Server" jelző csak akkor értelmes, ha a modul "A szerveren" van fordítva. Ezért az összes többi fordítási jelzőt el kell távolítani a különféle problémák elkerülése érdekében.
• Ha a modul módszereit tömeges adatfeldolgozásra, az adatbázisba való olvasásra és írásra használják, akkor a munka sebességének növelése érdekében célszerű letiltani a hozzáférés-szabályozást a "Privileged" jelző beállításával. Ez a mód csak a kiszolgálón lefordított megosztott modulokhoz érhető el.

Űrlap modul

A felhasználói műveletek feldolgozására szolgál, pl. az adatbevitellel és azok helyességének feldolgozásával kapcsolatos különféle események. A normál űrlap modul teljes egészében az ügyfélen van lefordítva. A modul kezelt formában a végrehajtási kontextus egyértelműen elhatárolja, ezért minden változónak és metódusnak rendelkeznie kell egy fordítási direktívával. Ha a direktíva nincs kifejezetten megadva, akkor ez a változó vagy metódus a szerver oldalon lesz lefordítva. Az űrlap modulban elérhetők a változók és metódusok leírására szolgáló szakaszok, valamint a főprogram részlege.

Objektum modul

Ez a modul sok konfigurációs objektumra jellemző, és általában az objektum események feldolgozására szolgál. Például az objektumok írásának és törlésének eseményei, dokumentumok feladása stb.

Egyes objektummodul-események megduplázzák az űrlapmodul eseményeket. Például a rekordhoz kapcsolódó események. Meg kell azonban érteni, hogy az űrlapmodul eseményei csak egy adott űrlapobjektumon kerülnek végrehajtásra. Általában több ilyen forma létezhet. Az objektummodul eseményei pedig mindenképpen, még abban a pillanatban is meg lesznek hívva programmunka egy tárggyal. Ezért, ha minden esetben szükséges valamilyen kódot végrehajtani, akkor jobb, ha ehhez egy objektummodul eseményt használunk.

Az objektummodult kizárólag a szerveren fordítják le. Ebben megadhatja azokat az exportálási változókat és metódusokat, amelyek más konfigurációs modulokban elérhetők lesznek. Ezen tulajdonságok és módszerek segítségével jelentősen bővíthetjük az objektum funkcionalitását.

Objektumkezelő modul

Ez a modul számos konfigurációs objektumhoz létezik. Ennek a modulnak az a fő célja, hogy újradefiniálja a szabványos kiválasztási eseményt, amely soronkénti bevitelkor történik, és kibővítse a menedzser funkcióit. A modul a szerver oldalon van lefordítva. Lehetőség van export tulajdonságok és módszerek definiálására. A menedzser export metódusainak meghívása nem igényli magát az objektumot.

A fentiekhez hozzáadhat néhány konfigurációs modult és a metódusok kölcsönös meghívásának módjait felügyelt alkalmazás módban. A nyíl azt az irányt jelzi, amelybe a megfelelő metódus hívásához léphet. Amint az a diagramból látható, a szerverkontextus teljesen zárt. De az ügyfélkörnyezetből elérhető a szerver metódusai.

Szimbólumok a sémán: O.M. Kliens - Kliens közös modul; O.M. Szerver - Szerver közös modul; M.F. Kliens - Az űrlap modul ügyfél eljárásai; M.F. Szerver – Az űrlapmodul szerver eljárásai.

A szoftvermodulok végrehajtható kódot tartalmaznak az 1C nyelven, amely szükséges ahhoz, hogy bizonyos módon reagáljanak a rendszer vagy a felhasználó műveleteire, amikor a vizuális fejlesztő eszközök nem elegendőek. A programmodulokban is leírhatjuk saját módszereinket (eljárásokat és függvényeket).

A szoftvermodul általában három részből áll:

• változó deklarációs terület;
• eljárás és funkció leírási terület;
• a program fő szövege.

Példa egy programmodul felépítésére:

//******************** VÁLTOZÓ NYILATKOZAT TERÜLET *****************************

Rem vezetéknév export; / /ez egy globális változó
Változónév, Patronim; //ez egy modulváltozó
Név módosítása; //ez is egy modulváltozó és elérhető

//modulunk bármely eljárásából és funkciójából

//*************** ELJÁRÁS ÉS FUNKCIÓ LEÍRÁSI TERÜLET ****************

Eljárás Eljárás1 ()
Változó Összesen ; / /Total egy helyi változó (eljárási változó)

Összesen = Vezetéknév + "" + Keresztnév + " "+ Apanév;

Vége eljárás

Funkció Funkció1 ()

// függvény utasítások

Return(Vezetéknév + " " + Keresztnév );

EndFunctions

//**************************** A PROGRAM FŐSZÖVEGE ******************** *

Vezetéknév = "Ivanov";
Név = "Iván";
Középső név = "Ivanovich";

//******************************************************************************

Egy adott programmodulban előfordulhat, hogy bármelyik terület hiányzik.
Változó deklarációs hatókör A modul szövegének elejétől a Procedure vagy a Function utasítás vagy bármely végrehajtható utasítás első utasításáig kerül. Ez a szakasz csak változó deklarációs utasításokat tartalmazhat.

Az eljárások és funkciók leírása a Procedure vagy a Function utasítás első utasításától kezdve az eljárás vagy függvény deklaráció törzsén kívüli bármely végrehajtható utasításba kerül.

A program fő szövegterülete Az eljárások vagy függvények törzsén kívüli első végrehajtható utasítástól a modul végéig kerül. Ez a szakasz csak végrehajtható utasításokat tartalmazhat. A program fő szövegének területe a modul inicializálásakor kerül végrehajtásra. Általában a fő programrészben célszerű utasításokat elhelyezni a változók inicializálására bizonyos értékekkel, amelyeket a modul eljárásainak vagy funkcióinak első hívása előtt hozzá kell rendelni.

A programmodulok a konfiguráció azon helyein helyezkednek el, ahol adott műveleti algoritmusok leírása szükséges. Ezeket az algoritmusokat olyan eljárásokként vagy függvényekként kell megtervezni, amelyeket a rendszer maga hív meg előre meghatározott helyzetekben (például hivatkozási űrlap megnyitásakor, párbeszédpanelen egy gombra kattintva, objektum megváltoztatásakor stb.).

Minden különálló programmodult a rendszer egészeként érzékel, így a programmodul összes eljárása és funkciója egyetlen kontextusban kerül végrehajtásra.

A modulok végrehajtási kontextusa kliens és szerver kontextusra oszlik. Emellett egyes szoftvermodulok mind kliens, mind szerver oldalon lefordíthatók.

Alkalmazási modul (felügyelt vagy normál)

Az alkalmazásmodul leírja a rendszer elején és végén inicializált események eljárásait (kezelőit). Például egy alkalmazás indításakor frissíthet néhány konfigurációs adatot, és kilépéskor megkérdezheti, hogy egyáltalán ki kell-e lépnie a programból. Ezenkívül ez a modul elfogja a külső berendezésekből, például kereskedelmi vagy pénzügyi eszközökből származó eseményeket. Érdemes megjegyezni, hogy az alkalmazásmodul csak az alkalmazás interaktív indításakor, azaz a programablak indításakor kerül végrehajtásra. Ez nem történik meg, ha az alkalmazás com-connection módban indul el.
Az 1C 8 platformon két különböző alkalmazásmodul található. Ezek a Közös alkalmazás modul és a Felügyelt alkalmazás modul. Különböző kliensek indításakor aktiválódnak. Például a felügyelt alkalmazás modul akkor aktiválódik, amikor a webes kliens, a vékony kliens és a vastag kliens felügyelt alkalmazás módban indul. A normál alkalmazásmodul pedig akkor indul el, amikor a vastag kliens normál alkalmazási módban elindul. Az alkalmazásindítási mód beállítása a „Fő indítási mód” konfigurációs tulajdonságban.

Az alkalmazás modul tartalmazhatja mind a 3 részt - változók deklarációit, eljárások és függvények leírását, valamint a program fő szövegét. Az alkalmazás modult a kliens oldalon fordítják le, ami erősen korlátoz minket sokféle adat felhasználásában. Kibővítheti egy alkalmazásmodul környezetét a megosztott modulok metódusaival, amelyeknél be van állítva a Call Server tulajdonság. Az exportálásként megjelölt alkalmazásprogram-modul összes változója és metódusa elérhető lesz bármely ügyféloldali konfigurációs modulban. Azonban bármilyen csábító is, ne helyezzen el nagy számú eljárást és funkciót ide. Minél több kód van egy adott modulban, annál hosszabb a fordítási idő, és ennek következtében az alkalmazás indítási ideje is.

Ahogy fentebb említettük, az alkalmazásmodul kezeli az alkalmazás kezdő és záró eseményeit. Ezen események mindegyikének kezeléséhez az alkalmazásmodulban van néhány kezelő: Before ... és When ... A különbségek közöttük a következők: amikor a kezelőben található, Előtte ... kódot végrehajtják, a művelet még nem történt meg, és megtagadhatjuk annak végrehajtását. Erre való az Elutasítás opció. Az On-kezelőkben a művelet már megtörtént, és nem tagadhatjuk meg az alkalmazás elindítását vagy kilépését.

Külső csatlakozó modul

• mind a 3 területet tartalmazhatja
• a konfiguráció gyökér részében található

A modul célja hasonló az alkalmazási modul céljához. Kezeli az alkalmazás kezdő és záró eseményeit. A külső csatlakozási modul akkor aktiválódik, amikor az alkalmazást com-connection módban indítják. Maga a külső csatlakozási folyamat nem interaktív folyamat. Ebben a módban programozott munka történik az információs bázissal, és az alkalmazás ablaka nem nyílik meg, ami bizonyos korlátozásokat ír elő az interaktív munkára szánt módszerek használatára vonatkozóan. Ebben a módban nem hívhat párbeszédablakokat, figyelmeztetéseket és üzeneteket a felhasználónak stb. Egyszerűen nem futnak.

Az alkalmazás modulhoz hasonlóan itt is elérhető mindhárom terület: változó deklarációk, eljárások és függvények leírásai, valamint a program fő szövege. A fő különbség az alkalmazás modulhoz képest, hogy com-connection módban az infobázissal minden munka a szerver oldalon történik, így a külső kapcsolati modul a szerver oldalon kerül összeállításra. Ennek megfelelően a gyakori ügyfélmodulok exportváltozói és metódusai nem érhetők el benne.

munkamenet modul

• szerver oldalon hajtják végre
• a konfiguráció gyökér részében található

Ez egy rendkívül speciális modul, amelyet kizárólag a munkamenet-paraméterek inicializálására terveztek. Miért kellett ehhez saját modult készíteni? Használata annak köszönhető, hogy maga az alkalmazás is elindítható különféle módok(amely egy felügyelt alkalmazásmodult, egy normál alkalmazásmodult vagy egy külső csatlakozási modult hajt végre), és a szekcióparamétereket inicializálni kell az indítási módtól függetlenül. Annak érdekében, hogy ne ugyanazt a programkódot írjuk mindhárom modulba, szükségünk volt egy további modulra, amely az alkalmazás indítási módjától függetlenül fut.

Egyetlen "SetSessionParameters" esemény van a szekciómodulban, amely a legelső, még az alkalmazásmodul PreSystemBegin eseménye előtt aktiválódik. Nincs benne változó deklarációs rész és fő programrész. És az exportálási módszereket sem lehet deklarálni. A modul a szerver oldalon van lefordítva.

Általános modulok

• tartalmazhat egy területet az eljárások és funkciók leírására
• szerver vagy kliens oldalon fut (a modul beállításaitól függően)
• a konfigurációs objektumok fájának ágában található "Általános" - "Általános modulok"

A közös modulok célja néhány általános algoritmus leírása, amelyeket más konfigurációs modulok hívnak meg. Az általános modul nem tartalmaz változó deklarációs területeket és a program törzsét. Ebben deklarálhatunk export metódusokat, amelyek elérhetőségét a modul beállításai határozzák meg (melyik oldalon fut: szerver vagy kliens oldalon). Tekintettel arra, hogy a változó deklaráció szakasza nem érhető el, nem lehet globális változókat definiálni megosztott modulokban. Ehhez használhatja az alkalmazás modult.

A megosztott modul viselkedése a beállított paraméterektől függ (globális vagy nem, különféle fordítási jelzők, elérhető-e szerverhívás stb.). Íme néhány tipp a megosztott modulok beállításához:

Jó gyakorlat, ha nem használjuk mindenhol a „Globális” zászlót. Ez csökkenti az alkalmazás indítási idejét, valamint javítja a kód olvashatóságát (persze, ha a közös modulnak teljesen értelmes neve van);
- Nem tanácsos egynél több összeállítási jelzőt használni. Nincs olyan sok metódus, amit különböző kontextusban kell végrehajtani, és ha mégis szükség van ilyen módszerekre, akkor külön közös modult lehet kijelölni hozzájuk;
- a "Szerverhívás" jelzőnek csak akkor van értelme, ha a modul "A szerveren" van lefordítva. Ezért az összes többi fordítási jelzőt el kell távolítani a különféle problémák elkerülése érdekében;
- ha a modul metódusaiban az adatok tömeges feldolgozása, az adatbázisba való olvasás és írás történik, akkor a munka sebességének növelése érdekében jobb, ha letiltja a hozzáférés-szabályozást a "Privileged" jelző beállításával. Ez a mód csak a kiszolgálón lefordított megosztott modulokhoz érhető el.

Űrlap modul

• mind a 3 területet tartalmazhatja
• szerver és kliens oldalon hajtják végre

Az űrlapmodult úgy tervezték, hogy kezelje a felhasználói műveleteket ezzel az űrlappal (gombkattintási esemény kezelése, űrlapattribútum módosítása stb.). Vannak olyan események is, amelyek közvetlenül az űrlaphoz kapcsolódnak (például annak megnyitása vagy bezárása). A felügyelt űrlapmodulok és a normál űrlapmodulok elsősorban abban különböznek egymástól, hogy a felügyelt űrlapmodul egyértelműen kontextusba van különítve. Minden eljárásnak vagy függvénynek rendelkeznie kell egy fordítási direktívával. Ha a fordítási direktíva nincs megadva, akkor ez az eljárás vagy függvény a szerver oldalon kerül végrehajtásra. A szokásos formában minden kód a kliens oldalon fut le.

A kezelt űrlapstruktúra tartalmaz egy változó deklarációs részt, az eljárások és funkciók leírását, valamint a program törzsét (az űrlap inicializálásakor fut le). A szabványos űrlap eseményeket az űrlap elvárt eljárásainak és funkcióinak listáján keresztül érhetjük el (Ctrl+Alt+P), vagy magának az űrlapnak a tulajdonságpalettáján keresztül.

Ha a fő attribútum hozzá van rendelve az űrlaphoz, akkor a fő attribútumként használt alkalmazásobjektum tulajdonságai és metódusai elérhetővé válnak az űrlapmodulban.

Objektum modul

• mind a 3 területet tartalmazhatja
• szerver oldalon hajtják végre

Ez a modul a legtöbb konfigurációs objektumhoz elérhető, és általában az objektumhoz közvetlenül kapcsolódó események feldolgozására szolgál. Például objektumok rögzítésének és törlésének eseményei, egy objektum adatainak kitöltésének ellenőrzése, dokumentum feladása stb.

Egyes objektummodul-események megduplázzák az űrlapmodul eseményeket. Például a rekordhoz kapcsolódó események. Meg kell azonban érteni, hogy az űrlapmodul eseményei csak az objektum adott formáján, azaz az adott űrlap megnyitásakor kerülnek végrehajtásra. Az objektummodul eseményei pedig mindenképpen meghívásra kerülnek, még az objektummal való programozás során is. Ezért ha olyan metódusokra van szüksége, amelyek egy objektumhoz vannak társítva anélkül, hogy az objektum egy adott formájához lennének kötve, akkor jobb, ha ehhez az objektummodult használja.

Objektumkezelő modul

• mind a 3 területet tartalmazhatja
• szerver oldalon hajtják végre

Az objektumkezelő modul csak az 1C 8.2-es verziótól kezdve jelent meg. A kezelőmodul minden alkalmazásobjektumhoz létezik, és ezt az objektumot konfigurációs objektumként kezeli. A menedzser modul lehetővé teszi egy objektum funkcionalitásának kiterjesztését olyan (írási) eljárások és függvények bevezetésével, amelyek nem az adatbázis-objektum egy adott példányára vonatkoznak, hanem magára a konfigurációs objektumra. Az objektumkezelő modul lehetővé teszi, hogy egy adott objektumhoz közös eljárásokat, függvényeket helyezzünk el, és ezeket kívülről, például feldolgozásból érjük el (természetesen, ha ez az eljárás vagy funkció az Export kulcsszóval történik). Mit ad ez nekünk újat? Általánosságban elmondható, hogy nem más, mint az eljárások objektumok szerinti rendszerezése és külön helyeken való tárolása - Object Manager Modules. Ezeket az eljárásokat és függvényeket ugyanígy elhelyezhetjük közös modulokban is, de az 1C azt tanácsolja, hogy az objektumok közös eljárásait és funkcióit helyezzük el az Object Manager Module-ban. Példák az Objektumkezelők modul eljárásainak és funkcióinak használatára: címtár vagy dokumentum egyes adatainak kezdeti kitöltése bizonyos feltételek mellett, címtár vagy dokumentum adatainak kitöltésének ellenőrzése bizonyos feltételek mellett stb.

Parancs modul

• tartalmazhat egy szakaszt, amely eljárásokat és funkciókat ír le
• ügyféloldalon hajtják végre

A parancsok az alkalmazásobjektumoknak vagy a konfiguráció egészének alárendelt objektumok. Minden parancshoz tartozik egy parancsmodul, amelyben leírhat egy előre meghatározott CommandProcess() eljárást a parancs végrehajtásához.

Bármely program egy programkódból áll, vagyis valójában egy tetszőleges nyelven írt műveletsorból, amelyet végre kell hajtani.

Ezt a programot azonban valahol meg kell írni, vagyis valahol el kell helyezkednie. A legtöbb esetben a programkód egyszerű szöveges fájlokban van írva. Az egyetlen különbség az, hogy a kiterjesztés bennük nem .txt, hanem .cpp vagy .php.

Hol van megírva az 1C program?

Mi az 1C modul?

Természetesen az 1C kód beírható valamilyen szövegfájlba is. Létezik azonban az 1C Configuration koncepciója - amely nemcsak a beállítások listáját, űrlapsablonokat és egyebeket tartalmazza, hanem az 1C programkódot is. Ezért az 1C kód a konfigurációban tárolódik.

A konfiguráció 1C objektumokból áll, amint azt az előző leckékben már figyelembe vettük. Minden 1C objektum beágyazott objektumokat tartalmaz, például egy könyvtárnak több formája van.

Minden 1C objektumnak, beleértve néhány beágyazottat is, saját modulja van - egy bizonyos szöveges fájl, amely a programkódot tartalmazza.

Vannak olyan objektumfüggetlen modulok is, amelyekbe egy adott objektumtól független programkód írható.

Így az 1C-ben nincs "egyetlen" program. Minden 1C konfigurációs objektumhoz van egy modulkészlet a programkód írásához.

Hogyan használják az 1C modulokat?

A teljes program nagyjából két típusra osztható:

• Objektum módszer
• Reakció az eseményekre.

Mód. Mint korábban említettük, az 1C objektum egy olyan integrált struktúra, amely adatokat és feldolgozási módszereket is tartalmaz. Ezek a metódusok olyan műveletek (metódusok) halmazát jelentik, amelyek meghívhatók adatok feldolgozására. Példa egy ilyen műveletre DirectoryObject.Write() – beírja a könyvtár egy elemét az adatbázisba.

Számos 1C objektum metódusa lehet szabványos (azaz 1C platformon programozható), és egy programozó írhatja az 1C nyelven. Ez utóbbi segítségével tetszés szerint bővítheti az 1C objektumok funkcionalitását.

Események. Az események sok más fejlesztőeszközben is megtalálhatók. A program célja nem csak az, hogy induláskor kiszámoljon valamit, hanem a felhasználó munkájának támogatása is.

Felhasználói esemény – a felhasználó megnyomta a gombot. Válaszul a kód egy része lefut, reagálva a felhasználó műveleteire.

Rendszeresemények - az 1C objektumot az adatbázisba írtuk. Az "Objektum rögzítése" rendszeresemény történt. Lehetőség van arra, hogy beállítsuk azt a reakciót, amely nem a felhasználó (aki megnyomta a gombot vagy mást csinált), hanem maga a rendszer által okozott eseményekre. Egy ilyen esemény szembetűnő példája a program kezdete.

Az 1C modulok végrehajtási sorrendje

Sok nyelven létezik olyan, hogy "belépési pont". Ez a legelső sor vagy függvény, amely a program indításakor kerül végrehajtásra.

Az 1C-ben több ilyen belépési pont található - minden ügyféltípushoz. Vagyis vastag kliens indításakor a belépési pont egy, vékony kliens indításakor egy másik. Ez lehetővé teszi különböző funkciók programozását különböző típusokügyfelek.

A megfelelő modul belépési pontja a BeforeSystemStart() és az AtSystemStart() rendszeresemény-kezelők (azaz sorrendben). Ezeket a funkciókat hajtják végre először, automatikusan elindíthatnak valamit.

Ha semmi sem indult el automatikusan, akkor az 1C interfész megnyílik a felhasználó előtt, és akkor minden attól függ. Rákattint a gombra - a gomb megnyomására szolgáló kezelő végrehajtásra kerül (ami viszont automatikusan is elindíthat valamit).

Munkavégzés 1C modulokkal

A konfigurátorban készült. A modult a Konfiguráció ablak segítségével nyithatja meg.

Szinte minden konfigurációs objektum rendelkezik kezelőmodullal, a legtöbb objektumhoz pedig objektummodul. A kezdő programozók gyakran nem értik a két modul céljának különbségét.

A céljuk különbségének megértése lehetővé teszi, hogy megfelelőbb szerkezetű programkódot írjon, és bizonyos esetekben megtakarítsa az 1C szerver erőforrásait, és növelje az alkalmazásmegoldás teljesítményét.

A cikkben megvizsgáljuk e modulok közötti alapvető különbségeket mind elméleti oldalról, mind konkrét gyakorlati példán keresztül.

Elmélet

Térjünk rá az objektum-orientált programozás (OOP) alapjaira, és vonjunk analógiát példánkkal. Az OOP-ban az objektumokon lévő metódusok feloszthatók statikus (statikus) és egyszerű. Egyszerű módszerek csak egy adott objektumon hívható meg, amelyhez az aktuális kódkörnyezetben hozzáférünk. A statikus metódusoknak nincs közvetlen hozzáférésük az objektumadatokhoz. Egy objektum eléréséhez először létre kell hoznia egy példányát. Ugyanez vonatkozik az 1C:Enterprise 8.x platformra is.

Az objektummodulban a platform olyan eljárásokat és függvényeket tárol, amelyek csak akkor hívhatók meg, ha egy adott objektummal dolgozik, például a "Nómenklatúra" hivatkozási elem objektumával. A menedzser modul olyan eljárásokat és függvényeket tartalmaz, amelyek egy adott típusú összes objektumra alkalmazhatók, de az objektum példányának kezdeti létrehozásával. Ez azt jelenti, hogy a nómenklatúra egy elemének megváltoztatásához ebből a modulból először az elemre hivatkozva hajtsa végre a "GetObject ()" metódust, majd dolgozzon vele a jövőben.

Térjünk át az elméletről a gyakorlatra.

Gyakorlat

Menjünk tovább gyakorlati példa. Tételezzük fel, hogy meg kell oldanunk az árulista nyomtatásának problémáját, a felhasználó vagy közvetlenül a címtár elemből, vagy a terméklista űrlapból nyomtat egy terméket. Tekintsünk két módot a feladat végrehajtására.

Nyomtatási eljárás az objektummodulban

A címtárobjektum modulban adja hozzá következő funkció:

// Hivatkozás átadása a függvénynek a könyvtárelemre Funkció PrintSelectedItems(Link) Export TabDoc = Új TabDoc; Elrendezés = Könyvtárak. Áruk. GetLayout(" Layout " ) ; Request = Új kérés; Kérés. Szöveg = " SELECT | Elemek . AS áruk bemutatása,| Áruk . Törlés megjelölése,| Áruk . kereskedői kód |TÓL TŐL| Könyvtár . Products AS Termékek|HOL | Áruk . B link (& ItemsArray)" ; Request. SetParameter(" Áruktömb " , Link) ; // Kiválasztás beállítása referencia alapján

A programkódot teljes egészében a nyomtatástervező generálja. Az egyetlen dolog, amit érdemes megjegyezni, az az, hogy a kérelemben a "Termékek" könyvtárelemre hivatkozva jelenik meg. A hivatkozás paraméterként kerül átadásra a függvénynek. A függvény meghívásának eredményeként a "PrintSelectedItems" visszaadásra kerül táblázatos dokumentum kitöltött tétellel.

A "PrintSelectedProducts" objektum metódusának a "Nyomtatás" űrlap parancsára történő meghívására szolgáló programkód a következő listában látható:

& OnClient eljárás nyomtatása (parancs) // Hívja a szerver eljárást a generált táblázatdokumentum lekéréséhez TabDoc = PrintServer() ; // A létrehozott táblázatos dokumentum megjelenítése TabDoc. Előadás() ; EndProcedure és OnServer függvény PrintServer() // A form objektum konvertálása a "Products" könyvtár objektumává, hogy meghívja a függvényt az objektummodulból ItemObject = FormAttributeToValue(" Object " ) ; // Hívja meg az objektummodul eljárását, átadva ott a szótár aktuális elemére való hivatkozást. Eredmény // visszatérés a kliens oldalra ObjectItem visszaadása. SelectSelectedItems(Object.Reference) ; EndFunctions

Így kinyomtattuk a könyvtár aktuális elemét, az objektumával dolgozva. De a feladatban azt mondták, hogy ki kell nyomtatni egy listát azokról a termékekről, amelyeket a felhasználónak magának kell kiválasztania. Egy tárggyal végzett munka során nem lehet egyszerű módon ilyen lehetőséget megadni a felhasználónak. A leghelyesebb az „Áruk” címtár elemeinek listájából nyomtatni.

Nyomtatási eljárás a menedzser modulban

Adja hozzá a következő exportálási eljárást a címtárkezelő modulhoz:

// Termékekre mutató hivatkozások tömbjének átadása Funkció PrintSelectedItems(ItemsArray) Export TabDoc = New SpreadsheetDocument; Elrendezés = Könyvtárak. Áruk. GetLayout(" Elrendezés " ) ; Request = Új kérés; Kérés. Szöveg = " SELECT | Elemek . AS áruk bemutatása,| Áruk . Törlés megjelölése,| Áruk . kereskedői kód |TÓL TŐL| Könyvtár . Products AS Termékek|HOL | Áruk . B link (& ItemsArray)" ; Request. SetParameter(" Items Array " , Items Array) ; // Szűrő beállítása tömb szerint Eredmény = Kérelem. Végrehajtás () ; AreaTitle = Elrendezés. GetRegion(" Cím " ) ; AreaFooter = Elrendezés. GetRegion(" Pince" ) ; TableHeader terület = Elrendezés. GetArea("Táblázatfejléc") ; AreaFooterTables = Elrendezés. GetRegion("Táblázatláb") ; AreaDetailRecords = Elrendezés. GetRegion(" Részletek " ) ; TabDoc. Egyértelmű() ; TabDoc. Output(AreaHeader) ; TabDoc. Output(RegionTableHeader) ; TabDoc. StartAutoGroupRows() ; SampleDetailRecords = Eredmény. Választ() ; A részletes feljegyzések mintavétele közben. Következő() LoopDetailRecordsArea. Lehetőségek. Fill(SelectionDetailRecords) ; TabDoc. Output(RégióRészletRekordok, SelectionDetailRecords. Level() ) ; EndCycle ; TabDoc. EndAutoGroupRows() ; TabDoc. Output(RegionFooterTables) ; TabDoc. Output(AreaFooter) ; Vissza TabDoc; EndFunctions

A fő különbség az objektummodul függvényeitől a függvényparaméter. Most egy tömb, amely a nyomtatandó termékekre mutató hivatkozásokat tartalmaz, paraméterként kerül átadásra.

A "Nyomtatás" űrlap parancsmodul programkódja a következő:

& A kliens eljárásban Print(Command) TabDoc = PrintServer() ; TabDoc. Előadás() ; EndProcedure és OnServer függvény PrintServer() // A keresési listában kiválasztott termékek hivatkozásainak tömbjének átadása // a "PrintSelectedItems" kezelőmodul funkciójába Kézikönyvek visszaküldése. Áruk. Kiválasztott elemek nyomtatása(Elemek. Lista. Kijelölt sorok) ; EndFunctions

Ebben az esetben a parancs 1C:Enterprise módban történő végrehajtásának eredménye a következő lesz:

A menedzser modulból történő metódus használata esetén a "Termékek" katalógus adatait anélkül érhetjük el, hogy minden hivatkozáshoz objektumot szereznénk be. Mivel egy objektum megszerzése azt jelenti, hogy a könyvtár eleme által az adatbázisból minden adatot lekérünk, és a kapott adatokat a RAM-ba helyezzük, a feladat második módon történő megvalósítása pozitívan befolyásolja a teljesítményt. Valójában ebben az esetben minimális erőforrást fogunk használni ( véletlen hozzáférésű memória) a szervergépen.

Mit kell használni?

Mint mindig, minden a konkrét feladattól függ. Ha dokumentumot szeretne nyomtatni, többet legjobb lehetőség- használja a menedzser modult. Ha ki kell töltenie egy objektumot, pl. külső feldolgozás töltő táblázatos részek, akkor ebben az esetben érdemesebb eljárásokat és függvényeket elhelyezni az objektummodulban, mivel munkájuk pontosan az objektumhoz kapcsolódik.

A tipikus "Trade Management" 11-es verzióban a dokumentumok nyomtatására szolgáló menedzser modult mindenhol használják. Ha megnézi a "Production Enterprise Management" konfigurációt, akkor a menedzser modult gyakorlatilag nem használják, mivel a konfigurációt a platform régebbi verzióiban írták, ahol nem volt teljes támogatása ennek a mechanizmusnak.

Konfiguráció a cikkből származó példákkal.

Nyomtatás (Ctrl+P)

A konfigurációs fa ágában található objektumok A közös modulokat úgy tervezték, hogy tartalmazzák bármely más konfigurációs modulból meghívható függvények és eljárások szövegeit.
FIGYELEM! Egy általános modul csak eljárás- és függvénydefiníciókat tartalmazhat.
Egy közös modul eljárásai és funkciói, amelyekre a fejlécek utalnak kulcsszó Az export a globális kontextus egyik összetevője. Az 1C:Enterprise nyelvi súgó „Programmodul forrásszövegeinek formátuma” és „Operátorok” részében többet megtudhat az írási eljárásokról egy közös modulban.
Egy közös modul szerkesztéséhez kattintson a Konfiguráció ablakban a Common modules típusú objektumok tulajdonságpalettájának Modul tulajdonságában a Megnyitás hivatkozásra. Az általános modul szövege szerkesztésre kerül kiadásra az 1C:Enterprise szövegszerkesztőben, programmodul szövegszerkesztő módban.
A konfiguráció részét képező közös modul csak a konfiguráció részeként kerül mentésre.
A Global tulajdonság határozza meg, hogy egy megosztott modul exportált metódusai a globális környezet részét képezik-e.
Ha a Globális tulajdonság True értékre van állítva, akkor a megosztott modul exportált metódusai elérhetők a globális környezet metódusaiként.
Ha a Globális tulajdonság False értékre van állítva, akkor a globális környezetben létrejön egy tulajdonság a megosztott modul nevének megfelelő névvel a metaadatokban. Ez a tulajdonság csak olvasható. Ennek a tulajdonságnak az értéke egy GenericModule objektum. Ezen az objektumon keresztül elérhetők a közös modul exportált metódusai. Így a nem globális megosztott modulok metódusainak elérése így néz ki: XXXXX.YYYYY, ahol az XXXXX a megosztott modul környezetének megfelelő tulajdonság neve, az YYYYY pedig a megosztott modul exportált metódusának neve.
Példa:

WorkWithTradeEquipment.ConnectBarcodeScanner();

Különféle kontextus és közös modulok

A gyakori modulok tulajdonságai és az előfeldolgozó utasítások segítségével megszervezheti a végrehajtást különféle módszerek közös modulokat a megfelelő kontextusban.
A közös modul minden tulajdonsága felelős a közös modul egy adott környezetben történő fordításának (és végrehajtásának) képességéért.
A következő tulajdonságok állnak rendelkezésre, amelyek felelősek azért a kontextusért, amelyben a megosztott modul metódusai elérhetők:
● Ügyfél ( rendszeres alkalmazása) – a közös modul módszerei elérhetők lesznek a vastag kliens számára normál alkalmazási módban;
● – A közös modulmódszerek elérhetőek lesznek vékonykliensekhez, webkliensekhez és vastag kliensekhez is
felügyelt alkalmazás mód;
● Szerver - a közös modul metódusai elérhetők lesznek a szerveren;
● Külső csatlakozás– a közös modul módszerei elérhetők lesznek a külső csatlakozásban.
Ha több tulajdonság van beállítva egyszerre, ez azt jelenti, hogy a megosztott modul metódusai több környezetben is elérhetők lesznek.
Ha egy megosztott modul rendelkezik a Szerver tulajdonsággal és bármely más tulajdonsággal, ez azt jelenti, hogy a megosztott modul egyszerre lesz elérhető a szerveren és a kiválasztott kliensben. Ugyanakkor meg kell érteni, hogy valójában a lefordított kód több változata lesz (a kiválasztott kliensek számától és a szervertől függően).
Ebben az esetben, ha egy ilyen közös modulban található metódust kliens oldalról hívjuk meg, akkor a közös modul kliens példánya, ha pedig a szerverről, akkor a szerver másolata kerül felhasználásra. Ebben az esetben az előfeldolgozó direktívák segítségével (további részletekért lásd itt) „megvédheti” a szervert a rajta nem végrehajtható kódtól.
Vegyünk egy példát. Egy megosztott modulban (amely végrehajtható vékony kliensés a szerveren) van egy módszer, amely kissé eltérő viselkedést mutat a vékony kliens oldalon és a szerver oldalon. Lássuk, hogyan lehet ezt megtenni:

#Ha ThinClient Akkor
// Figyelmeztetés megjelenítése
ShowAlertUser(„Az ügyfélen”);
#EndIf
Vége eljárás
Ezután a szerver oldalon a kód így fog kinézni:
Eljárás CommonModule Method() Export
// Különféle fontos kódok kerülnek ide
Vége eljárás
A vékony kliens oldalon pedig a kód így fog kinézni:
Eljárás CommonModule Method() Exportálás
// Különféle fontos kódok kerülnek ide
// Figyelmeztetés megjelenítése
ShowUserAlert("On Client");
Vége eljárás

Számos módja van az irányítás átadásának az ügyfélről a szerverre:
● hívjon egy szerver közös modul metódusát;
● egy űrlapban vagy parancsmodulban olyan metódust hívjon meg, amelyet fordítási direktívák előznek meg &AtServer, &AtServerWithoutContext

A kiszolgáló eljárásokból azonban nem hívható meg a kliens közös moduljainak metódusai (amelyek nem rendelkeznek a Server tulajdonságkészlettel) és egy űrlapmodul vagy parancsmodul kliens metódusai. A vezérlés visszatér az ügyfélhez, miután a kiszolgáló metódusának legkülső hívása befejeződött.
Kivételt képeznek a form modul és a parancsmodul metódusai, amelyeket fordítási direktívák előznek meg &A kliensnél A szerveren, &A kliensnélA kiszolgálónálKontextus nélkül
A következő szempontokat is meg kell említeni:
● Ha egy megosztott modul egynél több kliens számára elérhető, akkor a kód írásakor vegye figyelembe az ügyfelek által kiszabható maximális korlátozásokat, vagy használjon előfeldolgozó utasításokat a kliens-specifikus kód "elkülönítésére".
● Az előfeldolgozó utasítások akkor is értelmesek, ha egy közös modulnak több végrehajtási kontextusa van, például külső kapcsolat és vékony kliens, vagy (gyakrabban) kliens és kiszolgáló. Ebben az esetben az előfeldolgozó utasításai becsomagolják az interaktív kódot, amely nem használható a szerveren, de lehetséges a kliensen (lásd a fenti példát).
Az előfeldolgozó utasításokkal és a fordítási direktívákkal kapcsolatos további információkért tekintse meg az 1C:Enterprise Language Help (Eljárások és funkciók végrehajtása) című részét.
A Server Invocation tulajdonság szabályozza, hogy a kiszolgáló közös moduljának exportált metódusai hívhatók-e ügyfélkódból.
Ha a tulajdonság be van állítva, akkor a kiszolgálóoldali megosztott modul exportált metódusai elérhetők a kliens általi meghívásra. Ha a tulajdonság nincs beállítva, akkor az ilyen exportált metódusok csak a szerver metódusokból hívhatók meg (mind a kiszolgáló közös moduljainak metódusai, mind az űrlap- és parancsmodulok kiszolgáló metódusai).
Tanácsot. Javasoljuk, hogy a Server Invocation tulajdonságot False értékre állítsa, ha a kiszolgálóoldali közös modul olyan metódusokat tartalmaz, amelyeket nem kíván meghívni az ügyféltől (például biztonsági okokból).
jegyzet. Ha a tulajdonságok egyidejűleg vannak beállítva Ügyfél (rendszeres jelentkezés), Ügyfél (felügyelt alkalmazás), Külső csatlakozás, akkor a Call Server tulajdonság automatikusan visszaáll. Ha a Call server tulajdonság be van állítva, a tulajdonságok automatikusan visszaállnak Ügyfél (rendszeres jelentkezés), Ügyfél (felügyelt alkalmazás)És Külső csatlakozás ha ezek a tulajdonságok egyidejűleg lettek beállítva.
Ingatlan KiváltságosÚgy tervezték, hogy letiltja a hozzáférés-vezérlést egy közös modul metódusainak végrehajtásakor.
JEGYZET. Ha tulajdon Kiváltságos be van állítva, akkor a szerver tulajdonság automatikusan beáll a közös modulhoz, és a többi tulajdonság visszaáll ( Ügyfél (rendszeres jelentkezés), Ügyfél (felügyelt alkalmazás)és B külső csatlakozás). A privilegizált megosztott modul csak a szerveren futhat.

Visszatérési értékek újrafelhasználása

Ha a megosztott modul nem globális, akkor elérhetővé válik a Visszatérési értékek újrafelhasználása tulajdonság. Ez a tulajdonság a következő értékeket veheti fel:
● Ne használja – A visszatérési értékeket a rendszer nem használja fel újra ebben a megosztott modulban.
● Hívásonként és Munkamenetenként – A megosztott modul az adatújrafelhasználás észlelési módszerét használja. Ennek a módszernek az a lényege, hogy a kód végrehajtása során a rendszer az első függvényhívás után megjegyzi a paramétereket és a függvények eredményét. Amikor a függvényt ugyanazokkal a paraméterekkel ismét meghívjuk, a tárolt érték kerül visszaadásra (az első hívásból) anélkül, hogy magát a függvényt végrehajtaná. Ha a függvény a végrehajtás során megváltoztatja a paraméterértékeket, akkor a függvény újbóli meghívása nem teszi meg.
A híváseredmények mentésének a következő jellemzői különböztethetők meg:
● ha a funkciót a szerveren hajtják végre és a szerver kódból hívják, akkor a paraméterértékek és a hívás eredménye a szerveroldalon az aktuális munkamenethez emlékezik;
● ha a függvényt vastag vagy vékony kliensen hajtják végre, akkor a paraméterek értékei és a hívási eredmények a kliens oldalon tárolódnak;
● ha a függvényt a szerver oldalon hajtják végre és a kliens kódból hívják, akkor a hívási paraméterek értékei mind a kliens oldalon, mind a szerver oldalon (az aktuális munkamenetre vonatkozóan) megmaradnak.
A tárolt értékek törlődnek:
● ha a tulajdonság beállítása A hívás időtartamára:
● a szerver oldalon – amikor a vezérlés visszakerül a szervertől;
● kliens oldalon – amikor egy legfelső szintű 1C:Enterprise eljárás vagy függvény véget ér (a rendszer hívja meg az interfészről, és nem egy másik 1C:Enterprise eljárás vagy függvény);
● ha a megosztott modul tulajdonság beállítása A munkamenet időtartamára:
● szerver oldalon – a munkamenet végén;
● a kliens oldalon – amikor a kliens alkalmazás be van zárva.
A mentett értékek törlődnek:
● a szerveren, a vastag kliensben, a külső kapcsolaton, a vékony kliensben és a webes kliensben normál sebesség csatlakozások - 20 perccel a tárolt érték kiszámítása után vagy 6 perccel az utolsó használat után;
● vékony kliensben és alacsony kapcsolati sebességű webkliensben - 20 perccel a tárolt érték kiszámítása után;
● ha a szerver munkafolyamatában hiányzik a RAM;
● egy munkafolyamat újraindításakor;
● Amikor egy ügyfél másik munkafolyamatra vált.
Az értékek törlése után az exportált függvény hívása az első híváshoz hasonlóan történik.
Eljárások végrehajtására adott ingatlan a közös modulokat ez nem érinti - az eljárások mindig végrehajtásra kerülnek.

Ha egy megosztott modul visszatérési értékének újrafelhasználása van beállítva, számos korlátozás vonatkozik az exportált függvény paramétertípusaira. A paramétertípusok csak a következők lehetnek:
● Primitív típusok ( Nem definiált, NULL, logikai érték, szám, karakterlánc, dátum).
● Bármilyen hivatkozás adatbázis-objektumokra.
● A fenti típusú tulajdonságértékekkel rendelkező szerkezetek. Ebben az esetben a paraméterek azonosságát a struktúrák "tartalma" szabályozza.
Ha az exportált függvény bármilyen objektumot ad vissza, akkor valójában egy hivatkozást ad vissza a gyorsítótárban tárolt objektumra. Ha az objektum állapota megváltozik a hivatkozás fogadása után, akkor ugyanannak a függvénynek a következő hívása a már megváltozott objektumra való hivatkozást adja vissza anélkül, hogy ténylegesen végrehajtaná a funkciót. Ez a viselkedés addig folytatódik, amíg a tárolt értéket el nem távolítják (bármilyen okból). Más szóval, egy függvény megosztott modulból történő meghívása eredményeként kapott objektum állapotának megváltoztatása a visszatérési értékek újrafelhasználásával nem alapja a függvény tényleges meghívásának. Ne feledje azt is, hogy a visszaadott objektum-gyorsítótár közömbös
privilegizált mód állapota a függvényhívás időpontjában, visszatérési értékekkel újrafelhasználva. Ez a funkció a következő viselkedéshez vezethet:
● A függvényhívás tényleges végrehajtása visszatérési érték újrafelhasználásával (az első hívás) engedélyezett privilegizált móddal történt.
● Egy funkció végrehajtásakor olyan objektum érkezett, amely nem fogadható, ha a privilegizált módot letiltja.
● A funkció későbbi hívásai a privilegizált mód beállítása nélkül történtek.
● Mindaddig azonban, amíg a visszaadott objektumok gyorsítótárát ki nem ürítik vagy a tényleges hívást meg nem hajtják, a függvény formálisan elérhetetlen objektumot ad vissza.
● A fordított viselkedés is igaz, ahol az első hívás privilegizált mód beállítása nélkül történik, és a privilegizált mód nem ad vissza olyan objektumot, amelyet privilegizált módban kaphattak volna meg.

Ha a közös modulnak van egy tulajdonsága Visszatérési értékek újrafelhasználásaértékre van állítva A munkamenet időtartama alatt, akkor az ilyen modul funkciói által visszaadott értékek nem használhatják a típusú értékeket TemporaryTable Manager.
Ha egy megosztott modul függvényét újrafelhasználási készlettel ugyanabból a megosztott modulból hívják meg (például SharedModule néven), akkor emlékezzen a következő jellemzőre: ha a függvényt MyFunction() néven hívják, akkor a függvény minden alkalommal végrehajtódik a függvény meghívásakor. A tárolt értékek használatához a függvényt a teljes képzésű nevén kell meghívni:
GeneralModule.MyFunction().
A globális környezeti metódus eltávolítja az összes újrafelhasznált értéket, mind a kiszolgálóoldali, mind a kliensoldali, függetlenül attól, hogy a metódus hol van meghívva. A módszer végrehajtása után UpdateReusableValues() az első függvényhívás teljesen végrehajtódik.