I dati binari in 1C sono destinati alla memorizzazione di file di qualsiasi formato. Con il loro aiuto puoi:
- Organizzare l'interazione utilizzando un protocollo binario con vari dispositivi;
- Memorizzare file di qualsiasi formato come attributo dell'oggetto metadati;
- Converti dati di testo in binario (più spesso utilizzato per inviare report);
- Lavora con dati binari in memoria.
Cosa può fare il sistema
Quando si lavora con dati binari, la piattaforma 8.3 è in grado di fare quanto segue:
- Leggere e scrivere dati binari;
- Sposta i dati dal client al server e viceversa utilizzando l'archiviazione temporanea;
- Inizializzare un oggetto del tipo "Picture" 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;
- Calcolare la funzione hash utilizzando l'oggetto Data Hash.
Salvataggio dei dati sugli oggetti di scena
Ad esempio, creiamo un riferimento nella configurazione di test.
In effetti, è un po' sbagliato utilizzare 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à indesiderati e "freni" nel funzionamento del sistema. Sarebbe molto più corretto dal punto di vista del sistema organizzare un libro di riferimento separato "Immagini", un collegamento a cui potremmo impostare come tipo di attributo.
È importante notare che poiché gli attributi del tipo "ValueStorage" 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.
Leggere i dati dagli oggetti di scena
Creiamo un'elaborazione che restituirà il file memorizzato in formato binario nella nostra configurazione in un foglio di calcolo (questo è necessario, ad esempio, per stampare un logo aziendale).
Fondamentalmente, questo è tutto il codice di cui abbiamo bisogno. Utilizzando l'operatore Get(), leggiamo i dati binari memorizzati nell'attributo di riferimento corrispondente e li trasferiamo all'oggetto "Picture", che verrà mostrato nella cella in alto a sinistra del documento del foglio di calcolo del modulo (Fig. 9).
Fig. 9
Trasformazione dei dati
Non capita spesso, ma capita che quando si lavora con scambi non standard con sistemi esterni, sia necessario convertire i dati da un formato binario a un formato Base64 o viceversa.
Nella maggior parte dei casi la piattaforma trasforma da sola i dati, se ciò non avviene è 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 sicuramente, ma con un avvertimento importante: se nelle proprietà di configurazione è spuntato il checkbox "Modality use mode" (Fig. 10). In caso contrario, il suo utilizzo genererà un errore. 
Fig. 10
Per evitare che ciò accada, mentre sei nel modulo del modulo dell'elemento di riferimento, vai al menu Testo-> Refactoring-> Chiamate sincrone deprecate-> Converti chiamate di modulo.
Dopo qualche tempo, le chiamate sincrone verranno automaticamente convertite in asincrone e il codice assumerà la forma (Fig. 11)
Fig. 11
Quasi tutte le informazioni possono essere memorizzate nel value store, ad esempio,
... immagini (foto):
// in questo posto mostra tutto... Form Elements.PictureField1.Picture = Storage.Get (); TekImage.Write ();
... foglio di calcolo:
TabDoc = New TabularDocument; TabDoc.Display (Form Elements.TableDocumentField1); Archiviazione = Nuova Archiviazione di Valori (TabDoc); Scrivere ();
Fine della procedura
Procedura Ripristino da archivio Premere (Elemento)
TabDoc = Storage.Get (); Se TabDoc<>Quindi non definito Form Elements.TableDocumentField1.Offer (TabDoc); Finisci se;
Fine della procedura
... file arbitrari (dati binari):
L'otto supporta la compressione dei dati archiviati:
... elaborazione esterna e reporting:
Grado di compressione = Nuova compressione dati (9); // 9 massimo PropsStorageType = NewValueStore (New BinaryData ("c: \ report \ report.epf", Grado di compressione));
Fine della procedura
Procedura StartProcessingFrom Storage (Props StorageType)
TempFileName = TempFileDir () + "report.epf"; BinaryData = PropsTypeStorage.Get (); BinaryData.Write (TemporaryFileName); ExternalProcessing = ExternalProcessing.Create (TemporaryFileName); ExternalProcessing.GetForm().Open();
Fine della procedura
Lavorare con l'archiviazione
Se era BinaryData, può essere ripristinato dall'archiviazione dei valori utilizzando il metodo Get e scritto in un file utilizzando il metodo Write().
BinaryData = Storage.Get ();
BinaryData = Memoria;
Finisci se; BinaryData.Write (FileName);
Se fosse, ad esempio, un documento Word (file doc o un altro file di tipo registrato), può essere aperto in questo modo:
Per cancellare un campo di tipo Memoria valore, è 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 in un client Web ed è progettato tenendo conto delle restrizioni sull'utilizzo dei file imposte dai browser Web.
Il meccanismo è un insieme di metodi che possono essere utilizzati per inserire i dati archiviati localmente presso l'utente nella memoria temporanea dell'infobase, trasferire queste informazioni dalla memoria temporanea al database e recuperarle nel computer dell'utente. Le attività applicative più comuni risolte da questo meccanismo sono l'archiviazione delle 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 un'infobase in cui è possibile archiviare 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 del browser web è necessario trasferire il file selezionato dall'utente direttamente sul server senza possibilità di memorizzarlo sul client. Quando si trasferisce un file, viene collocato in una memoria temporanea e solo allora può essere utilizzato durante la scrittura di un oggetto nel database.
Il problema dell'applicazione più tipico risolto dall'archiviazione temporanea è fornire accesso a file o immagini prima che l'oggetto venga scritto nell'infobase, ad esempio sotto forma di elemento.
Un file o un dato binario inserito nella memoria è identificato da un indirizzo univoco, che può essere successivamente utilizzato nelle operazioni di scrittura, lettura o cancellazione. Questo indirizzo è dato dalle modalità di scrittura del file nella memoria temporanea. Un metodo separato nel linguaggio integrato consente di determinare se l'indirizzo passato è un indirizzo che punta ai dati nella memoria temporanea.
Base informativa
Il meccanismo consente di accedere ai dati binari archiviati negli attributi del tipo ValueStore.
Come nel caso della conservazione temporanea, le informazioni sono accessibili tramite un apposito indirizzo. È possibile ottenerlo tramite un metodo speciale passando un riferimento a un oggetto o una chiave di registrazione del registro delle informazioni e un nome di attributo. Nel caso di una sezione tabulare, è inoltre necessario trasferire l'indice della riga della sezione tabulare.
I metodi per lavorare con i file sono limitati quando si lavora con i dettagli dell'infobase. Per loro, a differenza dell'archiviazione 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 in una memoria temporanea
Lo scenario più tipico per l'utilizzo di questo meccanismo prevede il posizionamento iniziale dei dati dell'utente nell'archiviazione temporanea. Ci sono 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 determina la modalità di funzionamento interattiva è True, il metodo visualizzerà una finestra di dialogo di selezione file standard, in cui è possibile selezionare un file da inserire nel repository. In questo caso il metodo restituirà anche l'indirizzo del file selezionato.
Di conseguenza, il metodo restituisce False se l'utente ha rifiutato in modo interattivo di eseguire l'operazione nella finestra di dialogo di selezione del file. Il metodo è disponibile solo sul client.
Il secondo metodo, PlaceFileInTemporaryStorage(), è simile al precedente, tranne per il fatto che è disponibile sul server e i dati da scrivere nella memoria temporanea non sono rappresentati come percorso nel file system, ma come 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 un'infobase, potrebbe essere necessario estrarre i dati da un archivio temporaneo e posizionarli, ad esempio, in un oggetto di scena. Esiste un metodo server corrispondente per questo: GetFileFrom TemporaryStorage (). Questo metodo recupera i dati dall'archiviazione temporanea e li restituisce come risultato. Per fare ciò, è necessario specificare l'indirizzo nella memoria temporanea. Questo indirizzo viene restituito dai metodi precedenti PlaceFile () e PlaceFileTemporaryStorage () se hanno esito positivo.
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 cancellato. Per fare ciò, c'è il metodo DeleteFileFromTemporaryStorage(), 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 di appartenenza alla memoria temporanea
L'indirizzo del file può puntare sia a un archivio temporaneo che a una variabile di infobase. Per verificarne il tipo, esiste il metodo ThisTemporaryStorageAddress().
Verifica che l'indirizzo passato sia un indirizzo che punta al negozio. Restituisce True se l'indirizzo punta all'archiviazione temporanea. Il metodo è disponibile sul server.
Ottenere un indirizzo 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 GetFileAddressVinformationBase().
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 di registro informazioni) e il nome dell'attributo. Se è necessario ottenere l'indirizzo del file memorizzato nell'attributo della sezione tabellare, prima del nome dell'attributo nel parametro che specifica il nome dell'attributo, è necessario aggiungere il nome della sezione tabellare e il punto ".". Il metodo è disponibile sia sul client che sul server.
Recupero di un file da un'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 temporanea. Il secondo parametro specifica 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: eseguirlo 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. False significa che l'utente ha scelto di annullare l'operazione nella finestra di dialogo di salvataggio in linea del file.
Un esempio di utilizzo dei metodi di file
Nome selezionato variabile; Indirizzo Variabile di Stoccaggio Temporaneo; If PutFile (TemporaryStorage Address, SelectedName, True) Then Object.FileName = SelectedName; PlaceObjectFile (TemporaryStorageAddress); Finisci se;
Fine della procedura
// Copiare un file dalla memoria temporanea al // requisito della directory, registrare un oggetto, eliminare un file dalla memoria temporanea // & Procedura OnServer PlaceObjectFile (Indirizzo memoria temporanea)
DirectoryElement = FormInValue ("Oggetto"); BinaryData = GetFileFrom TemporaryStorage (Indirizzo TemporaryStorage); DirectoryElement.FileData = NewValueStore (BinaryData); FileDiskPath = Nuovo file (DirectoryElement.FileName); DirectoryElement.FileName = FilePathNaDisk.Name; DirectoryElement.Write (); Modifica = Falso; DeleteFileFrom Archiviazione temporanea (indirizzo di archiviazione temporanea); ValueVFormAttribute (DirectoryElement, "Oggetto");
Fine della procedura
// Leggere un file dalle props e salvarlo // sul disco locale in modalità interattiva & Sul client Procedura ReadFile AND Save OnDisk()
Indirizzo = GetAddressFileInInformationBase (Object.Link, "FileData"); GetFile (Indirizzo, Object.FileName, True);
Fine della procedura
Supporto per gli indirizzi nel campo dell'immagine
Il controllo del campo Immagine supporta la visualizzazione di un'immagine specificata dall'indirizzo del file nella memoria temporanea o in un database.
Per fare ciò, 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 (Indirizzo immagine, Vero)
Image.Data = 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 legate alle specifiche del modello di sicurezza del browser. Ad esempio, il client non può salvare da solo un file nel file system locale, 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 Values Store sul client
Problema:
Quando un Document ha un attributo del tipo ValueStore nella sezione tabulare, rallenta l'apertura del modulo del documento se questo attributo contiene dati di grandi dimensioni.
Motivo supposto:
Forse, quando il modulo viene aperto, il cliente non riceve un collegamento ai dati archiviati nel Values Store, ma i dati stessi.
Soluzione
- Nelle proprietà dell'attributo di 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 all'apertura di un modulo. Questo flag deve essere disabilitato, ma devi tenerne conto nel codice, poiché per impostazione predefinita il valore di questo campo non sarà sul client. Un esempio può essere visualizzato in 1C: Archivio.
Meglio ancora, usa deposito temporaneo per trasferire file tra client e server.
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 tramite la firma o eseguire alcune manipolazioni con l'immagine. Per lavorare con i 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 stream). Il sistema non offre l'opportunità di creare un oggetto Stream indipendente che non sia associato ad alcuna origine. Ma ci sono oggetti derivati che puoi creare: un flusso associato a un file su disco (un oggetto FileStream) o un flusso creato in memoria (un oggetto MemoryStream). Un flusso ti consente sia di leggere i dati che di scriverli. Per determinare la possibilità di eseguire determinate operazioni, lo stream (e gli oggetti derivati) dispongono di metodi speciali che consentono di determinare quale
le operazioni sono disponibili su questo flusso (metodi DisponibileRecord (), DisponibileLeggi (), DisponibileCambiaPosizione ()).
Se è necessario lavorare con un flusso a un livello superiore, in particolare, leggere / scrivere dati come un numero (di larghezza di bit diversa) o una stringa, gli oggetti ReadData / WriteData sono destinati a questo. Con l'aiuto di questi oggetti è possibile avvicinarsi in modo più strutturato ai dati binari che si trovano nello stream. Quindi, ad esempio, conoscendo il formato di un file, puoi leggere abbastanza comodamente un tale file, ottenendo i dati necessari dalle intestazioni (che, di regola, sono rappresentate dal numero e dai tipi di stringa), saltando i blocchi di dati non necessari e caricamento dei dati necessari al trattamento.
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 è chiuso.
- Se non sono necessarie ulteriori operazioni, il flusso ottenuto nel passaggio 1 viene chiuso.
- Se devi 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 prevede la possibilità di creare oggetti ReadData / WriteData direttamente da, ad esempio, un oggetto BinaryData.
Per eseguire varie operazioni con dati binari, il sistema offre la possibilità di ottenere una parte del flusso come frammento separato con accesso casuale (byte) (oggetto BufferBinaryData). La dimensione del buffer è 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 larghezze di bit come con
come un tutt'uno. In questo caso è possibile specificare l'ordine dei byte in parole: "little endian" o "big endian". È anche possibile dividere un buffer in più buffer e combinare più buffer di dati binari in un buffer risultante.
È importante notare che l'utilizzo di un buffer di dati binari può semplificare notevolmente l'implementazione se l'utilizzo di dati binari viene implementato sul lato dell'applicazione client in modalità asincrona. In questo caso, la lettura dei dati nel buffer verrà eseguita in modo asincrono e l'utilizzo dei dati nel buffer sarà sincrono.
L'utilizzo di dati binari è disponibile sul lato client (incluso il client Web) dell'applicazione e sul lato server, nonché in schemi sincroni e asincroni. Ulteriori esempi utilizzeranno 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 di file corretto che è stato selezionato nel sistema per un ulteriore utilizzo. Come file da controllare verrà utilizzato un file .wav con dati audio. Per archiviare i file .wav, viene utilizzato il Resource Interchange File Format (RIFF), la cui descrizione è fornita al collegamento:
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 nell'ordine little-endian.
3. i successivi 4 byte contengono il tipo di testo dei dati utilizzati: WAVE.
Per completare questi passaggi, è necessario il seguente codice in linea:
Lettura = Nuovo ReadData (FileName, Byte Order.LittleEndian);
Formato file = Read.ReadSymbols(4);
DataSize = Read.ReadInteger32();
Tipo di file = Read.ReadSymbols(4);
Se il formato del file<>“RIFF” Allora
Report (“Questo non è un file RIFF”);
Ritorno ;
Finisci se;
Se FileType = "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 in modo più dettagliato.
Innanzitutto viene aperto un file, il cui nome è contenuto nella variabile FileName, il file viene aperto in lettura ( Modalità di apertura file.), leggeranno solo dal file ( File Access.Leggi) e per la lettura verrà utilizzato un buffer di 16 byte.
Quindi viene formato un flusso per la lettura dei dati, che sarà nell'ordine dei byte meno significativo per i dati di tipo Number. Quindi vengono letti 4 caratteri dal flusso risultante, un numero intero a 32 bit e altri 4 caratteri. I dati risultanti vengono analizzati e, in base ai risultati dell'analisi, viene presa una decisione 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 = Nuovo Registrazione dati (nome file);
Per Indice = da 0 a 255 Ciclo
Write.WriteByte (indice);
Fine del ciclo;
Registra.Chiudi ();
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 si riceve 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.
Ad esempio, considereremo l'analisi dell'intestazione di un file RIFF dall'esempio di lettura dei dati (vedi qui). Verranno utilizzate esattamente le stesse informazioni sul formato del file per creare l'esempio. Pertanto, è necessario leggere un buffer della dimensione dell'intestazione del file dal file di origine. L'intestazione è composta da tre campi da 4 byte. Pertanto, è necessario leggere 12 byte.
Buffer = Nuovo BufferBinaryData(12);
File = FileStreams.Open (cartella TempFile() + "Accesso a Windows.wav", Modalità di apertura file., File Access.Leggi);
File.Leggi (buffer, 0, 12);
Taglia = Buffer.LeggiIntero32(4);
LineStream = NewMemoryStream (buffer);
StreamStrings.Go(0, PosizioneInStream.Start);
Formato file = LeggiStringhe.LeggiSimboli(4, "finestre-1251");
LeggiLinee.Chiudi();
StreamStrings.Go(8, PosizioneInStream.Start);
LineReader = NewDataReader (LineStream);
Tipo di file = ReadStrings.ReadCharacters ( 4, “finestre-1251”);
LeggiLinee.Chiudi();
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 profondità di bit supportata è possibile da qualsiasi posizione nel buffer. In questo esempio Buffer.LeggiIntero32 (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 il posizionamento diretto in questo buffer.
La lettura di una stringa, tuttavia, non è supportata dal buffer di dati binari. Pertanto, dovresti usare un oggetto che ti permetta di farlo: ReadingData. 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 è un intermediario 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, viene prima impostata la posizione nel flusso, 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à dell'utilizzo di 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 ( LeggiSimboli (),
Stringa di lettura (), WriteSymbols (), Stringa di scrittura ()). 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 di 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 tale struttura da un file in dati di tipo String.
Ma in questo caso, puoi facilmente modificare la posizione della 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, puoi utilizzare la seguente funzione per convertire la stringa in un oggetto BinaryData:
Funzione Ottieni dati binari da stringhe(Value StrParameter, Value Encoding = "UTF-8")
Flusso di memoria = Nuovo flusso di memoria;
Scrittore = Nuovo Scrittura dati (flusso di memoria);
Writer.WriteString(StrParameter, Codifica);
Scrittore.Chiudi();
Restituire StreamMemory.Close AND GetBinaryData();
EndFunction
La dimensione effettiva in byte può essere ottenuta chiamando la funzione Size() dell'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 a WriteData c'è un cambiamento nella posizione nel flusso con cui gli oggetti H Streaming dati/Scrittura dati- viene generata un'eccezione. Quindi, l'esempio seguente dimostra la corretta modifica della posizione nel flusso durante la scrittura dei dati nel flusso:
Flusso = Nuovo StreamInMemory ();
WriteData.WriteString("Ciao mondo!");
Registrazione dati.Chiudi();
Stream.Go (0, PosizioneInStream.Start);
Record di dati = Nuovo record di dati (Stream);
WriteData.WriteString("Fino!");
Registrazione dati.Chiudi();
L'esempio seguente hi ha generato un'eccezione:
Flusso = Nuovo StreamInMemory ();
WriteData.WriteStrok ("Ciao, mondo!");
Stream.Go (0, PositionInStream.Start);
// La riga successiva genererà un'eccezione
WriteData.WriteString ("Ciao!");
Allo stesso tempo, sono possibili situazioni in cui il comportamento del sistema sarà errato, ma non verranno generati errori:
Flusso = GetStream ();
ReadData = Nuovo ReadData (Stream);
TestString = ReadData.Read ();
SourcePosition = Stream.CurrentPosition ();
Record di dati = Nuovo record di dati (Stream);
WriteData.WriteString ("Stringa imprevista");
Registrazione dati.Chiudi ();
Stream.Go (OriginPosition, PositionInStream.Start);
// In generale, è impossibile determinare quale valore verrà inserito nella variabile TestString2
TestString2 = ReadData.ReadString ();
Il comportamento descritto in questa sezione è dovuto al fatto che
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 a seguito delle operazioni eseguite.
Inoltre, l'utilizzo simultaneo degli oggetti Data Read e Data Writer, che utilizzano lo stesso thread per il proprio lavoro, non è supportato.
Piattaforma tecnologica 1C: Enterprise 8 consente 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 archiviare file, un oggetto di scena (o risorsa di registrazione) con il tipo Valori di archiviazione.
Caricamento di un file arbitrario nell'infobase 1C
Qualsiasi file può essere rappresentato come dati binari e caricato in StoreValues.
Quando si convertono dati binari in oggetti Valori di archiviazione la costruzione è usata newValueStore (dati, compressione) con due parametri:
- Dati- dati binari da archiviare
- Compressione- rapporto di compressione dell'algoritmo di deflazione. Un numero intero nell'intervallo -1 ... 9. -1 è il rapporto di compressione predefinito. 0 - nessuna compressione, 9 - rapporto di compressione massimo. Valore predefinito: -1. Il parametro è facoltativo, se non specificato non viene utilizzata alcuna compressione.
// Converti il file in dati binari
File = New BinaryData (percorso);
// Crea un nuovo oggetto StoreValues
Archivio dati = Nuovo archivio valori (File, Nuova compressione dati (9));
Salvataggio di un file arbitrario dall'infobase 1C su disco
Per salvare un file dal database 1C su disco, è necessario determinare il percorso e il nome del file. Per questo, esiste 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 tipo ValueStorage
// 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 che sul computer sia installata un'applicazione che apra questo file.
// Ottieni il nome del file temporaneo con l'estensione richiesta
// Nella variabile Estensione devi inserire l'estensione del file, ad esempio "pdf"
Path = GetTemporaryFileName (estensione);
// Ottieni dati dalla memoria
// DataStore - un attributo di un oggetto con il tipo ValueStorage
Dati = Archivio dati. Ricevere() ;
// Scrivi i dati in un file temporaneo
Dati. Scrivi (percorso);
// Tentativo di aprire il file nell'applicazione prevista
// Se l'applicazione non viene trovata, verrà visualizzata la finestra di dialogo di sistema "Apri con..."
LaunchApplication (percorso);
