"1C: Trade Management" uued väljaanded: värskendus ilma arenduseta. Tegevusarvestus muutub reguleerituks

Selle põhjuseks on globaalse konteksti funktsiooni ConnectExternalComponent() mõned iseärasused.

Sageli on programmeerijatel probleeme väliste komponentide (näiteks kommertsseadmete draiverite) ühendamisega, kui kasutajad töötavad 1C-ga, luues serveriga terminali kaudu ühenduse.

Sel juhul näevad kasutajad näiteks seda pilti:

Kui kohalikest arvutitest töötades pole väliste komponentide ühendamisega probleeme.

Millega see seotud on? Selle põhjuseks on asjaolu, et kui kasutajad töötavad terminaliserveri kaudu, on neil vähem õigusi kui kohalikus arvutis töötades.

Saate seda hõlpsalt kontrollida, kui logite terminaliserverisse sisse administraatoriõigustega kontoga.

Selle erinevuse põhjuseks on asjaolu, et 1C ei saa registreerida välist komponenti registris, kui kasutaja töötab terminalis tavaõigustega, kuna tavakasutajal pole õigust süsteemi registri harusse kirjutada HKEY_CLASSES_ROOT.

Terminali väliskomponentide ühendamise teemalised väljaanded pakuvad selle probleemi lahendamiseks mitmesuguseid meetodeid.

Näiteks need:

1. Käivitage 1C esimest korda administraatoriõigustega.

See valik ei tööta alati. Ma selgitan allpool, miks.

2. Andke tavaterminali kasutajatele õigus kirjutada süsteemi registri harusse HKEY_CLASSES_ROOT.

Ebapiisavalt arenenud kasutajad ei tohiks seda teha, vastasel juhul võivad tekkida probleemid.

3. Erinevate vidinate abil registreerige VK täielike õigustega kasutaja nimel.

See pole ka hea.

Mis on siis parim viis sellest olukorrast välja tulla?

Pakun sellele probleemile oma lahenduse. Minu meelest - lihtne ja ilus.

Seda probleemi uurides esitasin endale küsimuse: miks 1C isegi üritab VK-d uue tee abil registreerida? Lõppude lõpuks on ta juba süsteemis registreeritud.

Asi selgus selles, et tüüpilistes 1C konfiguratsioonides (näiteks "Trade Management") kasutatakse globaalse konteksti meetodi Connect External Component() jaoks järgmist süntaksit:

ConnectExternalComponent("Kataloog. Ühendatud seadmed. Paigutus. DriverATOLBarcodeScanner", "ATOLScanner");

Nagu näete, on draiveri VC ühendatud kataloogi "Connected Equipment" paigutusega "ATOLBarcode Scanner Driver".

Mis siis saab?

1C salvestab komponendi kasutaja ajutisse kausta, näiteks "C:\Documents and Settings\User\Local Settings\Temp\1032\v8_4_12.tmp"

ja proovib seda registriosakonnas registreerida HKEY_CLASSES_ROOT täpselt seda teed mööda.

Terminalis pole tavakasutajatel õigust seda registriharu muuta, mistõttu komponent nendega ühendust ei loo.

Nüüd räägime sellest, kuidas sellest olukorrast välja tulla.

Globaalsel kontekstimeetodil ConnectExternalComponent() on mitu süntaksivalikut. Seda me kasutamegi.

Niisiis, samm-sammult:

1. Registreerige väliskomponent terminaliserveri utiliidi regsvr32.exe abil kaustas C:\WINDOWS\SYSTEM32 32-bitise operatsioonisüsteemi puhul või kaustas C:\WINDOWS\SYSWOW64 64-bitise operatsioonisüsteemi puhul.

2. Kasutage meetodi ConnectExternalComponent() jaoks üht kahest täiendavast süntaksivalikust.

Valik 1:

ConnectExternalComponent ("C:\WINDOWS\SysWOW64\Scaner1C.dll", "ATOLScanner", ExternalComponentType.COM);

DriverObject = Uus("AddIn.ATOLScanner.Scaner45");

2. valik:

ProgID = "AddIn.Scaner45";

ConnectExternalComponent(ProgID);

DriverObject = Uus(ProgID);

Minu arvates on eelistatum variant number 2.

Samal ajal ei proovi 1C VK-d uuesti registreerida, kasutades registris uut teed ja seega on kõik probleemid lahendatud.

Noh, see on kõik. Edu tööl!

[lingi vaatamiseks peate registreeruma]

Küsimus: väline komponent Native Api C++-s Linuxi jaoks (Ubuntu x64) versioonis 1C 8.3

Kirjutan VK-le, kuid ma ei saa ubuntus 1c-ga ühendust. Isegi 1c käivitatav fail ei loo ühendust. Nii et küsimus selle kohta:

1) Proovin VK-d ühendada artiklis toodud VNCOMPS-i näite põhjal

(lingi leiab päris lõpust: “Kopeerimine”).
NativeApi projekti sees on makefile. Selle abiga ehitan Ununtule .so raamatukogu.
Aga kui "Ühenda väline komponent" 1c jookseb kokku.
Samamoodi, kui ma ehitan "build.sh" abil (projekti juurtes).

Makefile'is endas muudan lipu m32 asemel m64, kuna 1c ja x64 süsteem ise. (parameetriga m32 ei ühenda see niikuinii)
Siin on näide VK helistamisest versioonist 1C 8.3:
Ühendus tehtud = Ühendage väline komponent("/home/alexeyubuntux64-20 gb/Documents/VNCOMP83/example/NativeAPI/AddInNative.so", "AddInNative", ExternalComponentType.Native); Just sellel teemal on artikkel.
Aga niipalju kui ma näen, on VNCOMPSi näites kõik need punktid juba arvesse võetud ja parandatud.

Kuid sisuliselt on see kompileerimisparameetrite küsimus. MB 32-bitine väliskomponent ühendub tavaliselt 32-bitise 1c-ga, kuid juurutasin selle Ubuntu x64 1c enterprise83 versioonis 8.3.5-1486 amd64. Ja ma tahan temaga VK-s ühendust võtta.

Kas kellelgi on ideid, kuidas seda probleemi lahendada?)
VNCOMPS-i näide peaks töötama, kuid ehitamise parameetreid tuleb kohandada või platvorm ise, millel testin, on vale.

Vastus: Huvitav, kas Java-s on võimalik välist komponenti kirjutada?

Küsimus: Välist komponenti (native) ei saa ühendada

Koostasin näite ITS-iga, 64- ja 32-bitiste süsteemide jaoks.

Ühendan nii:
Ühenduse tulemus = ConnectExternalComponent(KDLLPath, "Comp", ExternalComponentType.Native); Ühes arvutis ühendus toimib, teises mitte. OS-is on erinevus. Seal, kus ühendus luuakse, on Win7, kus Win10 pole. Samal ajal töötavad arvutis, kus minu komponent ei tööta, standardkomponendid.

Testitud erinevatel platvormidel (8.3.4.482, 8.3.6.2100, 8.3.11.2700, 8.3.12.1412).

Kuidas ma saan aru, miks see ühendust ei saa?

Vastus: vc_redist unustasid?

Küsimus: 1C8 ja Native tüüpi väline komponent

Tere päevast.
Mul on BP 3.0.50.12 konfiguratsioon ja soov rakendada sellesse Vesy-Softi kaalumist, kasutades UniServerAutot.
Arendajad koostasid komponendi Native for Windows 32 ja 64 jaoks ning arhiveerisid selle koos maifesti failiga. 1C jaoks on ka näide, kuidas kaalu arvutada. Selles, kasutades binaarandmetega paigutust, on see arhiiv näidatud, nagu ma aru saan. Näites on kõik korras: komponent on paigaldatud, ühendatud, seejärel luuakse ühendus ja loetakse kaal.
Aga niipea, kui hakkate seda 1C-le üle kandma, kaalu ei loeta. Tundub, et kõik on lihtsalt kirjutatud, aga ma ei saa aru, kus reha on.
Kellel vähegi aega - aidake, vaadake ühe silmaga, võib-olla on lahendus pealispinnal, aga ma lähen kuskile valesse kohta ja teen valesti. Ma pole kunagi varem pidanud Native tehnoloogiaga töötama...
Ja manuses on minu töötlustekst
Vastus:
Noh, mul on uudiseid...
Hakkasin lihtsalt samm-sammult nägema, mis hetkel see ebaõnnestuma hakkab. Selleks lõin tühja andmebaasi ja töötlesin seda käsuga. Analoogiliselt tarnija näitega viisin paigutuse üle uude konfiguratsiooni - see töötab teist korda. Need. esimene kord ei, aga teine kord jah. Sellest tekkiski mõte, et meie töötluses oleks siiski vaja komponendi ja objekti ühendamine erinevate protseduuride järgi eraldada.
Seejärel kandsin selle koos paigutuse ühendusega oma andmebaasi - see töötab. Pheh, see on hea.... Aga ma tahaksin ilma konfiguratsiooni muutmata, nii et liigume edasi
Üritan lisada töötlusse paigutuse. Selle suurus kasvab koheselt 10kb-lt 3mb-le ja märgatakse olulist töö aeglustumist - see ei sobi. Olen hakanud tegelema komponentide ühendamisega dll-i kaudu. Need. sisuliselt sama, kus ma alustasin. Kuid on üks "AGA": kasutaja kaustast dll-nime otsides märkasin, et see dll asub seal, kus (nagu ma aru saan) liidetakse 1C-s registreeritud dll-id:
C:\Users\USER\AppData\Roaming\1C\1cv8\ExtCompT
Sellest tulenevalt pole vaja kasutada dll-i täielikku teed, võite lihtsalt sisestada selle nime:
ConnectExternalComponent("Add1CUniServerAuto32.dll", "UniServerAuto", ExternalComponentType.Native);
Proovin... see kirub registreerimisel, aga tagastab kaalumise tulemuse. Selgub, et dll on juba registreeritud ja see tähendab, et peate selle lihtsalt ühendama. Eemaldan selle ja kõik töötab.
Kokkuvõtteks:
1. Kaalutöötluses hõlmas AtOpening protseduur välise komponendi ühendamist ja ühendamist objektiga.
2. dll-i tee Ma ei kirjutanud seda, ma lihtsalt märkisin selle nime.
Nüüd istun ja mõtlen, millal dll 1C-sse installiti? Tarkvara installimise ajal? Vaevalt... Kuhu see selle dll-i arendajakonfiguratsiooni käivitamise ajal vormi avamisel installitud on? Ma ei tea, aga see tundub mulle lähedane... Mis sa arvad?
Ja teiseks, uues kohas, kui on vaja paigaldada sama terminal, mida tuleb teha, et kõik toimiks? Kas peaksin tarkvara täielikult installima, toimingu kontrollimiseks käivitama müüja konfiguratsiooni ja seejärel (teoreetiliselt) peaks töötlemine toimima? Midagi on kuidagi keeruline... Või peaksin pärast tarkvara installimist töötluse käigus üks kord installima välise komponendi?
Tahaksin kuulda teie mõtteid sellel teemal...

Küsimus: Väline komponent.dll

Head päeva kõigile.
Küsimus.
dll-komponent, mis töötab suurepäraselt versioonis 1C 7.7
1s 8.1 ei taha üldse käivituda...
Proovisin ja kleepisin selle kausta C:\Program Files\1cv81\bin\cache1c.dll
Proovisin registreerida regsvr32 abil "C:\Program Files\1cv81\bin\cache1c.dll"
Registreerub probleemideta.
Kui soovin sellele juurde pääseda, kuvatakse tõrketeade:
Viga väliskomponendi laadimisel! cache1c.dll
Procedure ButtonExecutePress(Button) katse laadida välist komponenti( "C:\Program Files\1cv81\bin\cache1c.dll"); Erandi aruanne( "Väliskomponendi laadimisel tekkis viga!"+ "cache1c.dll" ); EndAttempt; Katse // Hangi komponendi objekt. // m = Uus ("cache1c.GTMcmd" ); m = Uus COMObject("cache1c.GTMcmd" ); Erandiaruanne(); EndAttempt; Menetluse lõpp

Vastus: See on võimatuse piirini banaalne...
Peate kõnede vahel pausi tegema (millisekundites)...
Protseduur ButtonExecutePress(Button) Attempt // Hangi komponendiobjekt. m = Uus COMObject("cache1c.GTMcmd" ); Erandi aruanne( "Välise komponendi objekti loomine ebaõnnestus"); EndAttempt; m.RemoteHost = "192.168.1.101" ; m.RemotePort = 6330; m.Connect(); m.Paus(100); ...... jne
1c 7.7 puhul - see pole vajalik, selgub, et käsitsemine on kiirem.

Küsimus: 1C serveriga välise komponendiga töötamine...

Tere päevast,
Seal on C++ keeles kirjutatud väline komponent, mille ülesanne on hankida teavet välisest andmebaasist ja tagastada päringutulemus 1C väärtuste tabeli kujul.
Väärtuste tabeli genereerimiseks praegusel hetkel kasutatakse liidest IDispatch* pBackConnection, mis saadakse funktsiooni Init() parameetrina. Järgmiseks kasutan lihtsalt väärtuste tabeli loomiseks 1C funktsioone, täidan selle ja tagastan selle CallAsFunc(...) teise parameetri juurde.
Probleemid algasid üleminekuga 1C õhukestele klientidele. Serveri poolel väline komponent tegelikult ei käivitu. Saate seda käivitada kliendi poolel, kuid see kõik näeb välja nagu kargud ja langeb 1C-s üldisest "kliendi-serveri" loogikast välja. Näiteks ei saa klient aru, mis on väärtustabel, probleemid “globaalsete” muutujatega, seanssidega jne.
NativeAPI on selles osas veelgi piiratum.
Tamburiiniga tantsimine viis selleni, et sain käivitada välise komponendi 1C serveri all, AGA töö jätkub seni, kuni proovitakse kutsuda Invoke'i pBackConnectionis. 8.2 serveri 64-bitine versioon üritab midagi teha kuni ajalõpuni, 32-bitine versioon (VK on loomulikult ka 32-bitine) kukub lihtsalt kohe ära.
Eeldan, et 1C server seda töörežiimi ei toeta.
Sellest tulenevalt tekivad küsimused: kas see on ajutine või taandub 1C loogika selle tööskeemi tühistamisele? Kui sisemisi 1C struktuure (väärtuste tabelit) pole sel viisil võimalik luua, kas on põhimõtteliselt kirjeldus selle kohta, mis väärtuste tabel süsteemi tasemel on, et proovida seda C++-s luua, täitke see ja seejärel lihtsalt libistage see tagastusparameetrina 1C-sse? Tahaks saada vähemalt suuna, mis suunas kaevata.
Aitäh.

Vastus:
Kirjutad üht ja mõtled teist.
1C keskkonnas pole eri seanssidel nähtavate muutujate deklareerimine praegu võimatu ja varem seda võimalust polnud. Teine seanss on füüsiliselt erinev protsess.
Seanss on andmebaasiga ühenduv seanss, s.t. kasutaja seanss. Või lisate sellesse kontseptsiooni midagi omast?
Ühe seansi jooksul oli võimalik ja nüüd on võimalik deklareerida seansimoodulis muutujaid, mis elavad ja on seansi sees erinevatest kohtadest nähtavad... tegelikult on neid 4.
- Seansimoodul;
- tavarakenduse moodul;
- Hallatud rakenduste moodul;
- Väline ühendusmoodul.
Muidugi peate konteksti meeles pidama. Serveri kontekst ei ole kliendi poolel otse juurdepääsetav ja vastupidi.
Tegelikult näeb 1C arhitektuur ette, et andmevahetus toimub järgmiselt:
- protseduuride/funktsioonide parameetrite/tagastustega;
- nn seansi parameetrite abil (ei saa olla objektid, vaid paletis reaalselt nähtavad).
Tabel vormil... kas see on seotud mingi objektitabeliga (töötlemine näiteks)? või mitte. Kui jah, siis on see serveris saadaval (&OnServer) ja redigeeri seal....
Ja veel, jah, väärtustabel pole kliendi poolel UV-valguses saadaval. Noh, nii otsustas 1C.
Ole nüüd! See töötab Exceliga, FSO ja paljude muude asjadega, kuid see ei tööta siin. Otsige veast kinni ja analüüsige....
Katse
...
teie tegevused
...
Erand
str = Veakirjeldus();
EndAttempt;
Tänapäevaste riistvaravõimaluste juures pole see argument.
Puhtalt sinu isiklik arvamus. Reaalsusega pole midagi pistmist. Mitte mingil juhul. Kordan veel kord, 1C töötab COM-iga suurepäraselt. Nii in-proc kui ka out-proc.
Sisestage kood, mida kasutate allalaadimiseks ja VK-ga ühenduse võtmiseks.
Muide, VK... kas teie puhul on see COM või Native API?
Kui COM, siis registreerid selle nimega... regsvr32 kaudu... kuidas siis bitisügavuse probleemi “lahendada”?

Küsimus: Välise komponendi paigaldamine

Palun öelge mulle, kuidas välist komponenti installida. Järgmise koodi täitmisel kuvatakse tõrge. Leidke paigutusest NameDecl.dll
SetExternalComponent("GeneralLayout.Layout") proovimine; Erand EndTry ;
Viga: välise komponendi installimine ebaõnnestus!

Vastus: ()
ConnectExternalComponent("GeneralLayout.Layout", "NameDecl", ExternalComponentType.Native) tagastab FALSE.
New("AddIn.NameDecl.CNameDecl", Undefined) = (()): Tüüp undefined (AddIn.NameDecl.NameDecl)

Küsimus: algne dll ei loo ühendust versiooniga 1c 8.1 (fptrwin32_fz54_9_11_0_5549.dll)

Tere.
1C värskendas võrgukassade atol dll-i ffd 1.05 jaoks (sisaldub hooldustöötluses fptrwin32_fz54_9_11_0_5549.dll).
Mul on vana 1C 8.1. Erinevalt versioonist 8.2 ei toeta see välisseadmetega töötamist samal viisil kui 8.2, seega peate esmalt dll Windowsis registreerima ja seejärel ühendama selle ainult 1C-ga?
ProgID = "AddIn.IntegrationComponent.ATOL_KKT_1C83_V9"; LoadExternalComponent("C:\fptrwin32_fz54_9_11_0_5549.dll"); ConnectExternalComponent(progID); Draiver = Uus(ProgID);
Kuid vana töötlus oli kirjutatud com "tehnoloogia" ja uus on native. Seetõttu annab regsvr32 registreerimisel vea:
Moodul on laaditud, kuid DllRegisterServeri sisenemispunkti ei leitud. Ja see soovitab kontrollida, kas see fail on õige dll- või OCX-fail.
Kas keegi on sarnase olukorraga kokku puutunud ja kuidas välja pääsesite? Ma saan aru, et 7.7-l on sarnane probleem.
Kood 8.2:
Layout = GetLayout("Integratsioonikomponent"); Aadress = PlaceInTemporaryStorage(Layout); ConnectExternalComponent(aadress, "IntegrationComponent", ExternalComponentType.Native); Draiver = New("AddIn.IntegrationComponent.ATOL_KKT_1C83_V9");
1C 8.2:
ConnectExternalComponent(<Местоположение>, <Имя>, <Тип>)
1C 8.1:
ConnectExternalComponent(<Идентификатор объекта>)
Valikud:
<Идентификатор объекта>(nõutud)
Tüüp: string. Välise komponendi objekti ProgID (programmiline identifikaator). Peab vastama süsteemi registreerimisandmebaasi (Registry) andmetele.
Kirjeldus:
Ühendab väliste komponentide objektid 1C:Enterprise'iga.
Pole saadaval serveris 1C:Enterprise. Ei kasutata välises ühendusmoodulis.
Märge:
Välised komponendid ühilduvad 1C:Enterprise 7.7 komponentidega.
Näide:
Katse
ConnectExternalComponent("AddinObject.Scanner");
Report("Vöötkoodiskanneri komponent on laaditud");
Erand
Report("Vöötkoodiskanneri komponenti pole laaditud");
Lõpeta katse
Kas selle dll-i saab kuidagi ühendada 8.1-ga või mitte?
Aitäh!

Vastus:
Selle probleemiga puutusin ka hiljuti kokku. 1c hilisemale versioonile ei olnud võimalik teisendada, kuna... dll, millega see konfiguratsioon töötab, lakkas lihtsalt töötamast ja 1c jooksis veaga kokku.
Lahendasin probleemi järgmiselt:
Tegin tühja 8.3 andmebaasi, milles töötlesin komponendi lähtestamist ja siis 8.1-st COM ühenduse kaudu pääsesin eelnevalt loodud andmebaasi ja initsialiseerisin seal komponendi. Siis, juba 8.1-s, kutsusin selle komponendi meetodid välja.
Muidugi on see kark, aga ma pole veel leidnud muud väljapääsu(
Koodi näide 8.3:
Muutuja draiveri eksport;
Funktsioon ÜhendusComponentsKKT() Eksport
Katse
Layout = GetLayout("Integratsioonikomponent");
Aadress = PlaceInTemporaryStorage(Layout);
ConnectExternalComponent(aadress, "IntegrationComponent", ExternalComponentType.Native);
Draiver = New("AddIn.IntegrationComponent.SMDrvFR1C20");
Tulemus = tõene;
Erand
Tulemus = vale;
EndAttempt;
Tagastamise tulemus
EndFunction
Koodi näide 8.1
Funktsioon CreateDriverObject(Driver) Export
Tulemus = tõene;
Katse
ConnectionString="Fail="""Tee andmebaasi""";
ComObject = uus COMObject("V83.Comnector");
Ühenda = ComObject.Connect(ConnectionString);
Töötlemine = Connect.Processing.ConnectExternalComponent.Create();
Ühenduse tulemus = Processing.ConnectionCCPComponents();
Kui Ühenduse tulemus siis
Draiver = töötlemine. Draiver;
EndIf;
Erand
Kes on seda teinud või sarnaste otsustega kokku puutunud, selgitage põhimõtet lihtsa näite abil. Tundub, et väliste komponentide ühendamisega on kõik selge.
// Näide väärtuste tabeli täitmisest TK.Clear(); Taotlus = uus taotlus; Query.Text = "VALI | Nomenklatuur.Link KUIDAS Nomenklatuur |ALT | Kataloog.Nomenklatuur AS-i nomenklatuur"; Päringu tulemus = Request.Execute(); Valik = Request Result.Select(); While Selection.Next() Cycle Page = TK.Add(); Fill inPropertyValues(Page, Selection); EndCycle;
Kas saaksite selle näite abil selgitada, milline osa koodist tavaliselt välja võetakse? Loogiline oleks päringuga osa eemaldada, aga kuidas me siis platvormist mööda minnes väliskomponendist andmebaasi juurde pääseme? Teksti pole mõtet välja tuua. Või võtke välja tabeliosa moodustamine. Jagage oma kogemusi nendega, kes on sellega kokku puutunud.

Vastus: Ja et sõna "ühildumatu" tähendab alati sõna "halb"? Jah, mulle tundub, et kui ma nimetasin oma stiili "1C: halvim programmeerimine sellel skriptimismootoril, mis looduses eksisteerib (tõlgitud kirjakeelde)!" ja siis ilmselt leidub inimesi, kes tahavad seda metsalist üle vaadata. Ja see näeb välja nagu klassika: "Ma pole Pasternakit lugenud, kuid ma ei nõustu temaga!"

Küsimus: välise komponendi ühendamine versioonides 1s 8.3.6 ja Win8

Peate ühendama välise komponendi vk_rs232.dll ise kirjutatud konfiguratsiooniga. Tundub, et see on registreeritud regsvr32.exe kaudu. "Tundub", sest sain teate, et "komponent on registreeritud, kuid tulemüüriga on midagi valesti." Sõnumi esimesele poolele tuginedes kirjutan koodi 1C-s
AfterConnecting = Uue hoiatuse kirjeldus("AfterConnectingVK", ThisForm); StartInstallingExternalComponents(,"C:\Controller\vk_rs232.dll"); StartConnectingExternalComponents(AfterConnecting,"C:\Controller\vk_rs232.dll","DLL_Scales");
ja ma saan sellest veast aru
"Välise komponendi installimine ebaõnnestus! Teie kasutatava klientrakenduse komponent võib puududa!".
Ja nüüd ma ei saa aru:
1. Võib-olla pole komponenti registris registreeritud – kuidas seda seal kontrollida?
2. Võib-olla ei tööta selle "versioon" Win8 all, kuigi mul on see 32-bitine.
3. Võib-olla on 1C ise liiga uus, st. Seetõttu ei saa see selle dll-iga töötada?
4. Noh, see on tühine – ma kirjutan midagi valesti.

Vastus: Ja see kõik viis mind järgmise probleemini. VneshComp on installitud, nüüd peate selle ühendama. Ja siin on mõlemad variandid
ConnectExternalComponent ("C:\Controller\vk_rs232.dll","Kaalud")
ConnectExternalComponent("GeneralLayout.Layout","Libra")

Süntaksivalik: nime ja asukoha järgi
Süntaks:
ConnectExternalComponent(<Местоположение>, <Имя>, <Тип>)
Valikud:
<Местоположение>(nõutud)
Tüüp: string.
Välise komponendi asukoht.
Asukohta saab kasutada:
failisüsteemi välise komponendi faili tee (pole veebikliendis saadaval), mitte ZIP-arhiiv;
binaarandmeid või ZIP-arhiivi salvestava paigutuse täiskvalifitseeritud nimi;
Välise komponendi URL binaarandmete või ZIP-arhiivina GetNavigationLinkiga sarnases vormingus.
<Имя>(nõutud)
Tüüp: string.
Ühendatava välise komponendi sümboolne nimi.
Nimi peab järgima sisseehitatud keele nimetavasid.
<Тип>(valikuline)
Tüüp: ExternalComponentType.
Ühendatava välise komponendi tüüp.
Ei kasutata, kui komponent on pakitud ZIP-arhiivi.
Meetodi valiku kirjeldus:
Ühendab Native- ja COM-tehnoloogia abil valmistatud komponente.
Komponenti saab salvestada teabebaasi või konfiguratsioonipaigutusse binaarandmetena või ZIP-arhiivis.
Käivitusrežiimide "Thin Client" ja "Web Client" jaoks tuleb komponent esmalt installida välise komponendi installimise meetodil.
Süntaksivalik: ID järgi
Süntaks:
ConnectExternalComponent(<ИдентификаторОбъекта>)
Valikud:
<ИдентификаторОбъекта>(nõutud)
Tüüp: string.
Väliskomponendi objekti identifikaator MS Windowsi registri ProgID (Programmaatiline identifikaator) kujul (näiteks: "AddIn.Scanner").
Peab vastama süsteemi registreerimisandmebaasi (Registry) andmetele.
Meetodi valiku kirjeldus:
Komponent peab olema realiseeritud COM-tehnoloogia abil ja registreeritud MS Windowsi registris.
Need komponendid ühilduvad 1C:Enterprise 7.7 komponentidega.
Tähelepanu! Meetodi valik ei tööta serveris ja välisühenduses.
Tagastusväärtus:
Tüüp: Boolean.
Tõsi – ühendus õnnestus.
Kirjeldus:
Ühendab välise komponendi 1C:Enterprise'iga.
Välised komponendid saab salvestada teabebaasi või konfiguratsioonipaigutustesse ZIP-arhiivina või binaarandmetena või failisüsteemi faili.
Töötades õhukese kliendi ja veebikliendiga, peab komponent olema eelinstallitud.
Saadavus:
Õhuke klient, veebiklient, server, välisühendus.
Märge:
Väliseid komponente saab juurutada kasutades Native API või COM tehnoloogiat. COM-tehnoloogia abil valmistatud komponendid ühilduvad 1C:Enterprise 7.7 komponentidega.
Veebiklient saab töötada ainult teabebaasi komponentidega, mis on pakendatud arhiivi.
Õhuke klient saab töötada teabebaasi komponentidega, mis on pakendatud arhiivi, ja komponentidega, mis asuvad failisüsteemis.
Paks klient saab hakkama kõigi komponentide salvestamise võimalustega. Sellisel juhul, kui komponent on installitud meetodil Install External Component, kasutatakse installitud komponenti ja kui pole installitud, võetakse komponent vastu ühenduse loomise ajal.
Server saab töötada kõigi komponentidega. Komponent salvestatakse vahemällu serveriseansi kohta.
Näide:
Kui ConnectExternalComponent("AddinObject.Scanner") Siis
Report("Vöötkoodiskanneri komponent on laaditud");
Muidu
Report("Vöötkoodiskanneri komponenti ei laadita");
endIf;

Õpetus

Sissejuhatus
See artikkel annab ülevaate sellest, kuidas väliskomponendid süsteemis 1C: Enterprise töötavad.
Kuvatakse Windowsi operatsioonisüsteemis failirežiimiga töötava 1C: Enterprise süsteemi versiooni 8.2 välise komponendi väljatöötamise protsess. Seda valikut kasutatakse enamikes väikeettevõtetele mõeldud lahendustes. VK juurutatakse C++ programmeerimiskeeles.
Välised komponendid "1C: Enterprise"
"1C: Enterprise" on laiendatav süsteem. Süsteemi funktsionaalsuse laiendamiseks kasutatakse väliseid komponente (EC). Arendaja seisukohast on VC väline objekt, millel on omadused ja meetodid ning mis võib genereerida ka sündmusi töötlemiseks süsteemis 1C: Enterprise.
Väliseid komponente saab kasutada selliste probleemide lahendamiseks, mida on 1C: Enterprise'i sisseehitatud programmeerimiskeeles keeruline või isegi võimatu rakendada. Eelkõige sisaldab see klass ülesandeid, mis nõuavad madalal tasemel suhtlemist operatsioonisüsteemiga, näiteks konkreetsete seadmetega töötamiseks.
Süsteem 1C: Enterprise kasutab väliskomponentide loomiseks kahte tehnoloogiat:
kasutades Native API-d

kasutades COM-tehnoloogiat

Antud piiranguid arvestades on erinevus kahe ülalmainitud tehnoloogia vahel tähtsusetu, seega kaalume videomängude arendamist Native API abil. Vajadusel saab rakendatud arendusi rakendada COM-tehnoloogiat kasutava arvutitarkvara arendamiseks ning väikeste muudatustega rakendada ka 1C: Enterprise süsteemis kasutamiseks muude töövõimalustega peale faili töörežiimi.
VK struktuur
Süsteemi 1C: Enterprise väliskomponent on esitatud DLL-i teegi kujul. Teegi kood kirjeldab järeltulijaklassi IComponentBase. Loodud klass peab määratlema meetodid, mis vastutavad välise komponendi funktsioonide rakendamise eest. Alistatud meetodeid kirjeldatakse üksikasjalikumalt allpool materjali esitamise ajal.
Demo VK käivitamine
Ülesanne:
Koostage ITS-i tellimusega kaasas olev väline komponent, mis on ette nähtud 1C välise komponendi mehhanismi peamiste võimaluste demonstreerimiseks

Ühendage demokomponent 1C konfiguratsiooniga

Veenduge, et deklareeritud funktsioonid töötavad õigesti

Koostamine
Demo-VK asub ITS-i tellimiskettal kataloogis “/VNCOMP82/example/NativeAPI”.
Demo-VC ehitamiseks kasutame Microsoft Visual Studio 2008. Selle toote muud versioonid ei toeta kasutatavat Visual Studio projektivormingut.

Avage projekt AddInNative. Projekti seadistustesse kaasame projekti koostamiseks vajalike päisefailidega kataloogi. Vaikimisi asuvad need ITS-i kettal kataloogis /VNCOMP82/include.
Ehitamise tulemuseks on fail /bind/AddInNative.dll. See on koostatud teek 1C konfiguratsiooniga ühenduse loomiseks.
VK ühendamine 1C konfiguratsiooniga
Loome tühja 1C konfiguratsiooni.
Allpool on hallatava rakenduse mooduli kood.
muutuja DemoComp; Protseduur süsteemi käivitamisel() Ühendage väliskomponent ("...\bind\AddInNative.dll", "DemoVK", väliskomponendi tüüp. Native); DemoComp = New("AddIn.DemoVK.AddInNativeExtension"); Menetluse lõpp
Kui 1C konfiguratsiooni käivitamisel viga ei teatatud, ühendati VK edukalt.
Ülaltoodud koodi täitmise tulemusena ilmub konfiguratsiooni globaalsesse nähtavusse objekt DemoComp, millel on omadused ja meetodid, mis on määratletud välise komponendi koodis.
Sisseehitatud funktsionaalsuse demonstreerimine
Kontrollime demo VK funktsionaalsust. Selleks proovime määrata ja lugeda mõningaid omadusi, kutsuda välja mõned VK meetodid ning võtta vastu ja töödelda ka VK-teade.
ITS-kettal olevas dokumentatsioonis on toodud demo-VC järgmised funktsioonid:
Haldamise komponendi objekti olek
Meetodid: Lülitage sisse, Välja lülitama
Omadused: Kaasas

Taimeri juhtimine
Iga sekund saadab komponent süsteemile 1C: Enterprise teate parameetritega Komponent, Taimer ja süsteemi kella loenduri rida.
Meetodid: Käivitamise taimer, StopTimer
Omadused: Taimer on olemas

meetod ShowInStatusLine, mis kuvab olekureal parameetritena meetodile edastatud teksti

meetod Laadi pilt üles. Laadib pildi määratud failist ja edastab selle binaarandmete kujul süsteemi 1C: Enterprise.

Veenduge, et need funktsioonid töötavad. Selleks käivitage järgmine kood:
muutuja DemoComp; Süsteemi käivitamise protseduur () ConnectExternalComponent(...); DemoComp = New("AddIn.DemoVK.AddInNativeExtension"); DemoComp.Disable(); Report(DemoComp.Enabled); DemoComp.Enable(); Report(DemoComp.Enabled); DemoComp.StartTimer(); Protseduuri lõpu protseduur Sündmuse välise töötlemise (allikas, sündmus, andmed) aruanne (allikas + " " + sündmus + " " + andmed); Menetluse lõpp
Konfiguratsiooni käivitamise tulemus on näidatud pildil

Paneel "Sõnumid" kuvab meetodite väljakutsete tulemused DemoComp.Disable() Ja Demo.Comp.Enable(). Sama paneeli järgnevad read sisaldavad VK-lt saadud sõnumite töötlemise tulemusi - Allikas, Sündmus Ja Andmed vastavalt.
Kohandatud väliskomponendi nimi
Ülesanne: muutke väliskomponendi nimi suvaliseks.
Eelmises jaotises kasutati identifikaatorit AddInNativeExtension, mille tähendust ei selgitatud. Sel juhul AddInNativeExtension- see on laienduse nimi.
VK-kood määratleb meetodi RegisterExtensionAs, tagastades nime süsteemile 1C: Enterprise, mis on vajalik VK hilisemaks registreerimiseks süsteemis. Soovitatav on määrata identifikaator, mis mingil määral paljastab välise komponendi olemuse.
Siin on meetodi täielik kood RegisterExtensionAs muudetud laiendi nimega:
bool CAddInNative::RegisterExtensionAs(WCHAR_T** wsExtensionName) ( wchar_t *wsExtension = L"SomeName"; int iActualSize = ::wcslen(wsExtension) + 1; WCHAR_T* siht = 0; if (m-m_Mälu_mälu ((void**)wsExtensionName, iActualSize * sizeof(WCHAR_T))) ::convToShortWchar(wsExtensionName, iActualSize) return false;
Toodud näites muudetakse VK nimeks SomeName. Seejärel peate VK ühendamisel määrama uue nime:
DemoComp = Uus("AddIn.DemoVK.SomeName");
VK atribuutide loendi laiendamine
Ülesanne:
Uurige VK omaduste rakendamist

Lisage stringi tüüpi lugemis-/kirjutusomadus

Lisage lugemis-/kirjutusstringi atribuut, mis salvestab viimase atribuutide komplekti andmetüübi. Vara väärtuse määramisel ei võeta midagi ette

Loodava komponendi omaduste määramiseks peab arendaja rakendama AddInNative.cpp teegi koodis järgmised meetodid:
GetNprops
Tagastab selle laienduse atribuutide arvu, 0, kui atribuute pole
FindProp
Tagastab selle atribuudi seerianumbri, mille nimi on parameetrites edasi antud
HangiPropName
Tagastab atribuudi nime selle seerianumbri ja läbitud keele identifikaatori järgi
GetPropVal
Tagastab vara väärtuse määratud järjekorranumbriga
SetPropVal
Määrab määratud järjenumbriga atribuudi väärtuse
IsPropReadable
Tagastab määratud järjenumbriga atribuudi loetavuse lipu
IsPropWritable
Tagastab määratud järjenumbriga atribuudi kirjutatavuse lipu

Vaatleme ülaltoodud klassimeetodite rakendamist CAddInNative.
Demo-VC-s on määratletud 2 atribuuti: Kaasas Ja Taimer on olemas (On Lubatud Ja IsTimerPresent).
Teegi koodi globaalses ulatuses on määratletud kaks massiivi:
static wchar_t *g_PropNames = (L"IsEnabled", L"IsTimerPresent"); static wchar_t *g_PropNamesRu = (L"Lubatud", L"Taimer on olemas");
mis salvestavad vene- ja ingliskeelseid kinnisvaranimesid. Päisefailis AddInNative.h loendus on määratletud:
enum Props ( ePropIsEnabled = 0, ePropIsTimerPresent, ePropLast // Alati viimane );
ePropIsEnabled Ja ePropIsTimerPresent, mille väärtused on vastavalt 0 ja 1, kasutatakse omaduste seerianumbrite asendamiseks tähenduslike identifikaatoritega. Atribuutide arvu saamiseks kasutatakse ePropLasti, mille väärtus on 2 (meetodil GetNprops). Neid nimesid kasutatakse ainult komponendi koodis ja need pole väljastpoolt saadaval.
Meetodid FindProp ja GetPropName teostavad massiiviotsinguid g_PropNames Ja g_PropNamesRu.
Väljade väärtuste salvestamiseks teegimoodulis on klassis CAddInNative atribuudid, mis salvestavad komponendi atribuutide väärtuse. meetodid GetPropVal Ja SetPropVal tagastada ja määrata nende omaduste väärtus vastavalt.
meetodid IsPropReadable Ja IsPropWritable ja tagasi tõsi või vale, olenevalt läbitud kinnistu järjekorranumbrist vastavalt rakendusloogikale.
Kohandatud atribuudi lisamiseks peate tegema järgmist.
Lisage massiividesse lisatava atribuudi nimi g_PropNames Ja g_PropNamesRu(fail AddInNative.cpp)

Loetlema Rekvisiidid(fail AddInNative.h) enne ePropLast lisage nimi, mis identifitseerib üheselt lisatava atribuudi

Korraldage mälu atribuutide väärtuste salvestamiseks (looge mooduli komponentide väljad, mis salvestavad vastavad väärtused)

Tehke meetodites muudatusi GetPropVal Ja SetPropVal eelmises etapis eraldatud mäluga suhtlemiseks

Vastavalt rakendusloogikale tehke meetodites muudatused IsPropReadable Ja IsPropWritable

Punktid 1, 2, 5 ei vaja selgitust. Nende sammude rakendamise üksikasjad leiate artikli lisast.
Anname testi omadustele nimed Test Ja Tüübi kontroll vastavalt. Seejärel saame 1. sammu tulemusena:
static wchar_t *g_PropNames = (L"IsEnabled", L"IsTimerPresent", L"Test", L"TestType"); static wchar_t *g_PropNamesRu = (L"Lubatud", L"Taimer on olemas", L"Test", L"Tüübikontroll");
Ülekanne Rekvisiidid näeb välja selline:
enum Props ( ePropIsEnabled = 0, ePropIsTimerPresent, ePropTest1, ePropTest2, ePropLast // Alati viimane );
Koodi oluliseks lihtsustamiseks kasutame STL C++. Eelkõige keelpillidega töötamiseks WCHAR, ühendame raamatukogu wstring.
Meetodi väärtuse salvestamiseks Test, määratleme klassis CAddInNative eravaldkonnas:
string test1;
Stringiparameetrite edastamiseks 1C: Enterprise ja väliskomponentide vahel kasutatakse mäluhaldurit 1C: Enterprise. Vaatame tema tööd lähemalt. Funktsioone kasutatakse vastavalt mälu eraldamiseks ja vabastamiseks AllocMemory Ja Vaba mälu failis määratletud Mäluhaldur.h. Kui süsteemile 1C: Enterprise on vaja edastada stringi parameeter, peab väline komponent eraldama selle jaoks mälu funktsiooni kutsudes. AllocMemory. Selle prototüüp näeb välja selline:
virtual bool ADDIN_API AllocMemory (tühine** pMemory, allkirjastamata pikk ulCountByte) = 0;
Kus pMälu- selle kursori aadress, kuhu eraldatud mäluala aadress asetatakse,
ulCountByte- eraldatud mäluala suurus.
Stringi mälu eraldamise näide:
WCHAR_T *t1 = NULL, *test = L"TEST_STRING"; int iActualSize = wcslen(test1)+1; m_iMemory->AllocMemory((void**)&t1, iActualSize * suurus(WCHAR_T)); ::convToShortWchar(&t1, test1, iActualSize);
Stringi andmetüüpidega töötamise mugavuse huvides kirjeldame funktsiooni wstring_p. See saab parameetrina wstringi stringi. Funktsiooni tulemuseks on täidetud struktuur tVariant. Funktsiooni kood:
bool CAddInNative::wstring_to_p(std::wstring str, tVariant* val) ( char* t1; TV_VT(val) = VTYPE_PWSTR; m_iMemory->AllocMemory((void**)&t1, (str.length()+1) * suurus(WCHAR_T)); memcpy(t1, str.c_str(), (str.length()+1) * sizeof(WCHAR_T); tagasta tõene)
Seejärel meetodi lüliti avalduse vastav käändeosa GetPropVal toimub järgmisel kujul:
juhtum ePropTest1: wstring_to_p(test1, pvarPropVal); murda;
meetod SetPropVal:
case ePropTest1: if (TV_VT(varPropVal) != VTYPE_PWSTR) return false; test1 = std::wstring((wchar_t*)(varPropVal -> pstrVal)); murda;
Teise omaduse rakendamiseks määratleme klassivälja CaddInNative
uint8_t last_type;
millesse salvestame viimase ülekantud väärtuse tüübi. Selleks lisage CaddInNative::SetPropVal meetodile käsk:
viimane_tüüp = TV_VT(varPropVal);
Nüüd, kui taotlete teise vara väärtuse lugemist, tagastame selle väärtuse viimane_tüüp, mida määratud ülesanne nõuab.
Kontrollime tehtud muudatuste funktsionaalsust.
Selleks tutvustame 1C konfiguratsiooni välimust järgmiselt:
muutuja DemoComp; Protseduur System Starts() Connect External Component("...", "DemoVK", External Component Type.Native); DemoComp = Uus("AddIn.DemoVK.SomeName"); DemoComp.TypeCheck = 1; Aruanne(String(DemoComp.TypeCheck)); DemoComp.Test = "Vasya"; Raport(String(DemoComp.Test)); DemoComp.Test = "Petya"; Raport(String(DemoComp.Test)); Aruanne(String(DemoComp.TypeCheck)); Menetluse lõpp
Käivitamise tulemusena saame sõnumite jada:
3
Vasja
Peeter
22
Teine ja kolmas teade on eelmises etapis seatud atribuudi lugemise tulemus. Esimene ja teine teade sisaldavad viimase atribuutide komplekti tüübikoodi. 3 vastab täisarvu väärtusele, 22 stringi väärtusele. Tüüpide ja nende koodide vastavus tuvastatakse failis tüübid.h, mis asub ITS-i kettal.
Meetodite loendi laiendamine
Ülesanne:
Laiendage välise komponendi funktsionaalsust järgmiste funktsioonidega:

Uurige võimalusi väliste komponentide meetodite rakendamiseks

Lisage funktsiooni meetod Funktsioon1, mis võtab parameetrina kaks stringi (“Parameeter1” ja “Parameeter2”). Tulemuseks on string nagu: „Kontrollimine. Parameeter1, parameeter 2"

Veenduge, et tehtud muudatused toimiksid.

Loodava komponendi meetodite määratlemiseks peab arendaja rakendama AddInNative teegi koodis järgmised meetodid:
GetNMethods, Otsi meetod, GetMethodName
Mõeldud vastava arvu meetodite saamiseks, otsige meetodi numbrit ja nime. Sarnaselt omaduste vastavate meetoditega
GetNParams
Tagastab määratud järjenumbriga meetodi parameetrite arvu; kui selle numbriga meetod puudub või sellel pole parameetreid, tagastab 0
GetParamDefValue
Tagastab määratud meetodi määratud parameetri vaikeväärtuse
HasRetVal
Tagastab lipu selle kohta, kas määratud järgulise tagastusväärtusega meetodil on tagastusväärtus: tõene tagastamisväärtusega meetodite ja vale muidu
CallAsProc
vale, ilmneb käitustõrge ja mooduli 1C: Enterprise täitmine lõpetatakse. Parameetrite massiivi mälu eraldab ja vabastab 1C: Enterprise.
CallAsFunc
Käivitab määratud järjenumbriga meetodi. Kui meetod naaseb vale, ilmneb käitustõrge ja mooduli 1C: Enterprise täitmine lõpetatakse. Parameetrite massiivi mälu eraldab 1C: Enterprise. Kui tagastatav väärtus on string või binaarne andmetüüp, eraldab komponent funktsiooniga mälu AllocMemory mäluhaldur, kirjutab sinna andmed ja salvestab selle aadressi struktuuri vastavale väljale. 1C: Ettevõte vabastab selle mälu helistades Vaba mälu.
Meetodite täielikku kirjeldust, sealhulgas parameetrite loendit, kirjeldatakse üksikasjalikult ITS-kettale lisatud dokumentatsioonis.
Vaatleme ülalkirjeldatud meetodite rakendamist.
Komponendi koodis on määratletud kaks massiivi:
static wchar_t *g_MethodNames = (L"Luba", L"Keela", L"ShowInStatusLine", L"StartTimer", L"StopTimer", L"LoadPicture"); static wchar_t *g_MethodNamesRu = (L"Luba", L"Keela", L"ShowInStatusLine", L"StartTimer", L"StopTimer", L"LoadImage");
ja loendus:
enum Methods ( eMethEnable = 0, eMethDisable, eMethShowInStatusLine, eMethStartTimer, eMethStopTimer, eMethLoadPicture, eMethLast // Alati viimane );
Neid kasutatakse funktsioonides GetNMethods, Otsi meetod Ja GetMethodName, analoogselt omaduste kirjeldusega.
meetodid GetNParams, GetParamDefValue, HasRetVal tööseadme lüliti, olenevalt läbitud parameetritest ja rakenduse loogikast, tagastab vajaliku väärtuse. meetod HasRetVal selle koodis on loend ainult meetoditest, mis võivad tulemuse tagastada. Nende pärast ta naaseb tõsi. Kõigi terasmeetodite puhul tagastab vale.
meetodid CallAsProc Ja CallAsFunc sisaldavad meetodi otse käivitatavat koodi.
Meetodi lisamiseks, mida saab kutsuda ainult funktsioonina, peate väliskomponendi lähtekoodis tegema järgmised muudatused.
Lisage massiividele meetodi nimi g_MethodNames Ja g_MethodNamesRu(fail AddInNative.cpp)

Lisage meetodite loendisse tähenduslik meetodi identifikaator (fail AddInNative.h)

Tehke funktsiooni koodis muudatused GetNParams programmi loogika järgi

Vajadusel tehke meetodi koodis muudatused GetParamDefValue, kui soovite kasutada meetodi parameetrite vaikeväärtusi.

Tehke funktsioonis muudatused HasRetVal

Tehke muudatusi funktsioonide loogikas CallAsProc või CallAsFunc, asetades sinna meetodi otse käivitatava koodi

Tutvustame massiive g_MethodNames Ja g_MethodNamesRu, samuti nimekirja kandmine meetodid vormile:
static wchar_t *g_MethodNames = (L"Luba", L"Keela", L"ShowInStatusLine", L"StartTimer", L"StopTimer", L"LoadPicture", L"Test"); static wchar_t *g_MethodNamesRu = (L"Luba", L"Keela", L"ShowInStatusLine", L"StartTimer", L"StopTimer", L"LoadPicture", L"Test");
Enum Methods ( eMethEnable = 0, eMethDisable, eMethShowInStatusLine, eMethStartTimer, eMethStopTimer, eMethLoadPicture, eMethTest, eMethLast // Alati viimane );
Redigeerime funktsiooni GetNprops nii, et see tagastab meetodi "Test" parameetrite arvu:
long CAddInNative::GetNParams(const long lMethodNum) ( switch(lMethodNum) ( case eMethShowInStatusLine: return 1; case eMethLoadPicture: return 1; case eMethTest: return 2; default: return 0; ) return 0; )
Teeme funktsioonis muudatused:
bool CAddInNative::GetParamDefValue(const long lMethodNum, const long lParamNum, tVariant *pvarParamDefValue) (TV_VT(pvarParamDefValue)= VTYPE_EMPTY; switch(lMethodNum) ( case eMethIntuseL case:methIntus MethStartTimer : case eMethStopTimer: case eMethTimer : / / Vaikimisi pole parameetrite väärtusi: return false;
Tänu lisatud reale
juhtum eMethTest:
kui üks või mitu argumenti puudub, on vastavatel parameetritel tühi väärtus ( VTYPE_EMPTY). Kui vajate parameetri vaikeväärtust, peaksite selle jaotises määrama eMethTest funktsiooni lüliti avaldus CAddInNative::GetParamDefValue.
Kuna testmeetod võib tagastada väärtuse, peate funktsiooni koodis muutma HasRetVal:
bool CAddInNative::HasRetVal(const long lMethodNum) ( switch(lMethodNum) ( case eMethLoadPicture: case eMethTest: return true; vaikimisi: return false; ) return false; )
Ja lisage funktsioonile meetodi käivitatav kood CallAsFunc:
bool CAddInNative::CallAsFunc(const long lMethodNum, tVariant* pvarRetValue, tVariant* paParams, const long lSizeArray) ( ... std::wstring s1, s2; switch(lMethodNum) ( case eMethLoadPestic: ...MethLoadPestic: ... if (!lSizeArray || !paParams) return s1 = (paParams) -> pwstrVal (paParams+1) -> pwstring_to_p(std::wstring(s1+s2), pvarRetValue ; ;
Kompileerime komponendi ja toome konfiguratsioonikoodi vormile:
muutuja DemoComp; Protseduur System Starts() Connect External Component("...", "DemoVK", External Component Type.Native); DemoComp = Uus("AddIn.DemoVK.SomeName"); lane = DemoComp.Test("Tere", "Maailm!"); Aruanne(per); Menetluse lõpp
Pärast konfiguratsiooni käivitamist saame teate: "Tere, maailm!", mis näitab, et meetod töötas edukalt.
Taimer
Ülesanne:
Uurige taimeri rakendamist demo VK-s

Muutke meetodit "StartTimer", lisades parameetritesse võimaluse edastada taimeri reaktsiooniintervall (millisekundites)

Veenduge, et tehtud muudatused toimiksid.

WinAPI-s saate sõnumit ajaga töötamiseks kasutada WM_TIMER. See teade saadetakse teie programmile ajaintervalliga, mille määrasite taimeri loomisel.
Taimeri loomiseks kasutage funktsiooni SetTimer:
UINT SetTimer(HWND hWnd, // akna deskriptor UINT nIDevent, // taimeri identifikaator (number) UINT nElapse, // viivitus TIMERPROC lpTimerFunc); // osuti funktsioonile
Operatsioonisüsteem saadab sõnumi WM_TIMER programmi argumendis määratud intervalliga nAeg(millisekundites). Viimases parameetris saate määrata funktsiooni, mis käivitatakse iga kord, kui taimer käivitub. Selle funktsiooni päis peaks välja nägema järgmine (nimi võib olla ükskõik milline):
tühine __stdcall TimerProc (HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
Vaatleme taimeri rakendamist demo-VC-s.
Kuna me kaalume Windowsi OS-i perekonna välise komponendi väljatöötamise protsessi, ei võta me taimeri kasutuselevõttu teistes operatsioonisüsteemides arvesse. Eelkõige GNU/Linux OS-i puhul erineb rakendamine funktsiooni süntaksi poolest SetTimer Ja TimerProc.
Käivitatav kood kutsub meetodi SetTimer, millele funktsioon edastatakse MyTimerProc:
m_uiTimer = ::SetTimer(NULL,0,100,(TIMERPROC)MyTimerProc);
Loodud taimeri ID asetatakse muutujasse m_uiTimer et seda hiljem välja lülitada.
Funktsioon MyTimerProc järgnevalt:
VOID CALLBACK MyTimerProc(HWND hwnd, // taimeriteadete akna käepide UINT uMsg, // WM_TIMER teade UINT idEvent, // taimeri identifikaator DWORD dwTime // praegune süsteemiaeg) ( if (!pAsyncEvent) return; wchar_t "ComponentNative", *what = L"Timer"; wchar_t *wstime = new wchar_t; , mis, wstime);
Funktsiooni olemus seisneb selles, et meetod kutsutakse Väline sündmus, mis saadab sõnumi süsteemile 1C: Enterprise.
Meetodi funktsionaalsuse laiendamiseks Käivitamise taimer Teeme järgmist.
Meetodi koodi muutmine GetNParams nii et see on meetodi jaoks eMethStartTimer tagastatud väärtus 1:
case eMethStartTimer: tagastamine 1;
Siin on meetodi kood CallAsProc vormile:
case eMethStartTimer: if (!lSizeArray || TV_VT(paParams) != VTYPE_I4 || TV_I4(paParams)<= 0) return false; pAsyncEvent = m_iConnect; #ifndef __linux__ m_uiTimer = ::SetTimer(NULL,0,TV_I4(paParams),(TIMERPROC)MyTimerProc); #else // код для GNU/Linux #endif break;
Nüüd kontrollime funktsionaalsust. Selleks kirjutame koodi konfiguratsiooni hallatava rakenduse moodulisse:
muutuja DemoComp; Protseduur System Starts() Connect External Component("...", "DemoVK", External Component Type.Native); DemoComp = Uus("AddIn.DemoVK.SomeName"); DemoComp.StartTimer(2000); Menetluse lõpp
Pärast seadistamise alustamist saab programm 2-sekundiliste intervallidega teateid, mis näitavad, et taimer töötab õigesti.
Koostoime süsteemiga 1C: Enterprise
Välise komponendi ja süsteemi 1C: Enterprise vahel suhtlemiseks failis kirjeldatud klassi IAddInDefBase meetodid AddInDefBase.h. Loetleme kõige sagedamini kasutatavad:
Veateate genereerimine
virtuaalne bool ADDIN_API AddError (allkirjata lühike wkood, konst WCHAR_T* allikas, konst WCHAR_T* descr, pikk kood)
wcode, scode- veakoodid (tõrkekoodide loendi koos kirjeldustega leiate ITS-i kettalt)
allikas- vea allikas
kirjeldus- vea kirjeldus
Sõnumi saatmine süsteemile 1C: Enterprise
virtuaalne bool ADDIN_API väline sündmus(WCHAR_T* wszSource, WCHAR_T* wszMessage, WCHAR_T* wszData) = 0;
wszSource- sõnumi allikas
wszMessage- Sõnumi tekst
wszData- edastatud andmed
Sõnumite pealtkuulamine toimub välise sündmuste töötlemise protseduuriga
Välise komponendi registreerimine süsteemis 1C: Enterprise
virtual bool ADDIN_API RegisterProfileAs(WCHAR_T* wszProfileName)
wszProfiilinimi- komponendi nimi.
Need meetodid on piisavad VK ja 1C täielikuks interaktsiooniks. Andmete vastuvõtmiseks välise komponendi kaudu süsteemist 1C: Enterprise ja vastupidi, saadab väline komponent spetsiaalse sõnumi, mille omakorda püüab kinni 1C-süsteem ja vajadusel kutsub välja välise komponendi meetodid andmete tagasi edastamiseks. .
tVariant andmetüüp
Andmete vahetamisel välise komponendi ja süsteemi 1C: Enterprise vahel kasutatakse andmetüüpi tVariant. Seda kirjeldatakse failis type.h, mille leiate ITS-i kettalt:
struct _tVariant ( _ANONYMOUS_UNION union ( int8_t i8Val; int16_t shortVal; int32_t lVal; int intVal; unsigned int uintVal; int64_t llVal; uint8_t ui8Val; uint16_t uintthor; uint16_t uintthor;3 _t errCode; wchar_tVal; struct tmVal; pInterfaceVal __VARIANT_NAME_2/*iface*/ ) __VARIANT_NAME_1 mõõtmete massiiv pvarVal TYPEVAR vt);
Tüüp tVariant on struktuur, mis sisaldab:
segu (liit), mis on ette nähtud otse andmete salvestamiseks

andmetüübi identifikaator

Üldiselt tüüpi muutujatega töötamine tVariant toimub vastavalt järgmisele algoritmile:
Hetkel muutujas salvestatud andmete tüübi määramine

Andmetele otse juurdepääsuks pääsete juurde vastavale seguväljale

Tüübi kasutamine tVariant lihtsustab oluliselt 1C: Enterprise süsteemi ja väliste komponentide koostoimet
Rakendus
Näidete kataloog sisaldab artikli näiteid
näited/1 – käivitage demokomponent
näited/2 - kinnisvaraloendi laiendamise demonstratsioon
näited/3 - meetodite loetelu laiendamise demonstratsioon
Iga kataloog sisaldab VS 2008 projekti ja valmis 1C konfiguratsiooni.