Comment copier des données binaires 1c. Extension des fonctionnalités de travail avec des données binaires

La plate-forme technologique 1C:Enterprise 8 vous permet d'enregistrer des fichiers arbitraires dans la base d'informations, de les récupérer à partir de là et de les utiliser de différentes manières. Examinons ces opérations à l'aide d'exemples.

Avant de télécharger un fichier dans la base d'informations 1C, vous devez obtenir l'adresse complète du fichier sur le disque. L'utilisation des boîtes de dialogue de sélection de fichiers est décrite dans .

Pour stocker des fichiers, utilisez un attribut (ou une ressource d'enregistrement) du type Valeurs de stockage.

Téléchargement d'un fichier arbitraire dans la base d'informations 1C

N'importe quel fichier peut être représenté sous forme de données binaires et chargé dans Stockage de valeur.

Lors de la conversion de données binaires en objet Valeurs de stockage conception utilisée nouvelles StorageValues (données, compression) avec deux paramètres :

Données— données binaires qui doivent être stockées en stockage
Compression— taux de compression de l'algorithme de déflation. Entier compris entre -1...9. -1 est le niveau de compression par défaut. 0 - pas de compression, 9 - compression maximale. Valeur par défaut : -1. Le paramètre est facultatif ; s’il n’est pas spécifié, la compression n’est pas utilisée.

//Convertir le fichier en données binaires
Fichier = Nouveau BinaryData(Chemin) ;

//Créer un nouvel objet Value Storage

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

Enregistrer un fichier arbitraire de l'infobase 1C sur le disque

Pour enregistrer un fichier de la base de données 1C sur le disque, vous devez déterminer le chemin et le nom du fichier. Pour ce faire, il existe une boîte de dialogue d'enregistrement de fichier, dont l'utilisation est décrite dans.

//Obtenir des données binaires à partir du stockage
//Data Storage - attribut d'un objet de type Value Storage

//Écrit les données reçues sur le disque
//La variable Path contient l'adresse complète du fichier sur le disque
Données. Écrire(Chemin) ;

Visualisation d'un fichier situé dans la base d'informations 1C

Pour afficher un fichier enregistré dans la base de données, vous devez disposer d'une application installée sur votre ordinateur qui ouvre le fichier.

//Obtenir le nom du fichier temporaire avec l'extension requise
//Dans la variable Extension, vous devez mettre l'extension du fichier, par exemple "pdf"
Chemin = GetTemporaryFileName (Extension) ;

//Recevoir des données du stockage
//Data Storage - attribut d'un objet de type Value Storage
Données = banque de données. Obtenir() ;

//Ecrit les données dans un fichier temporaire
Données. Écrire(Chemin) ;

//Essayer d'ouvrir le fichier dans l'application prévue
//Si l'application n'est pas trouvée, la boîte de dialogue système "Ouvrir avec..." apparaîtra.
LaunchApplication(Chemin) ;

Imprimer (Ctrl+P)

16.3. Travailler avec des données binaires

16.3.1. informations générales

Lors de la mise en œuvre de solutions applicatives, il peut y avoir des situations où il est nécessaire d'analyser diverses données binaires. Par exemple, vous devez déterminer le type de fichier à l'aide d'une signature ou effectuer quelques manipulations avec une image. Pour travailler avec des données binaires, 1C:Enterprise propose des interfaces logicielles spéciales. Ensuite, nous examinerons les possibilités de travailler avec des données binaires.
Tout travail avec des données binaires est basé sur le concept de flux. Couler est une généralisation logique d'une source de données arbitraire (dans le cas général) (objet Stream). Le système n'offre pas la possibilité de créer un objet Stream indépendant qui n'est associé à aucune source. Mais il existe des objets dérivés qui peuvent être créés - un flux associé à un fichier sur disque (objet FileStream) ou un flux créé en mémoire (objet MemoryStream). Un flux vous permet à la fois de lire des données et de les écrire. Pour déterminer la possibilité d'effectuer certaines opérations, un flux (et les objets dérivés) dispose de méthodes spéciales qui vous permettent de déterminer quelles
les opérations sont disponibles avec ce fil (méthodes EnregistrementDisponible(), DisponibleLecture(), DisponibleChangePosition()).
Si vous devez travailler avec un flux à un niveau supérieur, en particulier des données en lecture/écriture telles qu'un nombre (de profondeur de bits différente) ou une chaîne, alors les objets DataRead/DataWrite sont destinés à cela. En utilisant ces objets, vous pouvez adopter une approche plus structurée des données binaires situées dans le flux. Ainsi, par exemple, connaissant le format d'un fichier, vous pouvez lire assez confortablement un tel fichier, en obtenant les données nécessaires à partir des en-têtes (qui, en règle générale, sont représentées par les types numéro et chaîne), en sautant les blocs de données inutiles et charger ceux nécessaires au traitement.
Le schéma général pour travailler avec des données binaires peut être représenté comme suit :

Réception du flux en cours
Un objet Data Reader ou Data Writer est créé.
À l'aide de l'objet créé à l'étape 2, les actions requises sont effectuées.
L'objet créé à l'étape 2 est fermé.
Si aucune autre opération n'est requise, le flux obtenu à l'étape 1 est fermé.
Si vous devez continuer à travailler avec le flux, vous pouvez définir une nouvelle position dans le flux (si cette opération est prise en charge) et continuer à travailler à partir de l'étape 2.

Il est à noter qu'il est possible de combiner les paragraphes 1 et 2. En d'autres termes, le système offre la possibilité de créer des objets Lire des données/écrire des données directement à partir, par exemple, d'un objet BinaryData.
Pour effectuer diverses opérations avec des données binaires, le système offre la possibilité d'obtenir une partie du flux en tant que fragment séparé avec un accès aléatoire (octet par octet) (objet BufferBinaryData). La taille du tampon est définie lors de la création et ne peut pas être modifiée ultérieurement. Lorsque vous travaillez avec un tampon de données binaires, il est possible de travailler avec des nombres de profondeurs de bits différentes, comme
comme un tout. Dans ce cas, il est possible de préciser l'ordre des octets en mots : « little endian » ou « big endian » (big endian). Il est également possible de diviser un tampon en plusieurs et de combiner plusieurs tampons de données binaires en un seul tampon résultant.
Il est important de noter que travailler avec un tampon de données binaires peut simplifier considérablement la mise en œuvre si le travail avec des données binaires est implémenté côté application client en mode asynchrone. Dans ce cas, la lecture des données dans le tampon sera effectuée comme une opération asynchrone et le travail avec les données du tampon sera synchrone.
L'utilisation de données binaires est disponible côté client (y compris le client Web) de l'application et côté serveur, ainsi que dans les schémas de travail synchrones et asynchrones. D'autres exemples utiliseront un schéma de travail synchrone.

16.3.2. Lecture de données binaires

À titre d'exemple de lecture de données binaires, nous considérerons la tâche consistant à déterminer le format de fichier correct sélectionné dans le système pour une utilisation ultérieure. Un fichier .wav contenant des données audio sera utilisé comme fichier à vérifier. Pour stocker les fichiers .wav, le format RIFF (Resource Interchange File Format) est utilisé, dont une description est donnée sur le lien :

https://msdn.microsoft.com/enus/library/windows/desktop/ee415713.aspx (en anglais). Pour l'exemple de lecture, les informations de format suivantes seront utilisées :
1. Les 4 premiers octets du fichier contiennent l'identifiant de format : RIFF.
2. les 4 octets suivants contiennent la taille des données audio réelles dans l'ordre des octets petit-boutiste.
3. Les 4 octets suivants contiennent le type de texte des données utilisées : WAVE.
Pour effectuer ces actions, vous aurez besoin du code suivant dans le langage intégré :

Lire = Nouveau ReadData(FileName, ByteEndian.LittleEndian);
FileFormat = Read.ReadCharacters(4);
DataSize = Read.ReadInteger32();
Type de fichier = Read.ReadCharacters(4);
Si format de fichier<>« RIFF » Alors
Rapport("Ceci n'est pas un fichier RIFF");
Retour ;
Fin si ;
Si FileType = « WAVE » Alors
Rapport (« Ceci est un fichier WAV avec des données, taille » + DataSize + « octets »);
Sinon
Rapport (« Ceci n'est pas un fichier WAV »);
Retour;
fin si;

Regardons l'exemple plus en détail.
Tout d'abord, le fichier dont le nom est contenu dans la variable FileName est ouvert, le fichier est ouvert en lecture ( FichierOpenMode.Open), lira uniquement le fichier ( FileAccess.Read) et un tampon de 16 octets sera utilisé pour la lecture.
Ensuite, un flux est généré pour lire les données, qui aura l'ordre d'octet le moins significatif pour les données de type Number. Ensuite, 4 caractères, un entier de 32 bits et 4 caractères supplémentaires sont lus à partir du flux résultant. Les données résultantes sont analysées et, sur la base des résultats de l'analyse, une décision est prise quant à savoir si le fichier sélectionné est un fichier .wav ou non.

16.3.3. Écriture de données binaires

L'écriture de données binaires dans un fichier, dans le cas le plus simple, se fait comme suit :

Entrée = Nouveau WriteData (nom de fichier);
Pour indice = 0 à 255 Cycle
Write.WriteByte (Index);
Fin du cycle ;
Record.Close() ;

Cet exemple écrit dans un fichier une séquence d'octets de 0 à 255 (0xFF en hexadécimal). C'est l'option d'enregistrement la plus simple.
Vous pouvez également utiliser une méthode similaire à la méthode de lecture décrite dans l'exemple précédent, où un flux de fichier est obtenu et les données sont écrites dans ce flux de fichier.

16.3.4. Travailler avec un tampon de données binaires

Comme mentionné ci-dessus, le tampon de données binaires constitue un moyen pratique de manipuler des fragments de données binaires.
Non seulement la lecture des données est prise en charge, mais également l'écriture.
À titre d'exemple, nous envisagerons d'analyser l'en-tête du fichier RIFF à partir de l'exemple de lecture de données (voir ici). Pour construire l'exemple, exactement les mêmes informations sur le format de fichier seront utilisées. Ainsi, il est nécessaire de lire dans le fichier source un buffer de la taille de l'en-tête du fichier. L'en-tête se compose de trois champs de 4 octets. Ainsi, 12 octets doivent être lus.

Tampon = Nouveau BufferBinaryData(12);
Fichier = FileStreams.Open (répertoire de fichiers temporaires() + « Windows Logon.wav », FichierOpenMode.Open, FileAccess.Read);
Fichier.Read (Tampon, 0, 12);
Taille = Buffer.ReadInteger32(4);
StreamString = newStreamInMemory (Buffer);
StreamRows.Go(0, PositionInStream.Start);

Format de fichier = ReadLines.ReadCharacters(4, « Windows-1251 »);
ReadLines.Fermer();
StreamRows.Go(8, PositionInStream.Start);
RowReader = nouveau DataReader (RowStream);
Type de fichier = ReadLines.ReadCharacters( 4, « Windows-1251 »);
ReadLines.Fermer();

Le processus d'obtention de données dans un tampon de données binaires n'a rien de spécial. Les opérations ultérieures nécessitent quelques commentaires. La lecture de nombres de n'importe quelle profondeur de bits prise en charge est possible à partir de n'importe quelle position dans le tampon. Dans cet exemple Buffer.ReadInteger32(4); signifie lire un entier de 32 bits à partir de l'octet 4 du tampon. Ainsi, si vous devez lire plusieurs nombres situés à différents endroits du tampon, cela peut être fait sans positionnement direct dans ce tampon.
Toutefois, la lecture d'une chaîne n'est pas prise en charge par le tampon de données binaires. Par conséquent, vous devez utiliser un objet qui vous permet de faire cela : Lire les données. Un objet DataReader ne peut pas être créé à partir d'un tampon de données binaires. Mais à partir d'un tampon de données binaires, vous pouvez créer un flux qui est un intermédiaire universel entre l'emplacement de stockage physique des informations (fichier, tampon de données binaires) et un objet de haut niveau qui permet de travailler avec ces données.
Lorsqu'un objet DataReader est créé sur la base d'un flux, il commence à lire les données à partir de la position actuellement installée dans le flux. Par conséquent, dans l'exemple, la position dans le flux est d'abord définie, puis un objet DataReader est créé et le nombre de caractères requis est lu. Pour une description détaillée de la différence entre le nombre d'octets et de caractères lors de la lecture de chaînes, voir la section suivante 16.3.5

16.3.5. Caractéristiques d'utilisation

Lorsque vous utilisez des données binaires, vous devez prendre en compte les fonctionnalités liées à l'utilisation de données de type String. La particularité est que la longueur de la chaîne renvoyée par la fonction contextuelle globale StrLength() est mesurée en caractères. Dans les symboles, vous devez indiquer la taille des données à lire/écrire dans les méthodes d'écriture/lecture de chaînes dans les objets pour travailler avec des données binaires ( Lire les caractères(),
LireChaîne(), WriteCharacters(), ÉcrireString()). Cependant, il n'existe pas d'option univoque pour convertir la longueur d'une chaîne en caractères en un paramètre similaire en octets. Selon le contenu de la chaîne et l'encodage, ce rapport sera différent. Par conséquent, lorsque vous travaillez avec des structures de données incluant des chaînes de longueur variable, vous devez clairement comprendre dans quelles unités les longueurs de chaîne sont exprimées.
Si dans les données disponibles, la longueur de la chaîne est indiquée en octets et que la chaîne est spécifiée dans un codage de longueur variable multi-octets (par exemple, UTF-8), alors en utilisant des objets de données binaires, en lisant une telle structure à partir d'un fichier dans les données de type String sont généralement impossibles.
Mais dans ce cas, vous pouvez facilement modifier la position de lecture/écriture dans le flux de fichiers. Si la longueur d'une chaîne est spécifiée en caractères, alors il devient possible de lire une telle chaîne dans des données de type String, mais il devient impossible de modifier la position de lecture/écriture dans un tel flux.
Pour obtenir la longueur d'une chaîne en octets, vous pouvez utiliser la fonction suivante pour convertir la chaîne en objet BinaryData :

Fonction Obtenir des données binaires à partir d'une chaîne(Valeur StrParameter, Encodage de la valeur = « UTF-8 »)
MemoryThread = NouveauMemoryThread ;
Écrivain = Nouveau Écrire des données (StreamMemory);
Writer.Write String(StrParameter, Encodage) ;
Écrivain.Fermer();
Retourner StreamMemory.CloseAndGetBinaryData();
FinFonction

La taille réelle en octets peut être obtenue en appelant la fonction Size() sur l'objet BinaryData, qui est obtenu grâce à la fonction.
L'utilisation simultanée d'objets n'est pas recommandée Lire des données/écrire des données et diffuser des objets. Si entre deux opérations de lecture successives depuis ReadData ou deux opérations d'écriture successives vers WriteData il y a un changement de position dans le flux avec lequel travaillent les objets Ch ShadowData/EcritureDonnées– une exception est générée. Ainsi, l'exemple suivant démontre le changement correct de position dans un flux lors de l'écriture de données dans un flux :

Stream = newStreamInMemory();

WriteData.WriteString("Bonjour le monde!");
WriteData.Fermer();
Stream.Go (0, PositionInStream.Start);
DataWrite = newDataWrite (Flux);
WriteData.WriteString("Au revoir!");
WriteData.Fermer();
L'exemple suivant correspond à une exception levée :

Flux = NewStreamInMemory();

WriteData.WriteString("Bonjour tout le monde !");
Stream.Go(0, PositionInStream.Start);
// La ligne suivante lèvera une exception
WriteData.WriteString("Au revoir!");
Dans le même temps, des situations sont possibles où le comportement du système sera incorrect, mais aucune erreur ne sera générée :

Flux = GetStream();
ReadData = nouveau ReadData (Stream);
TestString = ReadData.Read();
InitialPosition = Stream.CurrentPosition();
DataWrite = newDataWrite (Flux);
WriteData.WriteString("Chaîne inattendue");
WriteData.Close();
Stream.Go(InitialPosition, PositionInStream.Start);
// En général, il est impossible de déterminer quelle valeur sera placée dans la variable TestString2
TestLine2 = ReadData.ReadLine();

Le comportement décrit dans cette section est dû à o Les objets Data Reader/Data Writer utilisent leurs propres tampons lorsqu'ils travaillent avec un flux. En conséquence, la position réelle du fil diffère de la position logique formée à la suite des opérations terminées.
De plus, l'utilisation simultanée d'objets Data Reader et Data Writer, qui utilisent un seul thread pour leur travail, n'est pas prise en charge.

Implémenté dans la version 8.3.10.2168.

Nous augmentons progressivement les fonctionnalités permettant de travailler avec des données binaires. Il y a plusieurs raisons à cela. Premièrement, nous n’avons pas mis en œuvre tout ce que nous avions prévu. Et deuxièmement, au cours de la discussion de nouvelles opportunités, nous avons reçu de votre part un certain nombre de souhaits, que nous avons également décidé de mettre en œuvre.

Nouvelles fonctions pour convertir des données binaires en différents formats

Dans un contexte global, nous avons ajouté un grand nombre de nouvelles fonctions de conversion de données binaires. Ainsi, par exemple, vous pouvez effectuer une conversion directe et inverse de données binaires en une chaîne normale, formater une chaîne Base64 et formater la chaîne BinHex. De plus, vous pouvez convertir les données binaires elles-mêmes en formats Base64, BinHex et retour.

Des conversions similaires sont prises en charge pour le type BufferBinaryData. De plus, vous pouvez convertir un tampon de données binaires en données binaires et vice versa.

De plus, deux nouvelles fonctions permettent de découper des données binaires en plusieurs parties, et inversement, de combiner plusieurs objets du type Données binaires en un seul. Dans ce cas, le nouvel objet contiendra les données de toutes les pièces dans l'ordre que vous spécifiez.

Ces fonctions sont similaires dans leur concept au fractionnement et à la fusion de fichiers, mais dans de nombreux cas, elles sont plus efficaces. Parce qu'il n'est pas nécessaire de sauvegarder d'abord les données binaires dans un fichier, et parce qu'il n'y a pas de copie inutile des données lors du fractionnement.

Ajout de la possibilité de travailler avec des flux aux objets qui fonctionnent avec des fichiers

Étant donné que l'utilisation de données binaires est en grande partie liée aux opérations sur les fichiers, nous avons considéré qu'il était tout à fait logique et naturel d'ajouter le travail avec les flux aux objets qui lisent et écrivent actuellement des fichiers d'une manière ou d'une autre.

En conséquence, vous pouvez désormais ouvrir des flux en lecture et en écriture lorsque vous utilisez des objets tels que :

LectureTexte Et ÉcrireTexte;
LectureFastInfoSet Et EntréeFastInfoSet;
LectureHtml Et PostHtml;
Lecture de JSON Et Entrée JSON;
Lecture de XML Et Entrée XML;
Lecture du fichier Zip Et Enregistrer le fichier Zip.

Vous pouvez recevoir le corps sous forme de flux lorsque vous travaillez avec HTTP :

HTTPRequête Et Réponse HTTP;
HTTPServiceRequest Et Réponse du service HTTP.

Document texte;
Document tabulaire;
Document formaté;
Schéma géographique;
Schéma graphique;
Connexion FTP.

L'écriture dans un flux est désormais disponible lorsque vous travaillez avec des types Image Et ConvertToCanonicalXML. Et en plus de cela, travailler avec des flux est désormais pris en charge dans diverses méthodes dont disposent les types Conversion XSL, Gestionnaire de cryptographie, CertificatCryptographie Et Hachage de données.

Copie efficace en lisant et en écrivant des données

Les outils binaires que nous avons implémentés ont permis de copier des flux. Mais sur de gros volumes de données, cette opération n’a pas été réalisée de manière très efficace.

Par conséquent, le type Lire les données nous avons mis en place une nouvelle méthode CopieB(). Cela élimine non seulement ce problème, mais simplifie également le texte, le rendant plus compréhensible.

Par exemple, auparavant, il était possible de recevoir des données binaires d'un flux et de les écrire dans un autre flux.

Désormais, il n'est plus nécessaire de recevoir des données binaires, la copie est effectuée au stade de la lecture des données.

Ce qui est bien, c'est que vous pouvez copier non seulement vers un flux, mais aussi vers un objet Écrire des données. Cette option est pratique lorsque, en plus des données du flux source, vous devez écrire certaines de vos propres données dans le flux de sortie.

Opérations logiques au niveau du bit sur un tampon de données binaires

Vous pouvez désormais utiliser des opérations logiques au niveau du bit lorsque vous travaillez avec des tampons de données binaires. À la suite de ces opérations, le résultat d'une combinaison bit à bit des octets d'origine et des octets du tampon donné sera écrit dans le tampon source selon les règles de l'opération logique sélectionnée. Nous avons mis en œuvre les opérations suivantes :

ÉcrireBitAnd();
ÉcrireBitOr();
WriteBitExclusiveOr();
ÉcrireBitIne();
Inverser().

Un bon exemple d'utilisation d'opérations logiques au niveau du bit est la tâche de décodage du format d'échange avec un équipement de vente au détail. Par exemple, le format d'échange avec les équipements de vente au détail est décrit par un champ de 1 octet. Ce champ contient un ensemble de caractéristiques décrivant la gamme de produits :

Bits 0-2 : taux de taxe ;
Bit 3 : 0 - marchandises à la pièce, 1 - marchandises en poids ;
Bit 4 : 0 - autoriser la vente, 1 - interdire la vente ;
Bit 5 : 0 - activer le comptage de quantité, 1 - désactiver le comptage de quantité ;
Bit 6 : 0 - la vente unique est interdite, 1 - la vente unique est autorisée ;
Bit 7 : Réservé.

Ensuite, le code qui extrait ces informations et les présente sous une forme pratique pour un traitement ultérieur peut ressembler à ceci.

Obtenir un nombre à partir de littéraux hexadécimaux et binaires

NuméroDeHexString();
NuméroDeBinaryString().

Les littéraux binaires sont utiles pour définir des masques lorsqu'ils sont utilisés conjointement avec des opérations au niveau du bit. Par exemple, dans l'exemple précédent avec analyse du format d'échange avec des équipements commerciaux, les masques sont spécifiés à l'aide de nombres décimaux. Ce n'est pas très pratique, car lors de l'écriture et de la lecture de code, vous devez constamment traduire mentalement le nombre décimal en système binaire.

Il est beaucoup plus pratique d’utiliser des littéraux binaires à la place. Dans le même temps, le code devient plus clair et le risque d'erreurs est considérablement réduit.

Les littéraux hexadécimaux sont pratiques à utiliser lors de l'analyse de formats techniques : formats d'image, de son, de vidéo.

Changements dans la technologie des composants externes NativeAPI

Auparavant, il existait un certain nombre de restrictions lors du transfert de données binaires entre 1C:Enterprise et un composant externe. Par exemple, il était impossible de transférer des données binaires vers un composant externe, et lorsque l'on travaillait dans un client Web, l'échange de données binaires était généralement impossible.

Nous supprimons désormais toutes ces restrictions. Vous pouvez échanger des données binaires dans les deux sens et même dans le client Web.

Cela n’affectera en rien le fonctionnement des composants externes existants. Ils fonctionneront comme avant. Mais dans les composants nouvellement créés, vous pouvez désormais transmettre des objets en tant que paramètres Données binaires.

Les données binaires dans 1C sont destinées au stockage de fichiers de format arbitraire. Avec leur aide, vous pouvez :

Organiser l'interaction à l'aide d'un protocole binaire avec divers appareils ;
Stocker des fichiers de n'importe quel format en tant qu'attributs d'objet de métadonnées ;
Convertir les données texte en binaire (le plus souvent utilisé pour l'envoi de rapports) ;
Travaillez avec des données binaires en mémoire.

Ce que le système peut faire

Lorsque vous travaillez avec des données binaires, Platform 8.3 peut effectuer les actions suivantes :

Lire et écrire des données binaires ;
Déplacez les données du client vers le serveur et inversement en utilisant le stockage temporaire ;
Initialiser un objet de type « Image » à l'aide de fichiers binaires ;
Lisez-les depuis le World Wide Web en utilisant les objets « Pièce jointe au courrier », « Connexion HTTP », etc.
Utiliser des outils cryptographiques pour crypter et signer les pièces jointes importantes ;
A l'aide de l'objet « Data Hashing », calculez la fonction de hachage.

Enregistrer les données dans les détails

Par exemple, créons un répertoire dans une configuration de test.

En fait, utiliser le même répertoire pour stocker des informations sur la nomenclature et les données d'images binaires est un peu incorrect. Avec des volumes de données suffisamment importants et des fichiers lourds et volumineux, des temps d'arrêt indésirables et des « freins » dans le fonctionnement du système peuvent survenir. Du point de vue du système, il serait beaucoup plus correct d'organiser un répertoire « Images » séparé, un lien vers lequel nous pourrions définir comme type d'accessoires.

Il est important de noter qu'en raison du fait que les attributs de type « ValueStorage » contenant des données binaires ne sont pas disponibles en mode application gérée, ils ne sont accessibles qu'à l'aide de la méthode FormAttributesValue.

Le champ de message représente un enregistrement de données binaires de stockage de valeurs.

Lire les données des accessoires

Créons un traitement qui sortira le fichier stocké sous forme binaire dans notre configuration dans un tableur (cela est nécessaire, par exemple, pour imprimer le logo d'une entreprise).

En gros, c'est tout le code dont nous avons besoin. À l'aide de l'opérateur Get(), nous lisons les données binaires stockées dans l'attribut de répertoire correspondant et les transférons vers l'objet « Image », qui sera affiché dans la cellule supérieure gauche de la feuille de calcul du formulaire (Fig. 9).

Figure 9

Conversion de données

Ce n'est pas courant, mais il arrive que lorsqu'on travaille avec des échanges non standards avec des systèmes externes, il soit nécessaire de convertir les données du format binaire au format Base64 ou vice versa.

Dans la plupart des cas, la plateforme convertit automatiquement les données ; si cela ne se produit pas, vous devez utiliser des fonctions de traduction globales :

Base64String – convertit la valeur spécifiée en une chaîne du codage correspondant ;
Base64Value – effectue la conversion inverse.

Optimisation du code ci-dessus

Le code présenté sur la figure 4 fonctionne certainement, mais avec une mise en garde importante : si la case « Mode d'utilisation des modalités » est cochée dans les propriétés de configuration (Fig. 10). Sinon, son utilisation provoquera une erreur.
Figure 10

Pour éviter que cela ne se produise, dans le module de formulaire d'élément d'annuaire, allez dans le menu Texte->Refactoring->Appels synchrones obsolètes->Convertir les appels du module.

Après un certain temps, les appels synchrones seront automatiquement convertis en asynchrones et le code prendra la forme (Fig. 11)

Figure 11