La piattaforma tecnologica 1C: Enterprise 8 permette di salvare file arbitrari nell'infobase, riceverli da lì e utilizzarli in vari modi. Consideriamo queste operazioni con esempi.
Prima di scaricare un file nell'infobase 1C, è necessario ottenere l'indirizzo completo del file sul disco. L'utilizzo delle finestre di dialogo per la selezione dei file è descritto in.
Per memorizzare i file, un props (o registra una risorsa) con il tipo StorageValues.
Caricamento di un file arbitrario nell'infobase 1C
Qualsiasi file può essere rappresentato come dati binari e caricato in StoreValues.
Durante la conversione di dati binari in oggetto StorageValues la costruzione è usata newValueStore (dati, compressione) con due parametri:
- Dati - dati binari da mettere in memoria
- Compressione - rapporto di compressione dell'algoritmo di deflazione. Un numero intero compreso tra -1 ... 9. -1 è il rapporto di compressione predefinito. 0 - nessuna compressione, 9 - rapporto di compressione massimo. L'impostazione predefinita è -1. Il parametro è facoltativo, se non specificato, non viene utilizzata alcuna compressione.
// Converte il file in dati binari
File \u003d New BinaryData (Path);
// Crea un nuovo oggetto ValueStorage
Data Store \u003d New Value Store (File, New Data Compression (9));
Salvataggio su disco di un file arbitrario dall'infobase 1C
Per salvare un file dal database 1C su disco, è necessario determinare il percorso e il nome del file. Per fare ciò, c'è una finestra di dialogo per il salvataggio dei file, il cui lavoro è descritto in.
// Ottieni dati binari dalla memoria
// DataStore - un attributo di un oggetto con il tipoValuesStorage
// Scrive i dati ricevuti su disco
// La variabile Path contiene l'indirizzo completo del file su disco
Dati. Scrivi (percorso);
Visualizzazione del file che si trova nell'infobase 1C
Per visualizzare un file salvato nel database, è necessario installare sul computer un'applicazione che apra questo file.
// Ottiene il nome del file temporaneo con l'estensione richiesta
// Nella variabile Extension, è necessario inserire l'estensione del file, ad esempio "pdf"
Path \u003d GetTemporaryFileName (estensione);
// Recupera i dati dalla memoria
// DataStore - un attributo di un oggetto con il tipoValuesStorage
Data \u003d Data Store. Ricevere() ;
// Scrive i dati in un file temporaneo
Dati. Scrivi (percorso);
// Tentativo di aprire il file nell'applicazione prevista
// Se l'applicazione non viene trovata, la finestra di dialogo di sistema "Apri con ..."
LaunchApplication (Path);
Quasi tutte le informazioni possono essere memorizzate nell'archivio valori, ad esempio,
... immagini (immagini):
// in questo posto mostra tutto ... Form Elements.PictureField1.Picture \u003d Storage.Get (); TekImage.Write ();
... documento del foglio di lavoro:
TabDoc \u003d Nuovo TabularDocument; TabDoc.Display (Form Elements.TableDoc Field1); Archiviazione \u003d Nuova archiviazione dei valori (TabDoc); Scrivi ();
Fine della procedura
Procedura Ripristino da magazzino Premere (elemento)
TabDoc \u003d Storage.Get (); Se TabDoc<>Undefined Then Form Elements.TableDocumentField1.Offer (TabDoc); Finisci se;
Fine della procedura
... file arbitrari (dati binari):
Otto supporta la compressione dei dati archiviati:
... elaborazione e reportistica esterna:
Grado di compressione \u003d Nuova compressione dati (9); // 9 massimo PropsStorageType \u003d NewValueStore (New BinaryData ("c: \\ reports \\ report.epf", Compression Degree));
Fine della procedura
Procedura Avvio Elaborazione da magazzino (Tipo di archiviazione puntelli)
TempFileName \u003d TempFileDir () + "report.epf"; BinaryData \u003d PropsTypeStorage.Get (); BinaryData.Write (TemporaryFileName); ExternalProcessing \u003d ExternalProcessing.Create (TemporaryFileName); ExternalProcessing.GetForm (). Open ();
Fine della procedura
Lavorare con l'archiviazione
Se era BinaryData, può essere ripristinato dall'archivio valori utilizzando il metodo Get e scritto su un file utilizzando il metodo Write ().
BinaryData \u003d Storage.Get ();
BinaryData \u003d Archiviazione;
Finisci se; BinaryData.Write (FileName);
Se fosse, ad esempio, un documento Word (file doc o un altro file di un tipo registrato), allora può essere aperto in questo modo:
Per cancellare un campo di tipo Archiviazione valori, è necessario assegnarlo Non definito:
Lavorare con file e immagini nella lingua incorporata 1C: Enterprise 8
Appuntamento
L'applicazione gestita dispone di un nuovo meccanismo per lavorare con i file. Fornisce lo scambio di file tra l'infobase e l'applicazione client. La particolarità di questo meccanismo è che è focalizzato sull'uso in un thin client e un client Web ed è progettato tenendo conto delle restrizioni sul lavoro con i file imposte dai browser web.
Il meccanismo è un insieme di metodi che possono essere utilizzati per posizionare i dati archiviati localmente presso l'utente nella memoria temporanea dell'infobase, trasferire queste informazioni dalla memoria temporanea al database e recuperarle nuovamente sul computer dell'utente. Le attività applicative più comuni risolte da questo meccanismo sono l'archiviazione di informazioni di accompagnamento, ad esempio immagini di merci, documenti relativi a contratti, ecc.
Ambito del metodo
Deposito temporaneo
L'archiviazione temporanea è un'area specializzata di una infobase in cui è possibile memorizzare i dati binari. Lo scopo principale è l'archiviazione temporanea delle informazioni durante l'interazione client-server fino a quando non vengono trasferite al database.
La necessità di archiviazione temporanea nasce dal fatto che nel modello di browser web è necessario trasferire il file selezionato dall'utente direttamente sul server senza possibilità di memorizzarlo sul client. Quando si trasferisce un file, viene posto in una memoria temporanea e solo allora può essere utilizzato durante la scrittura di un oggetto nel database.
Il problema applicativo più tipico risolto dalla memoria temporanea è fornire l'accesso a file o immagini prima che l'oggetto venga scritto nell'infobase, ad esempio sotto forma di un elemento.
Un file o un dato binario posto in memoria è identificato da un indirizzo univoco che può essere utilizzato successivamente nelle operazioni di scrittura, lettura o cancellazione. Questo indirizzo è dato dai metodi per scrivere il file nella memoria temporanea. Un metodo separato nel linguaggio integrato consente di determinare se l'indirizzo passato è un indirizzo che punta a dati nella memoria temporanea.
Base di informazioni
Il meccanismo consente di accedere ai dati binari archiviati negli attributi del tipo ValueStore.
Come nel caso della conservazione temporanea, è possibile accedere alle informazioni tramite un apposito indirizzo. Puoi ottenerlo tramite un metodo speciale passando un riferimento a un oggetto o una chiave del record del registro delle informazioni e un nome di oggetti di scena. Nel caso di una sezione tabellare, è inoltre necessario trasferire l'indice di riga della sezione tabulare.
I metodi di lavoro con i file sono limitati quando si lavora con i dettagli di infobase. Per loro, a differenza della memorizzazione temporanea, è disponibile solo la lettura delle informazioni, ma non la scrittura o l'eliminazione.
Descrizione dei metodi per lavorare con i file
Salvataggio dei dati nella memoria temporanea
Lo scenario più tipico per l'utilizzo di questo meccanismo prevede il posizionamento iniziale dei dati utente nella memoria temporanea. Esistono due metodi per questo: PlaceFile () e PlaceFileToTemporaryStorage ().
Il primo metodo, PlaceFile (), inserisce un file dal file system locale nella memoria temporanea. Il metodo può prendere l'indirizzo di destinazione nel negozio. Se non è definito o è una stringa vuota, verrà creato un nuovo file e il metodo restituirà il suo indirizzo tramite il parametro corrispondente.
Se il parametro che definisce la modalità operativa interattiva è True, il metodo visualizzerà una finestra di dialogo standard per la selezione dei file, in cui è possibile selezionare un file da collocare nella memoria. In questo caso, il metodo restituirà anche l'indirizzo del file selezionato.
Di conseguenza, il metodo restituisce False se l'utente in modalità interattiva ha rifiutato di eseguire l'operazione nella finestra di dialogo di selezione dei file. Il metodo è disponibile solo sul client.
Il secondo metodo, PutFileToTemporaryStorage (), è simile al precedente, tranne per il fatto che è disponibile sul server e i dati da scrivere nella memoria temporanea non sono rappresentati come un percorso nel file system, ma come una variabile BinaryData. Allo stesso modo, se non viene specificato alcun indirizzo di destinazione, viene creato un nuovo file nel repository. Il suo indirizzo viene restituito come risultato della funzione.
Recupero di un file dalla memoria temporanea
Quando si scrive un oggetto in una infobase, potrebbe essere necessario recuperare i dati da una memoria temporanea e posizionarli, ad esempio, in un oggetto di scena. Per questo, esiste un metodo server corrispondente: GetFileFrom TemporaryStorage (). Questo metodo recupera i dati dalla memoria temporanea e li restituisce come risultato. A tale scopo, è necessario specificare l'indirizzo nella memoria temporanea. Questo indirizzo viene restituito dai metodi precedenti PlaceFile () e PlaceFileTemporaryStorage () se riescono.
Rimozione di un file dalla memoria temporanea
Dopo che i dati sono stati salvati negli oggetti di scena, il file nella memoria temporanea può essere eliminato. Per fare ciò, c'è il metodo DeleteFileFrom TemporaryStorage (), che rimuove il file dalla memoria temporanea. Il metodo prende nel parametro l'indirizzo del file nella memoria temporanea. Disponibile sul server.
Verifica dell'indirizzo per l'appartenenza alla memoria temporanea
L'indirizzo del file può puntare sia a una memoria temporanea che a una variabile infobase. Per controllarne il tipo, c'è il metodo ThisTemporaryStorageAddress ().
Verifica che l'indirizzo passato sia un indirizzo che punta al negozio. Restituisce True se l'indirizzo punta alla memoria temporanea. Il metodo è disponibile sul server.
Ottenere un indirizzo per gli oggetti di scena
Dopo che i dati sono stati inseriti negli oggetti di scena nell'infobase, potrebbe essere necessario accedervi utilizzando i metodi dei file.
Ma prima di ottenere dati, ad esempio da un oggetto di scena, è necessario ottenere l'indirizzo di questo oggetto di scena. Per fare ciò, esiste un metodo chiamato GetFileAddressInInformationBase ().
Il suo scopo è restituire l'indirizzo del file nell'infobase secondo i parametri originali. Per fare ciò, è necessario passare la chiave dell'oggetto (può essere un riferimento a un oggetto o una chiave per un record del registro delle informazioni) e un nome di variabile. Se è necessario ottenere l'indirizzo del file memorizzato nell'attributo della sezione tabulare, prima del nome dell'attributo nel parametro che specifica il nome dell'attributo, è necessario aggiungere il nome della sezione tabulare e il punto ".". Il metodo è disponibile sia sul client che sul server.
Recupero di un file da una infobase
Il metodo GetFile () recupera un file dall'infobase e lo salva nel file system locale dell'utente. Il primo parametro definisce l'indirizzo del file negli oggetti di scena o nella memoria di file temporanei. Il secondo parametro definisce la posizione di destinazione del file risultante. In modalità non interattiva, è necessario specificare il percorso. In modalità interattiva, il parametro è facoltativo.
Per impostazione predefinita, il metodo viene eseguito in modo interattivo, ovvero l'ultimo parametro è True. Ciò significa che viene visualizzata una finestra di dialogo in cui è possibile specificare un'azione con il file risultante: avviarlo o salvarlo in una posizione specificata dall'utente. Se la modalità interattiva è attiva e il parametro Percorso di destinazione del file su disco non è specificato, l'operazione di apertura del file non è disponibile. Restituisce un valore booleano. Falso significa che l'utente ha scelto di annullare l'operazione nella finestra di dialogo di salvataggio del file in linea.
Un esempio di utilizzo dei metodi file
Variable SelectedName; Indirizzo variabile di archiviazione temporanea; Se PutFile (TemporaryStorage Address, SelectedName, True) Allora Object.FileName \u003d SelectedName; PlaceObjectFile (TemporaryStorageAddress); Finisci se;
Fine della procedura
// Copia di un file dalla memoria temporanea agli // oggetti di scena della directory, registrazione di un oggetto, eliminazione di un file dalla // memoria temporanea e procedura OnServer PlaceObjectFile (TemporaryStorage Address)
DirectoryElement \u003d FormInValue ("Object"); BinaryData \u003d GetFileFrom TemporaryStorage (TemporaryStorage Address); DirectoryElement.FileData \u003d NewValueStore (BinaryData); FileDiskPath \u003d Nuovo file (DirectoryElement.FileName); DirectoryElement.FileName \u003d FilePathNaDisk.Name; DirectoryElement.Write (); Modifica \u003d Falso; DeleteFileFrom TemporaryStorage (indirizzo di TemporaryStorage); ValueVFormAttribute (DirectoryElement, "Object");
Fine della procedura
// Leggi il file dagli oggetti di scena e salvalo // sul disco locale in modalità interattiva e sulla procedura client ReadFile AND Save OnDisk ()
Indirizzo \u003d GetAddressFileInInformationBase (Object.Link, "FileData"); GetFile (Address, Object.FileName, True);
Fine della procedura
Supporto per indirizzi nel campo immagine
Il controllo del campo Immagine supporta la visualizzazione di un'immagine specificata dall'indirizzo del file nella memoria temporanea o in un database.
A tale scopo, nella proprietà Data dell'elemento form, è necessario specificare un attributo di tipo stringa. Il valore di questa variabile verrà interpretato come l'indirizzo dell'immagine.
Esempio
PlaceFile (ImageAddress, True)
Image.Data \u003d ImageAddress
Restrizioni quando si lavora con il client Web
Il funzionamento del meccanismo descritto quando si utilizza il client Web presenta alcune limitazioni. Queste restrizioni sono correlate alle specifiche del modello di sicurezza del browser. Ad esempio, il client non può salvare un file nel file system locale da solo, ovvero è disponibile solo la versione interattiva dei metodi client PlaceFile () e GetFile (). Viene generata un'eccezione quando si tenta di utilizzare la modalità non interattiva. Le finestre di dialogo visualizzate in modalità interattiva sono specifiche di un particolare tipo di browser.
Funzionalità quando si lavora con Store of Values \u200b\u200bsul client
Problema:
Quando un documento nella sezione tabulare ha un attributo del tipo ValueStorage, rallenta l'apertura del modulo del documento, se questo attributo contiene dati di grandi dimensioni.
Motivo supposto:
Forse, quando si apre un modulo, il client non riceve un collegamento ai dati archiviati nell'archivio valori, ma i dati stessi.
Decisione
- Nelle proprietà dell'attributo tabella del modulo è presente un flag "Usa sempre". Se impostato, il contenuto del campo viene sempre passato tra il server e il client, ad esempio quando si apre un modulo. Questo flag deve essere disabilitato, ma è necessario tenerne conto nel codice, poiché per impostazione predefinita il valore di questo campo non sarà sul client. Un esempio può essere trovato in 1C: Archive.
Meglio ancora, usa deposito temporaneo per trasferire file tra client e server.
I dati binari in 1C sono progettati per memorizzare file di qualsiasi formato. Con il loro aiuto puoi:
- Organizza l'interazione utilizzando un protocollo binario con vari dispositivi;
- Archivia file di qualsiasi formato come attributo dell'oggetto metadati;
- Converti i dati di testo in binario (utilizzato più spesso per inviare rapporti);
- Lavora con dati binari in memoria.
Cosa può fare il sistema
Quando si lavora con dati binari, la piattaforma 8.3 è in grado di eseguire le seguenti operazioni:
- Leggere e scrivere dati binari;
- Spostare i dati dal client al server e viceversa utilizzando l'archiviazione temporanea;
- Inizializza un oggetto del tipo "Immagine" utilizzando file binari;
- Leggili dal World Wide Web utilizzando gli oggetti "Post Attachment", "NTTRC Connection", ecc.
- Utilizzare strumenti crittografici per crittografare e firmare allegati importanti;
- Calcola la funzione hash utilizzando l'oggetto Data Hash.
Salvataggio dei dati su oggetti di scena
Ad esempio, creiamo un riferimento nella configurazione di test.
In effetti, è un po 'sbagliato usare la stessa directory per memorizzare informazioni sulla nomenclatura e sui dati binari delle immagini. Con quantità di dati sufficientemente grandi e file pesanti di grandi dimensioni, possono verificarsi tempi di inattività e "freni" indesiderati nel funzionamento del sistema. Sarebbe molto più corretto dal punto di vista del sistema organizzare un libro di riferimento separato "Pictures", un collegamento a cui potremmo impostare come un tipo di attributo.
È importante notare che, poiché gli attributi del tipo "ValueStore" contenenti dati binari non sono disponibili nella modalità di applicazione gestita, l'accesso ad essi è possibile solo utilizzando il metodo FormAttributeValue.
Il campo del messaggio rappresenta il record di dati binari dell'archivio valori.
Lettura dei dati dagli oggetti di scena
Creiamo un'elaborazione che produrrà il file memorizzato in forma binaria nella nostra configurazione in un documento di foglio di calcolo (questo è necessario, ad esempio, per stampare un logo aziendale).
Fondamentalmente, questo è tutto il codice di cui abbiamo bisogno. Con l'aiuto dell'operatore Get (), leggiamo i dati binari memorizzati nel corrispondente riferimento della directory e li trasferiamo nell'oggetto "Picture", che verrà mostrato nella cella in alto a sinistra del foglio di calcolo del modulo (Fig. 9).
Fig. 9
Trasformazione dei dati
Non capita spesso, ma accade che quando si lavora con scambi non standard con sistemi esterni, sia necessario convertire i dati da un formato binario al formato Base64 o viceversa.
Nella maggior parte dei casi, la piattaforma stessa trasforma i dati, se ciò non accade, è necessario utilizzare le funzioni di traduzione globale:
- Base64String: converte il valore specificato in una stringa della codifica corrispondente;
- Valore Base64: esegue la conversione inversa.
Ottimizzazione del codice sopra
Il codice mostrato in Fig. 4 funziona certamente, ma con un avvertimento significativo: se la casella di controllo "Modalità di utilizzo" è spuntata nelle proprietà di configurazione (Fig. 10). In caso contrario, utilizzarlo genererà un errore. 
Fig. 10
Per evitare che ciò accada, mentre ci si trova nel modulo del modulo dell'elemento di riferimento, andare nel menu Testo-\u003e Refactoring-\u003e Chiamate sincrone deprecate-\u003e Converti chiamate al modulo.
Dopo un po 'di tempo, le chiamate sincrone verranno automaticamente convertite in asincrone e il codice assumerà la forma (Fig.11)
Fig. 11
Stampa (Ctrl + P)
16.3. Lavorare con dati binari
16.3.1. Informazione Generale
Quando si implementano soluzioni applicate, sono possibili situazioni in cui è necessario analizzare vari dati binari. Ad esempio, è necessario determinare il tipo di file dalla firma o eseguire alcune manipolazioni con l'immagine. Per lavorare con dati binari, 1C: Enterprise fornisce interfacce software speciali. Successivamente, considereremo le possibilità di lavorare con dati binari.
Tutto il lavoro con i dati binari si basa sul concetto di flusso. Flusso È una generalizzazione logica di un'origine dati arbitraria (nel caso generale) (oggetto flusso). Il sistema non fornisce la possibilità di creare un oggetto Stream indipendente che non sia associato ad alcuna sorgente. Tuttavia, esistono oggetti derivati \u200b\u200bche è possibile creare: un flusso associato a un file su disco (oggetto FileStream) o un flusso creato in memoria (oggetto MemoryStream). Un flusso consente sia di leggere che di scrivere dati. Per determinare la possibilità di eseguire determinate operazioni, il flusso (e gli oggetti derivati) dispongono di metodi speciali che consentono di determinare quali
le operazioni sono disponibili su questo flusso (metodi AvailableRecord (), AvailableRead (), AvailableChangePosition ()).
Se è necessario lavorare con un flusso a un livello superiore, in particolare, leggere / scrivere dati come un numero (di diversa larghezza di bit) o \u200b\u200buna stringa, allora gli oggetti ReadData / WriteData sono destinati a questo. Con l'aiuto di questi oggetti è possibile avvicinarsi a dati binari che si trovano in un flusso in modo più strutturato. Quindi, ad esempio, conoscendo il formato di un file, puoi leggere abbastanza comodamente un file del genere, ottenere i dati necessari dalle intestazioni (che, di regola, sono rappresentati dal numero e dai tipi di stringa), saltare i blocchi di dati non necessari e caricare i dati necessari per l'elaborazione.
Lo schema generale per lavorare con i dati binari può essere rappresentato come segue:
- Ricezione del flusso
- Viene creato un oggetto DataReader o DataWrite.
- Con l'aiuto dell'oggetto creato nel passaggio 2, vengono eseguite le azioni richieste.
- L'oggetto creato nel passaggio 2 viene chiuso.
- Se non sono necessarie ulteriori operazioni, il flusso ottenuto nella fase 1 viene chiuso.
- Se desideri continuare a lavorare con lo stream, puoi impostare una nuova posizione nello stream (se questa operazione è supportata) e continuare a lavorare dal passaggio 2.
Va notato che è possibile combinare le clausole 1 e 2. In altre parole, il sistema fornisce la possibilità di creare oggetti ReadData / WriteData direttamente da, ad esempio, un oggetto BinaryData.
Per eseguire varie operazioni con dati binari, il sistema fornisce la possibilità di ottenere una parte del flusso come un frammento separato con accesso casuale (byte) (oggetto BufferBinaryData). La dimensione del buffer viene impostata al momento della creazione e non può essere modificata in seguito. Quando si lavora con un buffer di dati binari, è possibile lavorare con numeri di diverse dimensioni di bit come con
nel suo insieme. Allo stesso tempo, è possibile specificare l'ordine dei byte in parole: "little endian" o "big endian". È anche possibile dividere un buffer in più e combinare più buffer di dati binari in un buffer risultante.
È importante notare che lavorare con un buffer di dati binari può semplificare notevolmente l'implementazione se lavorare con dati binari è implementato sul lato dell'applicazione client in modalità asincrona. In questo caso, la lettura dei dati nel buffer verrà eseguita in modo asincrono e il lavoro con i dati nel buffer è sincrono.
Lavorare con i dati binari è disponibile sul lato client (incluso il client web) dell'applicazione e sul lato server, così come negli schemi sincroni e asincroni. Ulteriori esempi useranno uno schema di lavoro sincrono.
16.3.2. Lettura di dati binari
Come esempio di lettura di dati binari, considereremo il problema di determinare il formato file corretto che è stato selezionato nel sistema per un ulteriore utilizzo. Verrà utilizzato un file .wav con dati audio come file da controllare. Per memorizzare i file .wav, viene utilizzato il formato RIFF (Resource Interchange File Format), di cui viene fornita una descrizione qui:
https://msdn.microsoft.com/enus/library/windows/desktop/ee415713.aspx (in inglese). Per l'esempio di lettura, verranno utilizzati i seguenti dati di formato:
1. i primi 4 byte del file contengono l'identificatore di formato: RIFF.
2. i successivi 4 byte contengono la dimensione dei dati audio effettivi in \u200b\u200bordine di byte little-endian.
3. i successivi 4 byte contengono il tipo di testo dei dati utilizzati: WAVE.
Per completare questi passaggi, è necessario il seguente codice incorporato:
Lettura \u003d Nuovo ReadData (FileName, Byte Order.LittleEndian);
Formato file \u003d lettura, lettura simboli(4);
Dimensione dati \u003d Read.ReadInteger32();
Tipo di file \u003d Read.ReadSymbols(4);
Se il file Format<> "RIFF" Allora
Report ("Questo non è un file RIFF");
Rimborso;
Finisci se;
Se FileType \u003d "WAVE" Allora
Report ("Questo è un file WAV con dati, dimensione" + DataSize + "byte");
Altrimenti
Report ("Questo non è un file WAV");
Ritorno;
Finisci se;
Consideriamo un esempio più in dettaglio.
Innanzitutto, viene aperto un file il cui nome è contenuto nella variabile FileName, il file viene aperto per la lettura ( Modalità di apertura dei file.), leggeranno solo dal file ( Accesso ai file Leggi) e per la lettura verrà utilizzato un buffer da 16 byte.
Quindi viene formato un flusso destinato alla lettura dei dati, che sarà nell'ordine di byte meno significativo per i dati di tipo Numero. Quindi, 4 caratteri, un numero intero a 32 bit e altri 4 caratteri vengono letti dal flusso risultante. I dati risultanti vengono analizzati e viene presa una decisione in base ai risultati dell'analisi se il file selezionato è un file .wav o meno.
16.3.3. Scrittura di dati binari
La scrittura di dati binari su un file, nel caso più semplice, viene eseguita come segue:
Voce \u003d Nuovo Record di dati (FileName);
Per indice \u003d da 0 a 255 cicli
Write.WriteByte (Indice);
Fine del ciclo;
Record.Close ();
Questo esempio scrive su un file una sequenza di byte da 0 a 255 (0xFF in esadecimale). Questa è l'opzione di registrazione più semplice.
È inoltre possibile utilizzare un metodo simile al metodo di lettura descritto nell'esempio precedente, quando viene ricevuto un flusso di file e i dati vengono scritti in questo flusso di file.
16.3.4. Lavorare con un buffer di dati binari
Come accennato in precedenza, un buffer di dati binari fornisce un modo conveniente per manipolare blocchi di dati binari.
Non è supportata solo la lettura dei dati, ma anche la scrittura.
Come esempio, prenderemo in considerazione l'analisi dell'intestazione di un file RIFF dall'esempio di lettura dei dati (vedi qui). Per creare l'esempio verranno utilizzate esattamente le stesse informazioni sul formato del file. Pertanto, è necessario leggere dal file sorgente un buffer delle dimensioni dell'intestazione del file. L'intestazione è composta da tre campi da 4 byte. Pertanto, devono essere letti 12 byte.
Buffer \u003d Nuovo BufferBinaryData(12);
File \u003d FileStreams.Open (TempFile Directory() + "Windows Logon.wav", Modalità di apertura dei file., Accesso ai file Leggi);
File.Read (Buffer, 0, 12);
Dimensione \u003d Buffer.ReadInteger32(4);
LineStream \u003d NewStreamInMemory (Buffer);
StreamStrings.Go(0, PositionInStream.Start);
Formato file \u003d ReadStrings.ReadSymbols(4, "windows-1251");
ReadLines.Close();
StreamStrings.Go(8, PositionInStream.Start);
LineReader \u003d NewDataReader (LineStream);
Tipo di file \u003d ReadStrings.ReadCharacters (4, "windows-1251");
ReadLines.Close();
Il processo di acquisizione dei dati in un buffer di dati binari non è niente di speciale. Ulteriori operazioni richiedono alcuni commenti. La lettura di numeri di qualsiasi larghezza di bit supportata è possibile da qualsiasi posizione nel buffer. In questo esempio Buffer.ReadInteger32 (4); significa leggere un intero a 32 bit a partire da 4 byte del buffer. Pertanto, se è necessario leggere più numeri situati in punti diversi nel buffer, ciò può essere fatto senza posizionamento diretto in questo buffer.
La lettura di una stringa, tuttavia, non è supportata dal buffer di dati binari. Pertanto, dovresti utilizzare un oggetto che ti consenta di farlo: Lettura dei dati. L'oggetto DataReader non può essere creato in base al buffer di dati binari. Ma in base al buffer di dati binari, è possibile creare un flusso che sia un mediatore universale tra la posizione di archiviazione fisica delle informazioni (file, buffer di dati binari) e un oggetto di alto livello che consente di lavorare con questi dati.
Quando un oggetto DataReader viene creato in base a un flusso, inizia a leggere i dati dalla posizione attualmente impostata nel flusso. Pertanto, nell'esempio, la posizione nel flusso viene prima impostata, quindi viene creato l'oggetto DataReader e viene letto il numero di caratteri richiesto. Per una descrizione dettagliata della differenza tra il numero di byte e caratteri durante la lettura delle stringhe, vedere la sezione successiva 16.3.5
16.3.5. Caratteristiche di utilizzo
Quando si utilizzano dati binari, è necessario tenere in considerazione le peculiarità di lavorare con dati di tipo String. La particolarità è che la lunghezza della stringa restituita dalla funzione di contesto globale StrLength () è misurata in caratteri. I simboli dovrebbero indicare le dimensioni dei dati di lettura / scrittura nei metodi di scrittura / lettura delle righe negli oggetti per lavorare con i dati binari ( ReadSymbols (),
ReadString (), WriteSymbols (), WriteString ()). Allo stesso tempo, non esiste un'opzione univoca per convertire la lunghezza della stringa in caratteri in un parametro simile in byte. A seconda del contenuto della stringa e della codifica, questo rapporto sarà diverso. Pertanto, quando si lavora con strutture dati che includono stringhe di lunghezza variabile, è necessario comprendere chiaramente in quali unità sono espresse le lunghezze delle stringhe.
Se nei dati disponibili la lunghezza della stringa è indicata in byte e la stringa è specificata in una codifica a lunghezza variabile multibyte (ad esempio, UTF-8), quindi utilizzando oggetti per lavorare con dati binari, è generalmente impossibile leggere una tale struttura da un file in dati di tipo String.
Ma in questo caso, puoi facilmente modificare la posizione di lettura / scrittura nel flusso di file. Se la lunghezza della stringa è specificata in caratteri, diventa possibile leggere tale stringa in dati di tipo String, ma diventa impossibile modificare la posizione di lettura / scrittura in tale flusso.
Per ottenere la lunghezza di una stringa in byte, è possibile utilizzare la seguente funzione per convertire la stringa in un oggetto BinaryData:
Funzione GetBinaryDataFromString(Value StrParameter, Value Encoding \u003d "UTF-8")
Memory Stream \u003d Nuovo flusso di memoria;
Writer \u003d New Scrittura dati (flusso di memoria);
Writer.WriteString(StrParameter, Encoding);
Writer.Close();
Restituisce StreamMemory.Close e GetBinaryData();
EndFunction
La dimensione effettiva in byte può essere ottenuta chiamando la funzione Size () sull'oggetto BinaryData, che si ottiene come risultato della funzione.
L'uso simultaneo di oggetti non è raccomandato ReadData / WriteData e oggetti in streaming. Se tra due operazioni di lettura sequenziale da ReadData o due operazioni di scrittura sequenziale su WriteData c'è un cambiamento nella posizione nel flusso con cui gli oggetti H streaming dati / Scrittura dati - viene generata un'eccezione. Quindi, il seguente esempio dimostra il corretto cambio di posizione nel flusso durante la scrittura dei dati nel flusso:
Stream \u003d New StreamInMemory ();
WriteData.WriteString("Ciao mondo!");
Registrazione dati. Chiudi();
Stream.Go (0, PositionInStream.Start);
Record di dati \u003d Nuovo record di dati (flusso);
WriteData.WriteString("Fino a!");
Registrazione dati. Chiudi();
Il seguente esempio hi ha generato un'eccezione:
Stream \u003d New StreamInMemory ();
WriteData.WriteStrok ("Hello, world!");
Stream.Go (0, PositionInStream.Start);
// La riga successiva genererà un'eccezione
WriteData.WriteString ("Bye!");
Allo stesso tempo, sono possibili situazioni in cui il comportamento del sistema sarà errato, ma non verranno generati errori:
Stream \u003d GetStream ();
ReadData \u003d New ReadData (Stream);
TestString \u003d ReadData.Read ();
SourcePosition \u003d Stream.CurrentPosition ();
Record di dati \u003d Nuovo record di dati (flusso);
WriteData.WriteStrok ("Stringa imprevista");
Data Recording.Close ();
Stream.Go (OriginPosition, PositionInStream.Start);
// In generale, è impossibile determinare quale valore verrà inserito nella variabile TestString2
TestString2 \u003d ReadData.ReadString ();
Il comportamento descritto in questa sezione è causato da
o Gli oggetti ReadData / WriteData utilizzano i propri buffer quando lavorano con un flusso. Di conseguenza, la posizione effettiva del flusso differisce dalla posizione logica, che si forma come risultato delle operazioni eseguite.
Inoltre, l'uso simultaneo degli oggetti Data Read e Data Writes, che utilizzano un thread per il loro lavoro, non è supportato.
