Le processus de travail en arrière-plan s'est terminé anormalement. Le processus de travail en arrière-plan s'est terminé anormalement. Obtenir un objet de travail

Question : Le processus de travail en arrière-plan s'est écrasé...

Bonjour à tous et bonne semaine !)
Comptabilité d'entreprise, édition 3.0 (3.0.46.11).
Plateforme 8.3.9.2033.
Lors de la publication de documents en groupes, l'erreur « Le processus de travail en arrière-plan s'est terminé anormalement » se produit. Aucune raison n'est donnée...
Redémarrer le serveur SQL, le serveur 1C (on ne sait jamais) n'aide pas... Peut-être que quelqu'un a rencontré un problème similaire ??? Il est même difficile de dire quand cette erreur est apparue car nous n'avons pas utilisé l'exécution groupée (clôture du mois) depuis longtemps...

Répondre:() () Encore une fois bon après-midi) J'ai allumé le magazine technologique et j'ai trouvé ces choses intéressantes (peut-être savez-vous quel est le problème ?) :
Une tentative a été effectuée pour effectuer une opération sur un objet qui n'est pas un socket...
Le processus se termine. Appel sortant refusé...
Aucun serveur hébergeant le service n'a été trouvé...

Question : tâches en arrière-plan

Plateforme 1C : Entreprise 8.3 (8.3.9.2170), conf BP 3.0.
La configuration configure l'intégration via des sources de données externes (type SGBD - OracleDatabase). Un certain nombre de tables ont été ajoutées à partir desquelles les données de base et les transactions sont chargées. Parce que Il y avait beaucoup de données, il a donc été décidé de procéder à un téléchargement par lots via des tâches en arrière-plan. La taille des portions est de 100 000, la taille du lot est de 10 000, le nombre de transactions dans le document est de 1 000, le nombre de tâches en arrière-plan exécutées simultanément est de 8.
Je lance, charge, tout va bien. Mais si je le mets la nuit, j'ai l'impression que 1c passe en mode veille, c'est-à-dire après un certain temps, comme le montre le journal, les tâches en arrière-plan sont démarrées, mais pas terminées. En conséquence, il s'est avéré que les tâches commençaient à midi et se terminaient à 8 heures du matin (lorsque j'ai déplacé la souris) et après cela, elles ont continué à être exécutées en mode normal. Je l'ai exécuté sur des clients légers et lourds. Il y a un réglage dans les paramètres - le temps d'endormissement dans une session passive est de 1200, mais cela ne s'applique-t-il pas uniquement au client léger et cela pourrait-il être un problème ? Je ne veux pas désactiver cela, parce que... les utilisateurs ne quittent pas le programme, laissez-les s'endormir. Quelqu'un a-t-il rencontré un problème similaire ? Comment avez-vous décidé ?

Répondre:

Une telle possibilité n’existe pas.

Quel est l'intérêt d'exécuter un travail en arrière-plan et d'attendre qu'il se termine ?
pour ne pas créer plus de 8 tâches en arrière-plan ?

Faites glisser le "gestionnaire" des tâches d'arrière-plan vers le côté serveur et laissez-le contrôler....

J'ai exécuté 40 à 50 tâches en arrière-plan sur le Pentuim D840 - le vol était normal, puis il était limité par le processeur/la mémoire.

Question : Comment transférer un fichier vers un travail en arrière-plan

Plateforme 8.3.6.2152
Vous devez transférer le fichier d'UV vers une tâche en arrière-plan pour un traitement ultérieur.
J'ai fait ceci :
&SurClient
Procédure Command1 (Command) FileDD = New BinaryData (FileName); StorageAddressForBackground = PlaceInTemporaryStorage(FileDD, UniqueIdentifier); Démarrer UploadLoadOnServer(StorageAddressForBackground) EndProcedure &OnServer Fonction StartUploadLoadOnServer(StorageAddressForBackground) Paramètres de la méthode = Nouveau tableau ; MethodParameters.Add(StorageAddressForBackground); Job = BackgroundTasks.Run("MyGeneralModule.MyBackground", MethodParameters); FinFonction
Dans le module général :

Procédure MyBackground(StorageAddress) Export FileDD = GetFromTemporaryStorage(StorageAddress); Si TypeValue(FileDD) = Type("BinaryData") Alors Inscription au Journal Inscription au Journal("Débogage", "Pas de DD"); Fin si ; Fin de la procédure J'ai essayé ceci : PlacedFiles = New Array ; PlacedFiles.Add(NewDescriptionofTransferFile(FileName)); PlacedFiles = Nouveau tableau ; Si NON PlaceFiles(PlaceFiles, PlaceFiles, False, UniqueIdentifier) ​​​​​​Alors Return ; Fin si ; StorageAddressForBackground = PlacedFiles.Storage ; J'ai essayé ceci : StorageAddressForBackground = PlaceInTemporaryStorage(Undefined, UniqueIdentifier); PlaceFile (StorageAddressForBackground, FileName, False);
Il est normalement transféré de l'arrière-plan vers le client via un stockage temporaire, mais pour une raison quelconque, il n'est pas transféré du client vers l'arrière-plan.

Répondre: En général, tout s'est avéré assez simple. Il s'avère que vous pouvez bêtement transmettre des données binaires en tant que paramètre à un travail en arrière-plan. Pour que les amateurs non qualifiés puissent citer des références et leur dire que « c'est ainsi que cela était prévu », le code de travail est :
&SurClient
Procédure Command1 (Command) Démarrer UploadLoadOnServer (New BinaryData (FileName)) EndProcedure
Fonction &OnServer Paramètres de la méthode StartUploadLoadOnServer(DD) = Nouveau tableau ; MethodParameters.Add(DD); Job = BackgroundTasks.Run("MyGeneralModule.MyBackground", MethodParameters); EndFunctions Procédure MyBackground(FileDD) Exporter Si TypeValue(FileDD) = Type("BinaryData") Alors Inscription au Journal("Débogage", "Oui DD"); Sinon Inscription au Journal("Débogage", "Pas de DD"); Fin si ; Fin de la procédure

Question : Exécution d'un travail en arrière-plan sous l'utilisateur souhaité

Bonjour!
Il existe 1C:Enterprise 8.3 (8.3.11.2924), UT 11.3.4.93 client - serveur.
Dans cette configuration, les mouvements dans le registre « Règlements avec les clients sur documents » sont effectués non pas au moment de la comptabilisation des documents, mais avec la tâche de routine « Exécution des mouvements différés dans les règlements avec les clients\fournisseurs ».
En même temps, parfois la tâche de routine générait une erreur, car a tenté d'effectuer des mouvements dans une période fermée (Avant la date d'interdiction de montage). Dans les paramètres de la tâche de routine, nous avons enregistré un utilisateur spécial dont la date d'interdiction était ouverte, après quoi tout a commencé à fonctionner.
Il faut toutefois s'assurer que ces mouvements dans les registres soient effectués au moment de la comptabilisation du document, et non au moment où le travail en arrière-plan est démarré selon le planning.
Si vous exécutez le code lui-même, qui effectue une tâche de routine lors de la publication d'un document, la même erreur se produit : la période est fermée. Et si vous exécutez par programme une tâche en arrière-plan qui exécute le même code au moment où le document est publié, cela provoque exactement la même erreur, car la période est fermée, et le travail d'arrière-plan, lancé par programme, est lancé sous le nom de l'utilisateur actuel, et sa date d'interdiction est fermée. Cependant, lorsqu'un travail en arrière-plan est lancé selon un planning dans lequel le « bon » utilisateur est installé dans le planificateur, tout se passe en trombe. Voici comment procéder par programme, comment exécuter par programme une tâche en arrière-plan sous l'utilisateur souhaité "via le planificateur" comme le font les tâches planifiées standard, dites-moi s'il vous plaît ?

Répondre:

N'est-ce pas celui pour lequel il est configuré ?
Cela doit être un problème de configuration

Lis2007 a dit :

Bonjour ! Parfois, la tâche de routine générait une erreur car... a tenté d'effectuer des mouvements dans une période fermée (Avant la date d'interdiction de montage). Dans les paramètres de la tâche de routine, nous avons enregistré un utilisateur spécial dont la date de bannissement était ouverte, après quoi tout a commencé à fonctionner

Cliquez pour agrandir...

Question : Débogage d'un travail en arrière-plan

Le travail en arrière-plan s'exécute avec une erreur. J'ai décidé de le déboguer.
Je le lance via un traitement externe avec une seule ligne :
BackgroundTasks.Run("MonModule.MaTâche");
Le point d'arrêt dans le module n'est pas atteint.
Le débogage sur le serveur est autorisé, le débogage est vérifié, la connexion automatique, les tâches en arrière-plan sont activées. Quel autre pourrait être le problème ?

Répondre: Dans les modules courants, il y avait un appel à des fonctions qui nécessitaient une exécution client plutôt que serveur. J'ai dû les mettre entre parenthèses #If Client Then. Celui d’arrière-plan a également fonctionné.

Question : Erreur lors de l'exécution d'un échange

Bonjour, dites-moi où creuser :
J'effectue un échange dans la base de données comptable. Environ trois douzaines de documents sont téléchargés depuis UT-shka via un échange standard. Ils réfléchissent longuement (environ une heure) et terminent par le message :
Le processus de travail en arrière-plan s'est écrasé

Probablement, chaque programmeur 1C 8.3 a dû tôt ou tard configurer l'exécution de certaines tâches selon un calendrier. Ci-dessous, je vais donner une description détaillée de ces mécanismes, j'espère que ce sera une information utile pour les programmeurs 1C novices. C'est très pratique, car cela ne nécessite aucune action humaine, la tâche de routine est configurée une fois et fonctionne selon votre emploi du temps.

Vous trouverez des instructions détaillées à l’aide d’un exemple ci-dessous.

Que sont les tâches de routine et d'arrière-plan dans 1C

• Tâches planifiées est un mécanisme spécial 1C Enterprise 8.3 conçu pour effectuer une action spécifique selon un calendrier donné.
• Travail en arrière-plan- les objets générés par une tâche de routine qui exécutent directement l'action prévue sans la participation de l'utilisateur ou du programmeur 1C 8.2.

Le mécanisme des jobs planifiés et en arrière-plan fonctionne en mode client-serveur (SQL), grâce aux fonctionnalités du SGBD. Si vous disposez d'une base de données de fichiers, alors la tâche peut également être configurée, mais selon un principe légèrement différent.

Configuration des tâches d'arrière-plan en mode client-serveur 1C

Tout d’abord, créons un nouvel objet de métadonnées – une tâche de routine. J'appellerai ma tâche « Chargement des taux de change ». Regardons la palette des propriétés de cet objet de configuration :

Obtenez 267 leçons vidéo sur 1C gratuitement :

• Nom de la méthode— chemin vers la procédure qui sera exécutée dans un travail en arrière-plan selon un planning donné. La procédure doit être dans un module commun. Il est recommandé de ne pas utiliser de standards, mais de créer les vôtres. N'oubliez pas que les tâches en arrière-plan s'exécutent sur le serveur !
• Usage- un signe d'utilisation d'une tâche de routine.
• Prédéterminé— indique si la tâche de routine est prédéterminée. Si vous souhaitez que la tâche de routine fonctionne immédiatement après avoir été placée dans la base de données, spécifiez cet indicateur. Sinon, vous devrez utiliser le traitement Job Console ou exécuter le travail par programme.
• Nombre de tentatives lorsqu'une tâche se termine anormalement— combien de fois le travail en arrière-plan a été redémarré s'il a été exécuté avec une erreur.
• Intervalle de nouvelle tentative lorsque le travail se termine anormalement— à quelle fréquence le travail en arrière-plan sera redémarré s'il s'est terminé avec une erreur.

Et le paramètre le plus intéressant est Calendrier:

Ici, vous configurez l'intervalle de lancement de la procédure spécifié dans le champ « Nom de la méthode ». Disons que j'ai configuré

Attention! N'oubliez pas de désactiver le blocage de l'exécution des tâches de routine et d'arrière-plan au niveau du SGBD !

Cela peut être fait dans l'utilitaire d'administration de la version client-serveur ou lors de la création d'une nouvelle base de données :

Configuration des tâches de routine en mode fichier 1C

En mode fichier, la configuration de telles tâches est un peu plus difficile. Pour une telle tâche, une session distincte du programme 1C doit être lancée. Ce problème est souvent résolu en créant un utilisateur « technique » dont la session est toujours en cours d'exécution.

En mode fichier, un travail de routine est initialisé au lancement de la méthode « RunTaskProcessing() ».

Pour un utilisateur spécifique, vous pouvez configurer cette méthode pour qu'elle s'exécute en utilisant une autre méthode -

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

• Nom de la procédure— le nom de la procédure connectée en tant que gestionnaire d'attente. Nom de la procédure exportée d'un module d'application géré (un module d'application standard) ou d'un module partagé global. La procédure doit être localisée sur le client.
• Intervalle— période entre les exécutions des opérations en secondes.
• Une fois- comment terminer la tâche, une fois ou non.

ConnectWaitHandler, 3600 ) ;

Une vidéo de deux minutes qui montre comment mettre en place une tâche de routine dans le configurateur 1C :

Probablement, aucune configuration sérieuse sur 1C 8.3 ou 8.2 ne peut se passer de l'utilisation de tâches de routine et d'arrière-plan. Ils sont très pratiques, puisqu’ils seront exécutés selon un planning clairement défini sans intervention de l’utilisateur ou du programmeur.

Par exemple, vous devez échanger des données avec un autre programme une fois par jour. À l'aide de tâches de routine et d'arrière-plan, 1C pourra effectuer ces actions de manière indépendante, par exemple en dehors des heures de travail. Cette méthode n’affectera en rien l’expérience utilisateur et permettra de gagner du temps.

Tout d'abord, voyons ce qu'ils signifient et quelle est leur différence :

• Tâche planifiée vous permet de lancer des actions spécifiques selon un planning préconfiguré.
• Travail en arrière-plan est un objet qui contient les actions à effectuer.

Supposons que notre entreprise vend quelque chose et dispose de son propre site Web sur lequel les prix sont indiqués. Nous souhaitons les télécharger une fois par jour pour maintenir leur pertinence.

Ouvrez la configuration et ajoutez une tâche planifiée.

Définition des propriétés

Examinons les paramètres les plus importants qui doivent être renseignés dans ses propriétés.

• Dans le champ " Nom de la méthode» sélectionne la procédure d'un module général spécifique qui sera directement exécutée. Il indiquera toutes les étapes de mise en ligne des prix sur notre site Internet. Veuillez noter que l'exécution aura lieu sur le serveur. C'est logique, car les opérations de routine sont effectuées sans la participation des utilisateurs.
• La tâche planifiée peut être désactivée ou activée selon les besoins. Il n'est pas nécessaire de modifier son emploi du temps à chaque fois. Pour cela, dans la palette des propriétés, cochez ou décochez le drapeau " Usage».
• Une autre chose importante est de déterminer si cette tâche de routine sera prédéterminé, ou non. Les tâches planifiées prédéfinies sont lancées automatiquement. Si cette fonctionnalité n'est pas installée, vous devrez alors les lancer par programme ou utiliser le traitement « Task Console » avec ITS.
• Vous pouvez également préciser nombre de répétitions et intervalle entre elles en cas de résiliation anormale. L'arrêt anormal fait référence aux situations dans lesquelles les tâches n'ont pas été terminées en raison d'une erreur.

Mise en place d'un planning

La dernière étape consiste à établir un calendrier pour notre téléchargement sur le site à l'aide du lien hypertexte correspondant dans la palette des propriétés.

Vous verrez un paramètre de planification typique dans 1C 8.3. Il n'y a rien de compliqué ici. Dans cet exemple, nous avons mis en place le lancement de notre mise en ligne de tarifs sur le site tous les jours de cinq à sept heures du matin. Dans le cas où la tâche planifiée n'a pas le temps d'être terminée avant 7h00, elle sera terminée dès le lendemain.

Bloquer les tâches planifiées

Exécutez l'utilitaire standard « Administration des serveurs d'entreprise 1C » et ouvrez les propriétés de l'infobase dans laquelle vous avez créé la tâche de routine (pour les versions client-serveur de 1C).

Dans la fenêtre qui s'ouvre (après avoir saisi votre login et votre mot de passe pour accéder aux informations de sécurité), vérifiez que la case « Le blocage des tâches de routine est activé » n'est pas cochée. Si vous rencontrez une situation dans laquelle la tâche ne fonctionne pas, vérifiez d'abord ce paramètre.

De la même manière, vous pouvez désactiver complètement les tâches de routine dans 1C 8.3. Pour désactiver des tâches en arrière-plan spécifiques, vous pouvez utiliser le traitement « Console des tâches en arrière-plan » intégré aux dernières versions.

Tâches en arrière-plan et planifiées en mode fichier

Dans ce mode, la mise en place et le lancement de ces tâches sont beaucoup plus difficiles à organiser. Le plus souvent, un compte supplémentaire est créé dont la session sera toujours ouverte.

Dans ce cas, les tâches de routine sont activées à l'aide de la méthode « RunTaskProcessing() ».

Vous pouvez également utiliser la construction suivante :

Comme nom de procédure, vous devez spécifier le nom de la procédure client qui sera exécutée. L'intervalle indique combien de secondes plus tard l'exécution aura lieu. Le paramètre « Une fois » n'est pas obligatoire. Il indique si cette procédure sera effectuée une ou plusieurs fois.

Suivi des erreurs dans les tâches en arrière-plan

Vous pouvez visualiser la progression des tâches en arrière-plan, ainsi que la présence d'éventuelles erreurs, dans le journal. Dans le filtre, sélectionnez l'application « Travail en arrière-plan » et, si nécessaire, sélectionnez l'importance qui vous intéresse, par exemple uniquement « Erreurs ».

Le journal affichera toutes les entrées correspondant à votre sélection, ainsi qu'un commentaire qui vous aidera à comprendre la raison de l'erreur.

Concept de programmation asynchrone

Le concept de programmation asynchrone est que le résultat d'une fonction n'est pas immédiatement disponible, mais après un certain temps sous la forme d'un appel asynchrone (violant l'ordre normal d'exécution).

Ceux. L'idée principale de la programmation asynchrone est d'émettre des appels de méthodes individuels et de continuer à effectuer d'autres travaux en parallèle sans attendre la fin des appels.

Certaines méthodes qui minimisent la probabilité d'exceptions ne nécessitent pas une approche asynchrone, mais d'autres l'exigent au tout début du développement.

Comme le montrent les graphiques, il n'y a pas de coefficient d'actions utilisateur interactives utiles avec un modèle de programmation synchrone, puisque le système bloque l'interface utilisateur, tandis qu'avec un modèle asynchrone, l'utilisateur continue de travailler activement dans le système.

Lors d'une exécution synchrone, l'application n'a qu'un seul thread. Avec le modèle de programmation asynchrone, vous pouvez exécuter plusieurs threads en parallèle et réagir aux nouvelles actions de l'utilisateur lors de leur exécution. Une fois le n-thread exécuté, vous affichez le résultat à l’écran.

Tâches en arrière-plan dans 1C:Enterprise 8

Dans 1C:Enterprise 8, les tâches en arrière-plan sont conçues pour effectuer des tâches d'application de manière asynchrone. Ils peuvent générer des tâches enfants en arrière-plan, par exemple, pour paralléliser des calculs complexes sur différents serveurs de travail du cluster dans un mode de fonctionnement client-serveur.

Il est possible de restreindre l'exécution de jobs d'arrière-plan ayant les mêmes méthodes en fonction d'un critère d'application spécifique. La création et la gestion programmatiques des tâches en arrière-plan sont possibles à partir de n'importe quelle connexion utilisateur à la base d'informations du système. Le travail en arrière-plan s'exécute au nom de l'utilisateur qui l'a créé.

Le mécanisme de tâches fonctionne à la fois dans les modes de fonctionnement client-serveur et fichier, mais les capacités d'administration et d'exécution de tâches dans les deux versions sont quelque peu différentes.

Option client-serveur

Dans la version client-serveur, la planification des tâches est effectuée par le planificateur de tâches, qui se trouve physiquement dans le gestionnaire de cluster.

Le planificateur vérifie périodiquement si des demandes ont été reçues pour exécuter des tâches en arrière-plan. Si des tâches doivent être exécutées, le planificateur détermine les processus de travail les moins chargés du cluster et attribue séquentiellement à chacun d'eux sa tâche à exécuter. Ainsi, le même processus de travail peut potentiellement exécuter plusieurs tâches en parallèle. Une fois qu'un travail est reçu par un processus de travail, le processus de travail établit une connexion à l'infobase et exécute le travail au sein de cette connexion. Une fois la tâche terminée, le processus de travail informe le planificateur si la tâche s'est terminée avec succès ou non.

Options de fichier

Depuis la version 8.3.3.641 de la plateforme, les développeurs ont considérablement simplifié le travail avec les tâches en arrière-plan dans la version fichier.

Auparavant, pour exécuter automatiquement des tâches, il était nécessaire de lancer une session 1C:Enterprise supplémentaire distincte, utilisée comme planificateur de tâches. Et dans cette session, il était nécessaire d'exécuter périodiquement la méthode de langage intégrée ExécuterTaskProcessing(). Cette approche était assez lourde, peu pratique et limitait considérablement l'utilisation de tâches d'arrière-plan et de routine dans la version fichier du travail.

Maintenant, tout est devenu beaucoup plus facile. Si un client léger ou lourd démarre, et également si le serveur web dispose de connexions client, alors dans chacune de ces applications un autre thread est automatiquement lancé avec une connexion à la base de données. Ces threads sont engagés dans l’exécution de tâches d’arrière-plan et de routine.

Chacune des applications répertoriées effectue ses propres tâches en arrière-plan. Si une application a lancé plusieurs tâches en arrière-plan, elles sont exécutées séquentiellement, dans l'ordre de leur réception.

L'inconvénient évident des travaux d'arrière-plan 1C: puisqu'elles sont exécutées côté serveur, il n'y a aucune possibilité de travail interactif avec l'utilisateur (par exemple, il est impossible d'afficher un message ou d'autres informations ; toutes ces données doivent être stockées dans la base d'informations et traitées ultérieurement dans d'une manière ou d'une autre).

Il convient de noter que les tâches en arrière-plan sont des objets purement logiciels et ne peuvent pas être stockées dans la base de données. Autrement dit, nous pouvons uniquement créer une instance d'une classe, initialiser ses propriétés et la lancer pour exécution.

Un exemple d'exécution de code asynchrone dans 1C:Enterprise 8

« Écrire des programmes dans lesquels le résultat d'un appel de fonction arrive sans savoir quand est beaucoup plus difficile que des programmes ordinaires. Appels imbriqués, gestion des erreurs, contrôle de ce qui se passe, tout devient plus compliqué », seuls ceux qui ne savent pas utiliser correctement les capacités de la plateforme le diront, mais pas nous !

Démontrons la simplicité et l'élégance de l'exécution de code asynchrone dans 1C:Enterprise 8 !

Étape 1. Créons un nouveau système de sécurité de l'information pour le développement de la configuration

Étape 2. Dans la configuration nous ajouterons le module général « Asynchronous Handlers »

Pourquoi avons-nous ajouté un module partagé ? Tout est simple ici : pour effectuer des opérations asynchrones dans 1C:Enterprise 8, on utilise des tâches en arrière-plan, qui ont leur propre gestionnaire - « BackgroundTask Manager ». Cet objet dispose d'une méthode « Run », à l'aide de laquelle la tâche en arrière-plan est lancée.

Passons à l'assistant de syntaxe.

Nous aurons donc besoin d'un module commun.

Étape 3. Dans le module général « Asyncronous Handlers » nous ajouterons la procédure d'export OurLongOperation()

Procédure OurLongOperation(Duration) Export // Simulation d'une action à long terme (Durée sec.). OperationStartDate = CurrentDate(); While CurrentDate() - Date de début de l'opération< Длительность Цикл КонецЦикла; КонецПроцедуры

Étape 4. Ajouter le traitement « Asynchronous Programming Concept » à la configuration (vous pouvez créer des traitements externes)

Ajoutez un attribut au formulaire :

Durée (Nombre)

et deux équipes

Effectuer une opération longue ;

Effectuez une opération longue-longue de manière asynchrone.

Étape 5. D'après l'assistant de syntaxe, remplissez le module formulaire

&Sur la procédure client Perform Long-RunningOperation(Command) ExecuteLong-RunningOperationOnServer(); EndProcedure &OnServer Procédure ExecuteLongOperationOnServer() AsynchronousHandlers.OurLongOperation(Duration); Fin de la procédure &Sur la procédure client Effectuer une opération de longue durée de manière asynchrone (commande) Effectuer une opération de longue durée de manière asynchrone sur le serveur (); Fin de la procédure &Sur la procédure du serveur Effectuer une opération de longue durée de manière asynchrone sur le serveur() Paramètres = New Array ; Paramètres.Add(Durée); BackgroundTasks.Execute("AsynchronousHandlers.OurLongOperation", Parameters, New UniqueIdentifier, "Exemple de concept de programmation asynchrone"); Fin de la procédure

Étape 6. Lançons et vérifions !

Résultat:

Si l'on clique sur le bouton « Effectuer une opération longue », alors l'interface utilisateur est bloquée pendant « Durée » secondes ;

Si l'on clique sur le bouton « Effectuer une opération de longue durée de manière asynchrone », l'interface utilisateur n'est pas bloquée et le code du programme est exécuté en parallèle.

Nous pouvons vérifier que le code du programme est exécuté de manière asynchrone en consultant le journal.

Nous pouvons déboguer le code du programme qui s'exécute en « arrière-plan » si nous définissons la propriété appropriée dans les paramètres de débogage.

Un exemple d'exécution de code asynchrone dans 1C:Enterprise 8 à l'aide de BSP

Considérons un exemple de mise en œuvre du concept de programmation asynchrone dans 1C:Enterprise 8 dans le BSP en utilisant l'exemple du traitement « Affaires courantes ».

La logique est la suivante : au lancement du programme, la zone de travail de la page d'accueil est initialisée, où peut être affiché le formulaire de traitement « Affaires courantes ». Ce formulaire est rempli par l'actualité de l'utilisateur, et son remplissage prend du temps. Si les développeurs n’avaient pas la possibilité d’exécuter du code de manière asynchrone, alors l’interface utilisateur serait bloquée pendant le remplissage du formulaire de traitement !

Analysons le code du programme du formulaire.

L'événement de formulaire « When CreatedOnServer » appelle la procédure « RunBackgroundTask » - c'est ce dont nous avons besoin.

Sans nous laisser distraire par les nuances, analysons cette procédure

Et on voit ici que le gestionnaire de tâches en arrière-plan et sa méthode « Run » sont utilisés. Notez que les développeurs stockent un identifiant unique pour la tâche en arrière-plan.

Pour ce faire, les développeurs utilisent la méthode ConnectWaitHandler(<ИмяПроцедуры>, <Интервал>, <Однократно>).

Dans la procédure accrochée Connectable_CheckTaskComplete() les développeurs appellent une fonction Travail terminé (ID de tâche)

Cette fonction vérifie l'exécution d'un job en arrière-plan par identifiant.

A noter que le BSP a développé des modules généraux pour supporter les opérations serveur à long terme.

Ainsi, le concept de programmation asynchrone dans 1C:Enterprise 8 augmente légèrement la complexité de résolution des problèmes pour le développeur, mais améliore considérablement la fonctionnalité du programme du point de vue de l'utilisateur.

Nous permet d'effectuer des calculs dans le système sans que l'utilisateur ne le remarque, c'est-à-dire en arrière-plan. De plus, ce mécanisme nous permet de paralléliser le processus de calcul. On peut même paralléliser la procédure qui sera exécutée. Pour ce faire, notre tâche en arrière-plan doit exécuter plusieurs tâches en arrière-plan supplémentaires. Dans ce cas, les processus sont parallélisés et, si nous disposons d’un système multiprocesseur et multicœur, notre algorithme fonctionnera efficacement. Après avoir lancé plusieurs processus, nous pouvons dire au système qu'il doit attendre la fin de ces processus afin de combiner d'une manière ou d'une autre le résultat.

Par exemple, dans les configurations typiques, pendant que l'utilisateur travaille, différents types de tâches de service en arrière-plan sont exécutés. Cela peut être démontré par des entrées de journal qui enregistrent le fait que de telles actions ont été effectuées. De plus, cela n’affecte en rien le travail de l’utilisateur, il ne les remarque tout simplement pas.

Idéalement, un travail en arrière-plan est implémenté dans une version client-serveur, auquel cas la totalité de la charge va au serveur. Quant à la version du fichier, un travail en arrière-plan est possible, mais il présente quelques particularités.

C'est ce que le système produira si vous ne tenez pas compte de ces fonctionnalités et exécutez un travail en arrière-plan dans la version fichier de l'infobase.

Le travail d'arrière-plan 1C présente certaines limites. Puisqu'il fonctionne côté serveur, il n'y a aucune possibilité de travail interactif avec l'utilisateur. Par exemple, vous ne pouvez pas afficher de message, ni aucune information. Toutes ces données doivent être stockées dans la base d'informations et traitées ultérieurement d'une manière ou d'une autre.

En contactant l'assistant de syntaxe, vous pouvez obtenir des informations plus détaillées sur les tâches d'arrière-plan 1C. Il convient de noter ici que cet objet est purement logiciel et qu'il n'est en aucun cas stocké dans la base de données. Autrement dit, nous créons une instance de la classe, initialisons les propriétés et la lançons pour exécution.

De quels outils disposons-nous pour gérer les tâches en arrière-plan ? Cette installation est un objet de métadonnées "Gestionnaire des tâches en arrière-plan". Cet objet a une méthode "Courir", en utilisant cette méthode, le travail en arrière-plan est lancé.

Il a les paramètres suivants :
"Nom de la méthode"- le nom de la procédure ou de la fonction à exécuter, et il doit s'agir d'une procédure ou d'une fonction du contexte serveur ;

"Options"- un tableau de paramètres dont le nombre d'éléments doit correspondre au nombre de paramètres de notre procédure/fonction spécifié dans le paramètre "Nom de la méthode";

"Clé"- une certaine clé d'unicité, qui est une ligne par laquelle le système comprend si une tâche en arrière-plan doit être lancée ou si une telle tâche est déjà en cours d'exécution ;

"Nom"- ici vous pouvez spécifier une description arbitraire de notre méthode.

La valeur de retour est un objet "Tâche de fond", contenant le nom de la méthode actuelle, la clé actuelle et plusieurs autres propriétés et méthodes. Une de ces méthodes est la méthode "Attendre terminé". Son objectif est que nous puissions dire au système de ne rien faire tant que le travail en arrière-plan n'est pas terminé.

Travail de fond 1C 8.2, 8.3 - Exemple d'utilisation

Donnons un exemple de travail avec des tâches d'arrière-plan 1C. Tout d'abord, nous allons créer un algorithme simple qui chargera brièvement le système 1C de telle manière que nous ne puissions rien faire pour le moment.

Pour ça:

1. Créons un module commun "Gestionnaires de tâches en arrière-plan", qui sera compilé côté serveur ;

2. Nous y décrirons la procédure d'exportation "ProduceBackgroundCalculation (Paramètre)", qui prend un paramètre de type chaîne ;

Procédure PerformBackgroundCalculation(Parameter) ExportStartTime = CurrentDate() ; While CurrentDate() - Heure de début< = 6 Цикл КонецЦикла ; КонецПроцедуры Процедура КнНажатие() ОбработчикиФоновыхЗаданий. ПроизветиФоновоеВычисление("Un paramètre") ; Fin de la procédure

Prêt. Désormais, lorsque vous démarrez le traitement et appuyez sur un bouton, le système se bloque pendant plusieurs secondes, pendant lesquelles rien ne peut être fait. C'est exactement ce que nous devions faire.

Nous allons maintenant veiller à ce que ces calculs soient effectués en arrière-plan, c'est-à-dire afin que la tâche d'arrière-plan 1C 8.2, 8.3 soit exécutée, mais ne nous gêne pas.

Pour ça:

1. En cours de traitement, dans l'événement de clic sur le bouton, écrivez le code suivant.

Procédure Paramètres KnPress() = Nouveau tableau ; Possibilités. Ajouter( "Un paramètre") ; Tâche de fond. Courir ( "Gestionnaires de tâches d'arrière-plan. Effectuer un calcul d'arrière-plan", Paramètres, Nouvel identifiant unique, "Test") ; Fin de la procédure

Ici, nous transmettons le nom de la procédure du module commun comme premier paramètre et un tableau de paramètres comme second. Le troisième paramètre doit recevoir une clé unique et le quatrième paramètre une description de notre procédure.