Verwaltete Formulardetails (1Cv8). Hauptformulardetails: Übertragen von Daten zwischen den Client- und Serverteilen des verwalteten Formulars

Nachfolgend sind die wichtigsten 1C-Objekte aufgeführt, die bei der Arbeit mit verwalteten Formularen verwendet werden. Es werden kurze Codebeispiele gegeben, die die traditionelle Verwendung dieser Objekte beim Schreiben von 1C-Konfigurationen veranschaulichen.

Diese Form

Wird im Formularmodul und in Prozeduren verwendet&Auf dem Client und &Auf dem Server.

Ermöglicht Ihnen den Zugriff auf Formularelemente und Details.

Der Zugriff auf das Formularelement erfolgt über ein Objekt Elemente und sieht so aus:

ThisForm.Elements.VersionNumber.Header = "v."+ProgramVersion;

Der Zugriff auf im Formular vorhandene Attribute erfolgt wie folgt:

ThisForm.Advertisement Text="Hallo, Kameraden!";

Vereinfachter Zugriff auf Formularelemente und Details

Grundsätzlich müssen Sie das Schlüsselwort nicht im Formularmodul angeben Diese Form . Sie können auf vereinfachte Weise auf Formularelemente und Details zugreifen:

// Formularelement

Elements.VersionNumber.Title = "v."+ProgramVersion;

// Formulardetails

Werbetext="Hallo, Kameraden!";

Funktionen zum Abrufen von Formulardetails (wichtig!)

Wenn das Formularattribut einen einfachen Typ hat – Zeichenfolge, Zahl, Datum ... dann können Sie den Wert des Attributs einfach über den Namen ermitteln (setzen):

Text=Produktname; // Produktname ist ein Formularattribut

Allerdings ist es auf diese Weise nicht möglich, Details „komplexer“ Art zu erhalten –Wertetabelle, Baum der Werte . Wenn Sie versuchen, ein Attribut dieses Typs anhand des Namens abzurufen, wird ein Objekt dieses Typs zurückgegebenDataFormsCollection.

Um den Wert eines Attributs mit einem „komplexen“ Typ zu erhalten, müssen Sie die Funktion verwendenFormAttributesValue():

CurrentTable=FormAttributesValue("SelectedConstructionObjects");

Um den Wert eines „komplexen“ Attributs festzulegen, können Sie die Funktion verwendenValueInFormAttributes(<Значение>, <ИмяРеквизита>) , beide Parameter sind erforderlich.

Funktionen FormAttributesValue() Und ValueInFormAttributes()Nur auf dem Server verfügbar.

Ein Objekt

Streng genommen gibt es im Formular kein solches Schlüsselwort. Wenn ein Formular erstellt wird, beispielsweise ein Elementformular, erstellt 1C einfach automatisch ein Attribut mit dem Namen im Formular Ein Objekt . Über dieses Attribut sind die Eigenschaften des aktuellen Objekts verfügbar, das auf dem Formular bearbeitet wird.

oder eine vollständigere Notation:

DiesesObjekt

Enthält das Objekt selbst. Gedacht, um ein Objekt in einem Objektmodul oder einem Formularmodul abzurufen.

Verwendung: Nur lesen.

Verfügbarkeit: Server, Thick Client, externe Verbindung.

Und Datenübertragungsobjekt zur Codestrukturierung, kontrollierte Form in der 1C 8.2-Umgebung.

Einführung

Beginnen wir mit einer kurzen Beschreibung des Konzepts des „verwalteten Formulars“ und verwandter Konzepte der 1C-Plattform. Plattformkenner sollten diesen Abschnitt vielleicht überspringen.

Im Jahr 2008 wurde eine neue Version der 1C-Plattform verfügbar: Enterprise 8.2 (im Folgenden als Managed Application bezeichnet), die die gesamte Arbeitsebene mit der Schnittstelle völlig verändert. Dazu gehören die Befehlsschnittstelle, Formulare und das Fenstersystem. Gleichzeitig ändert sich nicht nur das Modell zur Entwicklung der Benutzeroberfläche in der Konfiguration, sondern es wird auch eine neue Architektur zur Trennung der Funktionalität zwischen der Client-Anwendung und dem Server vorgeschlagen.
Die verwaltete Anwendung unterstützt die folgenden Arten von Clients:

• Thick Client (normaler und verwalteter Startmodus)
• Dünner Kunde
• Web-Client

Die verwaltete Anwendung verwendet Formulare, die auf neuer Technologie basieren. Sie heißen Verwaltete Formulare. Um den Übergang zu erleichtern, werden auch frühere Formulare (die sogenannten regulären Formulare) unterstützt, deren Funktionalität jedoch nicht weiterentwickelt wird und sie nur im Thick-Client-Startmodus verfügbar sind.
Die Hauptunterschiede verwalteter Formulare für einen Entwickler:

• Deklarative, nicht „pixelweise“ Beschreibung der Struktur. Die konkrete Platzierung der Elemente erfolgt automatisch durch das System bei der Anzeige des Formulars.
• Alle Funktionen des Formulars werden wie folgt beschrieben Einzelheiten Und Mannschaften. Details sind die Daten, mit denen das Formular arbeitet, und Befehle sind die auszuführenden Aktionen.
• Das Formular läuft sowohl auf dem Server als auch auf dem Client.
• Im Client-Kontext sind fast alle Anwendungstypen nicht verfügbar und dementsprechend ist es nicht möglich, die Daten in der Infobase zu ändern.
• Für jede Methode oder Formularvariable muss diese angegeben werden Kompilierungsanweisung, Definieren des Ausführungsorts (Client oder Server) und Zugriff auf den Formularkontext.

Lassen Sie uns die Anweisungen zum Kompilieren von Formularmethoden auflisten:

• &OnClient
• &Auf dem Server
• &OnServerOhne Kontext
• &OnClientOnServerWithout Context

Lassen Sie uns das oben Gesagte veranschaulichen. Der Screenshot zeigt ein Beispiel eines verwalteten Formulars und seines Moduls im Entwicklungsmodus. Finden Sie die deklarative Beschreibung, Requisiten, Kompilierungsanweisungen usw.

In allen weiteren Diskussionen geht es um die rechte Seite der Abbildung, um die Strukturierung des Modulcodes und um die Prinzipien, mit denen Sie eine effektive Client-Server-Interaktion implementieren können.

Definieren wir das Problem

Es sind mehrere Jahre vergangen, seit die neue Version der 1C-Plattform aktiv genutzt wird und viele Lösungen (Konfigurationen) sowohl von 1C als auch von seinen zahlreichen Partnern veröffentlicht wurden.
Haben Entwickler in dieser Zeit ein gemeinsames Verständnis der Prinzipien der Client-Server-Interaktion bei der Erstellung von Formularen entwickelt und hat sich der Ansatz zur Implementierung von Softwaremodulen in den neuen architektonischen Realitäten verändert?

Schauen wir uns die Codestruktur (Formularmodul) in mehreren Formen derselben Standardkonfiguration an und versuchen, Muster zu finden.
Mit Struktur meinen wir Codeabschnitte (meistens handelt es sich dabei um Kommentarblöcke), die vom Entwickler den Gruppenmethoden und Kompilierungsanweisungen für diese Methoden zugewiesen werden.
Beispiel 1:
Abschnitt der Ereignishandler. Methode – auf dem Client. Methode – auf dem Server. Methode – auf dem Client. Abschnitt der Dienstprozeduren und -funktionen. Hilfsfunktionen zur Eingabesteuerung
Beispiel 2:
Serviceabläufe und Funktionen Zahlungsdokumente Werte Eventhandler
Beispiel 3:
Dienstprozeduren auf dem Server Dienstprozeduren auf dem Client Dienstprozeduren auf dem Server ohne Kontext Header-Ereignishandler Befehlsereignishandler
Beispiel 4:
Allzweckprozeduren Formular-Ereignishandler Prozeduren des Subsystems „Kontaktinformationen“.
Im Wesentlichen fehlt die Codestruktur, oder um es milde auszudrücken, sie ähnelt der in Forms 8.1:

• Nicht informative Wörter „Allgemeines, Service, Hilfsprogramm“.
• Scheue Versuche, Client- und Servermethoden zu trennen.
• Methoden werden häufig nach Oberflächenelementen „Arbeiten mit dem tabellarischen Teil Produkte, Kontaktinformationen“ gruppiert.
• Beliebige Anordnung von Methoden und Codegruppen. Event-Handler können beispielsweise in einem Formular oben stehen, in einem anderen unten, in einem dritten überhaupt nicht hervorgehoben usw.
• Und vergessen wir nicht, dass dies alles in einer Konfiguration geschieht.
• Ja, es gibt Konfigurationen, in denen die Worte „General, Service, Auxiliary“ immer an den gleichen Stellen stehen, aber...

Warum brauchen Sie eine Codestruktur?

• Vereinfachung der Wartung.
• Vereinfachen Sie das Lernen.
• Aufzeichnen allgemeiner/wichtiger/erfolgreicher Grundsätze.
• ...Ihre Option

Warum hilft der bestehende Entwicklungsstandard von 1C nicht?

Schauen wir uns die auf ITS-Datenträgern und in verschiedenen „Entwicklerhandbüchern“ veröffentlichten Prinzipien an, die beim Schreiben eines verwalteten Formulars empfohlen werden.

• Minimieren Sie die Anzahl der Serveraufrufe.
• Maximale Rechenleistung auf dem Server.
• Nicht kontextbezogene Serveraufrufe sind schneller als kontextbezogene.
• Programm mit Blick auf die Client-Server-Kommunikation.
• usw.

Das sind Slogans, die absolut wahr sind, aber wie setzt man sie um? Wie kann die Anzahl der Aufrufe minimiert werden? Was bedeutet es, im Client-Server-Modus zu programmieren?

Designmuster oder Generationenweisheit

Client-Server-Interaktion wird seit Jahrzehnten in verschiedenen Softwaretechnologien eingesetzt. Die Antwort auf die im vorherigen Abschnitt skizzierten Fragen ist seit langem bekannt und lässt sich in zwei Grundprinzipien zusammenfassen.

• Fernfassade(im Folgenden als Remote Access Interface bezeichnet)
• Datenübertragungsobjekt(im Folgenden Datentransferobjekt genannt)

Ein Wort von Martin Fowler, seine Beschreibung dieser Prinzipien:

• … Jedes potenziell für den Fernzugriff vorgesehene Objekt muss über Folgendes verfügen: Schnittstelle mit geringer Granularität, wodurch die Anzahl der Aufrufe minimiert wird, die zum Ausführen einer bestimmten Prozedur erforderlich sind. ... Anstatt eine Rechnung und alle ihre Positionen einzeln anzufordern, müssen Sie alle Rechnungspositionen in einer Anfrage lesen und aktualisieren. Dies wirkt sich auf die gesamte Struktur des Objekts aus... Denken Sie daran: RAS-Schnittstelle enthält keine Domänenlogik.
• ...wenn ich eine fürsorgliche Mutter wäre, würde ich meinem Kind auf jeden Fall sagen: „Schreibe niemals Datentransferobjekte!“ In den meisten Fällen sind Datenübertragungsobjekte nichts anderes als aufgeblähter Feldsatz... Der Wert dieses ekelhaften Monsters liegt allein in der Möglichkeit Übertragen Sie mehrere Informationen in einem Anruf über das Netzwerk- eine Technik, die für verteilte Systeme von großer Bedeutung ist.

Beispiele für Vorlagen in der 1C-Plattform

Die Anwendungsprogrammierschnittstelle, die dem Entwickler bei der Entwicklung eines verwalteten Formulars zur Verfügung steht, enthält viele Beispiele dieser Prinzipien.
Zum Beispiel die OpenForm()-Methode, eine typische „raue“ Schnittstelle.
OpeningParameters = Neue Struktur("Parameter1, Parameter2, Parameter3", Wert1, Wert2, Wert3); Form = OpenForm(FormName, OpeningParameters);
Vergleichen Sie mit dem in Version 8.1 übernommenen Stil.
Form = GetForm(FormName); Form.Parameter1 = Wert1; Form.Parameter2 = Wert2; Form.Open();

Im Kontext eines verwalteten Formulars gibt es viele „Datenübertragungsobjekte“. Sie können auswählen systemisch Und Vom Entwickler definiert.
Systemmodelle modellieren ein Anwendungsobjekt auf dem Client in Form eines oder mehrerer Formulardatenelemente. Es ist unmöglich, sie ohne Bezugnahme auf die Formulardetails zu erstellen.

• DataFormsStructure
• DataFormsCollection
• DataFormStructureWithCollection
• DataShapesTree

Die Konvertierung von Systemdatenübertragungsobjekten in Anwendungstypen und umgekehrt erfolgt mit folgenden Methoden:

• ValueInFormData()
• FormDataValue()
• CopyFormData()
• ValueInFormAttributes()
• FormAttributesValue()

Bei der Anpassung einer bestehenden Lösung kommt häufig eine explizite Konvertierung zum Einsatz. Methoden können Eingabeparameter wie ValueTable anstelle von FormDataCollection erwarten (Funktionen verwenden), oder die Methode wurde im Kontext eines Anwendungsobjekts definiert und ist für den direkten Aufruf aus dem Formular nicht mehr verfügbar.
Beispiel 1C v8.1:
// auf dem Client im Kontext des Formulars FillUserCache(DepartmentLink)
Beispiel 1C v8.2:
// auf dem Server im Kontext des Formulars ProcessingObject = Form AttributesValue("Object"); ProcessingObject.FillUserCache(DepartmentRef); ValueFormAttributes(ProcessingObject, "Object");

Datenübertragungsobjekte, deren Struktur vom Entwickler festgelegt wird, sind eine kleine Teilmenge der sowohl auf dem Client als auch auf dem Server verfügbaren Typen. Am häufigsten werden als Parameter und Ergebnisse von Methoden einer „vergröberten“ Schnittstelle verwendet:

• Primitive Typen (String, Zahl, Boolescher Wert)
• Struktur
• Korrespondenz
• Array
• Links zu Anwendungsobjekten (eindeutige Kennung und Textdarstellung)

Beispiel: Die Methode akzeptiert eine Liste von Anweisungen zur Statusänderung und gibt eine Beschreibung der Fehler an den Client zurück.
&OnServerWithoutContext Function ServerChangeOrderStatus(Orders, NewStatus) Errors = New Match(); // [Bestellung][Fehlerbeschreibung] Für jede Bestellung aus dem Auftragszyklus StartTransaction(); Versuchen Sie es mit DocOb = Order.GetObject(); …. andere Aktionen, nicht nur mit der Bestellung möglich... Exception CancelTransaction(); Errors.Insert(Order, ErrorDescription()); EndAttempt; EndCycle; Rückgabefehler; EndFunction // ServerChangeOrderStatus()

Den Code strukturieren

Die Hauptziele, die das verwaltete Formularmodul widerspiegeln sollte, und Lösungsansätze.

• Klare Trennung von Client- und Servercode. Vergessen wir nicht, dass es sich zum Zeitpunkt der Ausführung um zwei interagierende Prozesse handelt, die jeweils über deutlich unterschiedliche verfügbare Funktionen verfügen.
• Eindeutige Identifizierung der RAS-Schnittstelle, welche Servermethoden können vom Client aufgerufen werden und welche nicht? Die Namen von Remote-Schnittstellenmethoden beginnen mit dem Präfix „Server“. Dadurch können Sie beim Lesen des Codes sofort erkennen, wie die Kontrolle an den Server übertragen wird, und die Verwendung kontextbezogener Hilfe wird vereinfacht. Beachten Sie, dass die offizielle Empfehlung (ITS) die Benennung von Methoden mit Postfixen empfiehlt, beispielsweise ChangeOrderStatusOnServer(). Wir wiederholen jedoch, dass nicht alle Servermethoden vom Client aufgerufen werden können und daher die logische Zugänglichkeit wichtiger ist als der Kompilierungsspeicherort. Daher markieren wir mit dem Präfix „Server“ nur Methoden, die dem Client zur Verfügung stehen; rufen wir die Beispielmethode ServerChangeOrderStatus() auf.
• Lesbarkeit. Geschmackssache, wir übernehmen die Bestellung, wenn das Modul mit den Verfahren zum Erstellen eines Formulars auf dem Server und den Fernzugriffsmethoden beginnt.
• Wartbarkeit. Es muss ein klarer Ort zum Hinzufügen von neuem Code vorhanden sein. Ein wichtiger Punkt ist, dass vom Konfigurator automatisch erstellte Methodenvorlagen am Ende des Moduls hinzugefügt werden. Da Ereignishandler für Formularelemente meist automatisch erstellt werden, befindet sich der entsprechende Block an letzter Stelle, um nicht jeden Handler an eine andere Stelle im Modul zu ziehen.

Nachfolgend finden Sie den Grundaufbau des Moduls, das die aufgeführten Ziele umsetzt.

• Grafische Option – zeigt deutlich den Hauptausführungsablauf.
• Die Textoption ist ein Beispiel für einen Vorlagenentwurf zum schnellen Einfügen einer Struktur in ein neues Formularmodul.

//////////////////////////////////////////////////////////////////////////////// // <(c) Автор=""Datum=""/> // <Описание> // // ///////////////////////////////////////////// // ///////////////////////// // MODULVARIABLEN ///////////////// // /////////////////////////////////////////// //// ////////// // AUF DEM SERVER //******* EREIGNISSE AUF DEM SERVER ******* &Auf dem Server Prozedur bei Erstellung auf dem Server (Fehler, Standardverarbeitung) / /Fügen Sie den Inhalt des Handlers ein. Ende der Prozedur //******* REMOTE ACCESS INTERFACE ******* //******* GESCHÄFTSLOGIK AUF DEM SERVER ******* ///////// /////////////////////////////////////////////////////////////////////// /////// /////////////////// // GEMEINSAME METHODEN VON CLIENT UND SERVER /////////////// /////// ///////////////////////////////////////////////////////////////////////// ///// //////// // AUF DEM KUNDEN //******* GESCHÄFTSLOGIK AUF DEM KUNDEN ******* //******* TEAM * ****** //******* KUNDENVERANSTALTUNGEN ******* ///////////////////////// ///// /////////////////////////////////////////////////////////////////////////// // / / HAUPTPROGRAMMBETREIBER

Verwandte Fragen

Abschließend werden wir einige Bereiche skizzieren, über die man bei der Programmierung der Client-Server-Interaktion nachdenken sollte.

• Implementierungsoptionen für die Fernzugriffsschnittstelle. Asynchronität, Detaillierungsgrad ...
• Caching. 1C hat eine erfolglose Architekturentscheidung getroffen, indem es Caching nur auf der Ebene der Aufrufmethoden allgemeiner Module einführte und keine Kontrollfunktionen (Relevanzzeit, Zurücksetzen bei Bedarf) bereitstellte.
• Implizite Serveraufrufe. Vergessen Sie nicht die technischen Besonderheiten; viele „harmlose“ Vorgänge auf dem Client provozieren eine Kontaktaufnahme der Plattform mit dem Server.

Formen in 1C:Enterprise dienen der Anzeige und Bearbeitung der in der Datenbank enthaltenen Informationen. Formulare können zu bestimmten Konfigurationsobjekten gehören oder separat davon existieren und werden von der gesamten Anwendungslösung verwendet.

Zum Beispiel ein Verzeichnis Nomenklatur kann mehrere Formen haben, die für bestimmte Zwecke verwendet werden – Bearbeiten eines Verzeichniselements, Anzeigen einer Liste usw.:

Darüber hinaus kann es allgemeine Formen geben, die nicht zu bestimmten Konfigurationsobjekten gehören – allgemeine Formen.

Grundformen

Jedes Konfigurationsobjekt kann zum Ausführen einiger Standardaktionen verwendet werden. Beispielsweise müssen Sie für jedes Verzeichnis möglicherweise eine Liste seiner Elemente anzeigen, einzelne Elemente des Verzeichnisses anzeigen, eine Gruppe des Verzeichnisses anzeigen und Elemente und Elementgruppen aus dem Verzeichnis auswählen. Für jedes Dokument ist die Liste solcher Aktionen viel kleiner: Anzeigen einer Liste von Dokumenten, Auswählen aus einer Liste von Dokumenten und Anzeigen eines separaten Dokuments.

Um sicherzustellen, dass solche Standardaktionen mit den Daten von Anwendungslösungsobjekten ausgeführt werden, gibt es für jedes von ihnen eine Reihe von Grundformularen, die bei der Durchführung der entsprechenden Aktionen verwendet werden. Jedes diesem Objekt untergeordnete Formular kann als Hauptformular zugewiesen werden. Zum Beispiel im Verzeichnis Nomenklatur Folgende Grundformen können existieren:

Und das Dokument Empfang von Waren und Dienstleistungen die Zusammensetzung der Hauptformen wird unterschiedlich sein:

Wenn der Benutzer also die Verzeichnisliste anzeigen möchte Nomenklatur oder Dokumentenliste Empfang von Waren und Dienstleistungen, öffnet das System das entsprechende Formular, das als Listenformular für diese Objekte vorgesehen ist.

Automatisch generierte Formulare

Ein wichtiges Merkmal des 1C:Enterprise 8-Systems ist der Mechanismus automatisch generierter Formulare. Dieser Mechanismus befreit den Entwickler davon, alle möglichen Formulare für jedes Konfigurationsobjekt erstellen zu müssen. Der Entwickler muss lediglich ein neues Konfigurationsobjekt hinzufügen und das System selbst generiert im richtigen Moment der Arbeit des Benutzers die erforderlichen Formulare, um die in diesem Objekt enthaltenen Informationen anzuzeigen.

Daher muss der Entwickler seine eigenen Formen von Anwendungslösungsobjekten nur dann erstellen, wenn diese Unterschiede (unterschiedliches Design oder spezifisches Verhalten) von den vom System automatisch generierten Formen aufweisen müssen.

Verknüpfen eines Formulars mit Daten

Ob ein Formular zu einem bestimmten Konfigurationsobjekt gehört, bestimmt nicht die Zusammensetzung der im Formular angezeigten Daten. Die Tatsache, dass das Formular beispielsweise zu einem Verzeichnis gehört Nomenklatur ermöglicht es Ihnen, es als eines der Hauptformulare für dieses Verzeichnis zuzuweisen, legt jedoch in keiner Weise fest, welche Daten dieses Formular anzeigt und wie es sich verhält.

Um ein Formular mit Daten zu verknüpfen, werden Formulardetails verwendet, die die Liste der vom Formular angezeigten Daten angeben. Alle Formulare selbst verhalten sich gleich, unabhängig davon, welche Daten sie anzeigen. Allerdings kann eines der Formularattribute als Hauptattribut dafür bestimmt werden (es wird fett hervorgehoben). In diesem Fall wird das Standardverhalten des Formulars und seiner Eigenschaften je nach Typ des Hauptformularattributs ergänzt:

Wenn beispielsweise ein Dokument als Hauptformularattribut zugewiesen ist Empfang von Waren und Dienstleistungen, dann fordert das System beim Schließen des Formulars eine Bestätigung der Erfassung und Veröffentlichung dieses Dokuments an. Wenn Sie beispielsweise ein Verzeichnis als Hauptanforderung des Formulars zuweisen Nomenklatur, dann erscheint beim Schließen des Formulars keine solche Bestätigungsanfrage.

Formularstruktur

Das Hauptmerkmal der Formulare besteht darin, dass sie vom Entwickler nicht im Detail „Pixel für Pixel“ gezeichnet werden. Ein Formular in einer Konfiguration ist eine logische Beschreibung der Zusammensetzung des Formulars. Und die spezifische Platzierung der Elemente erfolgt automatisch durch das System bei der Anzeige des Formulars.

Der angezeigte (für den Benutzer sichtbare) Teil des Formulars wird als Baum beschrieben, der Formularelemente enthält.

Elemente können Eingabefelder, Kontrollkästchen, Optionsfelder, Schaltflächen usw. sein. Darüber hinaus kann ein Element eine Gruppe sein, die andere Elemente enthält. Eine Gruppe kann als Panel mit einem Rahmen, als Panel mit Seiten (Lesezeichen), als Seite selbst oder als Befehlspanel dargestellt werden. Darüber hinaus kann das Element eine Tabelle sein, die auch Elemente (Spalten) enthält. Die Elementstruktur beschreibt, wie das Formular aussehen wird.

Die gesamte Funktionalität des Formulars wird in Form von Details und Befehlen beschrieben. Details sind die Daten, mit denen das Formular arbeitet, und Befehle sind die auszuführenden Aktionen. So muss der Entwickler im Formulareditor die notwendigen Details und Befehle in das Formular einbauen, Formularelemente erstellen, die diese anzeigen und ggf. Elemente in Gruppen anordnen.

Basierend auf dieser logischen Beschreibung generiert das System automatisch das Erscheinungsbild des Formulars zur Anzeige für den Benutzer. Dabei berücksichtigt das System verschiedene Eigenschaften der angezeigten Daten (z. B. Typ), um die Formularelemente für den Benutzer möglichst komfortabel anzuordnen.

Mit verschiedenen Einstellungen kann der Entwickler Einfluss auf die Anordnung der Elemente nehmen. Es kann die Reihenfolge der Elemente bestimmen und die gewünschte Breite und Höhe angeben. Dabei handelt es sich jedoch lediglich um einige zusätzliche Informationen, die dem System bei der Anzeige des Formulars helfen.

In Formularen kann der Entwickler nicht nur die Befehle des Formulars selbst verwenden, sondern auch globale Befehle, die in der Befehlsschnittstelle der gesamten Konfiguration verwendet werden. Darüber hinaus ist es möglich, parametrierbare Befehle zu erstellen, die unter Berücksichtigung der spezifischen Daten des aktuellen Formulars andere Formulare öffnen. Dies könnte beispielsweise der Aufruf eines Berichts über die Salden des Lagers sein, das aktuell im Rechnungsformular ausgewählt ist.

Die Formularangaben stellen die Verbindung mit den Daten sicher. In diesem Fall kann eines (und nur eines) der Details als das Hauptdetail bezeichnet werden; Es muss nicht unbedingt der Datentyp sein, auf den wir das Formular zeichnen. Das Verhalten des Formulars hängt jedoch vom Datentyp des Hauptattributs ab. Neben der Änderung des Verhaltens des Formulars ändert sich auch der Kontext des Formularmoduls. Zusammen mit den Methoden und Eigenschaften des Formulars werden darin auch die Methoden und Eigenschaften des Objekts verfügbar, bei dem es sich um den Wert des Hauptattributs handelt. Es ist wichtig, dass Formulare vom Typ Freiform keine grundlegenden Details enthalten. In diesem Fall wird das Verhalten des Formulars nur durch die Einstellungen des Benutzers bestimmt. Betrachten wir Fragen zu den grundlegenden Details.

Frage 10.05 der Prüfung 1C: Platform Professional. Wofür wird das Hauptformularattribut verwendet?

1. Definiert die Datenquelle für das Formular als Ganzes
2. Definiert die Standardfunktionen der Plattform für die Arbeit mit dem Formular mit Daten des im Hauptattribut angegebenen Typs
3. Bereitstellung der Möglichkeit, programmgesteuert auf Objektdetails aus dem lokalen Formularkontext zuzugreifen
4. Bietet Visualisierung von Objektdetails im Formulardialog
5. 2 und 3 sind richtig
6. 1 und 2 sind richtig

Die richtige Antwort ist Nummer sechs, siehe oben.

Frage 10.06 der Prüfung 1C: Platform Professional. Wozu werden die Formularangaben benötigt?

1. Beschreibt den Inhalt der Daten, die in einem Formular angezeigt, bearbeitet oder gespeichert werden
2. Zum Anzeigen und Bearbeiten von Daten in einem Formular
3. 1 und 2 sind richtig

Die richtige Antwort ist die dritte – beides.

Frage 10.07 der Prüfung 1C: Platform Professional. Um einer beliebigen kontrollierten Form grundlegende Attribute zuzuweisen ...

1. Sie müssen in den Eigenschaften der Formularattribute das Kontrollkästchen „Grundlegende Angaben“ aktivieren
2. Sie müssen die Eigenschaft „Daten“ des Formulars ausfüllen, indem Sie das erforderliche Formularattribut auswählen

Die richtige Antwort ist die zweite:

Frage 10.08 der Prüfung 1C: Platform Professional. Um die Hauptdetails einer beliebigen regulären Form zuzuordnen...

1. Das Formular muss zum Hauptformular gemacht werden, die Hauptdetails werden automatisch ermittelt
2. Sie müssen in den Eigenschaften der Formularattribute das Kontrollkästchen „Grundlegende Angaben“ aktivieren
3. Sie müssen zum Menü „Bearbeiten“ gehen, „Grundlegende Details“ auswählen und den gewünschten Wert auswählen
4. Sie müssen die Eigenschaft „Daten“ des Formulars ausfüllen, indem Sie das erforderliche Formularattribut auswählen

Die vierte richtige Antwort lautet:

Die wichtigsten Details sind fett hervorgehoben:

Frage 10.09 der Prüfung 1C: Platform Professional. Wenn es ein Hauptformularattribut gibt, ist es dann möglich, ein weiteres Hauptattribut hinzuzufügen?

1. Es ist unmöglich
2. Dies ist möglich, indem der Formularattributeigenschaft der entsprechende Wert zugewiesen wird
3. Dies ist nur programmgesteuert möglich, wenn auf das Objekt „Form“ zugegriffen wird
4. Dies ist möglich, indem der entsprechenden Formulareigenschaft ein weiterer Wert hinzugefügt wird

Die richtige Antwort ist die erste, es gibt unbedingt eine Hauptvoraussetzung, denn Der Zusammenhang mit dem Objekt muss eindeutig sein.

Frage 10.113 der Prüfung 1C: Platform Professional. Welches der in der Abbildung dargestellten Details des Formulars ist das wichtigste?

1. Liste der Währungskurse
2. DirectoryObject
3. Verzeichnisformulare enthalten keine grundlegenden Details
4. Verzeichnisformulare enthalten alle grundlegenden Details

Die zweite richtige Antwort ist die fett gedruckte.

So fügen Sie einem Verzeichniselement in 1C Accounting 8.3 (Revision 3.0) zusätzliche Details hinzu

2016-12-07T18:20:33+00:00

Es kommt vor, dass uns die bereits in 1C verfügbaren Funktionen fehlen. Und Sie müssen nicht immer einen Programmierer kontaktieren. Von einem dieser Fälle erzähle ich Ihnen im Zusammenhang mit dem neuen 1C: Accounting 8.3 (Edition 3.0).

Lassen Sie uns nicht genügend Felder haben, um Informationen über unsere Gegenparteien einzugeben. Und wir möchten ein neues Feld hinzufügen, das „Status“ heißt und einen von drei Werten hat – „Hoch“, „Mittel“ und „Niedrig“. Im Folgenden erkläre ich Ihnen Schritt für Schritt, wie Sie ein solches Feld hinzufügen, ohne den Konfigurator aufzurufen.

1. Gehen Sie zum Bereich „Administration“ und wählen Sie „Allgemeine Einstellungen“ ():

2. Suchen und aktivieren Sie das Kontrollkästchen „Zusätzliche Details und Informationen“, falls es nicht bereits aktiviert ist. Klicken Sie auf den Link „Weitere Details“:

3. Wählen Sie im linken Teil des sich öffnenden Einstellungsfensters „Konto“. Klicken Sie in der Symbolleiste auf die Schaltfläche „Neu“.

4. Ein Fenster zum Anlegen neuer Details für Elemente des Verzeichnisses „Gegenparteien“ hat sich geöffnet. Geben Sie „Status“ in das Feld „Name“ ein. Behalten Sie als Werttyp „Zusatzwert“ bei, beachten Sie jedoch in Zukunft, dass auch andere Werttypen möglich sind (Zeichenfolge, Zahl, Datum usw.). Aber was wir jetzt brauchen, ist der Mehrwert, da wir dem Benutzer eine begrenzte Auswahl von drei Optionen bieten möchten.

5. Um jede Option zu erstellen, gehen Sie zur Registerkarte „Werte“, klicken Sie dort auf die Schaltfläche „Erstellen“, geben Sie den Namen des Werts ein (z. B. „Hoch“) und klicken Sie auf die Schaltfläche „Speichern und schließen“.

6. Und so weiter, bis alle drei Werte mit den Namen „Hoch“, „Mittel“ und „Niedrig“ erstellt sind, wie in der Abbildung unten gezeigt. Klicken Sie auf die Schaltfläche „Speichern und schließen“.

7. Wie Sie sehen, verfügt die Gegenpartei nun über das Statusattribut in der Liste der zusätzlichen Details.

8. Wenn wir nun zu einem beliebigen Element des Kontrahentenverzeichnisses gehen, sehen wir ganz unten im Formular ein neues Statusfeld ( Wenn Sie es nicht sehen, erweitern Sie die im Formular ausgeblendete Gruppe „Zusätzliche Details“.):

9. In diesem Feld können wir einen der drei von uns erstellten Werte ersetzen. Über dieses Feld können Sie eine Auswahl in Form einer Liste treffen, diese in Berichten usw. anzeigen.