Mga pamamaraan ng pag-debug ng server (1Cv82). Mga pamamaraan ng pag-debug ng server (1Cv82) Paano patakbuhin ang 1s enterprise sa debug mode
Ipinatupad sa bersyon 8.3.7.1759.
Malubhang na-redesign namin ang mekanismo ng pag-debug. Mayroong ilang mga dahilan para dito. Una, gusto naming bigyan ka ng kakayahang i-debug ang lahat ng application na available ngayon. Pangalawa, ang lumang arkitektura ng debugger ay nangangailangan ng mga pagbabago upang makasabay sa mga kasalukuyang uso at makapag-evolve sa hinaharap. Pangatlo, kailangan ang isang unibersal na interface ng pag-debug, kung saan hindi lamang maaaring gumana ang 1C:Enterprise configurator, kundi pati na rin .
Pangunahing pakinabang
Upang mabigyan ka ng ideya ng saklaw ng mga pagbabagong ginawa namin, maikli nating ilista ang mga pangunahing bentahe ng bagong mekanismo.
Pag-debug sa HTTP
Ang nakaraang mekanismo ng pag-debug ay batay sa katotohanan na ang debugger na ipinatupad sa 1C:Enterprise configurator ay direktang nakipag-ugnayan sa mga bagay sa pag-debug (mga application ng kliyente at server). Ang pakikipag-ugnayan na ito ay isinagawa gamit ang TCP/IP protocol.
Gayunpaman, sa paglabas ng 1C:Enterprise applications sa Internet, at lalo na sa pagdating ng mga mobile application, ang diskarteng ito ay naging mapagkukunan ng mga limitasyon at abala. Hindi palaging pinapayagan ng TCP / IP protocol ang debugger na "makalusot" sa mga item sa pag-debug. Pagkatapos ng lahat, maaari silang nasa labas ng lokal na network kung saan tumatakbo ang debugger.
Samakatuwid, sa bagong mekanismo, pinili namin ang mas maraming "all-terrain" na HTTP protocol bilang transport protocol, na, sa pamamagitan ng paraan, ay ginagamit din ng mga application ng kliyente upang kumonekta sa mga infobase.
Modernong Debug na Arkitektura
Ang isang tampok ng nakaraang mekanismo ng pag-debug ay ang pangangailangang kumonekta sa infobase gamit ang configurator. Bilang resulta, ang nagde-debug na developer ay nagkaroon ng ganap na access sa lahat ng administrative function.
Ang bagong mekanismo ng pag-debug ay hindi na kailangang kumonekta sa infobase na ina-debug. Ang pangunahing bagay na kailangan ngayon ng debugger ay ang parehong configuration na gumagana para sa mga kliyente. Upang makuha ito, hindi na kailangang kumonekta sa na-debug na infobase. Maaari mong i-load ito, halimbawa, mula sa isang file.
Pag-debug ng mga mobile application
Salamat sa paggamit ng HTTP protocol, naging posible na i-debug ang mga application na pinaandar ng mobile platform. Bukod dito, maaari mong i-debug ang anumang mga konteksto: kliyente, server, pati na rin ang mga trabaho sa background.
Ngayon, habang nagde-debug, maaari mong baguhin ang mga halaga ng anumang naisusulat na mga variable. Upang mabilis na tingnan at baguhin ang mga lokal na variable, nagpatupad kami ng hiwalay na window. At ang mismong pagsusuri ng mga expression na ipinapakita ng debugger ay ginagawa na ngayon sa asynchronous mode.
Pag-debug sa Development Tools
Kapag gumagawa ng bagong mekanismo ng pag-debug, nagpatupad kami ng bago, unibersal na interface ng programming para sa pakikipag-ugnayan dito. Ang interface na ito ay ginagamit ng 1C:Enterprise configurator, at ang bagong development environment ay gumagamit na ngayon ng parehong interface. Kaya, available na ngayon ang lahat ng opsyon sa pag-debug kapag nagtatrabaho sa .
Arkitektura ng Proseso ng Debug
Ang bagong arkitektura ng pag-debug ay ganito ang hitsura:
Kasama sa pag-debug ang debugger, mga item sa pag-debug, at isang bagong item - debug server.
Walang direktang paglilipat ng impormasyon sa pagitan ng mga item ng debugger at debug. Ang lahat ng pakikipag-ugnayan ay nakaayos sa pamamagitan ng debug server. Ito ang pangunahing elemento ng mekanismo. Ang debug server ay may pila ng mensahe kung saan ang debugger at mga debug na bagay ay nagpapasa ng impormasyon sa isa't isa.
Parehong ang debugger mismo at ang mga debug item ay nakikipag-ugnayan sa debug server sa HTTP. Kaya, hindi na mahalaga ngayon kung saan matatagpuan ang mga debug item na ito.
Ang komunikasyon sa debug server ay sinisimulan ng debugger at mga debug na item. Para dito, inayos ang mga karagdagang koneksyon. Ang kanilang pangunahing layunin ay upang malaman kung mayroong impormasyon para sa kanila sa debug server. At kung ito ay lilitaw, kunin ang impormasyong ito.
Kaya, ang pakikipag-ugnayan ay one-way. Ang impormasyon ay patuloy na ipinapasa mula sa debug server patungo sa debugger, at sa pag-debug ng mga item.
Pagkakakilanlan ng Infobase
Ang lumang mekanismo ay gumamit ng isang string ng koneksyon upang matukoy ang mga infobase. Ang desisyong ito sa ilang mga kaso ay nagdulot ng mga problema sa pagtutugma ng mga item sa pag-debug at sa configurator. Dahil, una, ito ay case-sensitive, at pangalawa, kapag nagde-debug ng ilang konteksto, awtomatikong nabuo ng platform ang string ng koneksyon. At hindi ito palaging tumugma sa tinukoy mo noong ikinonekta ang infobase sa configurator. Ang paghahanap at pag-aayos ng mga ganitong sitwasyon ay naging kumplikado sa proseso ng pag-debug.
Sa bagong mekanismo, tinanggal namin ang string ng koneksyon. Ngayon ginagamit namin infobase identifier. Sa infobase ng file, nabubuo ang naturang identifier kapag unang nakakonekta ang isang koneksyon ng kliyente. Sa infobase ng server, ginagamit ang ID ng pagpaparehistro ng infobase sa cluster bilang isang identifier.
Ang isang magandang karagdagang punto dito ay pinananatili namin ang lumang mekanismo ng pag-debug sa platform sa ngayon (maaaring hindi ito kasama sa hinaharap). At magagamit mo ito kung gusto mo, o kung kailangan mo. Kaya, pinahusay namin ang lumang mekanismo, at ngayon ay ginagamit din nito ang infobase identifier, at hindi ang string ng koneksyon.
Mga Karaniwang Sitwasyon sa Pag-debug
Mula sa pananaw ng isang developer ng application, hindi nagbago ang mga karaniwang sitwasyon sa pag-debug. Ang tanging makabuluhang pagkakaiba ay ang bagong mekanismo ng pag-debug ay kailangang paganahin. Dahil ito ay hindi pinagana bilang default.
Sa kabila nito, makatuwirang kilalanin kung ano ang nangyayari ngayon kapag nagsimula kang mag-debug. Dahil maaaring maging kapaki-pakinabang ito sa iyo sa ilang hindi karaniwang sitwasyon sa trabaho.
Pagpipilian sa file
Bago mo simulan ang pag-debug sa mode ng file, kailangan mong tukuyin sa mga setting ng configurator na gusto mong gamitin ang bagong mekanismo ng pag-debug - " Pag-debug sa HTTP».
Sa kasong ito, awtomatikong ipo-prompt ka ng configurator na gamitin ang lokal na debug server. Dapat kang sumang-ayon dito at i-restart ang configurator.
Ang paraan ng pag-debug na iyong itinakda ay naka-save sa pagitan ng mga session ng Designer, ngunit ito ay nakaimbak sa konteksto ng mga infobase. Samakatuwid, para sa isa pang infobase, kakailanganin mong paganahin itong muli.
Ngayon, sa simula ng configurator, o kapag na-restart ito, awtomatikong sisimulan din ng platform ang debug server. Ito ay isang standalone na dbgs.exe application. Makikita mo ito sa task manager.
Ang parameter ng ownerPID nito ay naglalaman ng ID ng application na nagmamay-ari ng debug server na ito. Sa kasong ito, ito ang 1C:Enterprise configurator.
Ngayon, kung magsisimula ka ng 1C:Enterprise debugging session mula sa configurator, awtomatiko itong makokonekta sa debug server, at sa configurator makikita mo ang mga nakakonektang item sa pag-debug.
Kung ang session ng 1C:Enterprise ay inilunsad nang walang pag-debug, kung gayon, tulad ng dati, maaari mo itong ikonekta sa debugger. Ngayon lang kailangan mong tukuyin ang address ng debug server:
Maaari mong malaman ang address na ito mula sa mga setting ng mga debug item:
Mayroong isang hindi pangkaraniwang sandali na nauugnay sa pagtatrabaho sa ilang mga base ng file nang sabay-sabay. Sa bersyon ng file, ang bawat configurator na may pinaganang http debugging ay nagpapatakbo ng sarili nitong kopya ng debug server sa iba't ibang port:
Samakatuwid, kung mayroon kang maraming mga configurator na bukas nang sabay-sabay, pagkatapos ay upang ikonekta ang application ng kliyente sa debugger, kailangan mong piliin ang tama mula sa kanila.
Opsyon ng Client-server
Bago mo simulan ang pag-debug sa client-server mode, kailangan mong simulan ang 1C:Enterprise server sa debug mode, tulad ng dati, ngunit tukuyin na ang bagong mekanismo ng HTTP ay gagamitin para sa pag-debug. Halimbawa, tulad nito:
ragent.exe -debug -http
Kapag nagsimula ang server sa ganitong paraan, magsisimula din ang debug server.
Sa parameter ng ownerPID, magkakaroon ito ng ID ng 1C:Enterprise cluster manager.
Ngayon sa mga setting ng configurator, tulad ng sa kaso ng file base, kailangan mong tukuyin na gusto mong gamitin ang bagong mekanismo ng pag-debug - " Pag-debug sa HTTP».
Sa kasong ito, awtomatikong ipo-prompt ka ng configurator na gamitin ang cluster debug server, at hindi ang lokal na server. Dapat kang sumang-ayon dito at i-restart ang configurator.
Pagkonekta ng mga item sa pag-debug
Kapag sinisimulan ang mga sesyon ng pag-debug mula sa configurator, awtomatikong ikinokonekta ng mga application ang mga item sa pag-debug (parehong kliyente at server) sa debug server.
Kasabay nito, tulad ng dati, mayroon kang pagkakataong i-configure ang awtomatikong koneksyon ng mga item sa pag-debug sa configurator, anuman ang paraan ng paglunsad ng mga ito. Ngayon ang mga pagkakataong ito ay naging mas mayaman.
Una, ang platform ay nag-aalok na ngayon sa iyo ng lahat ng posibleng mga item sa pag-debug na mapagpipilian.
At pangalawa, lumitaw ang isa pang mas banayad na paraan ng pag-tune. Ito ay ang paggamit ng mga paunang ginawang seleksyon.
Maaari mong gamitin ang mga naturang filter kapwa kapag nagkokonekta ng mga debug na item at upang tingnan ang mga available na debug item.
Sa pagpili, bilang karagdagan sa mga item sa pag-debug mismo, maaari mong tukuyin ang mga partikular na user kung saan interesado ka sa mga session, at gayundin, kung gagamitin ang paghihiwalay ng data, tukuyin ang lugar ng infobase na made-debug.
Pagbabago ng mga variable, katangian ng bagay, at pagsusuri ng asynchronous na expression
Ang bagong mekanismo ng pag-debug ay nagpapahintulot sa iyo na baguhin ang mga halaga ng mga variable habang nagde-debug. Walang ganoong posibilidad sa nakaraang mekanismo.
Para sa maginhawang pagtingin at pagbabago ng mga lokal na variable, na tila ang pinakakaraniwang gawain, ipinatupad namin ang window " Mga lokal na variable».
Sa panlabas, ito ay halos kapareho sa pamilyar sa iyo na "Scoreboard". Ngunit, una, ang window na ito ay awtomatikong napuno ng lahat ng mga lokal na variable, at pangalawa, maaari mo na ngayong baguhin ang mga halaga ng mga variable.
Maaari mong baguhin ang mga halaga ng mga primitive na uri nang direkta sa cell " Ibig sabihin»:
At upang baguhin ang iba pang mga halaga, maaari mong gamitin ang window ng pagpapasok ng expression:
Ang isang magandang bonus ay ang tulong sa konteksto ay ganap na gumagana sa window na ito.
Sa eksaktong parehong paraan, maaari mong baguhin ang mga halaga ng anumang (hindi lamang lokal) na mga variable, mga katangian, na magagamit para sa pagsulat. Sa window ng pagkalkula ng expression (na tinatawag ng Shift+F9 command), maaari mong baguhin ang mga halaga ng mga variable pareho sa cell na "Halaga" at gamit ang isang hiwalay na dialog.
Sa pamamagitan ng paraan, ang pagsusuri ng expression mismo ay ginagawa na ngayon nang asynchronously. Nangangahulugan ito na inuutusan ng configurator ang pagkalkula ng item sa pag-debug. At ilang oras ang pagkalkula na ito ay inaasahan sa server. Kung nakumpleto ang pagkalkula, ang mga resulta ay agad na ipinadala sa configurator. Kung ang pagkalkula ay tumatakbo nang mahabang panahon, ang mga resulta ng mga kalkulasyong ito ay asynchronous na darating sa configurator sa ibang pagkakataon. Ang diskarte na ito ay nagpapahintulot sa iyo na huwag maghintay ng mahabang kalkulasyon sa configurator, at ipagpatuloy ang iyong trabaho.
Paano simulan ang pag-debug sa server 1C...
Bilang default, kapag ginagamit ang arkitektura ng 1C:Enterprise client-server, ang 1C code debugging mode ay gagana lamang sa panig ng kliyente. Ang mga pamamaraan at function ng server ay hindi nakikita ng client machine.
Upang paganahin ang paggamit ng pag-debug sa 1C server, dapat mong gawin ang mga sumusunod na hakbang:
1. Hanapin at ihinto ang serbisyong "Server Agent 1C: Enterprise 8.3" sa service manager (para sa bersyon 8.3).
2. Buksan ang system registry editor. Maaari mong gamitin ang command line o ang Start menu tool - Run ... at ang command regedit.
3. Hanapin ang sangay sa pagpapatala:
- Para sa bersyon 1C 8.1
- Para sa bersyon 1C 8.2
- Para sa bersyon 1C 8.3
4. Baguhin ang ImagePath property, idagdag ang "-debug" na direktiba sa dulo ng linya. Ang resultang string ng property ay: "C:\Program Files (x86)\1cv8\8.3.6.2152\bin\ragent.exe" -srvc -agent -regport 1541 -port 1540 -range 1560:1591 -d "C:\Program Mga file (x86)\1cv8\srvinfo" --debug
Pagkatapos nito, ang 1C server code ay maaaring ligtas na masuri gamit ang isang debugger at magtakda ng mga breakpoint kung saan man kinakailangan.
Tinatalakay ng artikulong ito kung paano i-enable ang pag-debug sa isang 1C 8.1, 8.2 at 8.3 server sa Windows at Ubuntu operating system.
Bilang karagdagan, tandaan ko na ang artikulong ito ay kasama sa isang maliit na serye ng mga artikulo tungkol sa pag-debug sa 1C:
- Paano paganahin ang pag-debug sa 1C server
I-on ang pag-debug sa 1C server sa Windows
Inilunsad namin ang registry editor sa pamamagitan ng pagpapatakbo ng regedit command (gamit ang Win + R o Start-> Run).
Maaari kang magbasa nang higit pa tungkol sa pag-debug ng HTTP at sa server ng pag-debug sa susunod na artikulo sa serye.
Paganahin ang pag-debug sa 1C server sa Ubuntu
Una naming i-set up ang server:
sudo service srv1cv83 stop
Pagkatapos nito, buksan ang file /etc/init.d/srv1cv83 bilang superuser at hanapin ang linya dito:
At dinadala namin ito sa form na ito:
Pagkatapos ay simulan muli ang server:
pagsisimula ng serbisyo ng sudo srv1cv83
Sa configurator sa client machine, pumunta sa "Mga Setting" -> "Start 1C:Enterprise" -> "Advanced" at paganahin ang dalawang item:
- "Itakda ang mode ng pahintulot sa pag-debug"
- "Simulan ang pag-debug sa pagsisimula"
Mababasa mo ang tungkol sa kung paano mag-install ng 1C server sa Ubuntu 16.04 / 18.04 in.
Iyon lang, sana ay naging kapaki-pakinabang sa iyo ang artikulong ito. Ipapaalala ko rin sa iyo ang tungkol sa iba pang mga artikulo sa serye tungkol sa pag-debug sa 1C, ang mga link sa kanila ay matatagpuan sa simula ng artikulong ito.
8, mayroong pangangailangan (higit pa sa ibaba) para sa isang makabuluhang muling paggawa ng pamamaraan ng pag-debug. Naipakita ito sa bersyon 8.3.7.1759. Una, nilikha ang isang unibersal na interface para sa pamamaraang ito, at pangalawa, tinitiyak ng naturang pagbabago ang karagdagang pag-unlad ng programa mismo. Pagkatapos ng lahat, ngayon ay maaari kang magtrabaho sa pag-debug hindi lamang sa pamamagitan ng Configurator, kundi pati na rin sa tulong ng Mga Tool sa Pag-unlad. Isaalang-alang kung paano paganahin ang pag-debug sa 1C server simula sa bagong bersyon.
Gamit ang bagong protocol
Ang nakaraang debugger, na ipinatupad sa mga nakaraang bersyon, ay namamahala sa mga application ng kliyente at server gamit ang TCP/IP protocol.
Sa kasalukuyan, ang paggamit ng naturang protocol ay nagsimulang limitahan ang pag-access ng 1C:Enterprise program sa Internet at lumikha ng abala para sa pagpapatakbo ng mga mobile application.
Samakatuwid, para sa libreng pag-access sa mga infobase na maaaring nasa labas ng lokal na grid, tinatanggap na ngayon ang flexible HTTP protocol para magamit.
Bagong arkitektura
Dati, kapag nagsasagawa ng pag-debug ng configuration, kailangang kumonekta ang isang empleyado sa infobase. Upang gawin ito, kinakailangan na bigyan siya ng mga karapatan ng administrator.
Sa bagong bersyon, hindi na kailangan para sa isang direktang koneksyon sa mga database - ito ay sapat lamang upang magkaroon ng parehong database bilang ang client. At maaari mo itong i-load mula sa isang file.
Mga mobile application
Gamit ang HTTP protocol, posible na ngayong i-debug ang data ng server, data ng kliyente, at mga application.
Iba pang pagbabago
Gamit ang bagong bersyon, posibleng baguhin ang mga halaga para sa mga lokal na variable sa pamamaraan ng pag-debug - isang bagong window ng mabilisang view ang ipinatupad para sa layuning ito.
Ang mode ng pagkalkula ay binago sa asynchronous, na nagbibigay-daan sa iyong magpatuloy sa pagtatrabaho nang hindi naghihintay ng mga resulta.
Debugger sa Development Tools
Ang pakikipag-ugnayan sa bagong pamamaraan ay ginagawa sa isang espesyal na idinisenyong unibersal na interface ng programming. Sa isang banda, ang interface na ito ay ginagamit ng Configurator. Sa kabilang banda, ipinapatupad ito sa bagong kapaligiran ng 1C:Enterprise Development Tools.
Ano ang hitsura nito ngayon
Pagkatapos baguhin ang programa, magpapatuloy ang pamamaraan ayon sa sumusunod na senaryo:
Ngayon ito ay nagsasangkot hindi lamang ang debugger at mga bagay, tulad ng dati. Ngayon isang karagdagang elemento ang naidagdag sa chain - Server.
Hindi lamang ito idinagdag - ito ay nagsisilbing pangunahing elemento ng pagpapalitan ng impormasyon sa pagitan ng debugger at mga bagay. At ang palitan mismo ay nangyayari sa pamamagitan ng mga mensaheng nakapila.
At dahil ang palitan na ito ay isinasagawa sa pamamagitan ng HTTP protocol, ngayon ay hindi mahalaga kung saan eksaktong matatagpuan ang data.
Ang mga kahilingan sa server ay nabuo ng debugger at mga bagay sa anyo ng mga karagdagang kahilingan sa koneksyon. Kapag lumitaw ang mga ito, pinadalhan sila ng mga naaangkop na tugon.
Paganahin ang pag-debug sa iba't ibang mga sitwasyon
Walang pagbabago para sa developer ng application. Ang makabuluhang pagkakaiba ay ang bagong mekanismo ay kailangang paganahin. Pagkatapos ng lahat, bilang default, ito ay hindi pinagana.
Isaalang-alang natin kung ano ang mangyayari kapag nagsimula ang mode kung pipiliin natin ang isa sa dalawang senaryo.
Iskrip ng file
Sa simula ng bersyon ng file, kinakailangan upang tukuyin sa mga setting ng pagsasaayos ang paggamit ng isang bagong mekanismo - "Pag-debug sa pamamagitan ng HTTP protocol".
Pagkatapos ay awtomatikong magmumungkahi ang Configurator gamit ang lokal na server. Dapat tanggapin ang kundisyong ito at mag-restart ang program sa Configurator mode.
Pagkatapos nito, ise-save ng bagong inilunsad na Configurator ang bagong paraan na napili namin sa susunod na session. Ngunit para sa parehong base ng impormasyon. Samakatuwid, kapag nag-access ng isa pang infobase, dapat din itong paganahin.
Awtomatikong ilulunsad na ngayon ng pinaganang mekanismo ang Debugger Server, na isang espesyal na dbgs.exe application. Ito ay ipinapakita sa window ng Task Manager.
Tutugma ang value ng ownerPID parameter sa ID ng application na nakatali dito.
Kapag nagsimula ka ng isang sesyon ng pag-debug sa pamamagitan ng Configurator, awtomatikong gagawin ang isang koneksyon sa server. At ito ay sumasalamin sa mga konektadong bagay.
Kung ang 1C program ay na-activate nang walang bagong mekanismo, kakailanganin mong manual na paganahin ang pag-debug sa 1C server. Ngayon lang kakailanganin mong tukuyin ang address ng server:
Pumunta sa Tools - Options
Ito ay nasa mga setting ng item:
Pumunta kami sa Koneksyon - Mga Setting
Kapag gumagamit ng isang script ng file na may maraming mga database nang sabay-sabay, kailangan mong isaalang-alang ang isang mahalagang nuance - ang bawat isa sa mga Configurator (na may naka-enable na mekanismo ng HTTP) ay nagpapadala ng sarili nitong Server:
Samakatuwid, kung maraming Configurator ang nakabukas, dapat na tukuyin ang tama upang ikonekta ang Kliyente.
Sitwasyon ng Client-Server
Ang pag-debug sa 1C server ayon sa senaryo ng client-server, tulad ng sa nakaraang kaso, ay nagsisimula sa pagsisimula ng mode. Tinutukoy nito ang paggamit ng bagong mekanismo ng HTTP. Ginagawa ito sa ganitong paraan:
ragent.exe -debug -http
Kapag inilunsad ito, awtomatikong magsisimula ang debugger sa likod nito.
Ang value ng ownerPID parameter ay tumutugma sa identification number ng 1C cluster manager.
Ang programa ay bubuo ng isang alok na gamitin ngayon ang debug server ng cluster (at hindi ang lokal tulad ng sa nakaraang senaryo). Sumasang-ayon kami at muling simulan ito.
Sa hinaharap, ang lahat ay magiging tulad ng isang script ng file. Kapag lamang inilunsad ang Server Base Configurator, hindi na magsisimula ang lokal na debugger server.
Umaasa kami na ang aming publikasyon ay nakatulong sa iyo na harapin ang problema kung paano paganahin ang pag-debug sa 1C server.
18.10.2016
Pag-debug sa 1C server (8.2, 8.3...)
Kung gumagana ang database ng 1C sa bersyon ng client-server, hindi pinagana ang mode ng pag-debug ng code sa gilid ng server. Samakatuwid, hindi gagana upang makita ang hakbang-hakbang kung ano ang mangyayari kapag ang isang function o pamamaraan ay naisakatuparan. Upang paganahin ang pag-debug sa panig ng server, kailangan mong sundin ang ilang simpleng hakbang.
Paganahin ang pag-debug sa server na "1C:Enterprise" 8.2, 8.3
Ang unang bagay na dapat gawin ay ihinto ang serbisyo ng server ng 1C:Enterprise. Pumunta kami sa "Start - Run" (o ang key na kumbinasyon na "Windows + R"), isulat ang "services.msc" (siyempre, kailangan mong buksan ang pamamahala ng mga serbisyo ng Windows mula sa Administrator)Pagkatapos huminto, buksan ang Windows registry editor ("Start - Run" (o ang key combination na "Windows + R"), isulat ang "regedit"), at maghanap ng branch na may pangalan. "" o "" depende sa bersyon ng platform
Interesado kami sa registry key na pinangalanang "ImagePath". Magdagdag ng "-debug" sa dulo ng key value. Nangangahulugan ito na ang debugging mode sa 1C server side ay naisaaktibo.
Ito ay: "C:\Program Files\1cv8\8.3.6.2530\bin\ragent.exe" -srvc -agent -regport 1541 -port 1540 -range 1560:1591 -d "C:\Program Files\1cv8\srvinfo"
Ito ay naging: "C:\Program Files\1cv8\8.3.6.2530\bin\ragent.exe" -srvc -agent -regport 1541 -port 1540 -range 1560:1591 -d "C:\Program Files\1cv8\srvinfo" -debug
Nagse-save kami at sinisimulan ang serbisyo ng 1C. Handa na ang lahat! Maligayang pag-debug!