So kopieren Sie Binärdaten 1s. Erweiterung der Funktionalität der Arbeit mit Binärdaten

Mit der Technologieplattform 1C:Enterprise 8 können Sie beliebige Dateien in der Informationsdatenbank speichern, von dort abrufen und auf verschiedene Arten verwenden. Schauen wir uns diese Operationen anhand von Beispielen an.

Bevor Sie eine Datei in die 1C-Informationsdatenbank hochladen, müssen Sie die vollständige Adresse der Datei auf der Festplatte abrufen. Das Arbeiten mit Dateiauswahldialogen wird in beschrieben.

Verwenden Sie zum Speichern von Dateien ein Attribut (oder eine Registerressource) mit dem Typ Speicherwerte.

Hochladen einer beliebigen Datei in die 1C-Informationsdatenbank

Jede Datei kann als Binärdaten dargestellt und geladen werden Wertspeicherung.

Beim Konvertieren von Binärdaten in ein Objekt Speicherwerte Design verwendet neue StorageValues(Daten, Komprimierung) mit zwei Parametern:

Daten– Binärdaten, die im Speicher gespeichert werden müssen
Kompression— Kompressionsverhältnis des Deflationsalgorithmus. Ganzzahl im Bereich -1...9. -1 ist die Standardkomprimierungsstufe. 0 – keine Komprimierung, 9 – maximale Komprimierung. Standardwert: -1. Der Parameter ist optional; wenn er nicht angegeben wird, wird keine Komprimierung verwendet.

//Konvertieren Sie die Datei in Binärdaten
File = New BinaryData(Path) ;

//Erstelle ein neues Value Storage-Objekt

DataStorage = NewValueStorage(File, NewDataCompression(9) ) ;

Speichern einer beliebigen Datei aus der 1C-Infobase auf der Festplatte

Um eine Datei aus der 1C-Datenbank auf der Festplatte zu speichern, müssen Sie den Pfad und den Dateinamen ermitteln. Dazu gibt es einen Dateispeicherdialog, dessen Funktionsweise in beschrieben ist.

//Binärdaten aus dem Speicher abrufen
//Datenspeicherung – Attribut eines Objekts mit dem Wertspeichertyp

//Schreiben Sie die empfangenen Daten auf die Festplatte
//Die Path-Variable enthält die vollständige Adresse der Datei auf der Festplatte
Daten. Write(Pfad) ;

Anzeigen einer Datei in der 1C-Informationsdatenbank

Um eine in der Datenbank gespeicherte Datei anzuzeigen, muss auf Ihrem Computer eine Anwendung installiert sein, die die Datei öffnet.

//Den Namen der temporären Datei mit der erforderlichen Erweiterung abrufen
//In der Extension-Variable müssen Sie die Dateierweiterung eingeben, zum Beispiel „pdf“
Path = GetTemporaryFileName(Extension) ;

//Daten vom Speicher empfangen
//Datenspeicherung – Attribut eines Objekts mit dem Wertspeichertyp
Daten = Datenspeicher. Erhalten() ;

//Daten in eine temporäre Datei schreiben
Daten. Write(Pfad) ;

//Es wird versucht, die Datei in der vorgesehenen Anwendung zu öffnen
//Wenn die Anwendung nicht gefunden wird, erscheint der Systemdialog „Öffnen mit…“.
LaunchApplication(Pfad) ;

Drucken (Strg+P)

16.3. Arbeiten mit Binärdaten

16.3.1. allgemeine Informationen

Bei der Implementierung von Anwendungslösungen kann es Situationen geben, in denen die Analyse verschiedener Binärdaten erforderlich ist. Sie müssen beispielsweise den Dateityp anhand einer Signatur bestimmen oder einige Manipulationen an einem Bild vornehmen. Für die Arbeit mit Binärdaten stellt 1C:Enterprise spezielle Softwareschnittstellen zur Verfügung. Als nächstes schauen wir uns die Möglichkeiten für die Arbeit mit Binärdaten an.
Alle Arbeiten mit Binärdaten basieren auf dem Konzept eines Streams. Fließen ist eine logische Verallgemeinerung einer beliebigen (im Allgemeinen) Datenquelle (Stream-Objekt). Das System bietet keine Möglichkeit, ein unabhängiges Stream-Objekt zu erstellen, das keiner Quelle zugeordnet ist. Es können jedoch abgeleitete Objekte erstellt werden – ein Stream, der einer Datei auf der Festplatte zugeordnet ist (FileStream-Objekt) oder ein im Speicher erstellter Stream (MemoryStream-Objekt). Mit einem Stream können Sie Daten sowohl lesen als auch schreiben. Um die Möglichkeit der Ausführung bestimmter Vorgänge zu bestimmen, verfügt ein Stream (und abgeleitete Objekte) über spezielle Methoden, mit denen Sie bestimmen können, welche
Operationen sind mit diesem Thread verfügbar (Methoden AvailableRecord(), AvailableRead(), AvailableChangePosition()).
Wenn Sie mit einem Stream auf einer höheren Ebene arbeiten müssen, insbesondere Daten wie eine Zahl (unterschiedlicher Bittiefe) oder einen String lesen/schreiben müssen, dann sind die DataRead/DataWrite-Objekte dafür vorgesehen. Mithilfe dieser Objekte können Sie einen strukturierteren Ansatz für die im Stream befindlichen Binärdaten wählen. Wenn Sie beispielsweise das Format einer Datei kennen, können Sie eine solche Datei ganz bequem lesen, die erforderlichen Daten aus den Headern abrufen (die in der Regel durch die Typen Zahl und Zeichenfolge dargestellt werden), unnötige Datenblöcke überspringen und Laden der für die Verarbeitung erforderlichen Dateien.
Das allgemeine Schema für die Arbeit mit Binärdaten lässt sich wie folgt darstellen:

Stream-Empfang läuft
Es wird ein Data Reader- oder Data Writer-Objekt erstellt.
Mithilfe des in Schritt 2 erstellten Objekts werden die erforderlichen Aktionen ausgeführt.
Das in Schritt 2 erstellte Objekt wird geschlossen.
Wenn keine weiteren Vorgänge erforderlich sind, wird der in Schritt 1 erhaltene Stream geschlossen.
Wenn Sie mit dem Stream weiterarbeiten müssen, können Sie eine neue Position im Stream festlegen (sofern dieser Vorgang unterstützt wird) und ab Schritt 2 weiterarbeiten.

Es ist erwähnenswert, dass die Absätze 1 und 2 kombiniert werden können. Mit anderen Worten: Das System bietet die Möglichkeit, Objekte zu erstellen Daten lesen/Daten schreiben direkt aus beispielsweise einem BinaryData-Objekt.
Um verschiedene Operationen mit Binärdaten durchzuführen, bietet das System die Möglichkeit, einen Teil des Streams als separates Fragment mit zufälligem (Byte-für-Byte-)Zugriff (Objekt) abzurufen BufferBinaryData). Die Puffergröße wird beim Erstellen festgelegt und kann später nicht mehr geändert werden. Beim Arbeiten mit einem binären Datenpuffer ist es möglich, mit Zahlen unterschiedlicher Bittiefe zu arbeiten
als ein Ganzes. In diesem Fall ist es möglich, die Bytereihenfolge in Worten anzugeben: „Little Endian“ oder „Big Endian“ (Big Endian). Es ist auch möglich, einen Puffer in mehrere aufzuteilen und mehrere binäre Datenpuffer zu einem resultierenden Puffer zusammenzufassen.
Es ist wichtig zu beachten, dass die Arbeit mit einem Binärdatenpuffer die Implementierung erheblich vereinfachen kann, wenn die Arbeit mit Binärdaten auf der Seite der Clientanwendung im asynchronen Modus implementiert wird. In diesem Fall erfolgt das Einlesen der Daten in den Puffer als asynchroner Vorgang und die Arbeit mit den Pufferdaten erfolgt synchron.
Das Arbeiten mit Binärdaten ist auf der Clientseite (einschließlich des Webclients) der Anwendung und auf der Serverseite sowie in synchronen und asynchronen Arbeitsschemata möglich. Weitere Beispiele verwenden ein synchrones Arbeitsschema.

16.3.2. Binärdaten lesen

Als Beispiel für das Lesen von Binärdaten betrachten wir die Aufgabe, das richtige Dateiformat zu ermitteln, das im System zur weiteren Verwendung ausgewählt wurde. Als zu prüfende Datei wird eine .wav-Datei mit Audiodaten verwendet. Zum Speichern von WAV-Dateien wird das Resource Interchange File Format (RIFF) verwendet, dessen Beschreibung unter dem Link gegeben wird:

https://msdn.microsoft.com/enus/library/windows/desktop/ee415713.aspx (auf Englisch). Für das Lesebeispiel werden folgende Formatinformationen verwendet:
1. Die ersten 4 Bytes der Datei enthalten die Formatkennung: RIFF.
2. Die nächsten 4 Bytes enthalten die Größe der tatsächlichen Audiodaten in Little-Endian-Byte-Reihenfolge.
3. Die nächsten 4 Bytes enthalten den Texttyp der verwendeten Daten: WAVE.
Um diese Aktionen auszuführen, benötigen Sie den folgenden Code in der integrierten Sprache:

Lesen = Neu ReadData(FileName, ByteEndian.LittleEndian);
FileFormat = Read.ReadCharacters(4);
DataSize = Read.ReadInteger32();
FileType = Read.ReadCharacters(4);
Wenn Dateiformat<>„RIFF“ Dann
Report("Dies ist keine RIFF-Datei");
Zurückkehren ;
EndIf ;
Wenn FileType = „WAVE“, dann
Bericht („Dies ist eine WAV-Datei mit Daten, Größe „+ DataSize + „Bytes“);
Ansonsten
Bericht („Dies ist keine WAV-Datei“);
Zurückkehren;
endIf;

Schauen wir uns das Beispiel genauer an.
Zuerst wird die Datei geöffnet, deren Name in der Variable FileName enthalten ist, die Datei wird zum Lesen geöffnet ( FileOpenMode.Open), liest nur aus der Datei ( FileAccess.Read) und zum Lesen wird ein 16-Byte-Puffer verwendet.
Anschließend wird ein Stream zum Lesen von Daten generiert, der für Daten vom Typ „Zahl“ die niedrigstwertige Bytereihenfolge aufweist. Anschließend werden 4 Zeichen, eine 32-Bit-Ganzzahl und 4 weitere Zeichen aus dem resultierenden Stream gelesen. Die resultierenden Daten werden analysiert und basierend auf den Ergebnissen der Analyse wird entschieden, ob es sich bei der ausgewählten Datei um eine .wav-Datei handelt oder nicht.

16.3.3. Binärdaten schreiben

Das Schreiben von Binärdaten in eine Datei erfolgt im einfachsten Fall wie folgt:

Eintrag = Neu WriteData(Dateiname);
Für Index = 0 bis 255 Zyklus
Write.WriteByte(Index);
EndCycle;
Record.Close() ;

In diesem Beispiel wird eine Bytefolge von 0 bis 255 (0xFF im Hexadezimalformat) in eine Datei geschrieben. Dies ist die einfachste Aufnahmemöglichkeit.
Sie können auch eine Methode verwenden, die der im vorherigen Beispiel beschriebenen Lesemethode ähnelt, bei der ein Dateistream abgerufen und Daten in diesen Dateistream geschrieben werden.

16.3.4. Arbeiten mit einem binären Datenpuffer

Wie oben erwähnt, bietet der Binärdatenpuffer eine bequeme Möglichkeit, Fragmente von Binärdaten zu manipulieren.
Es wird nicht nur das Lesen von Daten unterstützt, sondern auch das Schreiben.
Als Beispiel betrachten wir das Parsen des RIFF-Dateiheaders aus dem Datenlesebeispiel (siehe hier). Um das Beispiel zu erstellen, werden genau die gleichen Informationen über das Dateiformat verwendet. Daher ist es notwendig, aus der Quelldatei einen Puffer in der Größe des Dateiheaders zu lesen. Der Header besteht aus drei 4-Byte-Feldern. Somit müssen 12 Bytes gelesen werden.

Puffer = Neu BufferBinaryData(12);
Datei = FileStreams.Open(Temporäres Dateiverzeichnis() + „Windows Logon.wav“, FileOpenMode.Open, FileAccess.Read);
File.Read(Buffer, 0, 12);
Größe = Buffer.ReadInteger32(4);
StreamString = newStreamInMemory(Buffer);
StreamRows.Go(0, PositionInStream.Start);

FileFormat = ReadLines.ReadCharacters(4, „Windows-1251“);
ReadLines.Close();
StreamRows.Go(8, PositionInStream.Start);
RowReader = new DataReader(RowStream);
Dateityp = ReadLines.ReadCharacters( 4, „Windows-1251“);
ReadLines.Close();

Der Vorgang, Daten in einen binären Datenpuffer zu übertragen, ist nichts Besonderes. Weitere Vorgänge erfordern einige Kommentare. Das Lesen von Zahlen jeder unterstützten Bittiefe ist von jeder Position im Puffer aus möglich. In diesem Beispiel Buffer.ReadInteger32(4); bedeutet, eine 32-Bit-Ganzzahl ab Byte 4 des Puffers zu lesen. Wenn Sie also mehrere Zahlen lesen müssen, die sich an verschiedenen Stellen im Puffer befinden, kann dies ohne direkte Positionierung in diesem Puffer erfolgen.
Das Lesen eines Strings wird vom binären Datenpuffer jedoch nicht unterstützt. Daher sollten Sie ein Objekt verwenden, das Ihnen dies ermöglicht: Daten lesen. Ein DataReader-Objekt kann nicht aus einem binären Datenpuffer erstellt werden. Basierend auf einem binären Datenpuffer können Sie jedoch einen Stream erstellen, der ein universeller Vermittler zwischen dem physischen Speicherort von Informationen (Datei, binärer Datenpuffer) und einem übergeordneten Objekt ist, das Ihnen die Arbeit mit diesen Daten ermöglicht.
Wenn ein DataReader-Objekt basierend auf einem Stream erstellt wird, beginnt es mit dem Lesen von Daten an der Position, die derzeit im Stream installiert ist. Daher wird im Beispiel zunächst die Position im Stream festgelegt, anschließend ein DataReader-Objekt erstellt und die erforderliche Anzahl an Zeichen gelesen. Eine detaillierte Beschreibung des Unterschieds zwischen der Anzahl der Bytes und Zeichen beim Lesen von Strings finden Sie im nächsten Abschnitt 16.3.5

16.3.5. Nutzungsmerkmale

Bei der Verwendung von Binärdaten sollten Sie die Besonderheiten der Arbeit mit Daten vom Typ String berücksichtigen. Die Besonderheit besteht darin, dass die Länge des Strings, den die globale Kontextfunktion StrLength() zurückgibt, in Zeichen gemessen wird. In Symbolen sollten Sie in den Methoden zum Schreiben/Lesen von Zeichenfolgen in Objekten für die Arbeit mit Binärdaten die Größe der zu lesenden/schreibenden Daten angeben ( ReadCharacters(),
ReadString(), WriteCharacters(), WriteString()). Es gibt jedoch keine eindeutige Möglichkeit, die Länge einer Zeichenfolge in Zeichen in einen ähnlichen Parameter in Bytes umzuwandeln. Abhängig vom Inhalt der Zeichenfolge und der Kodierung ist dieses Verhältnis unterschiedlich. Daher sollten Sie beim Arbeiten mit Datenstrukturen, die Zeichenfolgen variabler Länge enthalten, genau verstehen, in welchen Einheiten die Zeichenfolgenlängen ausgedrückt werden.
Wenn in den verfügbaren Daten die Zeichenfolgenlänge in Bytes angegeben ist und die Zeichenfolge in einer Multibyte-Kodierung mit variabler Länge (z. B. UTF-8) angegeben ist, dann wird mithilfe binärer Datenobjekte eine solche Struktur aus einer Datei eingelesen Daten vom Typ String sind grundsätzlich nicht möglich.
In diesem Fall können Sie die Lese-/Schreibposition im Dateistream jedoch problemlos ändern. Wenn die Länge einer Zeichenfolge in Zeichen angegeben wird, wird es möglich, eine solche Zeichenfolge in Daten vom Typ „String“ einzulesen, es wird jedoch unmöglich, die Lese-/Schreibposition in einem solchen Stream zu ändern.
Um die Länge einer Zeichenfolge in Bytes zu ermitteln, können Sie die Zeichenfolge mit der folgenden Funktion in ein BinaryData-Objekt konvertieren:

Funktion Binärdaten aus String abrufen(Wert StrParameter, Wertkodierung = „UTF-8“)
MemoryThread = NewMemoryThread;
Autor = Neu WriteData(StreamMemory);
Writer.Write-String(StrParameter, Kodierung);
Schriftsteller.Schließen();
Gibt StreamMemory.CloseAndGetBinaryData zurück();
EndFunction

Die tatsächliche Größe in Bytes kann durch Aufrufen der Funktion Size() für das BinaryData-Objekt ermittelt werden, das als Ergebnis der Funktion ermittelt wird.
Die gleichzeitige Nutzung von Gegenständen wird nicht empfohlen Daten lesen/Daten schreiben und Stream-Objekte. Wenn zwischen zwei aufeinanderfolgenden Lesevorgängen von ReadData oder zwei aufeinanderfolgenden Schreibvorgängen auf WriteData eine Positionsänderung im Stream auftritt, mit dem die Ch-Objekte arbeiten ShadowData/WriteData– Es wird eine Ausnahme generiert. So demonstriert das folgende Beispiel die korrekte Positionsänderung in einem Stream beim Schreiben von Daten in einen Stream:

Stream = newStreamInMemory();

WriteData.WriteString("Hallo Welt!");
WriteData.Close();
Stream.Go (0, PositionInStream.Start);
DataWrite = newDataWrite(Stream);
WriteData.WriteString("Tschüss!");
WriteData.Close();
Das folgende Beispiel ist eine Antwort auf eine ausgelöste Ausnahme:

Stream = NewStreamInMemory();

WriteData.WriteString(“Hallo, Welt!”);
Stream.Go(0, PositionInStream.Start);
// Die nächste Zeile löst eine Ausnahme aus
WriteData.WriteString(“Bye!”);
Gleichzeitig sind Situationen möglich, in denen das Systemverhalten fehlerhaft ist, aber keine Fehler generiert werden:

Stream = GetStream();
ReadData = new ReadData(Stream);
TestString = ReadData.Read();
InitialPosition = Stream.CurrentPosition();
DataWrite = newDataWrite(Stream);
WriteData.WriteString(“Unerwartete Zeichenfolge”);
WriteData.Close();
Stream.Go(InitialPosition, PositionInStream.Start);
// Im Allgemeinen ist es unmöglich zu bestimmen, welcher Wert in die Variable TestString2 eingefügt wird
TestLine2 = ReadData.ReadLine();

Das in diesem Abschnitt beschriebene Verhalten wird verursacht durch o Datenleser-/Datenschreiberobjekte verwenden beim Arbeiten mit einem Stream ihre eigenen Puffer. Dadurch weicht die tatsächliche Position des Threads von der logischen Position ab, die sich aus den abgeschlossenen Vorgängen ergibt.
Auch die gleichzeitige Verwendung von Data Reader- und Data Writer-Objekten, die für ihre Arbeit einen Thread nutzen, wird nicht unterstützt.

Implementiert in Version 8.3.10.2168.

Wir erweitern schrittweise die Funktionalität für die Arbeit mit Binärdaten. Dafür gibt es mehrere Gründe. Erstens haben wir nicht alles umgesetzt, was wir geplant hatten. Und zweitens haben wir im Zuge der Diskussion neuer Möglichkeiten eine Reihe von Wünschen von Ihnen erhalten, die wir auch umgesetzt haben.

Neue Funktionen zum Konvertieren von Binärdaten in verschiedene Formate

Im globalen Kontext haben wir eine Vielzahl neuer Funktionen zur Konvertierung von Binärdaten hinzugefügt. So können Sie beispielsweise eine Vorwärts- und Rückwärtskonvertierung von Binärdaten in eine reguläre Zeichenfolge, Formatzeichenfolge, durchführen Base64 und Formatzeichenfolge BinHex. Darüber hinaus können Sie die Binärdaten selbst in Formate konvertieren Base64, BinHex und zurück.

Ähnliche Konvertierungen werden für den Typ unterstützt BufferBinaryData. Darüber hinaus können Sie einen Binärdatenpuffer in Binärdaten konvertieren und umgekehrt.

Darüber hinaus ermöglichen zwei neue Funktionen die Aufteilung binärer Daten in mehrere Teile und umgekehrt, um mehrere Objekte des Typs zusammenzufassen Binärdaten in eins. In diesem Fall enthält das neue Objekt die Daten aller Teile in der von Ihnen angegebenen Reihenfolge.

Diese Funktionen ähneln im Konzept dem Teilen und Zusammenführen von Dateien, sind jedoch in vielen Fällen effizienter. Weil es nicht notwendig ist, die Binärdaten zunächst in einer Datei zu speichern, und weil bei der Aufteilung kein unnötiges Kopieren der Daten anfällt.

Hinzufügen der Möglichkeit, mit Streams zu Objekten zu arbeiten, die mit Dateien arbeiten

Da die Verwendung von Binärdaten größtenteils mit Dateivorgängen zusammenhängt, hielten wir es für völlig logisch und natürlich, die Arbeit mit Streams zu den Objekten hinzuzufügen, die derzeit Dateien auf die eine oder andere Weise lesen und schreiben.

Daher können Sie jetzt Streams zum Lesen und Schreiben öffnen, wenn Sie Objekte verwenden wie:

Text lesen Und WriteText;
ReadingFastInfoSet Und EntryFastInfoSet;
LesenHtml Und PostHtml;
JSON lesen Und JSON-Eintrag;
XML lesen Und XML-Eintrag;
Zip-Datei lesen Und ZIP-Datei aufzeichnen.

Sie können den Body als Stream empfangen, wenn Sie mit HTTP arbeiten:

HTTPRequest Und HTTPResponse;
HTTPServiceRequest Und HTTPServiceResponse.

Text dokument;
Tabellarisches Dokument;
Formatiertes Dokument;
Geographisches Schema;
GraphicScheme;
FTPVerbindung.

Beim Arbeiten mit Typen ist jetzt das Schreiben in einen Stream möglich Bild Und ConvertToCanonicalXML. Darüber hinaus wird die Arbeit mit Streams jetzt in verschiedenen Methoden unterstützt, über die diese Typen verfügen XSL-Konvertierung, Kryptographie-Manager, ZertifikatKryptographie Und HashingData.

Effizientes Kopieren durch Lesen und Schreiben von Daten

Die von uns implementierten binären Tools ermöglichten das Kopieren von Streams. Bei großen Datenmengen wurde dieser Vorgang jedoch nicht sehr effizient durchgeführt.

Daher der Typ ReadData Wir haben eine neue Methode implementiert CopyB(). Dies beseitigt nicht nur dieses Problem, sondern vereinfacht auch den Text und macht ihn verständlicher.

Bisher war es beispielsweise möglich, Binärdaten von einem Stream zu empfangen und in einen anderen Stream zu schreiben.

Jetzt müssen keine Binärdaten mehr empfangen werden; das Kopieren erfolgt beim Lesen der Daten.

Das Schöne ist, dass man nicht nur in einen Stream, sondern auch in ein Objekt kopieren kann WriteData. Diese Option ist praktisch, wenn Sie zusätzlich zu den Daten aus dem Quellstream einige Ihrer eigenen Daten in den Ausgabestream schreiben müssen.

Bitweise logische Operationen an einem binären Datenpuffer

Sie können jetzt bitweise logische Operationen verwenden, wenn Sie mit binären Datenpuffern arbeiten. Als Ergebnis dieser Operationen wird das Ergebnis einer bitweisen Kombination der ursprünglichen Bytes und Bytes im angegebenen Puffer gemäß den Regeln der ausgewählten logischen Operation in den Quellpuffer geschrieben. Wir haben die folgenden Operationen implementiert:

WriteBitAnd();
WriteBitOr();
WriteBitExclusiveOr();
WriteBitIne();
Umkehren().

Ein gutes Beispiel für die Verwendung bitweiser logischer Operationen ist die Aufgabe, das Austauschformat mit Einzelhandelsgeräten zu dekodieren. Beispielsweise wird das Austauschformat mit Einzelhandelsgeräten durch ein 1-Byte-Feld beschrieben. Dieses Feld enthält eine Reihe von Merkmalen, die das Produktsortiment beschreiben:

Bits 0-2: Steuersatz;
Bit 3: 0 – Stückware, 1 – Gewichtsware;
Bit 4: 0 – Verkauf zulassen, 1 – Verkauf verbieten;
Bit 5: 0 – Mengenzählung aktivieren, 1 – Mengenzählung deaktivieren;
Bit 6: 0 – Einzelverkauf ist verboten, 1 – Einzelverkauf ist erlaubt;
Bit 7: Reserviert.

Dann könnte der Code, der diese Informationen extrahiert und sie in einer für die weitere Verarbeitung geeigneten Form darstellt, so aussehen.

Ermitteln einer Zahl aus hexadezimalen und binären Literalen

NumberFromHexString();
NumberFromBinaryString().

Binäre Literale sind nützlich zum Definieren von Masken, wenn sie in Verbindung mit bitweisen Operationen verwendet werden. Beispielsweise werden im vorherigen Beispiel mit der Analyse des Austauschformats mit kommerziellen Geräten Masken mithilfe von Dezimalzahlen angegeben. Dies ist nicht sehr praktisch, da Sie beim Schreiben und Lesen von Code ständig die Dezimalzahl im Kopf in das Binärsystem übersetzen müssen.

Es ist viel bequemer, stattdessen binäre Literale zu verwenden. Gleichzeitig wird der Code übersichtlicher und die Fehlerwahrscheinlichkeit deutlich reduziert.

Hexadezimale Literale lassen sich bequem beim Parsen technischer Formate verwenden: Bild-, Ton- und Videoformate.

Änderungen in der Technologie externer NativeAPI-Komponenten

Bisher gab es eine Reihe von Einschränkungen bei der Übertragung von Binärdaten zwischen 1C:Enterprise und einer externen Komponente. Beispielsweise war es nicht möglich, Binärdaten an eine externe Komponente zu übertragen, und bei der Arbeit in einem Webclient war der Austausch von Binärdaten generell nicht möglich.

Jetzt entfernen wir alle diese Einschränkungen. Sie können Binärdaten in beide Richtungen und sogar im Webclient austauschen.

Der Betrieb vorhandener externer Komponenten wird dadurch in keiner Weise beeinträchtigt. Sie werden wie zuvor funktionieren. Aber in neu erstellten Komponenten können Sie jetzt Objekte als Parameter übergeben Binärdaten.

Binärdaten in 1C sind zum Speichern von Dateien beliebigen Formats vorgesehen. Mit ihrer Hilfe können Sie:

Organisieren Sie die Interaktion mithilfe eines Binärprotokolls mit verschiedenen Geräten.
Speichern Sie Dateien beliebiger Formate als Metadatenobjektattribute.
Konvertieren Sie Textdaten in Binärdaten (am häufigsten zum Senden von Berichten verwendet).
Arbeiten Sie mit Binärdaten im Speicher.

Was das System kann

Bei der Arbeit mit Binärdaten kann Plattform 8.3 die folgenden Aktionen ausführen:

Binärdaten lesen und schreiben;
Verschieben Sie Daten mithilfe von temporärem Speicher vom Client zum Server und zurück.
Initialisieren Sie ein Objekt vom Typ „Bild“ mithilfe von Binärdateien.
Lesen Sie sie aus dem World Wide Web mithilfe der Objekte „Mail-Anhang“, „HTTP-Verbindung“ usw.
Verwenden Sie kryptografische Tools, um wichtige Anhänge zu verschlüsseln und zu signieren.
Berechnen Sie mithilfe des Objekts „Data Hashing“ die Hash-Funktion.

Daten in Attributen speichern

Lassen Sie uns beispielsweise ein Verzeichnis in einer Testkonfiguration erstellen.

Tatsächlich ist die Verwendung desselben Verzeichnisses zum Speichern von Nomenklaturinformationen und binären Bilddaten etwas falsch. Bei ausreichend großen Datenmengen und schweren, großen Dateien kann es zu ungewollten Ausfallzeiten und „Bremsen“ im Betrieb des Systems kommen. Aus Sicht des Systems wäre es viel korrekter, ein separates Verzeichnis „Bilder“ zu organisieren, einen Link, auf den wir als Requisitentyp setzen könnten.

Es ist wichtig zu beachten, dass Attribute des Typs „ValueStorage“, die Binärdaten enthalten, im verwalteten Anwendungsmodus nicht verfügbar sind und nur mit der Methode FormAttributesValue auf sie zugegriffen werden kann.

Das Nachrichtenfeld stellt einen binären Datensatz mit einem Wertspeicher dar.

Daten aus Requisiten lesen

Erstellen wir eine Verarbeitung, die die in unserer Konfiguration in binärer Form gespeicherte Datei in ein Tabellenkalkulationsdokument ausgibt (dies ist beispielsweise zum Drucken eines Firmenlogos erforderlich).

Im Grunde ist das der gesamte Code, den wir brauchen. Mit dem Get()-Operator lesen wir die im entsprechenden Verzeichnisattribut gespeicherten Binärdaten aus und übertragen sie an das „Picture“-Objekt, das in der oberen linken Zelle des Tabellenkalkulationsdokuments des Formulars angezeigt wird (Abb. 9).

Abb.9

Datenkonvertierung

Dies ist nicht üblich, aber es kommt vor, dass bei der Arbeit mit nicht standardmäßigen Austauschvorgängen mit externen Systemen eine Konvertierung der Daten vom Binärformat in das Base64-Format oder umgekehrt erforderlich ist.

In den meisten Fällen führt die Plattform eine automatische Konvertierung der Daten durch. Geschieht dies nicht, müssen Sie globale Übersetzungsfunktionen nutzen:

Base64String – wandelt den angegebenen Wert in einen String mit der entsprechenden Kodierung um;
Base64Value – führt die umgekehrte Konvertierung durch.

Optimierung des obigen Codes

Der in Abb. 4 dargestellte Code funktioniert sicherlich, allerdings mit einer wesentlichen Einschränkung: wenn in den Konfigurationseigenschaften das Kontrollkästchen „Modalitätsnutzungsmodus“ aktiviert ist (Abb. 10). Andernfalls führt die Verwendung zu einem Fehler.
Abb.10

Um dies zu verhindern, gehen Sie im Verzeichniselement-Formularmodul zum Menü Text->Refactoring->Veraltete synchrone Aufrufe->Modulaufrufe konvertieren.

Nach einiger Zeit werden synchrone Aufrufe automatisch in asynchrone umgewandelt und der Code nimmt die Form an (Abb. 11)

Abb.11