Modulstruktur

1C: Unternehmen 8.2 /
Für Entwickler /
Code-Konventionen

Inhaltsverzeichnis

1.1. In dem Programmmodul (allgemeine Module, Module von Objekten, Module von Objektmanagern, Module von Formularen, Befehle usw.) können im allgemeinen Fall die folgenden Abschnitte im Folgenden vorhanden sein Sequenzen :

Einige Abschnitte sind möglicherweise nur in Modulen eines bestimmten Typs vorhanden. Beispielsweise können Ereignishandler für Formularelemente nur in Formularmodulen vorhanden sein, und der Variablenbeschreibungsabschnitt und der Initialisierungsabschnitt können nicht in nicht globalen allgemeinen Modulen, Objektmanagermodulen, Datensatzgruppen, Konstantenwerten und Sitzungsmodulen definiert werden.

Die Anforderung, den Modulcode in Abschnitte zu unterteilen, soll die Lesbarkeit des Codes verbessern und die Einführung von Änderungen am Code durch verschiedene Autoren vereinfachen ( von Entwicklern ) wie in der kollektiven Entwicklung und in der Verfeinerung von Anwendungslösungen für bestimmte Implementierungen.

1.2. Vorlagenabschnitte (leer zum Kopieren) für allgemeine Module:

//////////////////////////////////////////////////// ////////////////////////////// // // // //////////// //////////////////////////////////////////////////// ////////////// ////////////////////////////////////// //////////////////////////////////////////// // // SOFTWARE-SCHNITTSTELLE // //////////////////////////////////////////////////// //////////////////////////// // SERVICEVERFAHREN UND -FUNKTIONEN

  • Der Abschnitt "Programmoberfläche" enthält Exportvorgänge und -funktionen, die von anderen Konfigurationsobjekten oder anderen Programmen (z. B. über eine externe Verbindung) verwendet werden sollen.
  • Der Abschnitt "Utility Procedures and Functions" enthält die Prozeduren und Funktionen, die die interne Implementierung eines allgemeinen Moduls bilden. In Fällen, in denen das gemeinsame Modul Teil einiger ist funktionell Subsysteme, die mehrere Metadatenobjekte enthalten, können in diesem Abschnitt auch Dienstexportverfahren und -funktionen enthalten sein, die nur von anderen Objekten dieses Subsystems aufgerufen werden sollen.
    Für allgemeine Bulk-Module wird empfohlen, diesen Abschnitt gemäß dem Funktionsattribut in Unterabschnitte zu unterteilen. Unterabschnitte sind mit einem Kommentar versehen, dessen Ausgabe in ähnlicher Weise empfohlen wird. Zum Beispiel:

//////////////////////////////////////////////////// ////////////////////////////// // Update der Informationsbasis

1.3. Vorlage für die Gestaltung von Abschnitten für Objektmodule, Manager, Datensatzgruppen, Behandlungen, Berichte usw.

//////////////////////////////////////////////////// ////////////////////////////// // SOFTWARE-SCHNITTSTELLE //////////// // //////////////////////////////////////////////////// ////////////// // VERARBEITER VON EREIGNISSEN //////////////////////////// //////////////////////////////////////////////// // // SERVICEVERFAHREN UND -FUNKTIONEN

  • Der Abschnitt "Programmschnittstelle" enthält Exportverfahren und -funktionen, die zur Verwendung in anderen Konfigurationsmodulen oder anderen Programmen (z. B. über eine externe Verbindung) vorgesehen sind. Es ist nicht erforderlich, in diesem Abschnitt Exportfunktionen und -prozeduren zu platzieren, die ausschließlich von den Modulen des Objekts selbst, seinen Formen und Befehlen aufgerufen werden sollen. Beispielsweise sind die Prozeduren zum Auffüllen des Tabellenteils eines Dokuments, die von der Füllverarbeitung im Objektmodul und vom Dokumentformular im Formularbefehlshandler aufgerufen werden, kein Programmschnittstellenmodul werden nur im Modul selbst und aus den Formen desselben Objekts aufgerufen. Sie sollten platziert werden in der Sektion "Utility Prozeduren und Funktionen."
  • Der Abschnitt "Ereignishandler" enthält Ereignishandler für das Objektmodul ( Prizavisi , PRO usw.).
  • Der Abschnitt "Utility-Prozeduren und -Funktionen" hat den gleichen Zweck wie in den allgemeinen Modulen.

1.4. Abschnittsentwurfsvorlage für Formularmodule:

//////////////////////////////////////////////////// ////////////////////////////// // HANDLER VON EREIGNISSEN DES FORMS /////////// //////////////////////////////////////////////////// /////////////// // HANDHABER VON EREIGNISSEN VON ELEMENTEN DER FORM //////////////////////////////// //////////////////////////////////////////////////// // // VERARBEITER VON EVENTS FORMTABELLEN ////////////////////////////////////////// ////////////////////////////////////// // PROZESSOREN FÜR TEAMS DER FORM /////// //////////////////////////////////////////////////// /////////////////////// // SERVICEVERFAHREN UND -FUNKTIONEN

  • Der Abschnitt „Ereignisbehandlungsroutinen für Formulare“ enthält die Prozeduren für Ereignisbehandlungsroutinen für Formulare: Erstellen eines Servers , Öffnen usw.
  • Der Abschnitt "Formularelement-Handler" enthält Prozeduren zum Verarbeiten von Elementen im Hauptteil des Formulars (alles, was nicht mit den Tabellen im Formular zusammenhängt).
  • In den Abschnitten „Ereignishandler der Formulartabelle <Name der Formulartabelle>“ finden Sie Vorgehensweisen für die Handler der Formulartabelle und der Tabellenelemente. Für Handlerprozeduren muss jede Tabelle eine eigene Partition haben.
  • Der Abschnitt „Formularbefehlshandler“ enthält Prozeduren für Formularbefehlshandler (deren Namen in der Eigenschaft Action von Formularbefehlen angegeben sind).
  • Der Abschnitt "Utility-Prozeduren und -Funktionen" hat den gleichen Zweck wie in den allgemeinen Modulen.

Siehe auch: Regeln zum Anlegen von Formularmodulen

2. Allgemeine Anforderungen an Abschnitte von Softwaremodulen.

2.1. Der Modulheader ist ein Kommentar ganz am Anfang des Moduls. Die Modulüberschrift enthält eine kurze Beschreibung und die Anwendungsbedingungen.
Zum Beispiel:

//////////////////////////////////////////////////// //////////////////////////// // // Client-Prozeduren und Funktionen für allgemeine Zwecke: // - zum Arbeiten mit Listen in Formularen; // - um mit dem Protokoll zu arbeiten; // - zur Bearbeitung von Aktionen benutzer im Gange Bearbeitung // mehrzeilig text zum Beispiel Kommentare in Dokumenten; // - andere. // ////////////////////////////////////////////////// //////////////////////////////////

Für Formularmodule wird empfohlen, eine Beschreibung der Formularparameter in die Kopfzeile einzufügen.

2.2. Variablenbeschreibungsabschnitt . Variablennamen werden entsprechend der allgemeinen vergeben Regeln für Variablennamen und ihre Verwendung ist im Artikel beschrieben. Verwendung globaler Variablen in Softwaremodulen .

Alle Modulvariablen sollten mit einem Kommentar versehen werden, der ausreicht, um ihren Zweck zu verstehen. Es wird empfohlen, den Kommentar in derselben Zeile zu platzieren, in der die Variable deklariert ist.
Beispiel:

Pem CurrencyAccounting Export; // Währung, in der die Buchhaltung geführt wird Perem Address Supports Export; // E-Mail-Adresse, an die Fehlermeldungen gesendet werden

2.3. Software-Schnittstelle Exportprozeduren und Funktionen der Programmierschnittstelle werden unmittelbar nach der Beschreibung der Variablen platziert. Solche Prozeduren und Funktionen sind für die Verwendung durch andere Konfigurationsobjekte oder andere Programme vorgesehen (z. B. über eine externe Verbindung). Sie sollten sich daher an einer „sichtbaren Stelle“ im Modul befinden.

Siehe auch: Beschreibung von Prozeduren und Funktionen.

2.4.1 Handler, Befehle und Formularelemente für Formularereignisse . Vor Serviceprozeduren und Funktionen im Formularmodul befinden sich Event-Handler des Formulars sowie Event-Handler für Befehle und Formularelemente.

Methodische Empfehlung (nützlicher Hinweis)

Es wird empfohlen, Handler eines Formularelements in der Reihenfolge zu platzieren, in der sie im Eigenschaftenfenster des Formulareditors aufgeführt sind. im Konfigurator .

2.4.2. Jedes Ereignis muss über eine eigene Prozedur verfügen. Wenn die gleichen Aktionen ausgeführt werden sollen, wenn Ereignisse in verschiedenen Elementen des Formulars auftreten:

  • Erstellen Sie eine separate Prozedur (Funktion), die die erforderlichen Aktionen ausführt

  • Erstellen Sie für jedes Formularelement einen separaten Handler mit dem Standardnamen

  • Rufen Sie die erforderliche Prozedur (Funktion) von jedem Handler aus auf.

Zum Beispiel falsch:

& OnClient-Prozedur zum Ausführen von Auswahlparametern für Anwendung (Element) = New Compliance (); Options Selection. Paste ("Nach Autor", Nach Autor); Options Selection. Paste ("Executive", Executive); Listenauswahl festlegen (Liste, Auswahloptionen); EndProcedure & On Client-Prozedur für das Authoring durch Ändern (Element) in Executive durch Ändern (Undefiniert); EndProcedure

richtig:

& OnClient-Prozedur für PerformIndicator (Item) SetSelection (); End Procedure & At Client Procedure Nach Autor Ändern (Element) Auswahl installieren (); EndProcedures & OnServer Procedure SetSelection () Auswahlparameter = New Compliance (); Options Selection. Paste ("Nach Autor", Nach Autor); Options Selection. Paste ("Executive", Executive); Listenauswahl festlegen (Liste, Auswahloptionen); EndProcedure

Diese Anforderung beruht auf der Tatsache, dass die Logik der Event-Handler-Prozeduren nicht für die Verwendung im Modulcode vorgesehen ist, sondern direkt von der Plattform aufgerufen wird. Das Mischen dieser beiden Szenarien in einer Prozedur verkompliziert unnötig ihre Logik und verringert ihre Robustheit (anstelle des vorgesehenen Aufrufszenarios muss der Prozedurcode bei einem Ereignis von der Plattform auf andere direkte Aufrufe aus dem Code zählen).

2.5. Die Ereignishandler für die Objektmodule und den Objektmanager werden nach dem Export, jedoch vor den Dienstprogrammprozeduren und Modulfunktionen platziert.

Methodische Empfehlung (nützlicher Hinweis)

Es wird empfohlen, Handler in der Beschreibung der eingebetteten Sprache in der angegebenen Reihenfolge zu platzieren.

2.6. Dienstprogrammprozeduren und Modulfunktionen , die keine Ereignishandler sind, aber die interne Implementierung eines Moduls darstellen, werden im Modul neben Ereignishandlern platziert.

In Fällen, in denen ein gemeinsames Modul Teil eines funktionalen Subsystems ist, das mehrere Metadatenobjekte enthält, kann dieser Abschnitt auch Prozeduren und Funktionen für den Export von Diensten enthalten, die nur von anderen Objekten dieses Subsystems aufgerufen werden sollen.

Es wird empfohlen, Verfahren und Funktionen, die von Natur aus oder aufgrund der Arbeitslogik miteinander verbunden sind, zusammenzustellen. Es wird nicht empfohlen, die Prozeduren und Funktionen des Moduls explizit in Server, Client und Funktionen ohne Kontext zu gruppieren, da eine solche "technologische" Reihenfolge das Verständnis der Modullogik erschwert und die Aufmerksamkeit des Entwicklers auf die Details seiner Implementierung lenkt.

2.7. Der Initialisierungsabschnitt enthält Anweisungen, die die Variablen des Moduls oder Objekts (Formulars) initialisieren. Zum Beispiel:

Support Address = "[email protected]"; // Adresse, um den technischen Support zu kontaktieren. Perform Initialization ();

Weitere Materialien zum Thema:
Datenbank aktualisieren , Ereignishandler , Software-Schnittstelle , Handler , Verfahren , Muster , Überschrift , Ende des Verfahrens , funktionen , Schnittstelle , beschreibung , Zwischenablage , zu kopieren , Abschnitt , austausch , Formen , ein Objekt , das Element , konfigurieren , Konfigurationen , dokumentieren

Materialien aus der Sektion: 1C: Enterprise 8.2 / Entwickler / Vereinbarungen beim Schreiben von Code

Weitere Materialien zum Thema:

Beschreibung der Abläufe und Funktionen

Skalierungsfunktionen für das ausgewählte Objekt

Übertragung von Konfigurationen auf der 1C: Enterprise 8.2-Plattform auf die 1C: Enterprise 8.3-Plattform ohne Kompatibilitätsmodus mit Version 8.2

Namen von Prozeduren und Funktionen

Privilegierten Modus verwenden


Wir finden: Die Struktur des Moduls 1c ist , Serviceprozeduren und -funktionen , Modul, Manager-Modul-Aufrufprozedur 1c 8 2, Aufrufen einer Prozedur aus einem anderen Modul 1c, englischer Modul-Header, 1c aus einer Verarbeitungsformular-Aufrufmodul-Prozedur, 1c 8 2 Aufrufen einer Prozedur aus dem Manager-Modul, 1


1C: Unternehmen 8