Linea di collegamento a 1s 8.3. Tre pilastri per lavorare con gli oggetti COM

Ciao Khabrachan!

In questo articolo voglio parlare di come si stabilisce l'integrazione con la piattaforma 1C nella mia organizzazione. Ciò che mi ha spinto a farlo è stata la quasi totale mancanza di informazioni tecniche su questo argomento. Leggendo vari articoli e rapporti sul tema della connessione di 1C con qualsiasi sistema informativo, sei sempre convinto che siano tutti di natura marketing, dimostrativa e mai tecnica, riflettendo il problema e l'essenza della sua soluzione.

Ti avverto che questo metodo non pretende in alcun modo di essere universale. Poiché esistono molte configurazioni 1C stesse e ancora più sistemi informativi, linguaggi e piattaforme, il numero di combinazioni possibili è enorme. Il mio obiettivo è dimostrare una possibile soluzione.

Ho scelto Python come linguaggio che verrà integrato con 1C. È molto adatto per l'automazione dei processi. Ciò è facilitato dal minimalismo della sintassi (il codice viene digitato molto rapidamente), una ricca libreria standard (meno bisogno di moduli di terze parti), multipiattaforma: con un'alta probabilità, il codice scritto nel sistema operativo Linix funzionerà con successo su Windows .

Per cominciare, delineerò i dati con cui lavoreremo. L'organizzazione è una società di vendita di energia nella regione dell'Estremo Oriente: serve circa 400mila abbonati, il database 1C si basa su una configurazione personalizzata. Per ogni abbonato vengono memorizzati i pagamenti, gli addebiti, i servizi consumati e gli schemi di calcolo, i contatori, le letture e tanti altri dati.

C'era una volta un'organizzazione che disponeva di un programma scritto in Delphi e che utilizzava MSSQL/Firebird come database. In quei tempi gloriosi, potevi connetterti al database utilizzando qualsiasi lingua ed eseguire molte azioni: selezionare gli abbonati debitori, registrare i pagamenti ricevuti, registrare le letture degli strumenti. Non sorprende che la raccolta di script che automatizzano la routine sia in costante crescita. I programmatori potevano eseguire qualsiasi azione senza aprire il programma stesso.

Purtroppo, con il passaggio a 1C, l'omaggio è terminato: non era più possibile connettersi direttamente al database. In generale, la stessa piattaforma 1C è indivisibile e non si presta bene all'integrazione con altri sistemi. Lei, come si suol dire, è una cosa in sé. Quando carichi i dati in 1C, dovresti ricordare che estrarli da lì non sarà così facile. Ma poiché l'organizzazione aveva bisogno di implementare sistemi di pagamento e un conto personale, era necessario trovare una soluzione.

I compiti principali che dovevo affrontare erano la capacità di ottenere rapidamente dati su uno specifico account personale: nome completo, indirizzo, dispositivi di misurazione, letture dello strumento, pagamenti, addebiti. Inoltre la generazione di documenti: rapporto di riconciliazione, ricevuta di pagamento. Quindi, non esiste alcuna possibilità di connessione diretta al database: chiunque abbia esaminato il database 1C su un server SQL ha visto che è difficile comprendere la massa di tabelle come aaa1, aaa2. E creare query con tali nomi di tabelle e campi è semplicemente irrealistico. Inoltre, molte tabelle 1C (soprattutto quelle più importanti, come una fetta delle ultime, equilibri e rivoluzioni) sono virtuali e sparse su diverse tabelle fisiche, raccolte da più join. Questo metodo non è adatto.

La piattaforma 1C offre la possibilità di connettersi ad essa tramite una connessione COM. Come molti programmi Windows, durante l'installazione di 1C nel sistema vengono registrati due oggetti COM: Automation Server e COM Connector. Entrambi gli oggetti possono essere gestiti utilizzando un linguaggio che supporta la tecnologia COM.

L'oggetto Automation Server è un'applicazione 1C, quasi non diversa da una normale applicazione client. La differenza è che è inoltre possibile controllare a livello di codice un'istanza dell'applicazione. Quando si lavora con un oggetto COM Connector, viene avviata una versione leggera dell'applicazione 1C, in cui non sono disponibili moduli, funzioni e metodi relativi all'interfaccia e agli effetti visivi. L'applicazione stessa si avvia in modalità "Connessione esterna". L'inizializzazione delle variabili globali (ad esempio, la determinazione dell'utente corrente e delle sue impostazioni) deve essere eseguita nel modulo di connessione esterna 1C. Se in modalità connessione esterna il codice chiama una funzione che non è disponibile in questa modalità, verrà lanciata un'eccezione (che verrà passata al nostro script Python). Le chiamate a funzioni non sicure dovrebbero essere strutturate con costrutti del tipo

#Se NON è un OuterJoin, allora Warning("Ciao!"); #Finisci se

Poiché lavorare con oggetti COM è una tecnologia esclusivamente disponibile solo per Windows, non sorprende che non sia inclusa nella distribuzione standard di Python. Dovrai installare un'estensione: un insieme di moduli che forniscono tutte le funzionalità necessarie per programmare sotto Windows in Python. Può essere scaricato come programma di installazione exe predefinito. L'estensione stessa fornisce l'accesso al registro, ai servizi, agli oggetti ODBC, COM, ecc. In alternativa, puoi installare immediatamente la distribuzione ActiveState Python, che viene fornita con un'estensione Win32 pronta all'uso.

Da tempo ho sperimentato la connessione COM nello sviluppo di applicazioni web, in particolare un account personale. Sono stati individuati i seguenti svantaggi:

La connessione COM è lenta. Le basse prestazioni sono uno svantaggio ben noto della tecnologia COM.
- Il processo di connessione con 1C, a seconda della configurazione, può richiedere da 1 a 8 secondi (nel mio caso - 6 secondi). Inutile dire che, stabilendo una connessione per ogni richiesta, ogni pagina impiegherà 8 secondi per caricarsi.
- Poiché le applicazioni web in Python funzionano come server indipendenti, il punto precedente può essere compensato memorizzando la connessione in qualche variabile globale e ripristinandola in caso di errore. Ad essere sincero, non ho ancora pensato a come mantenere una connessione in PHP.
- La funzionalità multipiattaforma dell'applicazione Web viene persa.

Sulla base dei punti sopra elencati, è stato deciso di modificare il principio di interazione, dividendolo in 2 parti: la prima dipendente dalla piattaforma (basata su Windows), caricando i dati 1C in qualsiasi formato conveniente e la seconda, indipendente dalla piattaforma, in grado di lavorare con i dati senza sospettare nulla di 1C in linea di principio.

La strategia d'azione è la seguente: lo script Python si connette a 1C, esegue le query necessarie e carica i dati nel database SQLite. Puoi connetterti a questo database da Python, PHP, Java. La maggior parte dei nostri progetti funziona in Python e, poiché non sopporto la scrittura manuale di query SQL grezze, tutto il lavoro con il database SQLite viene eseguito tramite SQLAlchemy ORM. Tutto ciò che serviva era descrivere la struttura dei dati del database in uno stile dichiarativo:

From sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column, Integer, Numeric, DateTime, Unicode, Boolean, LargeBinary, ForeignKey Base = declarative_base() classe Abonent(Base): __tablename__ = "abonents" id = Column(Integer, primario_key= Vero) account = Colonna(Unicode(32), indice=Vero) codice = Colonna(Unicode(32)) indirizzo = Colonna(Unicode(512)) fio = Colonna(Unicode(256)) sorgente = Colonna(Unicode(16) ) psu = Colonna(Unicode(256)) tso = Colonna(Unicode(256)) np = Colonna(Unicode(256)) street = Colonna(Unicode(256)) casa = Colonna(Intero) flat = Colonna(Intero) mro = Colonna(Unicode(256)) classe Pagamento(Base): __nometabella__ = "pagamenti" # e così via...

Ora devi solo importare questo modulo in qualsiasi progetto Python e puoi lavorare con i dati.

Prevedo la tua domanda: "perché SQLite"? Il motivo principale è che il database è di sola lettura, quindi i problemi con la scrittura su SQLite non dovrebbero preoccuparci. In secondo luogo, il formato di questo DBMS è conveniente: è più facile da visualizzare (ci sono molte utilità gratuite, inclusa una super estensione per FireFox). In terzo luogo, in alcuni casi è stato necessario ottenere l'accesso agli abbonati da macchine che non dispongono di una connessione al server MySQL. In questo caso è sufficiente copiare il file del database SQLite e questa macchina avrà accesso a tutte le informazioni.

Lo scarico avviene una volta al giorno di notte. L'immissione dei dati in 1C può essere automatizzata allo stesso modo. Ad esempio, è necessario registrare le letture lasciate dagli abbonati sul sito dell'account personale. In questo caso, ci colleghiamo nuovamente a 1C e creiamo e pubblichiamo a livello di codice il documento "Atto di letture". Fornirò il codice di seguito.

Lavorare con oggetti COM in Python è un po' insolito. In primo luogo, la "Pitonicità" del codice è persa: le regole per nominare variabili e funzioni in 1C, per usare un eufemismo, non corrispondono allo Zen di Python. In secondo luogo, tutti sanno che gli oggetti 1C vengono spesso denominati con caratteri cirillici, il che causerà problemi durante lo sviluppo in Python... ma possono essere risolti. Ti suggerisco di guardare il codice:

Importa pythoncom import win32com.client V82_CONN_STRING = "Srvr=v8_server;Ref=v8_db;Usr=nome utente;Pwd=megapass;" pythoncom.CoInitialize() V82 = win32com.client.Dispatch("V82.COMConnector").Connect(V82_CONN_STRING)

Come si può vedere dal codice, il client è inizializzato per funzionare con 1C. Un oggetto COM è definito dal nome “V82.COMConnector”. Tieni presente che questo nome è valido per la piattaforma V8.2, se disponi della versione 8.1, il nome sarà "V81.COMConnector".

Chiamiamo il metodo Connect() sul client inizializzato, passandogli la stringa di connessione. La stringa è composta dal nome del server, database, utente e password. L'oggetto V82 risultante memorizza la connessione all'applicazione 1C. Non ha un metodo Disconnect() o qualcosa del genere. Per disconnettersi dal database è sufficiente cancellare l'oggetto dalla memoria utilizzando la funzione del() oppure assegnarlo alla variabile None.

Avendo un oggetto, puoi accedere a qualsiasi campo e metodo del contesto globale 1C, operare con oggetti universali come TabularDocument, ValueTable, ecc. È importante notare che quando si lavora tramite una connessione COM, 1C funziona in modalità “Connessione esterna”. Non consente alcuna funzionalità interattiva, come finestre di dialogo popup, notifiche e, soprattutto, moduli. Sono sicuro che più di una volta maledirai gli sviluppatori di configurazione che racchiudono le funzionalità più importanti nella procedura Button1Press() nel modulo del modulo documento.

Parliamo di una cosa così importante come gli attributi cirillici. Nonostante il fatto che 1C sia un ambiente bilingue e per ogni metodo russo esista un analogo in lingua inglese, prima o poi dovrai ricorrere all'attributo cirillico. Se ciò non causa problemi nei linguaggi PHP o VBSCript,

Set Con = CreateObject("v81.COMConnector") Set v8 =Con.Connect("Stringa di connessione") Set AccountsManager = v8.Documents.Accounts.... Set AccountsRecord= AccountsManager.CreateItem() AccountsRecord.Account = ... ....AccountsRecord.Write()

Quindi il codice Python andrà semplicemente in crash con un errore di sintassi. Cosa fare? Modificare la configurazione? No, è sufficiente utilizzare i metodi getattr e setattr. Passando un oggetto COM e il nome cirillico dell'attributo a queste funzioni, è possibile ottenere e impostare valori di conseguenza:

#coding=catalogo cp1251 = getattr(V82.Catalogs, "PersonalAccount")

È importante quanto segue: i nomi dei dettagli, nonché i parametri di funzioni e metodi, devono essere trasmessi nella codifica cp1251. Pertanto, per evitare in anticipo confusione con le codifiche, è opportuno dichiararlo all'inizio del file: #coding=cp1251. È quindi possibile passare le stringhe senza preoccuparsi della loro codifica. Ma! Tutte le stringhe ricevute da 1C (risultati delle funzioni di chiamata, query) saranno nella codifica UTF-8.

Un esempio di codice che esegue una query nell'ambiente 1C, scorre il risultato e salva il database in SQLite:

#coding=cp1251 q = """ SELEZIONA Conti personali. Codice Codice AS, Conti personali. Edificio. Liquidazione. Nome + ", " + Conti personali. Indirizzo breve Indirizzo AS, Conti personali. Abbonato. Nome AS fio, Conti personali. Divisione. Nome AS psu, EXPRESS (Caratteristiche della fetta di conti personali dell'ultimo. Valore Directory AS. Organizzazioni di rete territoriale). Nome AS tso, Conti personali. Edificio. Punto popolato. Nome AS np, Conti personali. Edificio. Via. Nome AS strada, Conti personali. Edificio. Casa AS casa, Account personali.MainPremises.PremisesNumber AS appartamento, PersonalAccounts.Division.Parent.Name AS mro FROM Directory.PersonalAccounts AS PersonalAccounts CONNESSIONE SINISTRA RegisterInformation.CharacteristicsPersonalAccounts.Slice of the Last(, TypeCharacteristics = VALORE(Directory.Tipi di caratteristiche.Organizzazione rete territoriale)) Caratteristiche AS kiPersonalAccountsSliceLast SoftwarePersonalAccounts.Link = CharacteristicsPersonalAccountsSliceLast.Object """ query = V82.NewObject("Query", q) selezione = query.Execute().Scegli() CONN = db.connect() CONN.query(models.Abonent).delete() while Selection.Next(): abonent = models.Abonent() abonent.account = Selection.code.strip() abonent.code = Selection.code abonent.fio = selezione.fio abonent.indirizzo = selezione.indirizzo abonent.psu = selezione.psu abonent.tso = selezione.tso abonent.source = u"ASRN" abonent.np = selezione.np abonent.street = selezione.street abonent.casa = selezione.casa abonent.flat = selezione.flat abonent.mro = selezione.mro CONN.add(abonent) CONN.commit()

Qui CONN è la sessione di connessione con il database SQLite. Viene creato un oggetto query e il relativo testo viene compilato. Come notato sopra, il testo della richiesta deve essere in cp1251, per il quale viene prima dichiarata la codifica. Dopo aver eseguito la richiesta, tutti gli abbonati vengono eliminati nel database in modo da non aggiungere duplicati, quindi vengono aggiunti in un ciclo e segue il commit finale.

Quando lavoro con le richieste, ho scoperto le seguenti regole.

Quando selezioni i campi, assegna loro nomi in lettere latine; sarà molto più comodo accedervi tramite un selettore (punto), invece che getattr().
- Scegli solo tipi di dati primitivi: stringhe, numeri, data e booleano. Non selezionare mai collegamenti a un oggetto (documento, libro di consultazione)! In questo contesto i collegamenti non sono assolutamente necessari e sono addirittura dannosi, poiché qualsiasi chiamata a una prop o a un metodo di collegamento risulterà in una richiesta tramite una connessione COM. Se accedi agli attributi del collegamento in un ciclo, sarà estremamente lento.
- Se selezioni un campo di tipo Data, verrà restituito come oggetto PyTime. Questo è un tipo di dati speciale per la trasmissione di data e ora in una connessione COM. Non è così comodo lavorare come con il solito datetime. Se passi questo oggetto a int(), restituirà un timestamp, da cui potrai ottenere il datetime utilizzando il metodo fromtimestamp().

Ora diamo un'occhiata a come si formano i documenti stampati. Il fatto è che al consumatore deve essere data la possibilità di scaricare documenti preconfezionati, ad esempio una ricevuta di pagamento o un rapporto di riconciliazione. Questi documenti vengono generati in 1C secondo i requisiti stabiliti; la loro implementazione in Python richiederà molto tempo. Pertanto, è meglio generare documenti in 1C e salvarli in formato Excel.

Pertanto, il documento del report di riconciliazione viene generato mediante un'elaborazione esterna speciale. Per coloro che non hanno familiarità con la terminologia 1C: l'elaborazione è un programma autonomo che dispone di un proprio modulo, moduli, modelli progettati per essere eseguiti nell'ambiente 1C. È necessario inizializzare l'elaborazione, compilarne i dettagli e richiamare una funzione che ci restituirà un documento di foglio di calcolo destinato alla visualizzazione in 1C. Tale documento dovrà essere salvato in formato Excel e copiato sul server o registrato nel database.

Link = getattr(V82.Catalogs, "Report di sistema").FindByDescription("Rapporto di riconciliazione Ellen") nav_url = V82.GetURL(link, "Report") nome = V82.ExternalReports.Connect(nav_url) ExternalReport = V82.ExternalReports. Crea (nome) setattr(ExternalReport, "PersonalAccount", riferimento) table_doc = ExternalReport.GetDoc() percorso = V82.GetTempFileName("xls") table_doc.Write(percorso, V82 .SpreadsheetDocumentFileType.XLS) report = models.Report() report.account = riferimento.Code.strip() report.type = u"act" report.document = open(percorso, "rb").read() CONN.add(report)

Il frammento sopra fa quanto segue: L'elaborazione che genera il documento è connessa. L'elaborazione può essere integrata nella configurazione, archiviata su disco o in un database 1C (in alcune directory). Poiché le elaborazioni cambiano frequentemente, per non aggiornare ogni volta la configurazione, le elaborazioni che cambiano più frequentemente vengono archiviate nella directory “System Reports”, in un attributo di “value storage” denominato Report. L'elaborazione può essere inizializzata scaricandola dal database su disco e caricandola, oppure utilizzando il metodo GetURL(), al quale è necessario passare un collegamento all'elemento directory e il nome dell'attributo. Assegniamo i valori dei dettagli all'oggetto di elaborazione ricevuto, chiamiamo la funzione esportata GetDoc() e riceviamo un documento di foglio di calcolo che viene salvato in un file Excel temporaneo. Il contenuto di questo file viene scritto nel database SQLite.

L'ultima cosa che resta da considerare è l'immissione programmatica dei dati in 1C. Supponiamo che sia necessario inserire le testimonianze degli iscritti. Per fare ciò è sufficiente creare e realizzare il documento “Atto di assunzione di testimonianza”:

#coding=cp1251 atti = getattr(V82.Documents, "Atto di raccolta di testimonianze") act = act.CreateDocument() setattr(atto, "Testimonianza", 1024.23) setattr(atto, "Abbonato", "Ivanov") # Riempimento in altri dettagli... act.Write()
L'immissione dei dati è ora automatizzata.

Pertanto, ho delineato un metodo basato sul caricamento e sul download programmatico dei dati utilizzando una connessione COM. Questo metodo funziona con successo nella mia organizzazione da quasi un anno. Il database, formato da 1C, serve 3 sistemi di pagamento, acquisizione Internet (pagamento con carte via Internet), nonché un conto personale. Inoltre, vari script sono collegati al database per automatizzare la routine.

Nonostante i difetti del metodo (velocità di connessione COM lenta), in generale funziona stabilmente. Disponiamo di dati in un formato indipendente dalla piattaforma (SQLite), con cui è possibile lavorare da qualsiasi linguaggio. E la parte principale del codice è scritta in Python, il che significa che sono disponibili molti strumenti e tecniche che non puoi nemmeno sognare in 1C.

Questo è uno dei modi possibili per interagire con 1C. Sono sicuro che non sia una novità e probabilmente è già stato testato e ottimizzato da qualcuno. Tuttavia, ho cercato di presentare quanti più dettagli possibili del processo per proteggerti dalle trappole in cui io stesso ho camminato.

Auguro a tutti voi buona fortuna e ricordate che 1C non è così spaventoso come sembra!

Una delle opzioni per lo scambio di dati tra i database 1C è lo scambio tramite una connessione COM.

Utilizzando una connessione COM, puoi connetterti da un database 1C a un altro e leggere o scrivere dati. Questo metodo può essere utilizzato sia nelle versioni client-server dei database che nei database di file. In questo articolo vedremo esempi di questo tipo di connessione. Gli esempi utilizzano la piattaforma 8.2.

È possibile creare due tipi di oggetti COM per l'applicazione 1C. Questo V82.Applicazione E V82.COMConnettore. In caso di V82.Applicazione Viene lanciata una copia quasi completa dell'applicazione 1C. in caso di utilizzo V82.COMConnettore Viene avviata una piccola parte del server.
La velocità operativa in questo caso è maggiore, ma alcune funzioni potrebbero non essere disponibili. In particolare, lavorare con moduli e moduli comuni per i quali non è impostata la proprietà di lavorare con connessioni esterne. Per lo più dovresti usare V82.COMConnettore e solo in caso di mancanza di funzionalità V82.Applicazione. La differenza nella velocità operativa può essere particolarmente evidente nei database di grandi volumi.

Quindi iniziamo

1. Creiamo un oggetto COM
   • Per V82.Applicazione Connessione = Nuovo COMObject("V82.Application" ) ;
   • Per V82.COMConnettore Connessione = Nuovo COMObject("V82.COMConnector" );
2. Creiamo una stringa di connessione
   • per la versione server del database ConnectionString = "Srvr = " "ServerName" ";Ref = " "BaseName" ;
   • per la versione del file del database ConnectionString = "File = " "PathKBase" "; Usr = Nome Utente; Pwd = Password";
3. Connessione al database Tentativo di connessione = Connessione. Connetti(StringaConnessione) ; Messaggio di eccezione = Nuovo messaggio all'utente; Messaggio. Testo = + DescrizioneErrore() ; Messaggio. Per segnalare(); Finetentativo;
4. Disconnessione dal database Connessione = Non definita;

   Per oggetto V82.ApplicazioneÈ necessario terminare la connessione, altrimenti rimarrà una sessione incompleta che dovrà poi essere cancellata manualmente. In caso di V82.COMConnettore la connessione si interrompe automaticamente una volta completata la procedura con cui è stata stabilita la connessione.C'è ancora un piccolo punto.

   Per l'utente con cui viene effettuata la connessione, la casella di controllo "Richiedi conferma alla chiusura del programma" deve essere disabilitata nelle sue impostazioni.

Ora mettiamo insieme tutto il codice

Connessione = Nuovo COMObject("V82.Application" ) ; //Connessione = Nuovo COMObject("V82.COMConnector"); ConnectionString = "Srvr = " "Server1C" ";Rif = " "MyBase" "; Usr = Petya; Pwd = 123" ; //ConnectionString = "File = ""С:\MyBase""; Usr = Petya; Pwd = 123"; Tentativo di connessione = Connessione. Connetti(StringaConnessione) ; Messaggio di eccezione = Nuovo messaggio all'utente; Messaggio. Testo = "Impossibile connettersi al database"+ DescrizioneErrore(); Messaggio. Per segnalare(); Finetentativo; Connessione = Non definita;

Per il tipo di connessione V82.Applicazione il metodo viene utilizzato per l'oggetto COM creato inizialmente e per V82.COMConnettore viene applicato alla connessione. Quindi la richiesta viene elaborata utilizzando gli strumenti 1C standard. nel codice appare così:

Richiesta = Connessione. NuovoOggetto("Richiesta"); // Per V82.COMConnettore Richiesta = Connessione. NuovoOggetto("Richiesta"); // Per V82.Applicazione Richiesta. Testo = "SELEZIONA | Posizioni delle Organizzazioni Codice, | Posizioni delle organizzazioni.Nome|DA | Directory. Posizioni delle Organizzazioni AS Posizioni delle Organizzazioni"; Risultato = Richiesta. Correre(); Campione = Risultato. Scegliere() ; Ciao selezione. Successivo() Ciclo EndLoop ;

Per la versione 1C:Enterprise 8.3 tutto rimane invariato tranne che quando si creano oggetti COM è necessario utilizzare "Connettore V83.COM" O "V83.Applicazione".

Stampa (Ctrl+P)

Una delle opzioni per lo scambio di dati tra i database 1C è lo scambio tramite una connessione COM. Utilizzando una connessione COM, puoi connetterti da un database 1C a un altro e leggere o scrivere dati. Questo metodo può essere utilizzato sia nelle versioni client-server dei database che nei database di file. Questo articolo discute questi tipi di connessioni sulla piattaforma 8.3

connessione com

È possibile creare due tipi di oggetti COM per l'applicazione 1C. Queste sono vecchie connessioni V83.Applicazione e connessioni com V83.COMConnettore . In caso di V83.Applicazione Viene lanciata una copia quasi completa dell'applicazione 1C. In caso di utilizzo V83.COMConnettore Viene avviata una piccola parte del server. La velocità operativa in questo caso è maggiore, ma alcune funzioni potrebbero non essere disponibili. In particolare, lavorare con moduli e moduli comuni per i quali non è impostata la proprietà di lavorare con connessioni esterne. Per lo più dovresti usare V83.COMConnettore e solo in caso di mancanza di funzionalità V83.Applicazione. La differenza nella velocità operativa può essere particolarmente evidente nei database di grandi volumi. Per la piattaforma 8.2 utilizzato V82.Application o V82.COMConnector

Stabilire una connessione OLE

Connessione = Nuovo COMObject("V83.Application");

Stabilire una connessione COM

Connessione = Nuovo COMObject("V83.COMConnector");

Stringa di connessione

//Per l'opzione client-server
Stringa di connessione= “Srvr = ““NomeServer” “;Rif = “ “NomeBase” ;
//Per l'opzione modalità file:
Stringa di connessione= "File = ""PathKBase" “; Usr = Nome Utente; Password = Password”;
Tentativo
Connessione = Connessione . Collegare(StringaConnessione) ;
Eccezione
Messaggio = Nuovo messaggio all'utente;
Messaggio . Testo = “Impossibile connettersi al database” + DescrizioneErrori(); Messaggio . Per segnalare();
Finetentativo;

Disconnessione

Connessione = Non definita;
Per oggetto V83.ApplicazioneÈ necessario terminare la connessione, altrimenti rimarrà una sessione incompleta che dovrà poi essere cancellata manualmente. In caso di V83.COMConnettore la connessione si interrompe automaticamente una volta completata la procedura con cui è stata stabilita la connessione.C'è ancora un piccolo punto. Per l'utente con cui viene effettuata la connessione, la casella di controllo "Richiedi conferma alla chiusura del programma" deve essere disabilitata nelle sue impostazioni.

Metodo NewObject()

Per creare un nuovo oggetto, puoi utilizzare il metodo NewObject(), ad esempio:

Per V83.COMConnettore

RichiestaCOM = Connessione. NuovoOggetto( "Richiesta ") ;
TabellaCOM = Connessione. NuovoOggetto( “Tabella dei valori”) ;
ArrayCOM = Connessione. NuovoOggetto("Array");
ViewCOM =Connessione.NuovoOggetto

Per V83.Applicazione

RichiestaOLE = Connessione. NuovoOggetto(" Richiesta ") ;
TableOLE = Connessione. NuovoOggetto(“Tabella dei valori”) ;
ArrayOLE = Connection.NewObject("Vettore" ) ​​;
ViewCOM =Connessione.NuovoOggetto("Identificatore univoco", StringUID);

RichiestaCOM . Testo ="SCEGLIERE
| Posizioni delle Organizzazioni Codice,
| Posizioni delle organizzazioni.Nome
|DA | Directory.Posizioni delle organizzazioni
COME POSIZIONI DELLE ORGANIZZAZIONI”;
Risultato = RichiestaCOM. Correre();
Campione = Risultato. Scegliere () ;
Ciao selezione. Prossimo()Ciclo
FineCiclo;
Puoi anche utilizzare i gestori degli oggetti di configurazione:
DirectoryCOM = Connessione. Directory. Nome Directory;
DocumentCOM = Connessione. Documentazione. Nome del documento;
RegisterCOM = Connessione. Registri di informazione. NomeRegistro;

Ricezione e confronto dell'enumerazione tramite connessione COM

Per confrontare i valori degli elementi di enumerazione definiti nella configurazione, è necessario convertire questi elementi in uno dei tipi primitivi, il cui confronto è semplice. Tali tipi possono essere di tipo numerico o di tipo stringa. Puoi convertire il valore di un elemento di enumerazione in un tipo numerico come questo:

Articolo enum = Connection.Directories.Directory1.FindByCode(1).Props1;

PossibiliValues ​​= Enum Element.Metadata().Enum Values;

EnumerationElementNumber = PossibileValues.Index(PossibleValues.Find(Connection.XMLString(EnumerationElement)));

Se EnumerationItemNumber = 0 Allora Report( “Valore enumerativo1”);

ElseIfEnumerationItemNumber = 1 Poi Report("ValoreEnumerazione2");

finisci se;

Recupero di un oggetto tramite COM tramite identificatore

Attraverso i gestori di oggetti di configurazione otteniamo un oggetto com, ad esempio:
DocumentCOM = Connessione. Documentazione. Nome del documento;

Quindi otteniamo una stringa identificativa univoca:

StringUID =Connessione.string ( DocumentCOM.UniqueIdentifier())

Identificatore = Nuova U Identificatore univoco(StringUID);
CON linkByIdentifier = Documenti[NomeDocumento].GetLink(Identificatore);

Se devi trovare un oggetto com per documento per identificatore, devi scrivere in questo modo:

WidCOM = Connessione.NewObject("Identificatore univoco", StringUID);
LinkByIdentifier = Connection.Documents[NomeDocumento].GetLink(WidCOM);