Nelle forme regolari, la posizione degli elementi viene disegnata interamente manualmente. Per facilitare questo processo, la piattaforma offre diversi meccanismi:

- allineamento degli elementi- fornisce la centratura automatica o la "pressione" dei controlli sulle linee guida reciproche o l'allineamento delle dimensioni dei controlli:

- netto- tramite le Opzioni è possibile configurare la visualizzazione della griglia per un preciso allineamento manuale degli elementi:

La risposta corretta è la seconda. Questo è un pannello per allineare e unificare le dimensioni degli elementi.

Domanda 10.79 dell'esame 1C: Platform Professional.

1. Nulla cambierà
2. L'elemento "Iscrizione1" verrà spostato orizzontalmente e il suo bordo destro sarà allineato con il bordo destro dell'elemento "Iscrizione2"
3. L'elemento "Iscrizione2" verrà spostato orizzontalmente e il suo bordo destro sarà allineato con il bordo destro dell'elemento "Iscrizione1"
4. Entrambi gli elementi si sposteranno sulla linea di allineamento del bordo destro del modulo

La risposta corretta è la seconda. Le etichette verranno allineate a destra.

Domanda 10.82 dell'esame 1C: Platform Professional. Cosa succede quando fai clic sul pulsante della barra dei comandi contrassegnato nell'immagine?

1. Tutte le iscrizioni avranno la stessa dimensione in orizzontale
2. Nulla cambierà
3. Le etichette si sposteranno. L'asse di simmetria verticale di ciascun elemento di controllo coinciderà con l'asse di simmetria verticale della forma, cioè centrando ciascun controllo orizzontalmente
4. Le etichette si sposteranno orizzontalmente. I controlli non si sposteranno l'uno rispetto all'altro all'interno del gruppo, ad es. centrando, per così dire, un elemento nel suo insieme
5. Le etichette si sposteranno verticalmente. I controlli non si sposteranno l'uno rispetto all'altro all'interno del gruppo, ad es. centrando, per così dire, un elemento nel suo insieme

La risposta corretta è la quarta. Tutti i controlli selezionati verranno centrati attorno alla linea centrale comune.

Domanda 10.83 dell'esame 1C: Platform Professional. Cosa succede quando fai clic sul pulsante della barra dei comandi contrassegnato nell'immagine?

1. Tutte le iscrizioni avranno la stessa dimensione verticalmente. Come esempio verrà preso l'elemento di controllo "Inscription1".
2. Nulla cambierà
3. Tutte le iscrizioni avranno la stessa dimensione verticalmente. Come esempio verrà preso in considerazione l'elemento di comando "Inscription3".
4. Ciascuna etichetta sarà centrata verticalmente
5. Ci sarà una distribuzione uniforme delle iscrizioni nella direzione verticale. I controlli "Iscrizione1" e "Iscrizione3" rimarranno al loro posto e l'elemento "Iscrizione2" verrà spostato nella direzione desiderata. Quando si sposta un elemento, lo snap alla griglia di layout non viene preso in considerazione
6. Ci sarà una distribuzione uniforme delle iscrizioni nella direzione verticale. I controlli "Iscrizione1" e "Iscrizione3" rimarranno al loro posto e l'elemento "Iscrizione2" verrà spostato nella direzione desiderata. Quando sposti un elemento, questo si aggancerà alla griglia di marcatura se è impostata la modalità per il suo utilizzo

La risposta corretta è la prima. L'altezza degli elementi sarà standardizzata

Domanda 10.86 dell'esame 1C: Platform Professional. Cosa succede se clicchi sul pulsante cancellato della barra dei comandi nell'immagine?

1. Tutte le iscrizioni avranno la stessa dimensione verticalmente e orizzontalmente. Come esempio verrà preso l'elemento di controllo "Inscription1".
2. Tutte le iscrizioni avranno la stessa dimensione verticalmente e orizzontalmente. Come esempio verrà preso in considerazione l'elemento di comando "Inscription3".
3. Nulla cambierà
4. Le etichette verranno allineate automaticamente
5. Tutte le etichette avranno uno sfondo trasparente.

La risposta corretta è la numero quattro, il pulsante stesso si chiama "Allinea automaticamente"

Domanda 10.90 dell'esame 1C: Platform Professional. Disabilita la modalità di allineamento utilizzando le linee di allineamento in un modulo creato in precedenza:

1. È vietato
2. Potere. Per fare ciò, nella tavolozza delle proprietà del modulo, è necessario disabilitare la proprietà "Utilizza linee di allineamento".
3. Potere. Per fare ciò, selezionando la voce del menu principale "Strumenti-Opzioni", nella scheda "Modulo", è necessario disabilitare la proprietà "Utilizza linee di allineamento"
4. Potere. Per fare ciò, nella tavolozza delle proprietà del modulo è necessario disabilitare la proprietà "Utilizza linee di allineamento" oppure, selezionando la voce del menu principale "Strumenti-Opzioni", nella scheda "Modulo", disabilitare la proprietà "Utilizza linee di allineamento"

La risposta corretta è la seconda. Le linee di allineamento (contrassegnate da una freccia) sono disabilitate dalla proprietà del modulo corrispondente:

Domanda 10.92 dell'esame 1C: Platform Professional. Quando si allineano gli elementi del modulo, potrebbe essere visualizzata una griglia di layout:

1. Linee continue
2. Punti della scacchiera
3. Punti situati all'intersezione delle linee di marcatura
4. Le risposte 1 e 2 sono corrette
5. Le risposte 2 e 3 sono corrette
6. Le risposte 1, 2 e 3 sono corrette

La risposta corretta è la quinta. La posizione dei punti è controllata dall'opzione Scacchiera nei Parametri di sistema (vedi screenshot nel post).

Domanda 10.95 dell'esame 1C: Platform Professional.

1. Uno speciale indicatore di allineamento che mostra l'offset dei controlli. Viene proposto di spostare a sinistra l'elemento di controllo selezionato
2. Uno speciale indicatore di allineamento che mostra l'offset dei controlli. Viene proposto di spostare verso il basso l'elemento di controllo selezionato
3. Uno speciale indicatore di allineamento che mostra la sovrapposizione dei controlli. Viene proposto di spostare a sinistra l'elemento di controllo selezionato
4. Uno speciale indicatore di allineamento che mostra la sovrapposizione dei controlli. Viene proposto di spostare verso il basso l'elemento di controllo selezionato

La risposta corretta è la prima. Il margine inferiore è spostato a destra rispetto a quello superiore, quindi si propone di spostarlo a sinistra.

Domanda 10.96 dell'esame 1C: Platform Professional. Posso utilizzare le linee di allineamento per ridimensionare e spostare i controlli del modulo?

1. È vietato
2. Sì, se i controlli sono collegati a queste linee
3. È possibile se i controlli sono collegati a queste linee, ma le spostano solo
4. È possibile se i controlli sono allegati a queste righe, ma solo ridimensionare
5. Puoi sempre

La risposta corretta è la seconda. Gli elementi attaccati alla stessa tirante possono essere spostati insieme.

Domanda 10.97 dell'esame 1C: Platform Professional. Nella figura il cerchio rosso segnala:

1. Uno speciale indicatore di allineamento che mostra l'offset dei controlli. Viene proposto di spostare l'elemento di controllo selezionato verso sinistra e verso l'alto
2. Uno speciale indicatore di allineamento che mostra l'offset dei controlli. L'elemento di controllo selezionato può essere spostato verso destra e verso il basso
3. Uno speciale indicatore di allineamento che mostra la sovrapposizione dei controlli. Viene proposto di spostare l'elemento di controllo selezionato verso sinistra e verso l'alto
4. Uno speciale indicatore di allineamento che mostra la sovrapposizione dei controlli. L'elemento di controllo selezionato può essere spostato verso destra e verso il basso

La risposta corretta è la quarta. Dove puntano le frecce, devi spostarti lì.

Domanda 10.98 dell'esame 1C: Platform Professional. Nella figura il cerchio rosso segnala:

Domanda 10.110 dell'esame 1C: Platform Professional. Come posso utilizzare il pulsante della barra dei comandi mostrato in figura per allineare tutte e tre le etichette a destra?

1. Per prima cosa seleziona il controllo “Iscrizione1” cliccandoci sopra con il tasto sinistro del mouse e premendo contemporaneamente il tasto . Successivamente premere il pulsante indicato
2. Basta cliccare sul pulsante indicato
3. Utilizzando questo pulsante non è possibile allineare le etichette, poiché appartengono a pannelli diversi

La risposta corretta è la terza. L'allineamento funziona all'interno di un singolo pannello.

Domanda 10.115 dell'esame 1C: Platform Professional. Per visualizzare una griglia di layout in un form già esistente è sufficiente:

1. Nella tavolozza delle proprietà del modulo, imposta la proprietà "Usa griglia".
2. Selezionando la voce del menu principale “Strumenti-Opzioni”, nella scheda “Modulo”, impostare il flag “Usa Griglia”
3. Selezionando la voce del menu principale “Strumenti-Opzioni”, nella scheda “Modulo”, impostare il flag “Griglia di visualizzazione”
4. Selezionando la voce del menu principale "Strumenti-Opzioni", nella scheda "Modulo", impostare il flag "Griglia di visualizzazione", quindi nella tavolozza delle proprietà del modulo impostare la proprietà "Usa griglia"
5. Selezionando la voce del menu principale "Strumenti-Opzioni", nella scheda "Modulo", impostare i flag "Griglia di visualizzazione" e "Usa griglia"

La risposta corretta è la quarta; per il form è possibile specificare anche l'opzione se visualizzarlo o meno.

19.05.2015

Implementato nella versione 8.3.7.1759.

Per rendere chiaro di cosa parliamo in questo articolo è necessario fare una piccola spiegazione.

Una caratteristica dei moduli gestiti è che lo sviluppatore non modifica direttamente l'aspetto del modulo. Lo sviluppatore crea solo una descrizione del modulo utilizzando alcune regole logiche. Sulla base di queste regole, la piattaforma genera autonomamente una rappresentazione visiva del modulo. Inoltre, questa rappresentazione visiva dipende dalla dimensione della finestra in cui viene visualizzato il modulo. La stessa maschera mostrata in una finestra stretta o in una finestra espansa a schermo intero avrà un aspetto visivo diverso.

Quindi, quella parte della piattaforma che costituisce la rappresentazione visiva del modulo è chiamata meccanismo per posizionare gli elementi nel modulo.

Perché era necessario un nuovo meccanismo?

In primo luogo, il meccanismo precedente, purtroppo, presentava delle carenze. Il più significativo di questi era che molte modifiche alle proprietà degli elementi del modulo eseguite sul client richiedevano una chiamata al server. E qualsiasi accesso al server porta a un rallentamento.

In secondo luogo, abbiamo valutato l'esperienza di utilizzo dei moduli gestiti e scoperto una serie di esigenze critiche che dovevano essere affrontate.

In terzo luogo, volevamo integrare nel nuovo meccanismo opportunità di sviluppo futuro.

Principali cambiamenti

Il funzionamento del meccanismo precedente può essere schematicamente rappresentato come segue:

Lo sviluppatore crea un albero di elementi del modulo nel configuratore e imposta le proprietà degli elementi. Nel momento in cui la soluzione applicativa deve mostrare il modulo all'utente, accade quanto segue. Innanzitutto, la piattaforma crea una descrizione del modulo visivo sul server. Quindi questa descrizione viene trasmessa al cliente. E sul client, il visualizzatore genera l'immagine che l'utente vedrà.

L'azione principale eseguita sul server durante la creazione di una descrizione del modulo visivo è stata il calcolo della lunghezza delle linee. Questo si riferisce a tutti i tipi di titoli, iscrizioni e così via. Conoscendo la lunghezza delle linee, puoi già calcolare la disposizione degli elementi nel modulo.

Poiché questa operazione è stata eseguita sul server, si sono verificati due aspetti negativi. Innanzitutto, per il calcolo non abbiamo utilizzato i caratteri che verranno utilizzati sul client, ma quelli installati sul server. E possono differire, soprattutto quando si tratta di piattaforme diverse (Windows, Linux). Oppure è possibile che i caratteri necessari non siano affatto installati sul server. In secondo luogo, per calcolare le lunghezze, abbiamo utilizzato il motore di rasterizzazione dei caratteri presente sul server. E potrebbe non funzionare esattamente come il meccanismo per il rendering delle stringhe di testo che esiste sul client in un browser Internet, ad esempio. Di conseguenza, i moduli potrebbero apparire con testi “troncati” o, al contrario, con iscrizioni troppo larghe.

Un altro problema era che non veniva adattata la dimensione della finestra in cui il modulo sarebbe stato mostrato al cliente. Sul server, infatti, la descrizione del modulo è stata creata in base alla dimensione minima possibile della finestra, e l'ulteriore successo della sua visualizzazione dipendeva da quanto bene “può” allungarsi.

Nel nuovo meccanismo abbiamo diviso la generazione di una descrizione di un modulo visivo, che prima veniva eseguita interamente sul server, in due parti, server e client:

La parte server è diventata notevolmente più piccola. Non esegue alcun calcolo. Sul server viene creata solo una descrizione "vuota", che non contiene la lunghezza esatta dei campi di testo e in essa non sono ammessi elementi di adattabilità. Il server gestisce la visibilità degli elementi, ma solo quella determinata dalle opzioni funzionali e quella impostata dall'utente. Ma qui è impossibile fare diversamente, perché le opzioni funzionali stesse sono disponibili solo sul server. E la modifica interattiva delle impostazioni da parte dell'utente porterà in ogni caso a una chiamata al server.

Il risultato è una sorta di “prodotto semilavorato” di una rappresentazione visiva della forma, che viene trasferita al cliente.

Sul client vengono apportate le modifiche necessarie alla descrizione della forma visiva. Vengono calcolate le lunghezze delle linee, gli elementi di reattività relativi alle dimensioni del display del client e la visibilità. Successivamente, come prima, inizia a funzionare il visualizzatore, che crea la forma finale che il cliente vede.

Dato che il calcolo della lunghezza delle stringhe viene effettuato sul client, siamo riusciti a eliminare gli “spazi” non necessari e sciatti tra gli elementi. E l'elaborazione della visibilità sul client senza accedere al server ha permesso di accelerare il lavoro dei moduli. Perché attivare/disattivare la visibilità degli elementi del modulo è una delle operazioni più comuni.

Alcune nuove funzionalità

Elementi dell'interfaccia reattiva

Il nuovo meccanismo per posizionare gli elementi nel modulo non solo migliora le funzionalità disponibili in precedenza, ma aggiunge anche nuove funzionalità. Ad esempio, adatta l'aspetto del modulo alle dimensioni del display del client. Esistono diversi modi per farlo.

Innanzitutto viene eseguito l'avvolgimento automatico della riga, regolando l'altezza delle intestazioni e delle decorazioni. Puoi vedere come funziona nella figura:

Se nel modulo sono presenti righe lunghe che possono essere suddivise in singole parole, tali righe vengono, se necessario, spostate a capo. Di conseguenza, l'altezza della forma aumenta, perché la sua parte inferiore “si sposta” verso il basso. Di conseguenza, il modulo apparirà normale anche su schermi stretti. Inoltre, questo meccanismo funziona in modo dinamico, il che significa che puoi comprimere il modulo in tempo reale e con esso si avvolgeranno lunghe righe.

Il ritorno a capo automatico funziona per titoli di elementi, titoli di gruppi, decorazioni di testo e testo nei pulsanti che dispongono della visualizzazione Collegamento ipertestuale.

Il secondo elemento di adattabilità sta cambiando l'orientamento dei gruppi. I gruppi e il modulo nel suo insieme hanno una nuova opzione di orientamento: "Orizzontale se possibile". In questa opzione, se il display del client consente il posizionamento orizzontale degli elementi, questi verranno posizionati orizzontalmente. In caso contrario, si trovano verticalmente.

Il terzo elemento di adattabilità è la determinazione automatica del numero di colonne di un interruttore o di un interruttore a levetta. In precedenza, a meno che non vi fossero istruzioni speciali, il numero di colonne era impostato al massimo e veniva visualizzato su una riga. Ora, nella stessa situazione, viene analizzata la larghezza del modulo e il numero di colonne viene impostato in modo che l'interruttore/interruttore a levetta abbia un bell'aspetto sullo schermo.

Allineamento orizzontale e verticale

In precedenza, questa possibilità era assente e per implementare l'allineamento non standard era necessario inventare vari "trucchi". Ora è possibile specificare il modulo e il gruppo in che modo i suoi elementi devono essere allineati verticalmente e orizzontalmente. Ad esempio, nell'immagine seguente, un gruppo di pulsanti mostra tre possibili opzioni di allineamento: Sinistra, Centro e Destra:

In questa immagine i pulsanti sono disposti in un gruppo regolare che si estende orizzontalmente. Il posizionamento dei pulsanti all'interno di un gruppo è controllato dalla proprietà HorizonPositionSubordinates del gruppo.

Controllo dell'allineamento esterno

Ad esempio, disponi di un modulo in cui si trovano il campo Reparto, i gruppi Indirizzo e Telefono. Il meccanismo precedente allineava i campi di questi gruppi come mostrato nella figura a sinistra. I campi del modulo erano allineati tra loro e i campi di ciascun gruppo erano allineati tra loro.

Ora hai la possibilità di impostare l'allineamento end-to-end per i gruppi, in conseguenza del quale, ad esempio, tutti i campi del modulo saranno allineati allo stesso modo. Questa opzione è mostrata nell'immagine a destra.

Inoltre, puoi gestire l'allineamento end-to-end per ciascun gruppo separatamente. Pertanto, puoi, ad esempio, disabilitare l'allineamento end-to-end per il gruppo Telefono, quindi il modulo apparirà come mostrato nella figura a destra.

Allineamento di elementi e intestazioni

Un'altra nuova funzionalità apparsa è la capacità di controllare la posizione relativa di elementi e intestazioni. Sia in tutte le forme che nei singoli gruppi. Ad esempio, puoi “allungare” intestazioni ed elementi su diversi bordi del modulo o, viceversa, “tirarli” l'uno verso l'altro, allineando le intestazioni a destra e gli elementi a sinistra.

Limitazione della larghezza massima degli elementi

In precedenza, se dicevi a un elemento di allungarsi, l'elemento si allungava il più possibile. Ad esempio, a schermo intero. Per alcuni elementi questo era buono (come un campo HTML), ma per altri elementi potrebbe non essere così buono. Ad esempio, per i campi numerici. Perché i dati numerici, o i pulsanti che controllano il campo, sono finiti da qualche parte molto più a destra.

Ora gli elementi hanno proprietà booleane, con le quali puoi impostare la modalità di allungamento automatico in larghezza o altezza. In questa modalità, la piattaforma determina autonomamente fino a quali limiti il ​​campo può essere allungato. Se la modalità automatica è disabilitata, la piattaforma si comporterà come prima. Se specifichi una larghezza/altezza di campo specifica, verrà utilizzata quella. E se specifichi il valore 0, l'elemento si allungherà il più possibile.

Controllo della spaziatura tra gli elementi

È anche possibile controllare la spaziatura orizzontale e verticale tra gli elementi. Ad esempio, nella figura seguente, il gruppo di sinistra ha aumentato la spaziatura verticale, mentre il gruppo di destra ha ridotto la spaziatura verticale.

Disabilita l'allungamento del modulo

Abbiamo implementato un'altra, nuova modalità di funzionamento del modulo, che disabilita l'allungamento verticale dei suoi elementi. Questa modalità sarà utile per i moduli contenenti un numero limitato di elementi.

Disabilita lo scorrimento delle pagine

Per i moduli contenenti un gran numero di elementi, abbiamo anche modificato leggermente il comportamento. Ora lo scorrimento verticale non appare sulle pagine. Lo scorrimento verticale ora può avvenire sul modulo stesso o all'interno degli elementi del modulo, come una tabella, un foglio di calcolo e così via. E la pagina del modulo sarà sempre a tutta altezza. Ciò dovrebbe rendere l'esperienza dell'utente più semplice, poiché un gran numero di scroller su un modulo può spesso creare confusione e confusione.

Riepilogo

In questo articolo di recensione abbiamo elencato solo le principali funzionalità fornite dal nuovo meccanismo per l'inserimento degli elementi nel modulo. Ma non meno importante, a nostro avviso, è che questo meccanismo contiene una riserva significativa per lo sviluppo futuro.

E oggetto di trasferimento dati per strutturare il codice, forma controllata nell'ambiente 1C 8.2.

introduzione

Cominciamo con una breve descrizione del concetto di "modulo gestito" e dei concetti correlati della piattaforma 1C. Gli intenditori della piattaforma potrebbero voler saltare questa sezione.

Nel 2008 è diventata disponibile una nuova versione della piattaforma 1C: Enterprise 8.2 (di seguito denominata Applicazione gestita), che modifica completamente l'intero livello di lavoro con l'interfaccia. Ciò include l'interfaccia di comando, i moduli e il sistema a finestre. Allo stesso tempo, non solo cambia il modello per lo sviluppo dell'interfaccia utente nella configurazione, ma viene proposta anche una nuova architettura per separare le funzionalità tra l'applicazione client e il server.
L'applicazione gestita supporta i seguenti tipi di client:

• Thick client (modalità di avvio normale e gestita)
• Cliente sottile
• Cliente Web

L'applicazione gestita utilizza moduli basati sulla nuova tecnologia. Si chiamano Moduli gestiti. Per facilitare la transizione, sono supportati anche i moduli precedenti (i cosiddetti moduli Regular), ma le loro funzionalità non sono sviluppate e sono disponibili solo nella modalità di lancio del Thick Client.
Le principali differenze dei moduli gestiti per uno sviluppatore:

• Descrizione dichiarativa, non “pixel per pixel” della struttura. Il posizionamento specifico degli elementi viene eseguito automaticamente dal sistema quando viene visualizzato il modulo.
• Tutte le funzionalità del modulo sono descritte come dettagli E squadre. I dettagli sono i dati con cui funziona il modulo e i comandi sono le azioni da eseguire.
• Il modulo viene eseguito sia sul server che sul client.
• Nel contesto client quasi tutti i tipi di applicazioni non sono disponibili e di conseguenza è impossibile modificare i dati nell'infobase.
• Per ogni metodo o variabile del modulo è necessario specificarlo direttiva di compilazione, definendo la posizione di esecuzione (client o server) e l'accesso al contesto del modulo.

Elenchiamo le direttive per la compilazione dei metodi del form:

• &SuClient
• &Sul server
• &OnServerSenza contesto
• &OnClientOnServerSenza contesto

Illustriamo quanto sopra. Lo screenshot mostra un esempio di modulo gestito e il relativo modulo in modalità di sviluppo. Trova la descrizione dichiarativa, gli oggetti di scena, le direttive di compilazione, ecc.

Tutte le ulteriori discussioni riguarderanno il lato destro dell'illustrazione, come strutturare il codice del modulo e quali principi ti permetteranno di implementare un'efficace interazione client-server.

Definiamo il problema

Sono passati diversi anni da quando la nuova versione della piattaforma 1C viene utilizzata attivamente e molte soluzioni (configurazioni) sono state rilasciate sia da 1C che dai suoi numerosi partner.
Durante questo periodo, gli sviluppatori hanno sviluppato una comprensione comune dei principi dell'interazione client-server durante la creazione di moduli e l'approccio all'implementazione dei moduli software è cambiato nelle nuove realtà architettoniche?

Diamo un'occhiata alla struttura del codice (modulo del modulo) in diversi moduli della stessa configurazione standard e proviamo a trovare dei modelli.
Per struttura intendiamo sezioni di codice (molto spesso si tratta di blocchi di commenti) assegnate dallo sviluppatore a metodi di gruppo e direttive di compilazione per questi metodi.
Esempio 1:
Sezione dei gestori eventi Metodo - sul client Metodo - sul server Metodo - sul client Sezione delle procedure e funzioni del servizio Funzioni di controllo degli input ausiliari
Esempio 2:
Procedure e funzioni del servizio Documenti di pagamento Valori Gestori di eventi
Esempio 3:
Procedure di servizio sul server Procedure di servizio sul client Procedure di servizio sul server senza contesto Gestori di eventi di intestazione Gestori di eventi di comando
Esempio 4:
Procedure di uso generale Gestori di eventi del modulo Procedure del sottosistema “informazioni di contatto”.
In sostanza, manca la struttura del codice o, per dirla in parole povere, è simile a quella del Forms 8.1:

• Parole non informative “Generale, Servizio, Ausiliario”.
• Tentativi timidi di separare i metodi client e server.
• I metodi sono spesso raggruppati per elementi dell'interfaccia "Lavorare con la parte tabellare Prodotti, Informazioni di contatto".
• Disposizione arbitraria di metodi e gruppi di codici. Ad esempio, i gestori di eventi potrebbero essere in alto in un modulo, in basso in un altro, non evidenziati affatto in un terzo, ecc.
• E non dimentichiamo che tutto questo è all'interno di un'unica configurazione.
• Sì, ci sono configurazioni in cui le parole “Generale, Servizio, Ausiliario” sono sempre negli stessi posti ma...

Perché hai bisogno della struttura del codice?

• Semplificazione della manutenzione.
• Semplifica l'apprendimento.
• Registrare principi generali/importanti/di successo.
• ...la tua opzione

Perché lo standard di sviluppo esistente di 1C non aiuta?

Diamo un'occhiata ai principi pubblicati sui dischi ITS e in varie “Guide per sviluppatori...” che sono consigliati quando si scrive un modulo gestito.

• Ridurre al minimo il numero di chiamate al server.
• Massimo calcolo sul server.
• Le chiamate al server non contestuali sono più veloci di quelle contestuali.
• Programma pensando alla comunicazione client-server.
• e così via.

Sono slogan assolutamente veri, ma come metterli in pratica? Come ridurre al minimo il numero di chiamate, cosa significa programmare in modalità client-server?

Design pattern o saggezza generazionale

L'interazione client-server è utilizzata da decenni in varie tecnologie software. La risposta alle domande delineate nella sezione precedente è nota da tempo e si riassume in due principi fondamentali.

• Facciata remota(di seguito denominata Interfaccia di accesso remoto)
• Oggetto di trasferimento dati(di seguito denominato Oggetto di trasferimento dati)

Una parola di Martin Fowler, la sua descrizione di questi principi:

• … Ogni oggetto potenzialmente destinato all'accesso remoto deve avere interfaccia a bassa granularità, che ridurrà al minimo il numero di chiamate necessarie per eseguire una determinata procedura. ... Invece di richiedere una fattura e tutte le sue voci separatamente, è necessario leggere e aggiornare tutte le voci della fattura in un'unica richiesta. Ciò influisce sull'intera struttura dell'oggetto... Ricorda: interfaccia di accesso remoto non contiene la logica del dominio.
• ...se fossi una madre premurosa, direi sicuramente a mio figlio: "Non scrivere mai oggetti di trasferimento dati!" Nella maggior parte dei casi, gli oggetti di trasferimento dati non sono altro che set da campo gonfio... Il valore di questo mostro disgustoso risiede esclusivamente nella possibilità trasmettere più informazioni sulla rete in una chiamata- una tecnica di grande importanza per i sistemi distribuiti.

Esempi di modelli nella piattaforma 1C

L'interfaccia di programmazione dell'applicazione disponibile allo sviluppatore durante lo sviluppo di un modulo gestito contiene molti esempi di questi principi.
Ad esempio, il metodo OpenForm(), una tipica interfaccia “grezza”.
Parametri di apertura = Nuova struttura ("Parametro1, Parametro2, Parametro3", Valore1, Valore2, Valore3); Modulo = OpenForm(NomeForm, ParametriApertura);
Confronta con lo stile adottato nella v8.1.
Modulo = OttieniForm(NomeForm); Modulo.Parametro1 = Valore1; Modulo.Parametro2 = Valore2; Modulo.Apri();

Nel contesto di un modulo gestito, sono presenti numerosi "oggetti di trasferimento dati". Puoi selezionare sistemico E definito dallo sviluppatore.
Quelli di sistema modellano un oggetto applicativo sul client, sotto forma di uno o più elementi dati del modulo. È impossibile crearli senza fare riferimento ai dettagli del modulo.

• DataFormsStruttura
• DataFormsCollection
• DataFormStructureWithCollection
• DataShapesTree

La conversione degli oggetti di trasferimento dati di sistema in tipi di applicazioni e viceversa viene eseguita utilizzando i seguenti metodi:

• ValoreInFormData()
• ModuloDataValore()
• CopiaFormData()
• AttributiValoreInForm()
• ValoreAttributiForma()

Spesso viene utilizzata una conversione esplicita quando si adatta una soluzione esistente. I metodi possono prevedere (utilizzare funzionalità) parametri di input, come ValueTable anziché FormDataCollection, oppure il metodo è stato definito nel contesto di un oggetto dell'applicazione e non è più disponibile per la chiamata diretta dal modulo.
Esempio 1C v8.1:
// sul client nel contesto del modulo FillUserCache(DepartmentLink)
Esempio 1C v8.2:
// sul server nel contesto del modulo ProcessingObject = Form AttributesValue("Object"); ProcessingObject.FillUserCache(DepartmentRef); ValueFormAttributes(ProcessingObject, "Object");

Gli oggetti di trasferimento dati, la cui struttura è determinata dallo sviluppatore, sono un piccolo sottoinsieme dei tipi disponibili sia sul client che sul server. Molto spesso, come parametri e risultati dei metodi di un'interfaccia "grossolana" vengono utilizzati i seguenti:

• Tipi primitivi (stringa, numero, booleano)
• Struttura
• Corrispondenza
• Vettore
• Collegamenti agli oggetti dell'applicazione (identificatore univoco e rappresentazione testuale)

Esempio: il metodo accetta un elenco di ordini per modificare lo stato e restituisce al client una descrizione degli errori.
&OnServerWithoutContext Funzione ServerChangeOrderStatus(Ordini, NuovoStato) Errori = Nuova corrispondenza(); // [ordine] [descrizione dell'errore] Per ogni ordine dal ciclo degli ordini StartTransaction(); Prova DocOb = Order.GetObject(); …. altre azioni, possibili non solo con l'ordine... Eccezione CancelTransaction(); Errori.Inserisci(Ordine, DescrizioneErrore()); Finetentativo; FineCiclo; Errore di restituzione; EndFunction // ServerChangeOrderStatus()

Strutturare il codice

Gli obiettivi principali che il modulo del modulo gestito dovrebbe riflettere e gli approcci alla soluzione.

• Chiara separazione del codice client e server. Non dimentichiamo che al momento dell'esecuzione si tratta di due processi interagenti, ognuno dei quali ha funzionalità disponibili significativamente diverse.
• Chiara identificazione dell'interfaccia di accesso remoto, quali metodi server possono essere richiamati dal client e quali no? I nomi dei metodi di interfaccia remota iniziano con il prefisso "Server". Ciò consente di vedere immediatamente il trasferimento del controllo al server durante la lettura del codice e semplifica l'uso dell'aiuto contestuale. Tieni presente che la raccomandazione ufficiale (ITS) suggerisce metodi di denominazione con suffissi, ad esempio ChangeOrderStatusOnServer(). Ripetiamo però che non tutti i metodi server possono essere chiamati dal client, e quindi è più importante l'accessibilità logica, piuttosto che il luogo di compilazione. Quindi con il prefisso “Server” contrassegniamo solo i metodi disponibili al client; chiamiamo il metodo di esempio ServerChangeOrderStatus().
• Leggibilità. Questione di gusti, accettiamo l'ordine quando il modulo inizia con le procedure per creare un modulo sul server e le modalità di accesso remoto.
• Manutenibilità. Deve esserci una posizione chiara per l'aggiunta del nuovo codice. Un punto importante è che i modelli di metodo creati automaticamente dal configuratore vengono aggiunti alla fine del modulo. Poiché i gestori eventi per gli elementi del modulo vengono spesso creati automaticamente, il blocco corrispondente viene posizionato per ultimo, in modo da non trascinare ciascun gestore in un'altra posizione nel modulo.

Di seguito è riportata la struttura di base del modulo che implementa gli obiettivi elencati.

• Opzione grafica: mostra chiaramente il flusso principale di esecuzione.
• L'opzione testo è un esempio di modello di progettazione per inserire rapidamente una struttura in un nuovo modulo del modulo.

//////////////////////////////////////////////////////////////////////////////// // <(c) Автор=""Data=""/> // <Описание> // // /////////////////////////////////////////////// // /////////////////////////// // VARIABILI DEL MODULO ///////////////// // ///////////////////////////////////////////// //// ////////// // SUL SERVER //******* EVENTI SUL SERVER ******* &Sulla procedura del server quando viene creata sul server (errore, elaborazione standard) / /Inserire il contenuto del gestore Fine procedura //******* INTERFACCIA DI ACCESSO REMOTO ******* //******* LOGICA BUSINESS SUL SERVER ******* ///////// //////////////////////////////////////// /////// //////////////////// // METODI COMUNI DI CLIENT E SERVER /////////////// /////// ////////////////////////////////////////// ///// //////// // SUL CLIENTE //******* LOGICA AZIENDALE SUL CLIENTE ******* //******* TEAM * ****** //******** EVENTI CLIENTI ******* /////////////////////////// ///// //////////////////////////////////////////// // / / PRINCIPALI OPERATORI DEL PROGRAMMA

Domande correlate

In conclusione, delineeremo diverse aree a cui è utile pensare quando si programma l'interazione client-server.

• Opzioni di implementazione dell'interfaccia di accesso remoto. Asincronia, livello di dettaglio...
• Memorizzazione nella cache. 1C ha preso una decisione architettonica infruttuosa, introducendo la memorizzazione nella cache solo a livello di metodi di chiamata di moduli comuni e non fornendo funzionalità di controllo (tempo di pertinenza, ripristino su richiesta).
• Chiamate al server implicite. Non dimenticare le caratteristiche tecnologiche; molte operazioni “innocue” sul client provocano la piattaforma a contattare il server.

introduzione

Moduli gestiti. Un nuovo sviluppo 1C progettato per facilitare il lavoro dello sviluppatore, dandogli più tempo per scrivere codice semplificando la progettazione dell'interfaccia. In effetti, spesso risulta che il cosiddetto. Le "forme controllate" sono completamente incontrollabili. Gli UV non possono fare cose banali come minimizzare/massimizzare una finestra, per non parlare del suo posizionamento sullo schermo e dell'impostazione della sua dimensione in pixel. Forse queste funzioni sono state considerate non rivendicate e non sono state incluse nella nuova interfaccia, ma la pratica dimostra che a volte mancano molto. Da tempo il problema è stato parzialmente risolto da WSH, ma volevo qualcosa di più. In questo modo è stato implementato un componente esterno per rendere i “moduli gestiti” un po’ più gestibili.

Che cosa? Dove? Quando?

Questo VK è una libreria di funzioni per il controllo dello stato e della posizione delle finestre. La libreria contiene anche diverse utili funzioni di sistema.

Controllo dello stato della finestra:

Espandere ( Finestra di intestazione ) — espande la finestra a schermo intero

Comprimi (Titolo Finestra) - riduce a icona la finestra sulla barra delle applicazioni

Nascondi (Titolo Finestra) - nasconde la finestra (mentre il codice del modulo continua ad essere eseguito)

Spettacolo () - mostra l'ultima funzione nascosta nascondere() finestra

CollapseWindow (WindowTitle) - in ripristina la finestra al suo stato originale

Visibilità VERA (WindowTitle) - p controlla se la finestra è visibile sullo schermo

TRUE Espanso (WindowTitle) - controlla se la finestra è ingrandita a schermo intero

TRUE Collassato (WindowTitle) — controlla se la finestra è ridotta a icona sulla barra delle applicazioni

Imposta la trasparenza(Titolo finestra, coefficiente) - imposta la trasparenza della finestra. Il grado di trasparenza viene impostato utilizzando un coefficiente (0-255).

Controllo della posizione della finestra:

OttieniPosizione(Titolo della finestra, X, Y) - Ottiene le coordinate dell'angolo superiore sinistro della finestra rispetto allo schermo. Le coordinate vengono restituite tramite parametriX,Y.

Mossa(Titolo della finestra, X, Y) - sposta la finestra in una posizione specificataXY. In questo caso XYsono le coordinate dell'angolo in alto a sinistra della finestra.

Ottieni taglie- ottiene le dimensioni della finestra in pixel. I valori vengono restituiti tramite i parametri corrispondenti.

Imposta dimensioni(Titolo finestra, Larghezza, Altezza) - imposta la dimensione della finestra in pixel.

Funzioni del sistema:

OttieniPermessoCorrente(Horz, Verde) - ottiene la risoluzione dello schermo corrente. I valori vengono restituiti tramite i parametri corrispondenti.

GetPermissionList() - ottiene un elenco delle risoluzioni dello schermo disponibili nel sistema. I dati vengono restituiti nel formato “RESOL.1, RESOL.2, RESOL.3...”. Nell'elaborazione demo c'è un esempio di generazione di un elenco di permessi su un modulo.

SetPermission(Risoluzione schermo selezionato) - imposta la risoluzione dello schermo. Il parametro specifica il numero di serie dell'autorizzazione. L'elaborazione demo mostra un esempio di impostazione di una risoluzione da un elenco generato in precedenza.

Bonus:

Sonno (ora del sonno) sonno().Il tempo di sonno è indicato in millisecondi.

Segnale (frequenza, durata) - implementazione della funzione classicabip().Consente di impostare la frequenza e la durata del suono.

Totale

La libreria è stata scritta per le nostre esigenze e probabilmente verrà ulteriormente sviluppata secondo necessità. Se qualcuno ha un'idea brillante per espandere le sue funzionalità nell'ambito dell'argomento per il quale è stato concepito, scrivi i tuoi desideri. Se le idee si rivelano utili, verranno implementate.

Il set di consegna comprende: Una base con un VC collegato sotto forma di layout generale ed elaborazione dimostrativa. VK nell'archivio zip.