Când lucrați în 1C, există multe operațiuni de rutină care trebuie lansate sau programate pentru a efectua una sau alta acțiune, de exemplu: postarea documentelor sau încărcarea datelor în 1C de pe un site web.

Am postat recent un articol: E timpul să automatizăm acest lucru:

Sarcini de rutină și de fundal

Motorul de job este proiectat pentru a executa orice aplicație sau funcționalitate conform unui program sau asincron.

Mecanismul sarcinii rezolvă următoarele probleme:

• Abilitatea de a defini proceduri de reglementare în etapa de configurare a sistemului;
• Executarea actiunilor specificate conform programului;
• Efectuarea unui apel la o anumită procedură sau funcție în mod asincron, de ex. fără a aștepta finalizarea acestuia;
• Urmărirea progresului unei sarcini specifice și obținerea stării de finalizare a acesteia (o valoare care indică dacă a avut succes sau nu);
• Obținerea unei liste de sarcini curente;
• Abilitatea de a aștepta finalizarea uneia sau mai multor sarcini;
• Managementul jobului (posibilitate de anulare, blocare a executiei etc.).

Mecanismul de lucru este format din următoarele componente:

• Metadatele sarcinilor de rutină;
• Sarcini regulate;
• Locuri de muncă de fundal;
• Planificator de sarcini.

Lucrările de fundal și sunt concepute pentru a îndeplini sarcinile aplicației în mod asincron. Sarcinile de fundal sunt implementate folosind limbajul încorporat.

Sarcini programate și sunt concepute pentru a îndeplini sarcinile aplicației conform unui program. Sarcinile de rutină sunt stocate în baza de informații și sunt create pe baza metadatelor definite în configurație. Metadatele unei sarcini de reglementare conțin informații precum numele, metoda, utilizarea etc.

O sarcină de rutină are un program care determină la ce momente trebuie executată metoda asociată sarcinii de rutină. Programul, de regulă, este specificat în baza de informații, dar poate fi specificat și în etapa de configurare (de exemplu, pentru sarcini de rutină predefinite).

Programatorul de sarcini este utilizat pentru a programa execuția sarcinilor de rutină. Pentru fiecare job programat, planificatorul verifică periodic dacă data și ora curente se potrivesc cu programarea jobului programat. Dacă se potrivește, planificatorul atribuie acea sarcină execuției. Pentru a face acest lucru, pentru această sarcină programată, planificatorul creează o sarcină de fundal, care realizează procesarea efectivă.

Cred că este suficient cu descrierea - să trecem la implementare:

Crearea unei sarcini de rutină

Numele metodei– calea către procedura care va fi executată într-un job de fundal conform unui program dat. Procedura trebuie să fie într-un modul comun. Se recomandă să nu utilizați module comune standard, ci să vă creați propriile module. Nu uitați că joburile de fundal rulează pe server!

Utilizare– semn de utilizare a unei sarcini de rutină.

Predeterminat– indică dacă sarcina de rutină este predeterminată.

Dacă doriți ca sarcina de rutină să funcționeze imediat după ce a fost plasată în baza de date, specificați atributul Predeterminat. În caz contrar, va trebui să utilizați procesarea „Job Console” sau să declanșați ca sarcina să ruleze în mod programatic.

Numărul de reîncercări atunci când un job se încheie anormal– de câte ori a fost repornit jobul de fundal dacă a fost executat cu o eroare.

Interval de reîncercare când jobul se termină anormal– cât de des va fi repornită lucrarea de fundal dacă a fost finalizată cu o eroare.

Stabilirea unui program

Programa finalizarea sarcinii:

În fiecare oră, doar o zi	Perioada RepeatDays = 0, Perioada RepeatDays = 3600
În fiecare zi, o dată pe zi	Perioada RepeatDays = 1, Perioada RepeatDays = 0
O zi, o dată	PeriodRepeatDays = 0
Din două în două zile, o dată pe zi	PeriodRepeatDays = 2
În fiecare oră de la 01.00 la 07.00 în fiecare zi	PeriodRepeatDays = 1RepeatPeriodDuringDay = 3600StartTime = 01.00 Ora de încheiere = 07.00
În fiecare sâmbătă și duminică la ora 09.00	Perioada RepeatDays = 1WeekDays = 6, 7StartTime = 09.00
În fiecare zi timp de o săptămână, săriți peste o săptămână	PeriodRepeatDays = 1PeriodWeeks = 2
La ora 01.00 o dată	Ora de începere = 01.00
Ultima zi a fiecărei luni la ora 9:00.	PeriodRepeatDays = 1DayInMonth = -1StartTime = 09.00
A cincea zi a fiecărei luni la ora 9:00	PeriodRepeatDays = 1DayInMonth = 5StartTime = 09.00
A doua zi de miercuri a fiecărei luni la ora 9:00	PeriodRepeatDays = 1DayWeekMonth = 2DaysWeek = 3 Ora de începere = 09.00

Caracteristici de execuție a joburilor de fundal în variante de fișier și client-server

Mecanismele de executare a joburilor de fundal în versiunile fișier și client-server sunt diferite.

În versiune de fișier trebuie să creați un proces dedicat clientului care va efectua lucrări de fundal. Pentru a face acest lucru, procesul client trebuie să apeleze periodic funcția context global ExecuteJobProcessing. Doar un proces client pe bază de informații ar trebui să proceseze joburi de fundal (și, în consecință, să apeleze această funcție). Dacă nu a fost creat un proces client pentru a procesa joburi de fundal, atunci când accesați programatic motorul de job, va fi afișată eroarea „Job Manager is not active”. Nu este recomandat să utilizați un proces client care procesează joburi de fundal pentru alte funcții.

Odată ce procesul client care procesează joburile de fundal este pornit, alte procese client pot accesa programatic motorul jobului de fundal, de exemplu. poate rula și gestiona joburi de fundal.

În versiunea client-server Pentru a executa joburi de fundal, se folosește un planificator de activități, care se află fizic în managerul de cluster. Pentru toate joburile de fundal aflate în coadă, planificatorul primește procesul de lucru cel mai puțin încărcat și îl folosește pentru a rula jobul de fundal corespunzător. Procesul de lucru execută jobul și notifică planificatorul despre rezultatele execuției.

În versiunea client-server, este posibilă blocarea execuției sarcinilor de rutină. Executarea sarcinilor de rutină este blocată în următoarele cazuri:

• Pe baza de informații a fost instalată o blocare explicită a sarcinilor de rutină. Blocarea poate fi setata prin consola cluster;
• Există un bloc de conexiune în baza de informații. Blocarea poate fi setata prin consola cluster;
• Metoda SetExclusiveMode() cu parametrul True a fost apelată din limbajul încorporat;
• În alte cazuri (de exemplu, la actualizarea configurației bazei de date).

Procesarea lansării și vizualizarea sarcinilor programate poti descarca aici.

Probabil că fiecare programator 1C 8.3 mai devreme sau mai târziu a trebuit să configureze execuția anumitor sarcini într-un program. Mai jos voi oferi o descriere detaliată a acestor mecanisme, sper că acestea vor fi informații utile pentru programatorii începători 1C. Acest lucru este foarte convenabil, deoarece nu necesită acțiune umană, sarcina de rutină este configurată o singură dată și funcționează conform programului dvs.

Veți găsi instrucțiuni detaliate folosind un exemplu de mai jos.

Care sunt sarcinile de rutină și de fundal în 1C

• Sarcini programate este un mecanism special 1C enterprise 8.3 conceput pentru a efectua o acțiune specifică conform unui program dat.
• Lucru de fundal- obiecte generate de o sarcină de rutină care realizează direct acțiunea intenționată fără participarea utilizatorului sau a programatorului 1C 8.2.

Mecanismul joburilor programate și de fundal funcționează în modul client-server (SQL), datorită funcționalității DBMS. Dacă aveți o bază de date de fișiere, atunci și sarcina poate fi configurată, dar după un principiu puțin diferit.

Configurarea joburilor de fundal în modul client-server 1C

Mai întâi, să creăm un nou obiect de metadate - o sarcină de rutină. Îmi voi numi sarcina „Încărcare cursuri valutare”. Să ne uităm la paleta de proprietăți a acestui obiect de configurare:

Obțineți 267 de lecții video pe 1C gratuit:

• Numele metodei— calea către procedura care va fi executată într-un job de fundal conform unui program dat. Procedura trebuie să fie într-un modul comun. Este recomandat să nu folosiți cele standard, ci să vă creați propriile. Nu uitați că joburile de fundal rulează pe server!
• Utilizare— un semn de utilizare a unei sarcini de rutină.
• Predeterminat— indică dacă sarcina de rutină este predeterminată. Dacă doriți ca sarcina de rutină să funcționeze imediat după ce a fost plasată în baza de date, specificați acest indicator. În caz contrar, va trebui să utilizați procesarea Job Console sau să faceți ca jobul să ruleze în mod programatic.
• Numărul de reîncercări atunci când un job se încheie anormal— de câte ori a fost repornit jobul de fundal dacă a fost executat cu o eroare.
• Interval de reîncercare când jobul se termină anormal— cât de des va fi repornită lucrarea de fundal dacă a fost finalizată cu o eroare.

Și cel mai interesant decor este Programa:

Aici configurați intervalul de lansare al procedurii specificate în câmpul „Numele metodei”. Să zicem că am configurat

Atenţie! Nu uitați să dezactivați blocarea execuției joburilor de rutină și de fundal la nivel DBMS!

Acest lucru se poate face în utilitarul de administrare al versiunii client-server sau la crearea unei noi baze de date:

Configurarea sarcinilor de rutină în modul fișier 1C

În modul fișier, configurarea unor astfel de lucrări este ceva mai dificilă. Pentru o astfel de sarcină, trebuie lansată o sesiune separată a programului 1C. Acest lucru este adesea rezolvat prin crearea unui utilizator „tehnic” a cărui sesiune rulează mereu.

În modul fișier, un job de rutină este inițializat atunci când este lansată metoda „RunTaskProcessing()”.

Pentru un anumit utilizator, puteți configura această metodă să ruleze folosind o altă metodă -

ConnectWaitHandler( <ИмяПроцедуры>, <Интервал>, <Однократно>).

• Numele procedurii— numele procedurii conectate ca operator de așteptare. Numele procedurii exportate a unui modul de aplicație gestionat (un modul de aplicație obișnuit) sau a unui modul partajat global. Procedura trebuie să fie localizată pe client.
• Interval— perioada dintre execuțiile operațiunilor în secunde.
• O dată- cum să finalizați sarcina, o dată sau nu.

ConnectWaitHandler, 3600);

Un videoclip de două minute care arată cum să configurați o sarcină de rutină în configuratorul 1C:

Sarcinile programate în 1C sunt concepute pentru a efectua anumite proceduri într-un program, cu o anumită frecvență.

Sarcinile de rutină sunt stocate în baza de informații și au un program de lansare. Lansarea în sine este complet automată dacă baza de informații funcționează în modul client-server. Dacă baza de date este bazată pe fișiere, atunci trebuie să efectuați următorii pași:

• alocați un utilizator special pentru a efectua sarcini de rutină;
• sub acest utilizator trebuie deschisă o bază de date, în care funcția trebuie executată periodic ExecuteTaskProcessing().

Crearea unei sarcini de rutină

Sarcinile programate sunt un obiect de metadate de configurare 1C. Situat în grupul General. Să luăm în considerare parametrii și proprietățile sarcinilor de rutină.

Numele metodei— calea către procedura de export din modulul general, care va fi executată conform unui program dat. Procedura trebuie executată pe server. În acest sens, sarcinile de rutină sunt oarecum asemănătoare cu un obiect Abonați-vă la eveniment.

Cheie— vă permite să creați mai multe sarcini de rutină de același tip. De exemplu, sincronizarea datelor între mai multe baze de informații poate fi implementată folosind un singur obiect de metadate Sarcină de rutină, în timp ce mai multe sarcini de rutină în sine vor fi create (în funcție de numărul de baze de date pentru schimb). Aceste sarcini de rutină vor fi diferențiate folosind proprietatea Cheie. Numai un job cu aceeași cheie poate fi executat la un moment dat.

Utilizare— un indicator care indică dacă sarcina programată este activată.

Predeterminat— aici putem face o analogie cu elemente de director predefinite. Elementele predefinite sunt create în configurator și utilizate de utilizatori în munca lor. Utilizatorul creează el însuși elemente obișnuite. La fel este și cu sarcinile de rutină: dacă este predefinit, atunci există și poate fi executat conform unui program imediat după creare în configurator. Dacă steagul Predeterminat nu este instalat, atunci utilizatorul trebuie să creeze una sau mai multe sarcini de rutină de acest tip (de exemplu, prin Job Console).

Numărul de reîncercări atunci când un job se încheie anormal— determină de câte ori va fi repornită o lucrare de fundal dacă a fost finalizată cu o eroare.

Interval de reîncercare când jobul se termină anormal— determină cât de des va fi repornită lucrarea de fundal dacă a fost finalizată cu o eroare.

Programează lucrul cu sarcini de rutină

În aceste exemple, vom lua în considerare lucrul cu sarcini obișnuite, nepredefinite, de rutină.

Crearea programatică a unei sarcini de rutină

//Creează o sarcină
„RegularTaskName”) ;

//Setați cheia pentru sarcina programată (opțional)
Exercițiu. Cheie = "TaskKey" ;

//Activați sarcina de rutină
Exercițiu. Utilizare = Adevărat;

//Scrie o sarcină de rutină
Exercițiu. Scrie() ;

Primirea programatică a unei sarcini programate pentru modificarea parametrilor

În acest exemplu, presupuneți că există o singură sarcină de rutină de un anumit tip. Dacă există mai multe sarcini, atunci, știind , nu este dificil să faceți modificările corespunzătoare la cod.

„Nume sarcină de rutină”] ) ) ;

Dacă Sarcini. Cantitate() > 0 Atunci
Job= Jobs[ 0 ] ;

In caz contrar
Task = RegularTasks. Creați sarcină de rutină( „Nume sarcină de rutină”) ;

EndIf ;

// Sarcina de rutină este în variabila Task. Puteți modifica parametrii acestuia.

Apelarea casetei de dialog pentru modificarea programului unei sarcini de rutină

Există un tip special de dialog pentru lucrul cu programul unei sarcini de rutină. Încă presupunem că avem o singură sarcină de rutină de acest tip.

//Obțineți o matrice cu sarcini de rutină de tipul necesar
Sarcini = Sarcini obișnuite. Obține Sarcini de rutină(structură nouă ("Metadate", Metadate. Sarcini de rutină[ „Nume sarcină de rutină”] ) ) ;

//Dacă sarcina există, atunci prin condiție este una
Dacă Sarcini. Cantitate() > 0 Atunci
Job= Jobs[ 0 ] ;

//Dacă nu există nicio sarcină, creați-o
In caz contrar
Task = RegularTasks. Creați sarcină de rutină( „Nume sarcină de rutină”) ;

EndIf ;

Schedule=Sarcina. Programa;

//Creează un dialog pentru modificarea programului unei sarcini de rutină
Dialog de editare = New ScheduleDialog al RoutineTask (Schedule) ;

//Afișează dialogul utilizatorului și procesează modificările programului
DacăEditDialog. OpenModal() Apoi
Exercițiu. Program = EditDialog. Programa;
Exercițiu. Scrie() ;
EndIf ;

Lucrările de fundal din 1C pot fi lansate automat conform unui program (adică sunt instanțe de joburi de rutină), sau dezvoltatorul însuși poate iniția lansarea unui job de fundal pentru a executa un algoritm arbitrar (un exemplu izbitor este generarea de rapoarte în fundalul).
IMPORTANT!!! Pentru bazele de date de fișiere, începând cu versiunea platformei 8.3.3.641, nu este necesară lansarea unei sesiuni separată în care vor fi executate joburi de fundal. Acestea. Anterior, în bazele de date de fișiere, pentru a rula joburi de fundal, era necesar să se execute metoda contextului global „RunTaskProcessing()”. Detalii la acest link.

Procedura pentru rularea unui algoritm arbitrar într-un job de fundal

Pentru a rula algoritmul nostru într-un job separat de fundal, vom folosi metoda "Alerga()" manager de post de fundal: Sintaxă: A executa(<ИмяМетода>, <Параметры>, <Ключ>, <Наименование>)

• <ИмяМетода>(necesar); Tip: șir
  Numele procedurii exportate sau al funcției unui modul comun non-global care poate fi executat pe server, sub forma ModuleName.MethodName.
• <Параметры>(optional); Tip: matrice
  O serie de parametri trecuți metodei. Numărul și tipurile de parametri trebuie să se potrivească cu parametrii metodei. (mai multe detalii în Syntax Assistant)
• <Ключ>(optional); Tip: șir
  Dacă este specificată o cheie, aceasta trebuie să fie unică printre cheile joburilor de fundal active care au același nume de metodă ca și jobul de fundal.
• <Наименование>(optional); Tip: șir.
  Descrierea sarcinii.

Procedura pentru rularea unui job de fundal

În cazul nostru, vom folosi procedura de export situată în modulul general „GeneralModuleServer”(Cred că nu este necesar să explicăm faptul că modulul trebuie să fie pe partea de server) Procedură Scrieți informații DESPRE Produse în fundal (Parametrul de activitate de fundal) Solicitare de export de date = Solicitare nouă ("SELECT | Produse. Link AS Nomenclatură | FROM | Director. Nomenclatură Produse AS"); Fetch = DataRequest.Execute().Select(); While Selection.Next() MH Cycle = Registre de informații.Date de produs.CreateRecordManager(); MZ.Period = CurrentDate(); MZ.Nomenclature = Sampling.Nomenclature; MH.Information = BackgroundTaskParameter; MZ.Write(); EndCycle; Sfârșitul procedurii Pentru a demonstra funcționarea jobului de fundal, vom crea înregistrări în registrul nostru de informații pentru fiecare articol, iar parametrul va fi transmis din forma în care este lansat jobul de fundal.

Comanda de pornire a lucrării de fundal

Parametrul pe care îl vom trece în procedura de execuție va fi preluat din atributul formularului gestionat (atribut de tip „String”):

Codul modulului de formular gestionat va arăta astfel: &În procedura client StartBackgroundJob(Command) StartBackgroundJobOnServer(); Sfârșitul procedurii &Pe server Procedura Start Job Background On Server () // Formează o matrice cu parametrii Job Parameters = New Array; JobParameters.Add(TaskParameter); // Începem execuția în fundal a algoritmului BackgroundTasks.Execute(// Metoda noastră de export în modulul general „GeneralModuleServer.WriteInformationOnProductsInBackground”, // Trecem o matrice cu parametriTaskParameters, // Specificăm cheia de activitate New UniqueIdentifier, // Specificăm numele jobului de fundal „Lucrul nostru de fundal”); Sfârșitul procedurii

Rezultatul executiei

Ca urmare a executării jobului de fundal, vor fi generate intrări în registrul de informații (de care aveam nevoie).

Concept de programare asincronă

Conceptul de programare asincronă este că rezultatul unei funcții nu este disponibil imediat, ci după un timp sub forma unui apel asincron (încălcând ordinea normală de execuție).

Acestea. Ideea principală a programării asincrone este de a emite apeluri individuale de metodă și de a continua să facă alte lucrări în paralel fără a aștepta ca apelurile să se termine.

Unele metode care minimizează probabilitatea excepțiilor nu necesită o abordare asincronă, dar altele o necesită chiar la începutul dezvoltării.

După cum se poate observa din grafice, nu există un coeficient de acțiuni interactive utile ale utilizatorului cu un model de programare sincronă, deoarece sistemul blochează interfața cu utilizatorul, în timp ce cu un model asincron, utilizatorul continuă să lucreze activ în sistem.

Când rulează sincron, aplicația are un singur fir. Cu modelul de programare asincronă, puteți rula mai multe fire de execuție în paralel și puteți reacționa la noile acțiuni ale utilizatorului pe măsură ce rulează. Odată ce n-thread-ul este executat, afișați rezultatul pe ecran.

Sarcini de fundal în 1C: Enterprise 8

În 1C:Enterprise 8, joburile de fundal sunt concepute pentru a îndeplini sarcinile aplicației în mod asincron. Ele pot genera joburi de fundal copii, de exemplu, pentru a paraleliza calcule complexe pe diferite servere de lucru ale clusterului într-un mod de operare client-server.

Este posibil să se restricționeze execuția joburilor de fundal care au aceleași metode pe baza unui criteriu de aplicare specific. Crearea și gestionarea programatică a joburilor de fundal este posibilă de la orice conexiune de utilizator la baza de informații de sistem. Lucrarea de fundal rulează în numele utilizatorului care a creat-o.

Mecanismul sarcinilor funcționează atât în ​​modul de operare client-server, cât și în modul fișier, dar capacitățile de administrare și executare a sarcinilor în ambele versiuni sunt oarecum diferite.

Opțiune client-server

În versiunea client-server, programarea sarcinilor este efectuată de planificatorul de sarcini, care este localizat fizic în managerul de cluster.

Programatorul verifică periodic pentru a vedea dacă au fost primite solicitări pentru a rula joburi în fundal. Dacă există joburi care trebuie executate, planificatorul determină procesele de lucru cel mai puțin încărcate din cluster și atribuie succesiv fiecăruia sarcina de executat. Astfel, același proces de lucru poate executa mai multe joburi în paralel. După ce un job este primit de un proces de lucru, procesul de lucru stabilește o conexiune la baza de informații și execută jobul în cadrul acelei conexiuni. După finalizarea lucrării, procesul de lucru notifică planificatorul dacă lucrarea a fost finalizată cu succes sau fără succes.

Opțiunea fișier

Începând cu versiunea 8.3.3.641 a platformei, dezvoltatorii au simplificat semnificativ munca cu joburi de fundal în versiunea de fișier.

Anterior, pentru a executa automat sarcini, era necesar să se lanseze o sesiune suplimentară separată 1C:Enterprise, folosită ca planificator de sarcini. Și în această sesiune a fost necesar să se execute periodic metoda limbajului încorporat ExecuteTaskProcessing(). Această abordare a fost destul de greoaie, incomodă și a limitat foarte mult utilizarea sarcinilor de bază și de rutină în versiunea fișierului de lucru.

Acum totul a devenit mult mai ușor. Dacă pornește un client subțire sau gros și, de asemenea, dacă serverul web are conexiuni client, atunci în fiecare dintre aceste aplicații este lansat automat un alt fir cu o conexiune la baza de date. Aceste fire sunt angajate în îndeplinirea sarcinilor de bază și de rutină.

Fiecare dintre aplicațiile enumerate își realizează propriile sarcini de fundal. Dacă o aplicație a inițiat mai multe joburi de fundal, acestea sunt executate secvenţial, în ordinea în care au fost primite.

Dezavantajul evident al joburilor de fundal 1C: deoarece sunt executate pe partea de server, nu există posibilitatea de a lucra interactiv cu utilizatorul (de exemplu, este imposibil să se afișeze un mesaj sau alte informații; toate aceste date trebuie să fie stocate în baza de informații și prelucrate în continuare în într-un fel).

Trebuie remarcat faptul că joburile de fundal sunt obiecte pur software și nu pot fi stocate în baza de date. Adică, putem doar să creăm o instanță a unei clase, să-i inițializam proprietățile și să o lansăm pentru execuție.

Un exemplu de execuție a codului asincron în 1C:Enterprise 8

„Scrierea de programe în care rezultatul unui apel de funcție ajunge necunoscut când este mult mai dificilă decât cele obișnuite. Apeluri imbricate, gestionarea erorilor, control asupra a ceea ce se întâmplă - totul devine mai complicat”, doar cei care nu știu să folosească în mod corespunzător capacitățile platformei vor spune asta, dar nu noi!

Să demonstrăm simplitatea și eleganța execuției codului asincron în 1C:Enterprise 8!

Pasul 1. Să creăm un nou sistem de securitate a informațiilor pentru dezvoltarea configurației

Pasul 2.În configurare vom adăuga modulul general „Manetari asincroni”

De ce am adăugat un modul partajat? Totul este simplu aici: pentru a efectua operațiuni asincrone în 1C:Enterprise 8, se folosesc joburi de fundal, care au propriul manager - „BackgroundTask Manager”. Acest obiect are o metodă „Run”, cu ajutorul căreia este lansată sarcina de fundal.

Să trecem la asistentul de sintaxă.

Deci vom avea nevoie de un modul comun.

Pasul 3.În modulul general „Manetari asincroni” vom adăuga procedura de export OurLongOperation()

Procedura OurLongOperation(Duration) Export // Simularea unei acțiuni pe termen lung (Durata sec.). OperationStartDate = CurrentDate(); While CurrentDate() - Data de începere a operațiunii< Длительность Цикл КонецЦикла; КонецПроцедуры

Pasul 4. Adăugați procesarea „Concept de programare asincronă” la configurație (puteți crea procesare externă)

Adăugați un atribut la formular:

Durata (număr)

si doua echipe

Efectuați LongOperation;

Efectuați o operațiune lungă și lungă în mod asincron.

Pasul 5. Conform asistentului de sintaxă, completați modulul formular

&Pe Procedura Client Efectuați Operațiune de funcționare lungă (comandă) Execute Operațiune de funcționare lungă pe server(); EndProcedure &OnServer Procedure ExecuteLongOperationOnServer() AsynchronousHandlers.OurLongOperation(Duration); Sfârșitul procedurii &Pe procedura client Efectuați operațiune de lungă durată asincron (comandă) Efectuați operațiune de funcționare lungă asincron pe server (); Sfârșitul procedurii &Pe server Procedura Efectuați o operație de lungă durată asincron pe Server() Parametri = New Array; Parametri.Add(Durata); BackgroundTasks.Execute("AsynchronousHandlers.OurLongOperation", Parametri, New UniqueIdentifier, "Exemplu de concept de programare asincronă"); Sfârșitul procedurii

Pasul 6. Hai să lansăm și să verificăm!

Rezultat:

Dacă facem clic pe butonul „Efectuați operație lungă”, atunci interfața cu utilizatorul este blocată pentru „Durata” secunde;

Dacă facem clic pe butonul „Perform long-running operation asynchronously”, interfața cu utilizatorul nu este blocată și codul programului este executat în paralel.

Putem verifica dacă codul programului este executat asincron, analizând jurnalul.

Putem depana codul de program care rulează în „background” dacă setăm proprietatea corespunzătoare în parametrii de depanare.

Un exemplu de execuție a codului asincron în 1C:Enterprise 8 folosind BSP

Să luăm în considerare un exemplu de implementare a conceptului de programare asincronă în 1C:Enterprise 8 în BSP folosind exemplul de procesare „Afaceri curente”.

Logica este următoarea: la lansarea programului, se inițializează zona de lucru a paginii de start, unde poate fi afișat formularul de procesare „Afaceri curente”. Acest formular este completat de afacerile curente ale utilizatorului și este nevoie de timp pentru a-l completa. Dacă dezvoltatorii nu ar avea capacitatea de a executa codul asincron, atunci interfața cu utilizatorul ar fi blocată în timp ce formularul de procesare era completat!

Să analizăm codul de program al formularului.

Evenimentul formular „When CreatedOnServer” apelează procedura „RunBackgroundTask” - de asta avem nevoie.

Fără a fi distras de nuanțe, să analizăm această procedură

Și aici vedem că sunt utilizate managerul de job de fundal și metoda sa „Run”. Rețineți că dezvoltatorii stochează un ID unic pentru jobul de fundal.

Pentru a face acest lucru, dezvoltatorii folosesc metoda ConnectWaitHandler(<ИмяПроцедуры>, <Интервал>, <Однократно>).

În procedura agățată Connectable_CheckTaskComplete() dezvoltatorii apelează la o funcție JobCompleted(TaskID)

Această funcție verifică execuția unui job de fundal prin identificator.

Trebuie remarcat faptul că BSP a dezvoltat module generale pentru a sprijini operațiunile pe termen lung pe server.

Astfel, conceptul de programare asincronă din 1C:Enterprise 8 crește ușor complexitatea rezolvării problemelor pentru dezvoltator, dar îmbunătățește semnificativ funcționalitatea programului din punctul de vedere al utilizatorului.