1c como descobrir sobre a execução do manipulador de espera. "piscando" a interface, ou cadeias de chamadas assíncronas

Código 1C v 8.2 UP Connect Processor Waiting (<ИмяПроцедуры>, <Интервал>, <Однократно>)
Parâmetros:
<ИмяПроцедуры>
<Интервал>(obrigatório) Tipo: Número. Intervalo de tempo, em segundos, com precisão de 1/10 de segundo, após o qual será feita a chamada do procedimento (número positivo) .Se for especificado um valor menor que 1, o valor do terceiro parâmetro deve ser True.
<Однократно>(opcional) Tipo: Booleano. O sinalizador de execução única do manipulador de espera.
True - o manipulador de espera especificado será executado uma vez. Valor padrão: False
Descrição: anexa o procedimento especificado como um manipulador de espera. O procedimento será chamado enquanto o sistema está esperando sempre após o intervalo de tempo especificado.

Disponibilidade:
Cliente magro, cliente web, cliente gordo.

Observação:
A chamada para o manipulador de espera continua até que o formulário seja fechado ou até que DisableWaitHandler do formulário seja chamado. Código 1C v 8.2 UE DisableWaitingHandler (<ИмяПроцедуры>)

Código 1C v 8.2 UP
& OnClient
Procedimento WrapperHandler ()
ProcessWaiting ();
Fim do Procedimento

& No servidor
Processo de procedimento em espera ()
// faça o que for necessário
Fim do Procedimento

//....
ConnectWaitingHandler ("HandlerShell", 3, True);

<ИмяПроцедуры>, <Интервал>, <Однократно>)
Conecta uma chamada ao procedimento especificado de um módulo de aplicativo gerenciado (módulo de aplicativo regular) ou um módulo comum global em um intervalo de tempo especificado. A chamada será feita apenas no “estado de repouso”, ou seja, no momento em que o programa não realizar nenhuma ação. A chamada para o manipulador de espera continua até que o sistema seja encerrado ou até que o método de contexto global DisableWaitHandler seja chamado.
Relatório de Vendas de Procedimento Código 1C v 8.x por Dia ()
// ...
Fim do Procedimento

//...
ConnectWaitingHandler ("ReportOverDaySales", 60); // todo minuto
Código 1C v 8.x // Em verificações padrão dyn. atualizações de configuração a cada 20 minutos.
ConnectWaitingHandler ("WaitingHandlerDynamicChangeIB CheckWaiting", 20 * 60);
// conecte um manipulador de troca de dados
ConnectWaitingHandler ("DataExchangeCheck", chapVariableValue ("chapNumber ofExchangePolishSeconds"));
ConnectWaitingHandler ("CheckRepliesOnConnectionApplication", 86400); // = 24 (h) * 60 (min) * 60 (s) = 1 dia

For Form
Código 1C v 8.x ConnectWaitingHandler (<ИмяПроцедуры>, <Интервал>, <Однократно>)
Parâmetros:
<ИмяПроцедуры>(obrigatório) Tipo: String. O nome do procedimento a ser conectado como um manipulador de espera.
<Интервал>(obrigatório) Tipo: Número. Intervalo de tempo, em segundos, com precisão de 1/10 de segundo, após o qual será feita a chamada de procedimento (número positivo). Se o valor especificado for menor que 1, o valor do terceiro parâmetro deve ser True.
<Однократно>(opcional) Tipo: Booleano. O sinalizador de execução única do manipulador de espera. 0 True - o manipulador de espera especificado será executado uma vez. Valor padrão: False

Descrição:
Anexa o procedimento especificado como um manipulador de espera. O procedimento será chamado enquanto o sistema está esperando sempre após o intervalo de tempo especificado.

Disponibilidade:
Cliente espesso.
Observação:
A chamada para o manipulador de espera continua até que o formulário seja fechado ou até que DisableWaitHandler do formulário seja chamado.
Exemplo:
Código 1C v 8.x ConnectWaitingHandler ("Em espera", 1);
Código 1C v 8.x Form. Intervalo de salvamento automático = 300; // 5 minutos
If Form.AutoSave Interval<>0 então
Form.ConnectWaitingHandler ("EventHandlerByTimer", Integer (Form.AutoSaveInterval * 60));
Fim se;

Aguardando processamento no sistema 1C: Enterprise, conforme segue da documentação, destina-se à execução periódica do procedimento do módulo global em um intervalo de tempo especificado. O código a ser executado será semelhante a este:
Código 1C v 7.x Processamento de expectativa ("RefreshCounter _", 1);
Onde "RefreshCounter_"- o nome do procedimento do módulo global, que será lançado com uma frequência de 1 segundo. (segundo parâmetro igual a 1)

Mas! O problema é que você só pode executar o processamento de espera uma vez. Reiniciar cancelará o anterior. Em outras palavras, se você deseja fazer, por exemplo, um processamento temporizador para contar o tempo decorrido, então você pode iniciar apenas um temporizador, porque iniciar o segundo cronômetro interromperá o primeiro. Mas e se você precisar iniciar 2, 3 ou mais desses temporizadores ao mesmo tempo? Ou você ainda precisa verificar periodicamente o status dos documentos?

Existe uma saída! O processamento de espera deve ser iniciado no contexto do formulário para desacoplar este encadeamento do contexto global. E então será possível iniciar periodicamente o procedimento do módulo local, ou seja, procedimento localizado no módulo do seu formulário de processamento.

O código a ser executado será semelhante a este:
Código 1C v 7.x Form.Waiting Processing ("RefreshCounter _", 1);
Onde "RefreshCounter_"- nome do procedimento do módulo local do formulário de processamento, que será lançado com a frequência de 1 segundo. (segundo parâmetro igual a 1)
Assim, em cada processamento, você pode iniciar seu próprio processamento de espera, que funcionará enquanto o formulário estiver aberto.

Em formulários que você pode usar Código 1C v 8.х Form.Waiting Processing ("ProcedureName", Startup Time),
onde ProcedureName é o nome do procedimento que inicia após segundos de inicialização
No próprio procedimento, você precisa inserir o Código 1C v 8.x Form.Waiting Processing ("ProcedureName", 0) para interromper o processamento de espera (é claro, depois que as condições necessárias forem atendidas).
Uma fonte

Disponibilidade:
Cliente magro, cliente web, cliente gordo.

Código 1C v 8.2 UP
& OnClient
Procedimento WrapperHandler ()
ProcessWaiting ();
Fim do Procedimento

& No servidor
Processo de procedimento em espera ()
// faça o que for necessário
Fim do Procedimento

//....
ConnectWaitingHandler ("HandlerShell", 3, True);

Descrição:
Anexa o procedimento especificado como um manipulador de espera. O procedimento será chamado enquanto o sistema está esperando sempre após o intervalo de tempo especificado.

A plataforma 1C nos fornece os recursos de chamadas de procedimento assíncronas, que, às vezes, podem ser usadas para coisas simples, mas divertidas. Por exemplo, você pode "piscar" tudo que tem uma cor ou qualquer capacidade de mudar o design visual. Além disso, você pode usar um mecanismo mais simples, mas não controlado, ou projetar uma cadeia interessante de chamadas assíncronas e definir seu comportamento preferido.

Estamos falando aqui, é claro, sobre o procedimento AttachWaitHandler ().

Deixe-me lembrar a sintaxe do procedimento:

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

Além disso, se você especificar um intervalo de menos de um segundo, o procedimento deve ser iniciado uma vez. É aqui que perdemos o controle sobre o fluxo de execução e perdemos a capacidade de "personalizá-lo" (com flexibilidade, individualmente).

Mas essa limitação é facilmente contornada.

Para não espalhar o pensamento ao longo da árvore, darei imediatamente um exemplo simples e o explicarei.

Digamos que temos uma planilha no formulário e queremos "piscar" 5 vezes com parte de sua área.

//////////////////////// // // // Vamos "piscar" a área do Documento de Planilha 5 vezes, com um intervalo de meio segundo // ///////////// ///////// & OnClient Procedure Blink Area (Command) mf Blink Time = 3; // Balcão. Atributo de formulário "visível" nos procedimentos de manipuladores de espera ConnectWaitingHandler ("ShowAreaSelection", 0.1, True); // Você também pode chamar diretamente EndProcedure & On the Client Procedure ShowSelectionArea () Area = Object.TD.Area (mfFirstDataString, mfFirstDataColumn, mfLastDataRow, mfLastDataColumn); Borda = Nova Linha (TabularDocumentCellLineType.Double); Region.Circle (Border, Border, Border, Border); // Contorne a área com mfFlashToFlash = mfFlashMoT - 1; // Decrementa o contador ConnectWaitingHandler ("RemoveAreaSelection", 0.5, True); // Conectar a cadeia de chamadas assíncronas EndProcedure & No Client Procedure RemoveSelectionArea () Area = Object.TD.Area (mfFirstDataString, mfFirstDataColumn, mfLastDataRow, mfLastDataColumn); Borda = Nova Linha (TabularDocumentCellLineType.NoLine); Region.Circle (Border, Border, Border, Border); // Remova o contorno da área If mfSkindBlink> 0 Then ConnectWaitingHandler ("ShowAreaSelection", 0.5, True); // Repita enquanto houver no contador EndIf; Fim do Procedimento

O principal requisito é apenas que a variável do contador mfHow to Blink seja "visível" a partir dos procedimentos que executamos de forma assíncrona. DENTRO este caso variável é um atributo de formulário.

Um leitor atento deve ter notado que, com a formação de tais correntes, matamos dois coelhos com uma cajadada só:

Ignoramos a restrição de repetibilidade de chamadas de procedimento com valores de intervalo menores que um segundo;
Temos a capacidade de formar cadeias de diferentes comprimentos e complexidades:
- conecte um manipulador de espera diretamente no próprio procedimento de manipulador de espera;
- fazer com que tais procedimentos se conectem entre si;
- organizar uma estrutura mais complexa de cadeias de chamadas;
- complicar infinitamente a variabilidade do controle de chamadas (por exemplo, alterar dentro das chamadas não apenas seus contadores, mas também os valores dos intervalos, estilos de design (de modo que um arco-íris brilhe 🌈).

Apesar da simplicidade do método descrito, existe um potencial considerável oculto nele.

Em 2017, é mais flexível controlar o comportamento do programa - isso é moderno.