1s 8 rutinfeladat. Rutin- és háttérfeladatok (1Cv8)

Az 1C-ben végzett munka során számos rutinművelet van, amelyeket ütemterv szerint kell elindítani vagy kialakítani egy vagy másik művelet végrehajtásához, például: dokumentumok közzététele vagy adatok betöltése az 1C-be egy webhelyről.

Nemrég tettem közzé egy cikket: Itt az ideje automatizálni:

Rutin- és háttérfeladatok

A munkamotort úgy tervezték, hogy bármely alkalmazást vagy funkciót ütemezetten vagy aszinkron módon hajtson végre.

A feladatmechanizmus a következő problémákat oldja meg:

• Képes szabályozási eljárások meghatározására a rendszer konfigurációs szakaszában;
• Meghatározott tevékenységek ütemezés szerinti végrehajtása;
• Adott eljárás vagy függvény hívása aszinkron módon, azaz. anélkül, hogy megvárná annak befejezését;
• Egy adott feladat előrehaladásának nyomon követése és annak befejezettségi állapotának megállapítása (egy érték, amely jelzi, hogy sikeres volt-e vagy sem);
• Az aktuális feladatok listájának beszerzése;
• Képes megvárni egy vagy több feladat befejezését;
• Jobkezelés (lemondási lehetőség, végrehajtás letiltása stb.).

A munkamechanizmus a következő összetevőkből áll:

• Rutinfeladatok metaadatai;
• Rendszeres feladatok;
• Háttérmunkák;
• Feladat ütemező.

A háttérfeladatok és az alkalmazási feladatok aszinkron végrehajtására készültek. A háttérfeladatok a beépített nyelv segítségével valósulnak meg.

Ütemezett feladatok és az alkalmazási feladatok ütemezett végrehajtására szolgálnak. A rutinfeladatokat az információs bázis tárolja, és a konfigurációban meghatározott metaadatok alapján hozzák létre. A szabályozási feladat metaadatai olyan információkat tartalmaznak, mint a név, a módszer, a felhasználás stb.

Egy rutinfeladatnak van egy ütemezése, amely meghatározza, hogy a rutinfeladathoz társított metódust mikor kell végrehajtani. Az ütemezés általában az információs bázisban van megadva, de megadható a konfigurációs szakaszban is (például előre meghatározott rutinfeladatokhoz).

A feladatütemező a rutinfeladatok végrehajtásának ütemezésére szolgál. Az ütemező minden ütemezett feladatnál rendszeresen ellenőrzi, hogy az aktuális dátum és idő egyezik-e az ütemezett job ütemezésével. Ha egyezik, az ütemező hozzárendeli a feladatot a végrehajtáshoz. Ehhez az ütemezett feladathoz az ütemező létrehoz egy háttérfeladatot, amely elvégzi a tényleges feldolgozást.

Azt hiszem, ennyi elég is a leírásból – térjünk rá a megvalósításra:

Rutinfeladat létrehozása

A módszer neve– annak az eljárásnak az elérési útja, amely adott ütemezés szerint egy háttérfeladatban fog végrehajtani. Az eljárásnak egy közös modulban kell lennie. Javasoljuk, hogy ne szabványos közös modulokat használjon, hanem saját maga készítsen. Ne felejtse el, hogy a háttérben futó feladatok a szerveren futnak!

Használat– rutinfeladat használatának jele.

Előre meghatározott– jelzi, hogy a rutinfeladat előre meghatározott-e.

Ha azt szeretné, hogy a rutinfeladat azonnal működjön az adatbázisba helyezés után, adja meg az attribútumot Előre meghatározott. Ellenkező esetben a „Job Console” feldolgozást kell használnia, vagy aktiválnia kell a feladat programozott futtatását.

Az újrapróbálkozások száma, ha egy job rendellenesen fejeződik be– hányszor indult újra a háttérfeladat, ha hibásan futott le.

Újrapróbálkozási időköz, ha a munka rendellenesen fejeződik be– milyen gyakran indul újra a háttérfeladat, ha hibásan fejeződött be.

Ütemezés felállítása

Menetrend a feladat teljesítése:

Minden órában, csak egy nap	RepeatDays Period = 0, RepeatDays Period = 3600
Minden nap naponta egyszer	RepeatDays Period = 1, RepeatDays Period = 0
Egy nap, egyszer	PeriodRepeatDays = 0
Minden második nap naponta egyszer	PeriodRepeatDays = 2
Óránként 01:00 és 07:00 között minden nap	PeriodRepeatDays = 1RepeatPeriodDuringDay = 3600Kezdési idő = 01.00 Vége = 07.00
Minden szombaton és vasárnap 09.00 órakor	RepeatDays Period = 1 WeekDays = 6, 7Kezdési idő = 09.00
Minden nap egy hétig, hagyj ki egy hetet	PeriodRepeatDays = 1PeriodWeeks = 2
Egyszer 01:00-kor	Kezdési időpont = 01.00
Minden hónap utolsó napja 9:00.	PeriodRepeatDays = 1 DayInMonth = -1Kezdőidő = 09.00
Minden hónap ötödik napja 9:00	PeriodRepeatDays = 1 DayInHónap = 5Kezdési idő = 09.00
Minden hónap második szerdája 9:00-kor	PeriodRepeatDays = 1napHétHónap =2napHét =3 Kezdési időpont = 09.00

A háttérfeladatok végrehajtásának jellemzői fájl és kliens-szerver változatokban

A háttérfeladatok végrehajtásának mechanizmusa a fájl és a kliens-szerver verziókban eltérő.

Fájl verzióban létre kell hoznia egy dedikált ügyfélfolyamatot, amely háttérfeladatokat hajt végre. Ehhez az ügyfélfolyamatnak rendszeresen meg kell hívnia az ExecuteJobProcessing globális kontextusfüggvényt. Infobázisonként csak egy ügyfélfolyamat dolgozhat fel háttérfeladatokat (és ennek megfelelően hívhatja meg ezt a függvényt). Ha nem jött létre ügyfélfolyamat a háttérfeladatok feldolgozásához, akkor a jobmotor programozott elérésekor a „Job Manager nem aktív” hibaüzenet jelenik meg. Nem ajánlott olyan ügyfélfolyamatot használni, amely más funkciók háttérfeladatait dolgozza fel.

A háttérfeladatokat feldolgozó kliensfolyamat elindítása után a többi ügyfélfolyamat programozottan hozzáférhet a háttérfeladat-motorhoz, pl. háttérmunkákat futtathat és kezelhet.

Kliens-szerver verzióban A háttérfeladatok végrehajtásához egy feladatütemezőt használnak, amely fizikailag a fürtkezelőben található. Az összes sorban álló háttérfeladat esetében az ütemező a legkevésbé terhelt munkavégző folyamatot kapja meg, és azt használja a megfelelő háttérfeladat futtatására. A dolgozói folyamat végrehajtja a munkát, és értesíti az ütemezőt a végrehajtás eredményeiről.

A kliens-szerver verzióban lehetőség van a rutinfeladatok végrehajtásának blokkolására. A rutinfeladatok végrehajtása a következő esetekben blokkolva van:

• Az információs bázison a rutinfeladatok kifejezett blokkolása van telepítve. A zár a fürtkonzolon keresztül állítható be;
• Az információs bázison van egy csatlakozási blokk. A zár a fürtkonzolon keresztül állítható be;
• A True paraméterrel rendelkező SetExclusiveMode() metódus a beépített nyelvből lett meghívva;
• Néhány más esetben (például az adatbázis-konfiguráció frissítésekor).

Ütemezett feladatok indításának és megtekintésének feldolgozása itt tudod letölteni.

Aszinkron programozási koncepció

Az aszinkron programozási koncepció az, hogy egy függvény eredménye nem azonnal elérhető, hanem egy idő után valamilyen aszinkron (a normál végrehajtási sorrendet megsértő) hívás formájában.

Azok. Az aszinkron programozás fő gondolata, hogy egyéni metódushívásokat adjon ki, és párhuzamosan folytassa a többi munkát anélkül, hogy megvárná a hívások befejezését.

Egyes módszerek, amelyek minimalizálják a kivételek valószínűségét, nem igényelnek aszinkron megközelítést, mások viszont a fejlesztés legelején.

Amint az a grafikonokból látható, szinkron programozási modell esetén nincs együtthatója a hasznos interaktív felhasználói műveleteknek, mivel a rendszer blokkolja a felhasználói felületet, míg aszinkron modell esetén a felhasználó továbbra is aktívan dolgozik a rendszerben.

Szinkron futás esetén az alkalmazásnak csak egy szála van. Az aszinkron programozási modellel több szálat futtathat párhuzamosan, és futás közben reagálhat az új felhasználói műveletekre. Az n-szál végrehajtása után az eredmény megjelenik a képernyőn.

Háttérfeladatok az 1C:Enterprise 8-ban

Az 1C:Enterprise 8-ban a háttérfeladatokat úgy tervezték, hogy az alkalmazási feladatokat aszinkron módon hajtsák végre. Létrehozhatnak alárendelt háttérfeladatokat, például a fürt különböző működő szerverein végzett összetett számítások párhuzamosításához kliens-szerver üzemmódban.

Lehetőség van az azonos módszerekkel rendelkező háttérfeladatok végrehajtásának korlátozására egy adott alkalmazási feltétel alapján. A háttérfeladatok programozott létrehozása és kezelése lehetséges bármely felhasználói kapcsolatról a rendszer információs bázisához. A háttérfeladat annak a felhasználónak a nevében fut, aki létrehozta.

A feladatmechanizmus kliens-szerver és fájl üzemmódban is működik, de a feladatok adminisztrációs és végrehajtási lehetőségei mindkét verzióban némileg eltérőek.

Kliens-szerver opció

A kliens-szerver verzióban a feladatütemezést a feladatütemező végzi, amely fizikailag a fürtkezelőben található.

Az ütemező rendszeresen ellenőrzi, hogy érkezett-e kérés a háttérfeladatok futtatására. Ha vannak végrehajtandó jobok, az ütemező meghatározza a fürt legkevésbé terhelt dolgozói folyamatait, és egymás után mindegyikhez hozzárendeli a végrehajtandó feladatot. Így ugyanaz a dolgozói folyamat potenciálisan több feladatot is végrehajthat párhuzamosan. Miután a dolgozói folyamat megkapta a munkát, a dolgozói folyamat kapcsolatot létesít az információs bázissal, és végrehajtja a feladatot ezen a kapcsolaton belül. A munka befejezése után a dolgozói folyamat értesíti az ütemezőt, hogy a feladat sikeresen vagy sikertelenül fejeződött-e be.

Fájl opció

A platform 8.3.3.641-es verziójától kezdve a fejlesztők jelentősen leegyszerűsítették a munkát a háttérfeladatokkal a fájlverzióban.

Korábban a feladatok automatikus végrehajtásához külön, további 1C:Enterprise munkamenetet kellett elindítani, amelyet feladatütemezőként használtak. És ebben a munkamenetben szükség volt a beépített nyelvi módszer időszakos végrehajtására ExecuteTaskProcessing(). Ez a megközelítés meglehetősen körülményes, kényelmetlen volt, és nagymértékben korlátozta a háttér- és rutinfeladatok használatát a munka fájlváltozatában.

Most minden sokkal könnyebbé vált. Ha egy vékony vagy vastag kliens indul, és ha a webszervernek is vannak klienskapcsolatai, akkor ezekben az alkalmazásokban automatikusan elindul egy másik szál az adatbázishoz való csatlakozással. Ezek a szálak háttér- és rutinfeladatok végrehajtásával foglalkoznak.

A felsorolt ​​alkalmazások mindegyike elvégzi a saját háttérfeladatait. Ha egy alkalmazás több háttérfeladatot kezdeményezett, azok egymás után, a beérkezésük sorrendjében kerülnek végrehajtásra.

Az 1C háttérmunkák nyilvánvaló hátránya: mivel a szerver oldalon futnak, nincs lehetőség interaktív munkavégzésre a felhasználóval (például nem lehet üzenetet vagy más információt megjeleníteni; mindezeket az adatokat az információs bázison belül kell tárolni, és tovább kell feldolgozni valamilyen módon).

Meg kell jegyezni, hogy a háttérmunkák tisztán szoftverobjektumok, és nem tárolhatók az adatbázisban. Vagyis csak egy osztály példányát tudjuk létrehozni, a tulajdonságait inicializálni és végrehajtásra elindítani.

Példa az aszinkron kódvégrehajtásra az 1C:Enterprise 8-ban

„Sokkal nehezebb olyan programokat írni, amelyekben egy függvényhívás eredménye ismeretlenül mikor érkezik meg, sokkal nehezebb, mint a hétköznapiak. Beágyazott hívások, hibakezelés, a történések ellenőrzése - minden bonyolultabbá válik” – csak azok mondják ezt, akik nem tudják, hogyan kell megfelelően használni a platform képességeit, de mi nem!

Mutassuk meg az aszinkron kódvégrehajtás egyszerűségét és eleganciáját az 1C:Enterprise 8-ban!

1. lépés. Hozzunk létre egy új információbiztonsági rendszert a konfigurációfejlesztéshez

2. lépés. A konfigurációban hozzáadjuk az „Aszinkron kezelők” általános modult.

Miért adtunk hozzá egy megosztott modult? Itt minden egyszerű: az aszinkron műveletek végrehajtásához az 1C:Enterprise 8-ban háttérfeladatokat használnak, amelyeknek saját kezelőjük van - „BackgroundTask Manager”. Ez az objektum rendelkezik egy „Futtatás” metódussal, melynek segítségével elindul a háttérfeladat.

Forduljunk a szintaktikai asszisztenshez.

Tehát szükségünk lesz egy közös modulra.

3. lépés Az „Asyncronous Handlers” általános modulban hozzáadjuk az OurLongOperation() exportálási eljárást.

Eljárás OurLongOperation(Duration) Export // Hosszú távú művelet szimulációja (Duration sec.). OperationStartDate = AktuálisDátum(); Míg CurrentDate() - A művelet kezdő dátuma< Длительность Цикл КонецЦикла; КонецПроцедуры

4. lépés. Adja hozzá az „Asynchronous Programming Concept” feldolgozást a konfigurációhoz (külső feldolgozást hozhat létre)

Adjon hozzá egy attribútumot az űrlaphoz:

Időtartam (szám)

és két csapat

Végezze el a LongOperation-t;

Végezzen aszinkron hosszú-hosszú műveletet.

5. lépés. A szintaxis asszisztens szerint töltse ki az űrlap modult

&Az ügyféleljáráson hajtsa végre a Long-RunningOperation(Command) ExecuteLong-RunningOperationOnServer(); EndProcedure &OnServer eljárás ExecuteLongOperationOnServer() AsynchronousHandlers.OurLongOperation(Duration); Az eljárás vége &Az ügyfélen Eljárás Hosszan futó művelet végrehajtása aszinkron módon (parancs) Hosszú távú művelet aszinkron végrehajtása a kiszolgálón (); Az eljárás vége &A kiszolgálón Eljárás Hosszan futó művelet végrehajtása aszinkron módon a kiszolgálón() Paraméterek = Új tömb; Parameters.Add(Duration); BackgroundTasks.Execute("AsynchronousHandlers.OurLongOperation", Parameters, New UniqueIdentifier, "Példa aszinkron programozási koncepcióra"); Az eljárás vége

6. lépés. Indítsuk el és ellenőrizzük!

Eredmény:

Ha a „Hosszú működés végrehajtása” gombra kattintunk, akkor a felhasználói felület „Időtartam” másodpercekre blokkolva lesz;

Ha a „Hosszú üzemelés aszinkron végrehajtása” gombra kattintunk, a felhasználói felület nem blokkolódik, és a programkód párhuzamosan fut.

A naplóból ellenőrizhetjük, hogy a programkód aszinkron módon fut-e le.

A „háttérben” futó programkódot akkor tudjuk hibakeresni, ha beállítjuk a megfelelő tulajdonságot a hibakeresési paraméterekben.

Példa aszinkron kódvégrehajtásra az 1C:Enterprise 8-ban BSP használatával

Tekintsünk egy példát az aszinkron programozási koncepció megvalósítására az 1C:Enterprise 8-ban a BSP-ben, az „Aktuális ügyek” feldolgozás példájával.

A logika a következő: a program indításakor a kezdőoldal munkaterülete inicializálódik, ahol az „Aktuális” feldolgozási űrlap jeleníthető meg. Ezt az űrlapot a felhasználó aktuális ügyei töltik ki, kitöltése időbe telik. Ha a fejlesztők nem tudták aszinkron kódot futtatni, akkor a felhasználói felület blokkolva lenne a feldolgozási űrlap kitöltése közben!

Elemezzük az űrlap programkódját.

A „When CreatedOnServer” űrlapesemény meghívja a „RunBackgroundTask” eljárást – erre van szükségünk.

Anélkül, hogy az árnyalatok megzavarnák, elemezzük ezt az eljárást

És itt látjuk, hogy a háttérfeladat-kezelőt és annak „Futtatás” módszerét használják. Vegye figyelembe, hogy a fejlesztők egyedi azonosítót tárolnak a háttérmunkához.

Ehhez a fejlesztők a módszert használják ConnectWaitHandler(<ИмяПроцедуры>, <Интервал>, <Однократно>).

A kiakasztott eljárásban Connectable_CheckTaskComplete() a fejlesztők függvényt hívnak Feladat befejezve (Feladatazonosító)

Ez a funkció egy háttérfeladat végrehajtását ellenőrzi azonosító alapján.

Meg kell jegyezni, hogy a BSP általános modulokat fejlesztett ki a hosszú távú szerverműveletek támogatására.

Így az 1C:Enterprise 8 aszinkron programozási koncepciója kissé megnöveli a problémák megoldásának összetettségét a fejlesztő számára, de jelentősen javítja a program funkcionalitását a felhasználó szempontjából.

A regiszterek rendszeres törlése (például az SCP konfigurációban az „Objektumverziók” információs regiszter), ütemezett számítások végrehajtása, dokumentumok egy bizonyos időpontban történő kitöltése - ez nem az 1C rutinfeladatokkal végrehajtható műveletek teljes listája.

Hozzon létre egy feladatot

Nem az a célunk, hogy leírjuk a végrehajtható modul kódját, bemutatjuk az általános működési elveket és egy rutinfeladat létrehozását.

A rutinfeladat pótolhatatlan:

1. Ha az adott feladat egyik feltétele egy bizonyos algoritmus időszakos végrehajtásának szükségessége;
2. Ha a kódot az adatbázis kezelőinek és felhasználóinak intézkedéseitől függetlenül végre kell hajtani;
3. Ha egy végrehajtható eljárás elindítása nem függ az infobase objektumokkal előforduló külső eseményektől.

Létrehozásához lépjen az információs bázisra a „Konfigurátor” módban. Ezután keresse meg a „Rutinfeladatok” ágat a konfigurációs fában, amely az „Általános” fülön található, majd kattintson a „Hozzáadás” gombra (1. ábra).

Nézzük meg közelebbről a tulajdonságai ablakát (2. ábra):
2. ábra

1. Név, szinonimák és megjegyzések - a mezők kitöltésének szabályai és alapelvei minden konfigurációs objektum esetében hasonlóak, és nem szükséges újra leírni őket;
2. Módszer neve – az általános modul olyan eljárása, amely a lehető legpontosabban írja le a kívánt algoritmust (a kiválasztás gombra kattintva megnyílik a rendelkezésre álló eljárások, amelyek ábrázolása az általános modul nevéből és az eljárás nevéből áll különböző oszlopokban táblázat);
3. Kulcs – nem annyira az ütemezett feladat egyediségét határozza meg, hanem inkább a feladat alapján elindított háttérfolyamat egyediségét, hosszkorlátja van;
4. Ütemezés – cikkünk külön bekezdését szenteljük ennek az elemnek a leírásának;
5. Használat – ennek a jelölőnégyzetnek a bejelölése meghatározza a feladat tevékenységét, az IGAZ azt jelenti, hogy a feladat az ütemezésnek megfelelően indul el és hajtódik végre;
6. Előre definiált – ha egy elemnél ez a jelölőnégyzet van, ezek a feladatok nem törölhetők, automatikusan létrejönnek, amikor a konfigurációt elmentik az adatbázisba;
7. Ismétlések száma - ha kivétel történik a végrehajtás során, akkor újraindul, így nem jön létre végtelen ciklus, a program korlátozza az újraindítások számát;
8. Újrapróbálkozási időköz – a rendellenesen befejezett feladatok újraindításai között eltelt idő másodpercben.

Nézzük meg közelebbről a menetrendet.

A rutinfeladat ütemezése

3. ábra

Mindenekelőtt az ablak alsó részére kell figyelni, itt jelennek meg a részletes információk, lebontva, hogy a feladat milyen gyakran és mikor kerül végrehajtásra.

"Általános lap:

• Feladat kezdési dátuma;
• A feldolgozás befejezési dátuma;
• A feladat ismétlésének gyakorisága.

Ha ezen a lapon nincs megadva dátum, akkor a feladatra nem lesz határidő beállítva.

„Napi” fül (4. ábra)
4. ábra

A feladat kezdési és befejezési idejét, valamint napközbeni indítási gyakoriságát jelző beviteli mezők mellett tartalmaz egy táblázatos részt a végrehajtás gyakoriságának részletes beállításához.

A „Napi” és a „Heti” fülek a megfelelő időszakokra vonatkozó információkat tartalmaznak.

A működés jellemzői

A munka kliens-szerver verziójában a rutinfeladatok végrehajtását a szerver eszközök határozzák meg. Az adminisztrációs konzolról engedélyezheti vagy letilthatja egy adott adatbázishoz tartozó feladatok futtatásának lehetőségét.

A munka fájlverziójával sokkal bonyolultabb a helyzet. Egy bizonyos platformkiadás előtt a háttér- és rutinfolyamatokat csak akkor hajtották végre, ha az ExecuteTaskProcessing() metódus aktiválva volt, amikor a rendszer egy bizonyos felhasználó alatt elindult. Ebben az esetben az algoritmusok időszakosan indultak el, amíg a módszert kezdeményező felhasználó a programban volt.

Jelenleg a munka fájlverziójában a háttérfeladatok munkája egyenletesen oszlik el az adatbázisban jogosult felhasználók között, ha a program az AllowExecuteSheduledJobs kiegészítő paraméterrel indult, akkor ez a folyamat lesz felelős a rutin karbantartásért.

Teljesen letilthatja a háttér- és rutinmunkát egy fájl módban futó adatbázisban, ha törli vagy átnevezi az adatbázist tartalmazó mappában található DoNotCopy.txt fájlt. A fájl jelenléte azt jelzi a platformnak, hogy a munka az eredetiben, és nem az adatbázis másolatában történik.

Ezenkívül a szabványos 1C szállításokban lehetővé vált az ütemezett munka közvetlenül a programból történő kezelése anélkül, hogy bemenne a „Configurator”-ba. A “ZUP” konfigurációban, 3.1.3.223-as verzióban az Adminisztráció->Karbantartás->Rutin műveletek->Rutin- és háttérfeladatok menüből nyithatja meg a kezelési űrlapot (5. ábra)
5. ábra

A megnyíló űrlap intuitív felülettel rendelkezik, és lehetővé teszi a következőket:

A feladatot közvetlenül az űrlapról is elindíthatja.

Valószínűleg az 1C 8.3 vagy 8.2 egyetlen komoly konfigurációja sem nélkülözheti a rutin- és háttérfeladatokat. Nagyon kényelmesek, mivel egyértelműen meghatározott ütemterv szerint kerülnek végrehajtásra, felhasználó vagy programozó beavatkozása nélkül.

Például naponta egyszer kell adatot cserélnie egy másik programmal. A rutin és a háttérfeladatok segítségével az 1C képes lesz önállóan végrehajtani ezeket a műveleteket, például munkaidőn kívül. Ez a módszer semmilyen módon nem befolyásolja a felhasználói élményt, és időt takarít meg.

Először is nézzük meg, mit jelentenek, és mi a különbségük:

• Ütemezett feladat lehetővé teszi bármely konkrét művelet elindítását egy előre konfigurált ütemezés szerint.
• Háttér munka egy objektum, amely tartalmazza a végrehajtandó műveleteket.

Tételezzük fel, hogy cégünk árul valamit, és van saját weboldala, amelyen az árak megtalálhatók. A relevanciájuk megőrzése érdekében naponta egyszer szeretnénk feltölteni őket.

Nyissa meg a konfigurációt, és adjon hozzá egy ütemezett feladatot.

Tulajdonságok beállítása

Nézzük meg a legfontosabb paramétereket, amelyeket ki kell tölteni a tulajdonságaiban.

• mezőben " A módszer neve» egy adott általános modul eljárását választja ki, amely közvetlenül végrehajtásra kerül. Jelzi az árak weboldalunkra történő feltöltésének minden lépését. Felhívjuk figyelmét, hogy a végrehajtás a szerveren történik. Ez logikus, mert a rutinműveleteket a felhasználó részvétele nélkül hajtják végre.
• Az ütemezett feladat szükség szerint letiltható vagy engedélyezhető. Nem kell minden alkalommal módosítani az ütemtervét. Ehhez a tulajdonságok palettán állítsa be vagy törölje a jelzőt " Használat».
• Egy másik fontos dolog annak beállítása, hogy ez a rutinfeladat lesz-e előre meghatározott, vagy nem. Az előre meghatározott ütemezett feladatok automatikusan elindulnak. Ha ez a funkció nincs telepítve, akkor programozottan kell elindítania őket, vagy használnia kell a „Task Console” feldolgozást az ITS-sel.
• Meg is adhatja az ismétlések száma és a köztük lévő intervallum rendellenes felmondás esetén. A rendellenes leállás azokra a helyzetekre vonatkozik, amikor a feladatokat hiba miatt nem fejezték be.

Ütemezés felállítása

Az utolsó lépés a webhelyre való feltöltés ütemezése a tulajdonságok palettán található megfelelő hiperhivatkozás segítségével.

Egy tipikus ütemezési beállítást láthat az 1C 8.3-ban. Nincs itt semmi bonyolult. Ebben a példában minden nap reggel öttől hétig beállítjuk az árak webhelyre történő feltöltését. Abban az esetben, ha az ütemezett feladatot 7:00 előtt nincs ideje elvégezni, az már másnap elkészül.

Ütemezett feladatok blokkolása

Futtassa az „Administering 1C Enterprise Servers” szabványos segédprogramot, és nyissa meg annak az információs bázisnak a tulajdonságait, ahol a rutinfeladatot létrehozta (az 1C kliens-szerver verzióihoz).

A megnyíló ablakban (miután megadta bejelentkezési nevét és jelszavát az információbiztonság eléréséhez), ellenőrizze, hogy a „Rutinfeladatok blokkolása engedélyezve van” jelölőnégyzet nincs-e bejelölve. Ha olyan helyzetbe ütközik, amikor a feladat nem működik, először ellenőrizze ezt a beállítást.

Ugyanígy teljesen letilthatja a rutinfeladatokat az 1C 8.3-ban. Adott háttérfeladatok letiltásához használhatja a „Background Job Console” feldolgozást, amely a legújabb kiadásokban található.

Háttér és ütemezett feladatok fájl módban

Ebben a módban ezeknek a feladatoknak a beállítása és elindítása sokkal nehezebben szervezhető. Leggyakrabban egy további fiók jön létre, amelynek munkamenete mindig nyitva lesz.

Ebben az esetben a rutinfeladatok a „RunTaskProcessing()” metódussal aktiválódnak.

Használhatja a következő konstrukciót is:

Az eljárás neveként meg kell adnia a végrehajtandó kliens eljárás nevét. Az intervallum azt mutatja, hogy hány másodperccel később kerül sor a végrehajtásra. Az „Egyszer” paraméter nem szükséges. Ez tükrözi, hogy ezt az eljárást egyszer vagy többször hajtják végre.

Követési hibák a háttérmunkákban

A naplóban megtekintheti a háttérben végzett feladatok előrehaladását, valamint a lehetséges hibák jelenlétét. A szűrőben válassza ki a „Háttérmunka” alkalmazást, és ha szükséges, válassza ki az érdeklődés fontosságát, például csak a „Hibák”.

A napló megjeleníti az összes olyan bejegyzést, amely megfelel a választásának, egy megjegyzéssel együtt, amely segít megérteni a hiba okát.

Az 1C ütemezett feladatokat úgy tervezték, hogy bizonyos eljárásokat ütemezetten, bizonyos gyakorisággal hajtsanak végre.

A rutinfeladatokat az információs bázis tárolja, és indítási ütemtervük van. Maga az indítás teljesen automatikus, ha az információs bázis kliens-szerver módban működik. Ha az adatbázis fájl alapú, akkor a következő lépéseket kell végrehajtania:

• rutinfeladatok elvégzésére speciális felhasználót rendeljen ki;
• e felhasználó alatt meg kell nyitni egy adatbázist, amelyben a funkciót időszakonként végre kell hajtani ExecuteTaskProcessing().

Rutinfeladat létrehozása

Az ütemezett feladatok egy 1C konfigurációs metaadat objektum. Az Általános csoportban található. Tekintsük a rutinfeladatok paramétereit és tulajdonságait.

A módszer neve— az export eljárás elérési útja az általános modulban, amely adott ütemezés szerint kerül végrehajtásra. Az eljárást a szerveren kell végrehajtani. Ebből a szempontból a rutinfeladatok némileg hasonlóak egy objektumhoz Iratkozz fel az eseményre.

Kulcs— lehetővé teszi több azonos típusú rutinfeladat létrehozását. Például több információs bázis közötti adatszinkronizálás megvalósítható egyetlen metaadat objektum használatával Rutinfeladat, miközben több rutinfeladat is létrejön (a cserélendő adatbázisok számától függően). Ezeket a rutinfeladatokat a tulajdonság segítségével megkülönböztetjük Kulcs. Egyszerre csak egy feladat hajtható végre ugyanazzal a kulccsal.

Használat— zászló, amely jelzi, hogy az ütemezett feladat engedélyezve van-e.

Előre meghatározott— itt egy analógiát vonhatunk le előre meghatározott könyvtárelemekkel. Az előre meghatározott elemek a konfigurátorban jönnek létre, és a felhasználók munkájuk során használják őket. A felhasználó maga hoz létre hétköznapi elemeket. Ugyanez a helyzet a rutinfeladatokkal: ha előre definiálva van, akkor létezik, és a konfigurátorban történő létrehozás után azonnal ütemezetten végrehajtható. Ha a zászló Előre meghatározott nincs telepítve, akkor a felhasználónak létre kell hoznia egy vagy több ilyen típusú rutinfeladatot (például keresztül Munkakonzol).

Az újrapróbálkozások száma, ha egy job rendellenesen fejeződik be— meghatározza, hogy egy háttérfeladat hányszor induljon újra, ha hibásan fejeződött be.

Újrapróbálkozási időköz, ha a munka rendellenesen fejeződik be— meghatározza, hogy milyen gyakran induljon újra a háttérfeladat, ha hibásan fejeződött be.

Programmunka rutinfeladatokkal

Ezekben a példákban a szokásos, nem előre meghatározott, rutinfeladatokkal való munkavégzést fogjuk megfontolni.

Rutinfeladat programozott létrehozása

//Feladat létrehozása
"Rendszeres feladatnév") ;

//Az ütemezett feladat kulcsának beállítása (opcionális)
Gyakorlat. Key = "TaskKey" ;

//Rutinfeladat engedélyezése
Gyakorlat. Használat = Igaz ;

//Rutinfeladat írása
Gyakorlat. Ír() ;

Ütemezett feladat programozott fogadása a paraméterek módosításához

Ebben a példában tegyük fel, hogy csak egy adott típusú rutinfeladat létezik. Ha több feladat van, akkor a ismeretében nem nehéz megfelelő változtatásokat végrehajtani a kódon.

"RoutineTaskName"] ) ) ;

Ha Feladatok. Mennyiség() > 0 Akkor
Munka= Munkák[ 0 ] ;

Másképp
Task = RegularTasks. rutinfeladat létrehozása( "RoutineTaskName") ;

EndIf ;

//A rutinfeladat a Task változóban található. Meg lehet változtatni a paramétereit.

Egy rutinfeladat ütemezésének módosítására szolgáló párbeszédablak meghívása

Létezik egy speciális párbeszédtípus a rutinfeladatok ütemezésével való munkavégzéshez. Továbbra is feltételezzük, hogy csak egy ilyen típusú rutinfeladatunk van.

//Készítsen egy tömböt a szükséges típusú rutinfeladatokkal
Feladatok = Rendszeres feladatok. Get RoutineTasks(new Structure("Metadata" , Metadata. RoutineTasks[ "RoutineTaskName"] ) ) ;

//Ha a feladat létezik, akkor feltétel szerint egy
Ha Feladatok. Mennyiség() > 0 Akkor
Munka= Munkák[ 0 ] ;

//Ha nincs feladat, hozza létre
Másképp
Task = RegularTasks. rutinfeladat létrehozása( "RoutineTaskName") ;

EndIf ;

Schedule=Feladat. Menetrend;

//Plalógus létrehozása egy rutinfeladat ütemezésének módosításához
Szerkesztési párbeszédpanel = Új ütemezési párbeszédpanel a Rutinfeladathoz (Ütemezés) ;

//A párbeszédablak megjelenítése a felhasználónak és az ütemezés módosításainak feldolgozása
IfEditDialog. OpenModal() Akkor
Gyakorlat. Ütemezés = Edit Dialog. Menetrend;
Gyakorlat. Ír() ;
EndIf ;