Como acessar o procedimento do módulo geral 1c. Módulos comuns

Hoje veremos módulos comuns, o que são, por que são necessários e como usá-los. Você pode colocar funções usadas em vários documentos em um módulo comum. Por exemplo, calculando o valor na parte tabular do documento.

Por exemplo, vamos pegar nossa configuração antiga, que usei em artigos anteriores. Nele temos dois documentos: Chegada de Mercadoria ao armazém e Liberação de Mercadoria ao armazém. Ambos os documentos possuem procedimentos que calculam o valor em uma linha tabular.

Cada documento contém o mesmo código para cálculo do valor.

Procedimento MateriaisPriceOnChange(Elemento)
Linha TabularPart = Elements.Materials.CurrentData;
TabularPartLine.Amount = TabularPartLine.Quantity * TabularPartLine.Price;
Fim do procedimento

Hoje iremos movê-lo para um módulo comum e chamá-lo a partir do documento.

Criamos um módulo geral para cálculo do valor

E então vamos começar, primeiro você precisa criar um módulo comum. Para isso, vá ao configurador, procure o item Módulos gerais, clique com o botão direito e adicione novos, escreva o nome WorkWithDocuments. Nós inserimos o seguinte código nele.

Certifique-se também de marcar as caixas ao lado de Cliente (aplicativo gerenciado) e Servidor na janela de propriedades.

Agora você precisa alterar ligeiramente o código no módulo de formulário do documento. À esquerda na configuração procuramos o documento Chegada de Mercadoria, expandimos as janelas até a janela Formulários, clicamos duas vezes em Formulário de Documento e na janela de formulário que se abre, vá até a aba Módulo na parte inferior. Temos esse código

Este procedimento funciona ao alterar a Quantidade na parte tabular do documento de Entrada de Mercadoria e calcular o valor.

&NoCliente



Fim do procedimento

E este procedimento começa a funcionar quando o Preço muda na parte tabular do documento de Entrada de Mercadorias e calcula o valor.

&NoCliente

Linha TabularPart = Elements.Materials.CurrentData;
TabularPartLine.Amount = TabularPartLine.Quantity * TabularPartLine.Price;
Fim do procedimento

Substitua por este

&NoCliente
Procedimento MateriaisQuantityOnChange(Elemento)
Linha TabularPart = Elements.Materials.CurrentData;

Fim do procedimento
&NoCliente
Procedimento MateriaisPriceOnChange(Elemento)
Linha TabularPart = Elements.Materials.CurrentData;
WorkWithDocuments.CalculateSum(TabularPartRow);
Fim do procedimento

Como você notou, apenas uma linha muda, à primeira vista pode parecer que uma linha foi substituída por outra. Mas não esqueça que este é um exemplo. Na verdade, a quantidade de código pode ser muito maior se, por exemplo, você realizar cálculos usando uma fórmula complexa, caso em que o código será visivelmente reduzido.

Fazemos o mesmo para o documento Liberação de mercadorias do armazém, executamos e verificamos a funcionalidade do código. Então você e eu fizemos o primeiro módulo comum, espero que meu artigo seja útil para alguém.

Módulos da plataforma 1C:Enterprise 8.3, 8.2

Módulos comuns

Funções declaradas com o sinalizador "export" nesse módulo podem ser chamadas de qualquer lugar na configuração. A chamada é feita via CommonModuleName.FunctionName().

Esses módulos não possuem uma seção variável.

A execução dos módulos comuns depende das configurações em suas propriedades:

Bandeira "Global"

Se este sinalizador for definido, o contexto desse módulo se tornará global. Ou seja, ao acessar suas funções de exportação, não é necessário especificar o nome do módulo. Mas os nomes das suas funções de exportação devem ser exclusivos dentro do contexto de configuração global.

Bandeira do servidor

As funções desse módulo podem ser executadas no servidor.

Sinalizador "Cliente (aplicativo normal)"

As funções de tal módulo podem ser executadas no cliente no modo normal de aplicação.

Sinalizador "Cliente (aplicativo gerenciado)"

As funções de tal módulo podem ser executadas no cliente no modo de aplicativo gerenciado.

Sinalizador "Chamada do Servidor"

O sinalizador está disponível para módulos com o sinalizador "Servidor" definido. Permite ao cliente chamar as funções de exportação deste módulo (que serão executadas no servidor).

Sinalizador de associação externa

As funções de exportação de tal módulo podem ser chamadas ao conectar-se a partir de uma fonte externa.

Bandeira "Privilegiado"

Num módulo com este sinalizador, a verificação de direitos será desativada. Adequado para produtividade ou atividades administrativas.

Opção de reutilização

Se você habilitar esta opção, os valores de retorno das funções de exportação serão armazenados em cache imediatamente após a primeira chamada. O armazenamento em cache é possível durante a chamada (o tempo de execução de um procedimento específico) ou durante a sessão do usuário.

Módulo de aplicação

Projetado para lidar com eventos de inicialização e encerramento de aplicativos. Existem dois tipos: para aplicativos regulares e gerenciados.

Você não deve sobrecarregá-lo, pois isso afeta o tempo de inicialização do aplicativo.

Módulo de sessão

Um módulo especial usado para inicializar parâmetros de sessão. É necessário para não duplicar o código nos vários módulos do aplicativo.

Deve ser utilizado com cuidado, pois o módulo pode ser executado diversas vezes, podendo também ser executado sem iniciar novamente o banco de dados. Executado antes dos módulos do aplicativo.

Atenciosamente, (professor e desenvolvedor).

Os módulos comuns são responsáveis ​​​​por armazenar procedimentos e funções que são chamados de outros locais do sistema 1C. É considerada uma boa prática colocar o código que é chamado diversas vezes em um procedimento em um módulo comum. Esta regra é universal para todas as configurações, portanto, qualquer desenvolvedor 1C deve ser capaz de trabalhar com esses objetos de configuração. Para isso, você precisa entender todas as nuances e saber aproveitar corretamente as oportunidades que a plataforma oferece.

Criando um módulo comum em 1C

Após criar uma função em um dos módulos do objeto, houve a necessidade de utilizar um algoritmo semelhante em outro local. A melhor coisa a fazer aqui é transferir o código para um módulo comum, mas antes disso é necessário criá-lo. Para fazer isso, precisamos ir ao configurador e encontrar a aba “Geral” na árvore de configuração. Em seguida, selecione “Módulos Gerais” e use o botão em forma de sinal de mais branco no círculo verde.

As propriedades do módulo comum adicionado serão abertas à direita e teremos que descobrir o que cada uma delas significa. Eles podem ter direções diferentes, portanto, antes de montar um novo objeto, é aconselhável decidir o que iremos armazenar ali. Na verdade, no futuro será possível alterar as propriedades de acordo com as tarefas:

• "Global". Este sinalizador é definido se o módulo se destina a armazenar procedimentos e funções que devem ser chamados sem especificar o nome do módulo. Naturalmente, devem ser exportáveis ​​e os seus nomes devem ser únicos no contexto de todo o contexto global. Eles não serão diferentes em uso das funções padrão da plataforma;
• "Cliente". Depende das configurações do sistema e regula se os procedimentos do módulo podem ser executados no lado do cliente;
• "Servidor". São marcados módulos gerais, dentro dos quais se planeja colocar algoritmos para execução no servidor;
• "Junção externa". Os procedimentos do módulo com esta propriedade ativada poderão ser executados através da conexão de uma fonte externa;
• "Chamada de Servidor". Responsável por permitir que procedimentos do módulo chamem o servidor enquanto rodam no cliente;
• "Privilegiado". Habilitar esta configuração permitirá que você não verifique os direitos de acesso ao executar o código de procedimento do módulo. Você pode chamar um módulo comum com esta configuração somente no servidor. As configurações de Cliente e Conexão Externa serão redefinidas;
• "Reuso". Pode assumir os seguintes valores: “Não utilizar”, “Durante a sessão”, “Durante a chamada”. Ao chamar um procedimento várias vezes, o sistema pode usar dados previamente calculados dentro do procedimento (chamada) ou a vida de toda a sessão (lançamento 1C). Você deve ter muito cuidado com esta configuração, pois podem ocorrer erros devido ao uso incorreto de tais módulos.

Existem situações em que é necessário criar um módulo comum com chamadas de procedimento no servidor e cliente com diferenças no algoritmo. Diretivas de pré-processador com verificação são usadas para delimitar o código. Como resultado, será um código para a chamada do servidor e outro para a chamada do cliente.
Procedure AlgorithmServerClient() Export #If ThinClient Then // o código é executado se a chamada do procedimento veio do cliente ShowUserAlert("No cliente"); ElseIf Server Then // o código é executado se a chamada do procedimento vier do servidor VariableServer = "Server call"; #TheEndIfTheEndProcedure

Um exemplo de transferência de código para um módulo 1C comum

Vamos considerar uma situação em que temos dois eventos no formulário do documento que envolvem um procedimento de multiplicação de quantidade e preço na seção tabular. Este é um algoritmo bastante comum, visto que é encontrado em muitos documentos de compras e vendas. Vamos transferir o código do procedimento para um módulo comum, que primeiro deve ser criado para poder utilizar este código em outros documentos.

Como para nossa tarefa precisamos apenas de uma chamada do cliente e não precisamos de dados do banco de dados, definimos apenas o flag “Cliente”. Se quiser usar o mesmo módulo no futuro para cálculos mais complexos, marque “Servidor” nas propriedades. A fase preparatória está concluída e podemos prosseguir com a escrita do código.

Vamos criar um procedimento de exportação no módulo e transferir para lá o algoritmo de cálculo do valor do procedimento no módulo de formulário. A string da seção da tabela será usada como parâmetro de procedimento na entrada. No módulo de formulário de documento, alteramos as chamadas de procedimento no mesmo módulo para uma chamada de procedimento do módulo geral.

Fragmento 1

Fragmento 2

Quando o sistema for iniciado, não notaremos a diferença, mas essa estrutura de código é muito mais conveniente de ler e manter. É claro que, neste exemplo, a quantidade de código não pode mostrar todos os benefícios. No caso de um algoritmo complexo para dezenas de objetos de configuração, o ganho na quantidade de código e em sua estrutura também afetará a velocidade do sistema. Além disso, desenvolvedores 1C experientes recomendam não descrever algoritmos em módulos de formulário, mas colocá-los em módulos gerais configurados corretamente.

Ao desenvolver módulos gerais, as regras geralmente aceitas para sua criação devem ser levadas em consideração:

• Coloque procedimentos e funções relacionados a funcionalidades semelhantes em um módulo comum separado;
• O nome do módulo deve refletir sua pertença ao contexto (Cliente, Servidor) e evitar palavras comuns (manipuladores, procedimentos, etc.);
• Separe a lógica interna do servidor da aplicação e a lógica do cliente da interface;
• Tenha cuidado ao criar um módulo compartilhado global. Não ter que se referir a um procedimento através do nome do módulo pode causar confusão, especialmente se o sistema for suportado por múltiplas equipes de desenvolvimento.

Módulos criados corretamente o ajudarão a navegar na estrutura de configuração e a fazer melhorias com muito mais rapidez. Se você vir uma oportunidade de tornar universal uma função útil e colocá-la em um módulo comum, faça-o. No futuro, você e seus colegas ficarão gratos por esta decisão.

Imprimir (Ctrl+P)

Os objetos localizados no ramo Módulos Gerais da árvore de configuração destinam-se a conter os textos de funções e procedimentos que podem ser chamados a partir de qualquer outro módulo de configuração.
ATENÇÃO! Um módulo geral só pode conter definições de procedimentos e funções.
Os procedimentos e funções de um módulo comum para o qual a palavra-chave Export é especificada em seus cabeçalhos são um dos componentes do contexto global. Mais informações sobre como escrever procedimentos em um módulo geral podem ser encontradas nas seções “Formato dos textos fonte dos módulos do programa” e “Operadores” da ajuda integrada da linguagem.
Para editar um módulo comum, na paleta de propriedades de um objeto do tipo Módulos Comuns na janela Configuração, na propriedade Módulo, clique no link Abrir. O texto do módulo geral será emitido para edição no editor de texto do sistema 1C:Enterprise no modo de edição de texto do módulo de software.
O módulo comum, por fazer parte da configuração, é salvo apenas como parte da configuração.
A propriedade Global determina se os métodos exportados de um módulo comum fazem parte do contexto global.
Se a propriedade Global estiver configurada como True, então os métodos exportados do módulo comum estarão disponíveis como métodos do contexto global.
Se a propriedade Global estiver definida como False, uma propriedade será criada no contexto global com um nome que corresponda ao nome do módulo comum nos metadados. Esta propriedade é somente leitura. O valor desta propriedade é o objeto GeneralModule. Os métodos exportados deste módulo comum estão disponíveis através deste objeto. Assim, o acesso aos métodos de módulos compartilhados não globais se parece com XXXXX.YYYYY, onde XXXXX é o nome da propriedade correspondente ao contexto do módulo compartilhado e YYYYY é o nome do método exportado do módulo compartilhado.
Exemplo:

Trabalhando COM Equipamentos de Varejo.ConnectBarcode Scanner();

Vários contextos e módulos comuns

Usando as propriedades dos módulos comuns e instruções do pré-processador, você pode organizar a execução de vários métodos de módulos comuns no contexto desejado.
Cada propriedade de um módulo comum é responsável pela capacidade de compilar (e executar) o módulo comum em um contexto específico.
Estão disponíveis as seguintes propriedades, que são responsáveis ​​pelo contexto em que os métodos do módulo geral estão disponíveis:
● Cliente (aplicativo normal)– os métodos do módulo comum estarão disponíveis para o cliente grosso no modo de aplicação normal;
● – os métodos do módulo geral estarão disponíveis para o thin client, web client, bem como para o heavy client em
modo de aplicativo gerenciado;
● Servidor – os métodos do módulo comum estarão disponíveis no servidor;
● Junção externa– métodos do módulo comum estarão disponíveis na conexão externa.
Se várias propriedades forem definidas ao mesmo tempo, isso significa que os métodos do módulo comum estarão disponíveis em vários contextos.
Se um módulo comum possuir a propriedade Servidor e qualquer outra propriedade definida, isso significa que o módulo comum estará disponível simultaneamente no servidor e no cliente selecionado. É preciso entender que na verdade serão várias versões do código compilado (de acordo com a quantidade de clientes selecionados e do próprio servidor).
Além disso, se um método localizado em tal módulo comum for chamado do lado do cliente, então a cópia do cliente do módulo comum será usada e, se for do servidor, a cópia do servidor. Neste caso, usando diretivas de pré-processador (veja aqui para mais detalhes), você pode “proteger” o servidor de códigos que não podem ser executados nele.
Vejamos um exemplo. No módulo comum (que pode ser executado no thin client e no servidor) existe um método que possui comportamento um pouco diferente no lado do thin client e no lado do servidor. Vamos ver como isso pode ser feito:

#Se ThinClient então
//Mostra aviso
Mostrar alerta de usuário(“No cliente”);
#Fim se
Fim do procedimento
Então, no lado do servidor, o código ficará assim:
Procedimento Método CommonModule() Exportar
// Vários códigos importantes vão aqui
Fim do procedimento
E no lado do thin client o código ficará assim:
Procedimento CommonModule Method() Exportar
// Vários códigos importantes vão aqui
//Mostra aviso
ShowUserAlert(“No cliente”);
Fim do procedimento

Existem várias maneiras de transferir o controle do cliente para o servidor:
● chamar o método do módulo comum do servidor;
● em um formulário ou módulo de comando, chame um método precedido por diretivas de compilação &OnServer, &OnServerSem Contexto

Ao mesmo tempo, é impossível chamar métodos de módulos comuns do cliente (que não possuem a propriedade Servidor definida) e métodos de cliente de um módulo de formulário ou módulo de comando a partir de procedimentos do servidor. O controle retornará ao cliente após a conclusão da chamada do método do servidor externo.
A exceção são os métodos do módulo de formulário e do módulo de comando, que são precedidos por diretivas de compilação &OnClientOnServer, &OnClientOnServerSem Contexto
Os seguintes pontos também devem ser mencionados:
● Se um módulo comum estiver disponível para mais de um cliente, ao escrever o código do programa, você deverá considerar as restrições máximas que podem ser impostas pelos clientes ou usar instruções do pré-processador para “isolar” o código específico do cliente.
● As instruções do pré-processador também fazem sentido quando um módulo comum possui vários contextos de execução, por exemplo, uma conexão externa e um thin client, ou (o que é muito mais comum) algum cliente e um servidor. Nesse caso, as instruções do pré-processador enquadrarão o código interativo que não pode ser usado no servidor, mas pode ser usado no cliente (veja o exemplo acima).
Para obter mais informações sobre instruções de pré-processador e diretivas de compilação, consulte a seção “Execução de procedimentos e funções” da ajuda da linguagem incorporada.
A propriedade Call Server destina-se a controlar a capacidade de chamar métodos exportados do módulo comum do servidor a partir do código do cliente.
Se a propriedade for definida, os métodos exportados do módulo comum do servidor estarão disponíveis para chamada do cliente. Se a propriedade não estiver definida, esses métodos exportados só poderão ser chamados a partir de métodos do lado do servidor (ambos os métodos de módulos comuns do lado do servidor e métodos do lado do servidor de módulos de formulário e módulos de comando).
Conselho . Recomenda-se definir a propriedade Server Call como False nos casos em que o módulo comum do servidor contém métodos que você não deseja chamar do cliente (por exemplo, por motivos de segurança).
Observação. Se as propriedades forem definidas ao mesmo tempo Cliente (aplicativo normal), Cliente (aplicativo gerenciado), Junção externa, a propriedade Servidor de chamada será redefinida automaticamente. Se a propriedade Call server estiver definida, as propriedades serão redefinidas automaticamente Cliente (aplicativo normal), Cliente (aplicativo gerenciado) E Junção externa, se essas propriedades foram definidas ao mesmo tempo.
Propriedade Privilegiado destina-se a desabilitar o controle de direitos de acesso ao executar métodos de um módulo comum.
OBSERVAÇÃO. Se a propriedade Privilegiado instalado, a propriedade Servidor é automaticamente definida para o módulo comum e as propriedades restantes são redefinidas ( Cliente (aplicativo normal), Cliente (aplicativo gerenciado) e B conexão externa). Um módulo compartilhado privilegiado só pode ser executado no servidor.

Reutilizando valores de retorno

Se o módulo compartilhado não for global, a propriedade Reuse Return Values ​​ficará disponível. Esta propriedade pode assumir os seguintes valores:
● Não usar – Não há reutilização de valores de retorno para funções neste módulo comum.
● Por chamada e por sessão – O módulo compartilhado utiliza um método para determinar a reutilização de dados. A essência deste método é que durante a execução do código, o sistema lembra os parâmetros e o resultado das funções após a primeira chamada da função. Quando uma função é chamada novamente com os mesmos parâmetros, o valor armazenado (da primeira chamada) é retornado sem executar a função em si. Se uma função alterar os valores dos parâmetros durante sua execução, chamar a função novamente não fará isso.
Os seguintes recursos para salvar resultados de chamadas podem ser destacados:
● se uma função for executada no servidor e chamada a partir do código do servidor, os valores dos parâmetros e o resultado da chamada serão lembrados para a sessão atual no lado do servidor;
● se a função for executada em um cliente grosso ou fino, os valores dos parâmetros e resultados da chamada serão lembrados no lado do cliente;
● se uma função for executada no lado do servidor e chamada a partir do código do cliente, os valores dos parâmetros de chamada serão lembrados tanto no lado do cliente quanto no lado do servidor (para a sessão atual).
Os valores salvos são excluídos:
● se a propriedade estiver definida como Durante a chamada:
● no lado do servidor – ao retornar o controle do servidor;
● no lado do cliente – quando um procedimento ou função de linguagem interna de nível superior termina (chamado pelo sistema a partir da interface, e não de outro procedimento ou função de linguagem interna);
● se a propriedade do módulo compartilhado estiver definida como Durante a sessão:
● no lado do servidor – no final da sessão;
● no lado do cliente – ao fechar a aplicação cliente.
Os valores salvos serão excluídos:
● no servidor, no cliente grosso, na conexão externa, no cliente fino e no cliente web com velocidade de conexão normal - 20 minutos após o cálculo do valor armazenado ou 6 minutos após a última utilização;
● em thin client e web client com baixa velocidade de conexão – 20 minutos após cálculo do valor salvo;
● se houver falta de RAM no processo de funcionamento do servidor;
● ao reiniciar o fluxo de trabalho;
● quando o cliente muda para outro fluxo de trabalho.
Após a remoção dos valores, a chamada para a função exportada é realizada como na primeira chamada.
Esta propriedade dos módulos comuns não afeta a execução dos procedimentos - os procedimentos são sempre executados.

Se um módulo comum for configurado para reutilizar valores de retorno, diversas restrições serão impostas aos tipos de parâmetros exportados pela função. Os tipos de parâmetros só podem ser:
● Tipos primitivos ( Indefinido, NULL, Booleano, Número, String, Data).
● Quaisquer referências a objetos de banco de dados.
● Estruturas com valores de propriedade dos tipos acima. Neste caso, a identidade dos parâmetros é controlada “pelo conteúdo” das estruturas.
Se a função exportada retornar um objeto, na verdade ela retornará uma referência ao objeto armazenado no cache. Se, após receber esta referência, o estado do objeto mudar, então uma chamada subsequente para a mesma função retornará uma referência ao objeto já modificado sem realmente executar a função. Este comportamento continuará até que o valor armazenado seja excluído (por qualquer motivo). Em outras palavras, alterar o estado de um objeto resultante de uma chamada de função de um módulo comum com reutilização de valores de retorno não é a base para a chamada de função real. Você também deve lembrar que o cache dos objetos retornados é indiferente a
estado de modo privilegiado no momento em que a função é chamada, reutilizando valores de retorno. Esse recurso pode levar ao seguinte comportamento:
● A execução propriamente dita da chamada de função com reaproveitamento dos valores de retorno (a primeira chamada) foi realizada com o modo privilegiado habilitado.
● Ao executar uma função foi recebido um objeto que não pode ser recebido com o modo privilegiado desabilitado.
● As chamadas subsequentes para a função foram realizadas sem definir o modo privilegiado.
● Entretanto, até que o cache do objeto de retorno seja limpo ou a chamada real seja feita novamente, a função retornará um objeto formalmente inacessível.
● O comportamento inverso também é verdadeiro, quando a primeira chamada é feita sem configurar o modo privilegiado, e no modo privilegiado não é retornado um objeto que poderia ter sido recebido no modo privilegiado.

Se um módulo comum tiver a propriedade Reutilizando valores de retorno está definido como Durante a sessão, então valores do tipo não podem ser usados ​​nos valores retornados pelas funções de tal módulo Gerenciador de horário.
Se uma função de um módulo compartilhado, com capacidade de reutilização definida, for chamada de dentro do mesmo módulo compartilhado (por exemplo, denominado GeneralModule), então a seguinte advertência deve ser mantida em mente: se a função for chamada pelo nome MyFunction() , então a função será executada toda vez que a função for chamada. Para que os valores armazenados possam ser utilizados, a função deve ser chamada pelo seu nome completo:
GeralModule.MyFunction().
O método de contexto global remove todos os valores reutilizados, tanto do lado do servidor quanto do lado do cliente, independentemente de onde o método é chamado. Depois de executar o método AtualizarValoresReutilizados() a primeira chamada de função será executada completamente.

Módulos 1C gerais- um objeto de metadados de configuração para 1C 8.3 e 8.2, que armazena o código do programa que é frequentemente chamado na configuração. Uma função/procedimento pode ser chamada de qualquer lugar na configuração (se for de exportação).

Como usar o módulo compartilhado

É uma boa prática colocar um procedimento ou função em um módulo comum se for chamado em mais de um local. Primeiramente, se o procedimento for corrigido, ele precisa ser corrigido em apenas um local. Em segundo lugar, isto consegue uma maior ordem no código.

Um exemplo típico de módulo geral é o processamento de lançamento em algum cadastro, obtenção do valor da diferença em dias úteis, recálculo de taxas de câmbio, recálculo de quantidade/preço/valor na seção tabular e outras funções.

Propriedades de módulos comuns

Uma das principais características dos módulos compartilhados de outros módulos é que você não pode declarar variáveis ​​compartilhadas.

Obtenha 267 videoaulas em 1C gratuitamente:

Vamos dar uma olhada mais de perto na paleta de propriedades do módulo geral:

• Global- se o sinalizador estiver definido, as funções e procedimentos deste módulo ficam disponíveis no contexto global. Aqueles. eles podem ser chamados em qualquer lugar da configuração acessando sem o nome do módulo comum. No entanto, uma condição é adicionada: os nomes dos procedimentos e funções neste módulo comum devem ser exclusivos no contexto global.
• Servidor— procedimentos e funções deste módulo comum podem ser executados no servidor.
• Junção externa— os códigos de programa deste módulo comum podem ser executados quando conectados por uma fonte externa (por exemplo, COM).
• Cliente (aplicativo gerenciado)— procedimentos e funções deste módulo comum podem ser usados ​​em um cliente grosso no modo de aplicativo gerenciado.
• Cliente (aplicativo normal)— os códigos de programa deste módulo comum podem ser usados ​​em um cliente grosso no modo de aplicação normal.
• Chamada de servidor— um sinalizador que permite ao cliente usar procedimentos e funções deste módulo comum.
• - se definido como True, a verificação de direitos de acesso será desabilitada neste módulo comum.
• Reuso— define as configurações dos valores retornados; se a opção estiver habilitada, após a primeira execução o sistema lembrará o valor desses parâmetros de entrada e retornará um valor pronto. Pode assumir os seguintes valores: não usado- desligar, durante a chamada- durante um determinado procedimento, durante a sessão— até que o usuário feche a sessão (programa).

Se você está começando a aprender programação 1C, recomendamos nosso curso gratuito (não se esqueça