„Blinken“ der Schnittstelle oder Ketten asynchroner Aufrufe. „Blinken“ der Schnittstelle oder Ketten asynchroner Aufrufe Verbinden Sie den Wait-Handler 1s 8.3
Code 1C v 8.2 UE ConnectWaitingHandler(<ИмяПроцедуры>, <Интервал>, <Однократно>)
Optionen:
<ИмяПроцедуры>
<Интервал>(erforderlich) Typ: Nummer. Zeitintervall in Sekunden, auf 1/10 Sekunde genau, nach dem die Prozedur aufgerufen wird (positive Zahl). Wenn ein Wert kleiner als 1 angegeben wird, muss der Wert des dritten Parameters True sein.
<Однократно>(optional) Typ: Boolean. Zeichen einer einmaligen Ausführung des Wartehandlers.
True – der angegebene Wait-Handler wird einmal ausgeführt. Standard: Falsch
Beschreibung: Verbindet die angegebene Prozedur als Wartehandler. Die Prozedur wird während des System-Timeout-Zeitraums jedes Mal aufgerufen, wenn das angegebene Zeitintervall abgelaufen ist.
Verfügbarkeit:
Thin Client, Webclient, Thick Client.
Notiz:
Der Aufruf des Wartehandlers wird fortgesetzt, bis das Formular geschlossen wird oder bis die DisableWaitHandler-Methode des Formulars aufgerufen wird. Code 1C v 8.2 UE DisableWaitingHandler(<ИмяПроцедуры>)
Code 1C v 8.2 UP
&OnClient
Prozedur ShellHandler()
ProcessWaiting();
Ende des Verfahrens
&Auf dem Server
Prozedur ProcessWaiting()
// tun, was immer nötig ist
Ende des Verfahrens
//....
ConnectWaitHandler("HandlerWrapper", 3, True);
<ИмяПроцедуры>, <Интервал>, <Однократно>)
Veranlasst einen Aufruf der angegebenen Prozedur eines verwalteten Anwendungsmoduls (eines regulären Anwendungsmoduls) oder eines globalen gemeinsam genutzten Moduls in einem angegebenen Zeitintervall. Der Aufruf erfolgt nur im „Ruhezustand“, also zu einem Zeitpunkt, an dem das Programm keine Aktionen ausführt. Der Aufruf des Wartehandlers wird fortgesetzt, bis das System heruntergefahren wird oder die DisableWaitHandler-Methode des globalen Kontexts aufgerufen wird.
Code 1C v 8.x Prozedur Sales ReportDay()
// ...
Ende des Verfahrens
//...
ConnectWaitingHandler("DaySalesReport", 60); // jede Minute
Code 1C v 8.x // In der standardmäßigen Dynamikprüfung. Konfigurationsaktualisierungen alle 20 Minuten.
ConnectWaitingHandler("IB DynamicChangeCheckWaitingHandler", 20 * 60);
// Den Datenaustausch-Handler verbinden
ConnectWaitingHandler("CheckingDataExchange", chValueVariable("chNumberofSecondsPollExchange"));
ConnectWaitingHandler("Antworten auf Verbindungsanwendungen prüfen", 86400); // = 24(h) * 60(min) * 60(s) = 1 Tag
Für Form
Code 1C v 8.x ConnectWaitingHandler(<ИмяПроцедуры>, <Интервал>, <Однократно>)
Optionen:
<ИмяПроцедуры>(erforderlich) Typ: String. Der Name der Prozedur, die als Wartehandler verbunden werden soll.
<Интервал>(erforderlich) Typ: Nummer. Zeitintervall in Sekunden, auf 1/10 Sekunde genau, nach dem die Prozedur aufgerufen wird (positive Zahl). Wenn ein Wert kleiner als 1 angegeben wird, muss der Wert des dritten Parameters True sein.
<Однократно>(optional) Typ: Boolean. Zeichen einer einmaligen Ausführung des Wartehandlers. 0True – der angegebene Wartehandler wird einmal ausgeführt. Standard: Falsch
Beschreibung:
Verbindet die angegebene Prozedur als Wartehandler. Die Prozedur wird während des System-Timeout-Zeitraums jedes Mal aufgerufen, wenn das angegebene Zeitintervall abgelaufen ist.
Verfügbarkeit:
Fetter Kunde.
Notiz:
Der Aufruf des Wartehandlers wird fortgesetzt, bis das Formular geschlossen wird oder bis die DisableWaitHandler-Methode des Formulars aufgerufen wird.
Beispiel:
Code 1C v 8.x ConnectWaitingHandler("WhenWaiting", 1);
Code 1C v 8.x Form.mAutosave Interval = 300; // 5 Minuten
Wenn Form.mAutosave-Intervall<>0 Dann
Form.ConnectWaitingHandler("TimerEventHandler", Int(Form.mAutoSaveInterval * 60));
endIf;
Warteverarbeitung im 1C:Enterprise-System, wie aus der Dokumentation hervorgeht, ist für die periodische Ausführung der globalen Modulprozedur in einem bestimmten Zeitintervall vorgesehen. Der auszuführende Code sieht folgendermaßen aus:
Code 1C v 7.x Waiting Processing("UpdateCounter_",1);
Wo „UpdateCounter_“– Name der globalen Modulprozedur, die jede Sekunde gestartet wird. (zweiter Parameter gleich 1)
Aber! Das Problem besteht darin, dass Sie die Warteverarbeitung nur einmal ausführen können. Durch einen Neustart wird der vorherige Vorgang abgebrochen. Mit anderen Worten: Wenn Sie beispielsweise eine Timer-Verarbeitung durchführen möchten, um die verstrichene Zeit zu zählen, können Sie nur einen Timer ausführen, weil Das Starten des zweiten Timers stoppt den ersten. Was aber, wenn Sie zwei, drei oder mehr dieser Timer gleichzeitig ausführen müssen? Oder müssen Sie dennoch regelmäßig den Status von Dokumenten scannen?
Es gibt einen Ausgang! Die Warteverarbeitung muss im Formularkontext ausgeführt werden, um diesen Thread vom globalen Kontext zu trennen. Und dann wird es möglich, die lokale Modulprozedur regelmäßig zu starten, d.h. Verfahren, das sich im Modul Ihres Verarbeitungsformulars befindet.
Der auszuführende Code sieht folgendermaßen aus:
Code 1C v 7.x Form.Waiting Processing("UpdateCounter_",1);
Wo „UpdateCounter_“- Name der Prozedur des lokalen Moduls des Verarbeitungsformulars, das im Abstand von 1 Sekunde gestartet wird. (zweiter Parameter gleich 1)
Somit können Sie in jeder Verarbeitung Ihre eigene Warteverarbeitung ausführen, die funktioniert, solange das Formular geöffnet ist.
Sie können es in Formularen verwenden Code 1C v 8.x Form.Waiting Processing("ProcedureName",StartTime) ,
Dabei ist ProcedureName der Name der Prozedur, die nach StartTime-Sekunden ausgeführt wird
In der Prozedur selbst müssen Sie Code 1C v 8.x Form.Waiting Processing("ProcedureName",0) einfügen, um die wartende Verarbeitung zu stoppen (natürlich nachdem die erforderlichen Bedingungen erfüllt sind).
Quelle
Code 1C v 8.2 UE ConnectWaitingHandler(<ИмяПроцедуры>, <Интервал>, <Однократно>)
Optionen:
<ИмяПроцедуры>
<Интервал>(erforderlich) Typ: Nummer. Zeitintervall in Sekunden, auf 1/10 Sekunde genau, nach dem die Prozedur aufgerufen wird (positive Zahl). Wenn ein Wert kleiner als 1 angegeben wird, muss der Wert des dritten Parameters True sein.
<Однократно>(optional) Typ: Boolean. Zeichen einer einmaligen Ausführung des Wartehandlers.
True – der angegebene Wait-Handler wird einmal ausgeführt. Standard: Falsch
Beschreibung: Verbindet die angegebene Prozedur als Wartehandler. Die Prozedur wird während des System-Timeout-Zeitraums jedes Mal aufgerufen, wenn das angegebene Zeitintervall abgelaufen ist.
Verfügbarkeit:
Thin Client, Webclient, Thick Client.
Notiz:
Der Aufruf des Wartehandlers wird fortgesetzt, bis das Formular geschlossen wird oder bis die DisableWaitHandler-Methode des Formulars aufgerufen wird. Code 1C v 8.2 UE DisableWaitingHandler(<ИмяПроцедуры>)
Code 1C v 8.2 UP
&OnClient
Prozedur ShellHandler()
ProcessWaiting();
Ende des Verfahrens
&Auf dem Server
Prozedur ProcessWaiting()
// tun, was immer nötig ist
Ende des Verfahrens
//....
ConnectWaitHandler("HandlerWrapper", 3, True);
<ИмяПроцедуры>, <Интервал>, <Однократно>)
Veranlasst einen Aufruf der angegebenen Prozedur eines verwalteten Anwendungsmoduls (eines regulären Anwendungsmoduls) oder eines globalen gemeinsam genutzten Moduls in einem angegebenen Zeitintervall. Der Aufruf erfolgt nur im „Ruhezustand“, also zu einem Zeitpunkt, an dem das Programm keine Aktionen ausführt. Der Aufruf des Wartehandlers wird fortgesetzt, bis das System heruntergefahren wird oder die DisableWaitHandler-Methode des globalen Kontexts aufgerufen wird.
Code 1C v 8.x Prozedur Sales ReportDay()
// ...
Ende des Verfahrens
//...
ConnectWaitingHandler("DaySalesReport", 60); // jede Minute
Code 1C v 8.x // In der standardmäßigen Dynamikprüfung. Konfigurationsaktualisierungen alle 20 Minuten.
ConnectWaitingHandler("IB DynamicChangeCheckWaitingHandler", 20 * 60);
// Den Datenaustausch-Handler verbinden
ConnectWaitingHandler("CheckingDataExchange", chValueVariable("chNumberofSecondsPollExchange"));
ConnectWaitingHandler("Antworten auf Verbindungsanwendungen prüfen", 86400); // = 24(h) * 60(min) * 60(s) = 1 Tag
Für Form
Code 1C v 8.x ConnectWaitingHandler(<ИмяПроцедуры>, <Интервал>, <Однократно>)
Optionen:
<ИмяПроцедуры>(erforderlich) Typ: String. Der Name der Prozedur, die als Wartehandler verbunden werden soll.
<Интервал>(erforderlich) Typ: Nummer. Zeitintervall in Sekunden, auf 1/10 Sekunde genau, nach dem die Prozedur aufgerufen wird (positive Zahl). Wenn ein Wert kleiner als 1 angegeben wird, muss der Wert des dritten Parameters True sein.
<Однократно>(optional) Typ: Boolean. Zeichen einer einmaligen Ausführung des Wartehandlers. 0True – der angegebene Wartehandler wird einmal ausgeführt. Standard: Falsch
Beschreibung:
Verbindet die angegebene Prozedur als Wartehandler. Die Prozedur wird während des System-Timeout-Zeitraums jedes Mal aufgerufen, wenn das angegebene Zeitintervall abgelaufen ist.
Verfügbarkeit:
Fetter Kunde.
Notiz:
Der Aufruf des Wartehandlers wird fortgesetzt, bis das Formular geschlossen wird oder bis die DisableWaitHandler-Methode des Formulars aufgerufen wird.
Beispiel:
Code 1C v 8.x ConnectWaitingHandler("WhenWaiting", 1);
Code 1C v 8.x Form.mAutosave Interval = 300; // 5 Minuten
Wenn Form.mAutosave-Intervall<>0 Dann
Form.ConnectWaitingHandler("TimerEventHandler", Int(Form.mAutoSaveInterval * 60));
endIf;
Warteverarbeitung im 1C:Enterprise-System, wie aus der Dokumentation hervorgeht, ist für die periodische Ausführung der globalen Modulprozedur in einem bestimmten Zeitintervall vorgesehen. Der auszuführende Code sieht folgendermaßen aus:
Code 1C v 7.x Waiting Processing("UpdateCounter_",1);
Wo „UpdateCounter_“– Name der globalen Modulprozedur, die jede Sekunde gestartet wird. (zweiter Parameter gleich 1)
Aber! Das Problem besteht darin, dass Sie die Warteverarbeitung nur einmal ausführen können. Durch einen Neustart wird der vorherige Vorgang abgebrochen. Mit anderen Worten: Wenn Sie beispielsweise eine Timer-Verarbeitung durchführen möchten, um die verstrichene Zeit zu zählen, können Sie nur einen Timer ausführen, weil Das Starten des zweiten Timers stoppt den ersten. Was aber, wenn Sie zwei, drei oder mehr dieser Timer gleichzeitig ausführen müssen? Oder müssen Sie dennoch regelmäßig den Status von Dokumenten scannen?
Es gibt einen Ausgang! Die Warteverarbeitung muss im Formularkontext ausgeführt werden, um diesen Thread vom globalen Kontext zu trennen. Und dann wird es möglich, die lokale Modulprozedur regelmäßig zu starten, d.h. Verfahren, das sich im Modul Ihres Verarbeitungsformulars befindet.
Der auszuführende Code sieht folgendermaßen aus:
Code 1C v 7.x Form.Waiting Processing("UpdateCounter_",1);
Wo „UpdateCounter_“- Name der Prozedur des lokalen Moduls des Verarbeitungsformulars, das im Abstand von 1 Sekunde gestartet wird. (zweiter Parameter gleich 1)
Somit können Sie in jeder Verarbeitung Ihre eigene Warteverarbeitung ausführen, die funktioniert, solange das Formular geöffnet ist.
Sie können es in Formularen verwenden Code 1C v 8.x Form.Waiting Processing("ProcedureName",StartTime) ,
Dabei ist ProcedureName der Name der Prozedur, die nach StartTime-Sekunden ausgeführt wird
In der Prozedur selbst müssen Sie Code 1C v 8.x Form.Waiting Processing("ProcedureName",0) einfügen, um die wartende Verarbeitung zu stoppen (natürlich nachdem die erforderlichen Bedingungen erfüllt sind).
Quelle
Die 1C-Plattform bietet uns die Möglichkeit, Prozeduren asynchron aufzurufen, die manchmal für einfache, aber unterhaltsame Dinge verwendet werden können. Sie können beispielsweise alles „blinken“, was eine Farbe hat oder die Möglichkeit hat, das visuelle Erscheinungsbild zu ändern. Darüber hinaus können Sie entweder einen einfacheren, aber unkontrollierten Mechanismus verwenden oder eine interessante Kette asynchroner Aufrufe erstellen und ihr das bevorzugte Verhalten zuweisen.
Die Rede ist hier natürlich von der Prozedur ConnectWaitingHandler().
Ich möchte Sie an die Syntax der Prozedur erinnern:
ConnectWaitHandler(<ИмяПроцедуры>, <Интервал>, <Однократно>)
Wenn Sie außerdem ein Intervall von weniger als einer Sekunde angeben, muss der Vorgang einmal gestartet werden. Hier verlieren wir die Kontrolle über den Ausführungsfluss und verlieren die Möglichkeit, ihn „anzupassen“ (flexibel, individuell zu konfigurieren).
Aber diese Einschränkung lässt sich leicht überwinden.
Um meine Gedanken nicht abschweifen zu lassen, gebe ich gleich ein einfaches Beispiel und erkläre es.
Nehmen wir an, wir haben ein Tabellenkalkulationsdokument auf dem Formular und möchten einen Bereich davon fünfmal „blinken“.
////////////////// // // „Blinken“ Sie den Bereich des Tabellenkalkulationsdokuments fünfmal im Abstand von einer halben Sekunde // //// /////// ///////// &Auf der Client-Prozedur BlinkArea (Befehl) mf How Many Times to Blink = 3; // Schalter. Formularattribut, „sichtbar“ in Wartehandlerprozeduren ConnectWaitHandler("ShowAreaSelection", 0.1, True); // Sie können EndProcedure &Auf der Client-Prozedur auch direkt aufrufen ShowArea Selection() Area = Object.TD.Area(mfFirstDataLine, mfFirstDataColumn, mfLastDataLine, mfLastDataColumn); Border = New Line(TableDocumentCellLineType.Double); Area.Circle(Border, Border, Border, Border); // Den Bereich umreißen mfHow much times to blink = mfHow much times to blink - 1; // Zähler dekrementieren Connect WaitHandler("RemoveArea Allocation", 0.5, True); // Eine Kette asynchroner Aufrufe verbinden Ende der Prozedur und auf der Client-Prozedur Remove Area Selection() Area = Object.TD.Area(mfFirstDataLine, mfFirstDataColumn, mfLastDataLine, mfLastDataColumn); Border = New Line(TableDocumentCellLineType.NoLine); Area.Circle(Border, Border, Border, Border); // Den Umriss des Bereichs entfernen. Wenn mf How Many Times to Blink > 0 Then Connect WaitHandler("Show Area Selection", 0.5, True); // So oft wiederholen, wie auf dem Zähler übrig ist EndIf; Ende des VerfahrensDie einzige Voraussetzung ist, dass die Zählervariable mfHow Many Times Blink in den Prozeduren, die wir asynchron starten, „sichtbar“ sein sollte. In diesem Fall ist die Variable ein Formularattribut.
Einem aufmerksamen Leser dürfte aufgefallen sein, dass wir mit der Bildung solcher Ketten zwei Fliegen mit einer Klappe schlagen:
- Wir umgehen die Beschränkung der Wiederholung von Prozeduraufrufen mit Intervallwerten von weniger als einer Sekunde;
- Wir haben die Möglichkeit, Ketten unterschiedlicher Länge und Komplexität zu bilden:
- Verbinden Sie den Wait-Handler direkt mit der Wait-Handler-Prozedur selbst.
- Stellen Sie sicher, dass solche Verfahren miteinander verbunden sind.
- eine komplexere Struktur von Anrufketten organisieren;
- erschweren die Variabilität der Anrufverwaltung unendlich (ändern Sie beispielsweise nicht nur die Zähler innerhalb von Anrufen, sondern auch Intervallwerte und Designstile (so dass das 🌈 wie ein Regenbogen schimmert).
Trotz der Einfachheit der beschriebenen Methode birgt sie ein erhebliches Potenzial.
Im Jahr 2017 ist es modern, das Programmverhalten flexibler zu verwalten.