La plate-forme technologique 1C: Enterprise 8 vous permet de sauvegarder des fichiers arbitraires dans l'infobase, de les recevoir à partir de là et de les utiliser de différentes manières. Considérons ces opérations par des exemples.
Avant de télécharger un fichier dans l'infobase 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, un accessoire (ou une ressource d'enregistrement) avec le type StockageValeurs.
Chargement d'un fichier arbitraire dans l'infobase 1C
Tout fichier peut être représenté sous forme de données binaires et chargé dans StoreValues.
Lors de la conversion de données binaires en objet StockageValeurs la construction est utilisée newValueStore (Données, Compression) avec deux paramètres:
- Les données - données binaires à stocker
- Compression - taux de compression de l'algorithme de déflation. Un entier compris entre -1 et 9. -1 est le taux de compression par défaut. 0 - pas de compression, 9 - taux de compression maximal. La valeur par défaut est -1. Le paramètre est facultatif, s'il n'est pas spécifié, aucune compression n'est utilisée.
// Convertit le fichier en données binaires
File \u003d New BinaryData (chemin);
// Créer un nouvel objet ValueStorage
Magasin de données \u003d nouveau magasin de valeurs (fichier, nouvelle compression de données (9));
Enregistrement d'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 le travail est décrit dans.
// Récupère les données binaires du stockage
// DataStore - un attribut d'un objet avec le typeValuesStorage
// Ecrit les données reçues sur le disque
// La variable Path contient l'adresse complète du fichier sur le disque
Les données. Ecrire (chemin);
Affichage du fichier situé dans l'infobase 1C
Pour afficher un fichier enregistré dans la base de données, une application qui ouvre ce fichier doit être installée sur l'ordinateur.
// Récupère le nom du fichier temporaire avec l'extension requise
// Dans la variable Extension, vous devez mettre l'extension de fichier, par exemple "pdf"
Chemin \u003d GetTemporaryFileName (Extension);
// Récupère les données du stockage
// DataStore - un attribut d'un objet avec le typeValuesStorage
Data \u003d magasin de données. Recevoir() ;
// Écrire des données dans un fichier temporaire
Les données. Ecrire (chemin);
// Tentative d'ouverture du fichier dans l'application prévue
// Si l'application n'est pas trouvée, la boîte de dialogue système "Ouvrir avec ..."
LaunchApplication (chemin);
Presque toutes les informations peuvent être stockées dans le magasin de valeurs, par exemple,
... images (photos):
// à cet endroit, il affiche tout ... Form Elements.PictureField1.Picture \u003d Storage.Get (); TekImage.Write ();
... feuille de calcul:
TabDoc \u003d Nouveau TabularDocument; TabDoc.Display (Eléments de formulaire.TableDoc Field1); Stockage \u003d Nouveau stockage des valeurs (TabDoc); Écrire ();
Fin de la procédure
Procédure Restauration à partir du stockage Appuyez sur (Élément)
TabDoc \u003d Storage.Get (); Si TabDoc<>Undefined Then FormElements.TableDocumentField1.Offer (TabDoc); Fin si;
Fin de la procédure
... fichiers arbitraires (données binaires):
Eight prend en charge la compression des données stockées:
... traitement externe et reporting:
Degré de compression \u003d nouvelle compression de données (9); // 9 maximum PropsStorageType \u003d NewValueStore (New BinaryData ("c: \\ reports \\ report.epf", degré de compression));
Fin de la procédure
Procédure StartProcessingFrom Storage (Props StorageType)
TempFileName \u003d TempFileDir () + "report.epf"; BinaryData \u003d PropsTypeStorage.Get (); BinaryData.Write (TemporaryFileName); ExternalProcessing \u003d ExternalProcessing.Create (TemporaryFileName); ExternalProcessing.GetForm (). Open ();
Fin de la procédure
Travailler avec le stockage
S'il s'agissait de BinaryData, il peut être restauré à partir du stockage de valeurs à l'aide de la méthode Get et écrit dans un fichier à l'aide de la méthode Write ().
BinaryData \u003d Storage.Get ();
BinaryData \u003d Stockage;
Fin si; BinaryData.Write (FileName);
S'il s'agissait, par exemple, d'un document Word (fichier doc ou autre fichier d'un type enregistré), alors il peut être ouvert comme ceci:
Pour effacer un champ de type Stockage de valeur, vous devez l'attribuer Indéfini:
Travailler avec des fichiers et des images dans le langage intégré 1C: Enterprise 8
Rendez-vous
L'application gérée dispose d'un nouveau mécanisme pour travailler avec des fichiers. Il permet l'échange de fichiers entre l'infobase et l'application cliente. La particularité de ce mécanisme est qu'il est axé sur l'utilisation dans un client léger et un client Web et est conçu en tenant compte des restrictions de travail avec les fichiers imposées par les navigateurs Web.
Le mécanisme est un ensemble de méthodes qui peuvent être utilisées pour placer des données stockées localement chez l'utilisateur dans le stockage temporaire de l'infobase, transférer ces informations du stockage temporaire vers la base de données et les récupérer sur l'ordinateur de l'utilisateur. Les tâches d'application les plus courantes résolues par ce mécanisme sont le stockage des informations d'accompagnement, par exemple des images de marchandises, des documents liés aux contrats, etc.
Portée de la méthode
Stockage temporaire
Le stockage temporaire est une zone spécialisée d'une infobase dans laquelle des données binaires peuvent être stockées. L'objectif principal est le stockage temporaire des informations pendant l'interaction client-serveur jusqu'à ce qu'elles soient transférées dans la base de données.
Le besoin d'un stockage temporaire est dû au fait que dans le modèle du navigateur Web, il est nécessaire de transférer le fichier sélectionné par l'utilisateur directement vers le serveur sans possibilité de le stocker sur le client. Lors du transfert d'un fichier, il est placé dans un stockage temporaire et ne peut être utilisé que lors de l'écriture d'un objet dans la base de données.
Le problème d'application le plus typique résolu par le stockage temporaire consiste à fournir l'accès aux fichiers ou aux images avant que l'objet ne soit écrit dans l'infobase, par exemple sous la forme d'un élément.
Un fichier ou des données binaires stockées sont identifiés par une adresse unique, qui peut être utilisée ultérieurement dans les opérations d'écriture, de lecture ou de suppression. Cette adresse est donnée par les méthodes d'écriture du fichier dans la mémoire temporaire. Une méthode distincte dans le langage intégré vous permet de déterminer si l'adresse transmise est une adresse qui pointe vers des données dans le stockage temporaire.
Base d'information
Le mécanisme permet d'accéder aux données binaires stockées dans des attributs de type ValueStore.
Comme dans le cas du stockage temporaire, les informations sont accessibles via une adresse spéciale. Vous pouvez l'obtenir via une méthode spéciale en passant une référence à un objet ou une clé d'enregistrement de registre d'informations et un nom d'accessoires. Dans le cas d'une section tabulaire, il est en outre nécessaire de transférer l'index de ligne de la section tabulaire.
Les méthodes de travail avec les fichiers sont limitées lorsque vous travaillez avec les détails de l'infobase. Pour eux, contrairement au stockage temporaire, seule la lecture des informations est disponible, mais pas leur écriture ni leur suppression.
Description des méthodes de travail avec les fichiers
Sauvegarde des données dans le stockage temporaire
Le scénario le plus courant d'utilisation de ce mécanisme implique le placement initial des données utilisateur dans le stockage temporaire. Il existe deux méthodes pour cela: PlaceFile () et PlaceFileToTemporaryStorage ().
La première méthode, PlaceFile (), place un fichier du système de fichiers local dans le stockage temporaire. La méthode peut prendre l'adresse cible dans le magasin. S'il n'est pas défini ou s'il s'agit d'une chaîne vide, un nouveau fichier sera créé et la méthode retournera son adresse via le paramètre correspondant.
Si le paramètre définissant le mode de fonctionnement interactif est Vrai, la méthode affichera une boîte de dialogue de sélection de fichier standard, dans laquelle vous pouvez sélectionner un fichier à placer dans le stockage. Dans ce cas, la méthode retournera également l'adresse du fichier sélectionné.
En conséquence, la méthode retourne False si l'utilisateur en mode interactif a refusé d'effectuer l'opération dans la boîte de dialogue de sélection de fichier. La méthode n'est disponible que sur le client.
La deuxième méthode, PutFileToTemporaryStorage (), est similaire à la précédente, sauf qu'elle est disponible sur le serveur et que les données à écrire dans le stockage temporaire ne sont pas représentées comme un chemin dans le système de fichiers, mais comme une variable BinaryData. De même, si aucune adresse cible n'est spécifiée, un nouveau fichier est créé dans le référentiel. Son adresse est renvoyée suite à la fonction.
Récupération d'un fichier à partir du stockage temporaire
Lors de l'écriture d'un objet dans une infobase, vous devrez peut-être récupérer des données d'un stockage temporaire et les placer, par exemple, dans un accessoire. Pour cela, il existe une méthode serveur correspondante - GetFileFrom TemporaryStorage (). Cette méthode récupère les données du stockage temporaire et les renvoie en conséquence. Pour ce faire, vous devez spécifier l'adresse dans le stockage temporaire. Cette adresse est retournée par les méthodes ci-dessus PlaceFile () et PlaceFileTemporaryStorage () si elles réussissent.
Suppression d'un fichier du stockage temporaire
Une fois les données enregistrées dans les accessoires, le fichier dans le stockage temporaire peut être supprimé. Pour ce faire, il existe une méthode DeleteFileFrom TemporaryStorage (), qui supprime un fichier du stockage temporaire. La méthode prend en paramètre l'adresse du fichier dans la mémoire temporaire. Disponible sur le serveur.
Vérification de l'adresse d'appartenance au stockage temporaire
L'adresse du fichier peut pointer à la fois vers un stockage temporaire et une variable d'infobase. Pour vérifier son type, il existe la méthode ThisTemporaryStorageAddress ().
Il vérifie que l'adresse transmise est une adresse pointant vers le magasin. Renvoie True si l'adresse pointe vers un stockage temporaire. La méthode est disponible sur le serveur.
Obtenir une adresse d'accessoires
Une fois les données placées dans les accessoires de l'infobase, il peut être nécessaire d'y accéder à l'aide de méthodes de fichiers.
Mais avant d'obtenir des données, par exemple à partir d'un accessoire, vous devez obtenir l'adresse de cet accessoire. Pour ce faire, il existe une méthode appelée GetFileAddressVInformationBase ().
Son but est de renvoyer l'adresse du fichier dans l'infobase selon les paramètres d'origine. Pour ce faire, vous devez transmettre la clé d'objet (il peut s'agir d'une référence à un objet ou d'une clé pour un enregistrement de registre d'informations) et un nom de variable. Si vous avez besoin de récupérer l'adresse du fichier stocké dans l'attribut de la section tabulaire, avant le nom de l'attribut dans le paramètre spécifiant le nom de l'attribut, vous devez ajouter le nom de la section tabulaire et le point ".". La méthode est disponible à la fois sur le client et sur le serveur.
Récupérer un fichier à partir d'une base d'informations
La méthode GetFile () récupère un fichier de la base d'informations et l'enregistre dans le système de fichiers local de l'utilisateur. Le premier paramètre définit l'adresse du fichier dans les accessoires ou dans le stockage de fichiers temporaires. Le deuxième paramètre spécifie l'emplacement cible du fichier résultant. En mode non interactif, vous devez spécifier le chemin. En mode interactif, le paramètre est facultatif.
Par défaut, la méthode est exécutée de manière interactive, c'est-à-dire que le dernier paramètre est True. Cela signifie qu'une boîte de dialogue s'affiche dans laquelle vous pouvez spécifier une action avec le fichier résultant: exécutez-le ou enregistrez-le dans un emplacement spécifié par l'utilisateur. Si le mode interactif est actif et que le paramètre Chemin cible vers le fichier sur le disque n'est pas spécifié, l'opération d'ouverture de fichier n'est pas disponible. Renvoie une valeur booléenne. False signifie que l'utilisateur a choisi d'annuler l'opération dans la boîte de dialogue d'enregistrement du fichier en ligne.
Un exemple d'utilisation des méthodes de fichier
Variable SelectedName; Adresse variable du stockage temporaire; Si PutFile (Adresse TemporaryStorage, SelectedName, True) Then Object.FileName \u003d SelectedName; PlaceObjectFile (adresse de stockage temporaire); Fin si;
Fin de la procédure
// Copie d'un fichier du stockage temporaire vers le // requis du répertoire, enregistrement d'un objet, suppression d'un fichier du // stockage temporaire et de la procédure OnServer PlaceObjectFile (adresse de stockage temporaire)
DirectoryElement \u003d FormInValue ("Object"); BinaryData \u003d GetFileFrom TemporaryStorage (adresse de stockage temporaire); DirectoryElement.FileData \u003d NewValueStore (BinaryData); FileDiskPath \u003d Nouveau fichier (DirectoryElement.FileName); DirectoryElement.FileName \u003d FilePathNaDisk.Name; DirectoryElement.Write (); Modification \u003d Faux; DeleteFileFrom TemporaryStorage (adresse de stockage temporaire); ValueVFormAttribute (DirectoryElement, "Object");
Fin de la procédure
// Lire le fichier à partir des accessoires et l'enregistrer // sur le disque local en mode interactif & Sur le fichier de procédure client ReadFile ET Save OnDisk ()
Address \u003d GetAddressFileInInformationBase (Object.Link, "FileData"); GetFile (Adresse, Object.FileName, True);
Fin de la procédure
Prise en charge des adresses dans le champ d'image
Le contrôle Champ d'image prend en charge l'affichage d'une image spécifiée par l'adresse de fichier dans le stockage temporaire ou dans une base de données.
Pour ce faire, dans la propriété Data de l'élément de formulaire, vous devez spécifier un attribut de type chaîne. La valeur de cette variable sera interprétée comme l'adresse de l'image.
Exemple
PlaceFile (ImageAddress, True)
Image.Data \u003d ImageAddress
Restrictions lors de l'utilisation du client Web
Le fonctionnement du mécanisme décrit lors de l'utilisation du client Web présente certaines limitations. Ces restrictions sont liées aux spécificités du modèle de sécurité du navigateur. Par exemple, le client ne peut pas enregistrer seul un fichier dans le système de fichiers local, c'est-à-dire que seule la version interactive des méthodes client PlaceFile () et GetFile () est disponible. Une exception est levée lors de la tentative d'utilisation du mode non interactif. Les boîtes de dialogue affichées en mode interactif sont spécifiques à un type de navigateur particulier.
Fonctionnalités lors de l'utilisation du magasin de valeurs sur le client
Problème:
Lorsqu'un Document de la section tabulaire a un attribut de type ValueStorage, il ralentit l'ouverture du formulaire de document, si cet attribut contient des données volumineuses.
Raison supposée:
Il est possible que lorsque le formulaire est ouvert, pas un lien vers les données stockées dans le magasin de valeurs ne soit envoyé au client, mais les données elles-mêmes.
Décision
- Dans les propriétés de l'attribut table du formulaire, il y a un drapeau "Toujours utiliser". S'il est défini, le contenu du champ est toujours transmis entre le serveur et le client - par exemple, lors de l'ouverture d'un formulaire. Cet indicateur doit être désactivé, mais vous devez en tenir compte dans le code, car par défaut la valeur de ce champ ne sera pas sur le client. Un exemple peut être consulté dans 1C: Archive.
Mieux encore, utilisez stockage temporaire pour transférer des fichiers entre le client et le serveur.
Les données binaires dans 1C sont conçues pour stocker des fichiers de n'importe quel format. Avec leur aide, vous pouvez:
- Organiser l'interaction à l'aide d'un protocole binaire avec divers appareils;
- Stockez des fichiers de n'importe quel format en tant qu'attribut de l'objet de métadonnées;
- Convertir les données texte en binaire (le plus souvent utilisé pour envoyer des 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, la plate-forme 8.3 est capable de faire ce qui suit:
- Lire et écrire des données binaires;
- Déplacer les données du client au serveur et inversement en utilisant le stockage temporaire;
- Initialiser un objet de type "Picture" à l'aide de fichiers binaires;
- Lisez-les depuis le World Wide Web en utilisant les objets «Post Attachment», «NTTRC Connection», etc.
- Utiliser des outils cryptographiques pour crypter et signer les pièces jointes importantes;
- Calculez la fonction de hachage à l'aide de l'objet Data Hash.
Sauvegarde des données dans les accessoires
Par exemple, créons une référence dans la configuration de test.
En fait, il est un peu faux d'utiliser le même répertoire pour stocker des informations sur la nomenclature et les données binaires des images. Avec des quantités de données suffisamment importantes et des fichiers lourds de grande taille, des temps d'arrêt indésirables et des «freins» dans le fonctionnement du système peuvent se produire. Il serait beaucoup plus correct du point de vue du système d'organiser un livre de référence séparé «Images», lien vers lequel nous pourrions définir comme type d'attribut.
Il est important de noter qu'en raison du fait que les attributs de type "ValueStore" contenant des données binaires ne sont pas disponibles en mode application gérée, leur accès n'est possible qu'à l'aide de la méthode FormAttributeValue.
Le champ de message représente l'enregistrement de données binaires du magasin 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 un logo d'entreprise).
En gros, c'est tout le code dont nous avons besoin. En utilisant l'opérateur Get (), nous lisons les données binaires stockées dans l'attribut de référence correspondant et les transférons vers l'objet «Picture», qui sera affiché dans la cellule supérieure gauche du tableur du formulaire (Fig. 9).
Fig. 9
Transformation des données
Ce n'est pas souvent le cas, mais il arrive que lorsque vous travaillez avec des échanges non standard avec des systèmes externes, il est nécessaire de convertir les données d'un format binaire au format Base64 ou vice versa.
Dans la plupart des cas, la plate-forme elle-même transforme les données, si cela ne se produit pas, vous devez utiliser les fonctions de traduction globale:
- Base64String - traduit la valeur donnée en une chaîne du codage correspondant;
- Valeur Base64 - effectue la conversion inverse.
Optimiser le code ci-dessus
Le code illustré sur la figure 4 fonctionne certainement, mais avec une mise en garde importante: si la case à cocher "Mode d'utilisation de la modalité" est cochée dans les propriétés de configuration (figure 10). Sinon, son utilisation générera une erreur. 
Fig. 10
Pour éviter que cela ne se produise, dans le module de formulaire de l'élément de référence, accédez au menu Texte-\u003e Refactoring-\u003e Appels synchrones obsolètes-\u003e Convertir les appels de module.
Après un certain temps, les appels synchrones seront automatiquement convertis en appels asynchrones et le code prendra la forme (Fig.11)
Fig. 11
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 appliquées, des situations sont possibles lorsqu'il est nécessaire d'analyser diverses données binaires. Par exemple, il est nécessaire de déterminer le type de fichier par la signature ou d'effectuer certaines manipulations avec l'image. Pour travailler avec des données binaires, 1C: Enterprise fournit des interfaces logicielles spéciales. Ensuite, nous examinerons les possibilités de travailler avec des données binaires.
Tout le travail avec des données binaires est basé sur le concept d'un flux. Couler Est une généralisation logique d'une source de données arbitraire (dans le cas général) (objet flux). Le système ne permet pas de créer un objet Stream indépendant qui n'est associé à aucune source. Cependant, il existe des objets dérivés que vous pouvez créer - un flux associé à un fichier sur le disque (un objet FileStream) ou un flux créé en mémoire (un objet MemoryStream). Un flux permet à la fois de lire et d'écrire des données. Pour déterminer la possibilité d'effectuer certaines opérations, le flux (et les objets dérivés) ont des méthodes spéciales qui vous permettent de déterminer quels
les opérations sont disponibles sur ce flux (méthodes DisponibleEnregistrement (), DisponibleLire (), AvailableChangePosition ()).
S'il est nécessaire de travailler avec un flux à un niveau supérieur, en particulier pour lire / écrire des données telles qu'un nombre (de largeur de bit différente) ou une chaîne, alors les objets ReadData / WriteData sont destinés à cela. A l'aide de ces objets, il est possible d'approcher les données binaires situées dans un flux de manière plus structurée. Ainsi, par exemple, connaissant le format d'un fichier, vous pouvez facilement lire un tel fichier, obtenir les données nécessaires à partir des en-têtes (qui, en règle générale, sont représentés par le nombre et les types de chaînes), sauter les blocs de données inutiles et charger les données 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
- Un objet DataReader ou DataWrite 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 opération supplémentaire n'est requise, le flux obtenu à l'étape 1 est fermé.
- Si vous souhaitez 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 clauses 1 et 2. En d'autres termes, le système offre la possibilité de créer des objets ReadData / WriteData 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 sous la forme d'un fragment séparé avec un accès aléatoire (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 tailles de bits différentes comme avec
comme un tout. Dans ce cas, il est possible de spécifier l'ordre des octets dans les mots: "little endian" ou "big endian". Il est également possible de diviser un tampon en plusieurs et de combiner plusieurs tampons de données binaires en un tampon résultant.
Il est important de noter que travailler avec un tampon de données binaires peut considérablement simplifier l'implémentation dans le cas où le travail avec des données binaires est implémenté du côté de l'application cliente en mode asynchrone. Dans ce cas, la lecture des données dans la mémoire tampon sera effectuée de manière asynchrone, et le travail avec les données dans la mémoire tampon est synchrone.
Le travail avec des données binaires est disponible côté client (y compris le client Web) et côté serveur, ainsi que dans les schémas synchrones et asynchrones. D'autres exemples utiliseront un schéma de travail synchrone.
16.3.2. Lecture de données binaires
Comme exemple de lecture de données binaires, nous examinerons le problème de la détermination du format de fichier correct qui a été sélectionné dans le système pour une utilisation ultérieure. Un fichier .wav avec des données audio sera utilisé comme fichier à vérifier. Pour stocker les fichiers .wav, le format de fichier d'échange de ressources (RIFF) est utilisé, dont une description est donnée ici:
https://msdn.microsoft.com/enus/library/windows/desktop/ee415713.aspx (en anglais). Pour l'exemple de lecture, les données 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 étapes, vous avez besoin du code intégré suivant:
Lecture \u003d Nouveau ReadData (Nom de fichier, ordre d'octets.LittleEndian);
Format de fichier \u003d Read.ReadSymbols(4);
Taille des données \u003d Read.ReadInteger32();
Type de fichier \u003d Read.ReadSymbols(4);
Si le format de fichier<> «RIFF» Puis
Rapport («Ceci n'est pas un fichier RIFF»);
Rembourser;
Fin si;
Si FileType \u003d "WAVE" alors
Rapport («Ceci est un fichier WAV avec données, taille» + DataSize + «octets»);
Autrement
Rapport («Ceci n'est pas un fichier WAV»);
Revenir;
Fin si;
Prenons un exemple plus en détail.
Tout d'abord, un fichier est ouvert dont le nom est contenu dans la variable FileName, le fichier est ouvert en lecture ( Mode d'ouverture de fichier.), ils ne liront qu'à partir du fichier ( Accès aux fichiers.Lire) et un tampon de 16 octets sera utilisé pour la lecture.
Ensuite, un flux est formé destiné à lire des données, qui seront dans l'ordre des octets le moins significatif pour les données de type Number. Ensuite, 4 caractères sont lus à partir du flux résultant, un entier de 32 bits et 4 autres caractères. Les données résultantes sont analysées et une décision est prise en fonction des résultats de l'analyse si le fichier sélectionné est un fichier .wav ou non.
16.3.3. Ecrire des données binaires
L'écriture de données binaires dans un fichier, dans le cas le plus simple, se fait comme suit:
Entrée \u003d Nouveau Enregistrement de données (FileName);
Pour Index \u003d 0 à 255 Cycle
Write.WriteByte (Index);
Fin de 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, lorsqu'un flux de fichiers est reçu et que des données sont écrites dans ce flux de fichiers.
16.3.4. Travailler avec un tampon de données binaires
Comme mentionné ci-dessus, un tampon de données binaires fournit un moyen pratique de manipuler des morceaux de données binaires.
Non seulement la lecture des données est prise en charge, mais également l'écriture.
A titre d'exemple, nous envisagerons d'analyser l'en-tête d'un fichier RIFF à partir de l'exemple de lecture de données (voir ici). Pour créer l'exemple, exactement les mêmes informations sur le format de fichier seront utilisées. Ainsi, il est nécessaire de lire un tampon de la taille de l'en-tête du fichier à partir du fichier source. L'en-tête se compose de trois champs de 4 octets. Ainsi, 12 octets doivent être lus.
Buffer \u003d Nouveau BufferBinaryData(12);
Fichier \u003d FileStreams.Open (Répertoire TempFile() + «Windows Logon.wav», Mode d'ouverture de fichier., Accès aux fichiers.Lire);
File.Read (Buffer, 0, 12);
Taille \u003d Buffer.ReadInteger32(4);
LineStream \u003d NewStreamInMemory (tampon);
StreamStrings.Go(0, PositionInStream.Start);
Format de fichier \u003d ReadStrings.ReadSymbols(4, «windows-1251»);
ReadLines.Close();
StreamStrings.Go(8, PositionInStream.Start);
LineReader \u003d NewDataReader (LineStream);
Type de fichier \u003d ReadStrings.ReadCharacters (4, «windows-1251»);
ReadLines.Close();
Le processus pour obtenir des données dans un tampon de données binaires n'a rien de spécial. D'autres opérations nécessitent quelques commentaires. La lecture de nombres de toute largeur de bit prise en charge est possible à partir de n'importe quelle position dans la mémoire tampon. Dans cet exemple Buffer.ReadInteger32 (4); signifie lire un entier de 32 bits commençant à 4 octets du tampon. Ainsi, s'il est nécessaire de lire plusieurs nombres situés à des endroits différents dans le tampon, cela peut se faire sans positionnement direct dans ce tampon.
Cependant, 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 ceci: Lecture de données. L'objet DataReader ne peut pas être créé sur la base du tampon de données binaires. Mais sur la base du tampon de données binaires, vous pouvez créer un flux qui est un médiateur universel entre l'emplacement de stockage physique (fichier, tampon de données binaires) et un objet de haut niveau qui vous 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 définie dans le flux. Par conséquent, dans l'exemple, la position dans le flux est d'abord définie, puis l'objet DataReader est créé et le nombre requis de caractères 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 particularités de travailler avec des données de type String. La particularité est que la longueur de la chaîne renvoyée par la fonction de contexte global StrLength () est mesurée en caractères. Les symboles doivent indiquer la taille des données en lecture / écriture dans les méthodes d'écriture / lecture de lignes dans les objets pour travailler avec des données binaires ( Lire les symboles (),
ReadString (), WriteSymbols (), WriteString ()). Cependant, il n'y a pas d'option sans ambiguïté pour convertir la longueur de chaîne en caractères en un paramètre similaire en octets. Selon le contenu de la chaîne et le codage, ce rapport sera différent. Par conséquent, lorsque vous travaillez avec des structures de données qui incluent 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 pour travailler avec des données binaires, il est généralement impossible de lire une telle structure à partir d'un fichier dans des données de type String.
Mais dans ce cas, vous pouvez facilement changer la position de lecture / écriture dans le flux de fichiers. Si la longueur de la chaîne est spécifiée en caractères, il devient alors possible de lire une telle chaîne dans des données de type String, mais il devient impossible de changer 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 GetBinaryDataFromString(Valeur StrParameter, Value Encoding \u003d "UTF-8")
Flux de mémoire \u003d nouveau flux de mémoire;
Writer \u003d Nouveau Écriture de données (flux de mémoire);
Writer.WriteString(StrParameter, encodage);
Écrivain.Close();
Retourner StreamMemory.Close & GetBinaryData();
FinFonction
La taille réelle en octets peut être obtenue en appelant la fonction Size () sur l'objet BinaryData, qui est obtenue à la suite de la fonction.
L'utilisation simultanée d'objets n'est pas recommandée ReadData / WriteData et des objets en streaming. Si entre deux opérations de lecture séquentielle de ReadData ou deux opérations d'écriture séquentielle vers WriteData, il y a un changement de position dans le flux avec lequel les objets H flux de données / écriture de données - une exception est levée. Ainsi, l'exemple suivant montre le changement correct de position dans le flux lors de l'écriture de données dans le flux:
Stream \u003d Nouveau StreamInMemory ();
WriteData.WriteString("Bonjour le monde!");
Enregistrement des données.Fermer();
Stream.Jump (0, PositionInStream.Start);
Enregistrement de données \u003d Nouvel enregistrement de données (flux);
WriteData.WriteString("Jusqu'à ce que!");
Enregistrement des données.Fermer();
L'exemple suivant a levé une exception:
Stream \u003d Nouveau StreamInMemory ();
WriteData.WriteStrok ("Bonjour 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:
Stream \u003d GetStream ();
ReadData \u003d Nouveau ReadData (Stream);
TestString \u003d ReadData.Read ();
SourcePosition \u003d Stream.CurrentPosition ();
Enregistrement de données \u003d Nouvel enregistrement de données (flux);
WriteData.WriteString ("Chaîne inattendue");
Enregistrement de données.Close ();
Stream.Go (OriginPosition, PositionInStream.Start);
// En général, il est impossible de déterminer quelle valeur sera placée dans la variable TestString2
TestString2 \u003d ReadData.ReadString ();
Le comportement décrit dans cette section est causé par
o les objets ReadData / WriteData utilisent leurs propres tampons lorsqu'ils travaillent avec un flux. En conséquence, la position réelle du flux diffère de la position logique, qui est formée à la suite des opérations effectuées.
En outre, l'utilisation simultanée des objets Data Read et Data Writes, qui utilisent un thread pour leur travail, n'est pas prise en charge.
