Mga pangunahing detalye ng form. Mga detalye ng pinamamahalaang form (1Cv8) Ang mga pinamamahalaang form 1c ay nagdaragdag ng mga detalye sa programmatically

Mga detalye ng form

Ang isang hanay ng mga detalye ng form ay naglalarawan sa komposisyon ng data na ipinapakita, na-edit o nakaimbak sa form. Kasabay nito, ang mga detalye ng form mismo ay hindi nagbibigay ng kakayahang magpakita at mag-edit ng data. Ang mga elemento ng form (tingnan ang seksyong "Mga Elemento ng Form" ng kabanatang ito) na nauugnay sa mga detalye ng form ay ginagamit para sa pagpapakita at pag-edit. Ang hanay ng lahat ng mga detalye ng form ay tatawaging data ng form.

Mahalaga! Dapat tandaan na, hindi tulad ng mga regular na form, ang lahat ng data sa isang pinamamahalaang form ay dapat na inilarawan sa anyo ng mga detalye. Hindi pinapayagang gumamit ng mga variable ng form module bilang data source para sa mga elemento ng form.

Posibleng magtalaga Mga pangunahing detalye ng form, ibig sabihin, mga katangian na tutukuyin ang karaniwang functionality ng form (extension ng form). Dapat tandaan na ang isang form ay maaari lamang magkaroon ng isang pangunahing katangian.

Extension ng form– ito ay mga karagdagang katangian, pamamaraan at mga parameter ng form ng ManagedForm object, katangian ng object na pangunahing elemento ng form.

Sa panahon ng proseso ng pagbuo ng form, maaari mong tahasang itakda ang kakayahang tingnan at i-edit ang mga partikular na detalye ng form, sa mga tuntunin ng mga tungkulin, gamit ang View at Edit properties (para sa higit pang mga detalye, tingnan ang seksyong "Mga setting ng form na nakabatay sa tungkulin" ng "Mga Editor ” kabanata). Bilang karagdagan, ang pagkakaroon ng isang partikular na katangian sa mismong form ay maaaring i-configure gamit ang mga opsyon sa pag-andar (higit pang mga detalye tungkol sa mga opsyon sa pag-andar ay matatagpuan sa kabanata na "Configuration Interface Management").

Pag-aari ng katangian ng form Naka-save na data ay isang senyales na ang isang interactive na pagbabago sa mga detalye ay hahantong sa isang pagtatangka na harangan ang data ng form para sa pag-edit, gayundin sa awtomatikong setting ng flag ng pagbabago ng form.

Available ang mga uri ng data sa isang pinamamahalaang form

Ang isang pinamamahalaang form ay naiiba rin sa isang regular na form sa mga uri ng data na ginagamit nito. Kung gumagana ang normal na form sa karamihan ng mga uri na ibinibigay ng 1C:Enterprise (kabilang ang mga uri ng DirectoryObject, DocumentObject, atbp.), kung gayon sa pinamamahalaang anyo ang mga sumusunod na kategorya ng mga uri ay maaaring makilala:

  • ang mga uri na direktang ginagamit sa form ay ang mga uri na umiiral sa gilid ng thin at Web client (halimbawa, Number, DirectoryLink.Products, GraphicScheme, TabularDocument);
  • mga uri na iko-convert sa mga espesyal na uri ng data—mga pinamamahalaang uri ng data ng form. Ang mga ganitong uri ay ipinapakita sa listahan ng mga detalye ng form sa mga panaklong, halimbawa (DirectoryObject.Products);
  • dynamic na listahan (para sa higit pang mga detalye, tingnan ang seksyong "Dynamic na Listahan" ng kabanatang ito).

Pag-convert ng mga Application Object sa Form Data

Ang ilang mga uri ng application (tulad ng DirectoryObject, atbp.) ay hindi umiiral sa manipis at Web client side (tingnan ang kabanata ng Managed Application Concept para sa higit pang mga detalye). Samakatuwid, upang kumatawan sa mga ganitong uri ng application sa form, ipinakilala ng platform ang mga espesyal na uri ng data na idinisenyo upang gumana sa mga pinamamahalaang form. Ang tampok na ito ng isang pinamamahalaang application ay ginagawang kinakailangan upang i-convert ang mga object ng application upang bumuo ng data (at vice versa).

Ang mga sumusunod na uri ng data ay ginagamit:

  • Form DataStructure - naglalaman ng isang hanay ng mga katangian ng isang arbitrary na uri. Ang mga katangian ay maaaring iba pang istruktura, koleksyon, o istrukturang may mga koleksyon. Ang ganitong uri ay kinakatawan, halimbawa, sa form na DirectoryObject.
  • Ang FormDataCollection ay isang listahan ng mga nai-type na halaga, katulad ng isang array. Ang isang elemento ng koleksyon ay ina-access sa pamamagitan ng index o identifier. Maaaring hindi available ang access sa pamamagitan ng ID sa ilang mga kaso. Ito ay dahil sa uri ng application object na kinakatawan ng koleksyon na ito. Ang identifier ay maaaring maging anumang integer. Ang ganitong uri ay kinakatawan, halimbawa, sa anyo ng isang tabular na bahagi.
  • Ang Form DataStructureWithCollection ay isang bagay na kinakatawan bilang isang istraktura at isang koleksyon sa parehong oras. Maaari itong tratuhin tulad ng alinman sa mga entity na ito. Ang uri na ito ay kumakatawan, halimbawa, isang hanay ng mga tala sa isang form.
  • Form DataTree – isang bagay na idinisenyo upang mag-imbak ng hierarchical data.

Ang isang application object ay kinakatawan ng alinman sa isa o higit pang mga elemento ng form ng data. Sa pangkalahatan, ang hierarchy at komposisyon ng data ng form ay nakasalalay sa pagiging kumplikado at pagkakaugnay ng mga object ng application ng pinamamahalaang form.

Halimbawa, ang isang dokumento na naglalaman ng isang tabular na bahagi ay kakatawanin ng isang bagay na may uri ng FormDataStructure (ang mismong dokumento), kung saan ang isang bagay na may uri ng FormDataCollection (tabular na bahagi ng dokumento) ay naka-subordinate.

Mahalaga! Kapag bumubuo ng isang pagsasaayos, mahalagang tandaan na ang mga object ng application ay magagamit lamang sa server, habang ang mga form ng data object ay maaaring gamitin sa parehong server at sa client.

Pagpasa ng data sa pagitan ng mga bahagi ng kliyente at server ng isang pinamamahalaang form

Sa katunayan, maaari nating sabihin na ang data ng form ay isang pinag-isang representasyon ng data mula sa iba't ibang mga object ng application kung saan gumagana ang form nang pantay at naroroon sa parehong server at kliyente. Iyon ay, ang form ay naglalaman ng ilang "projection" ng data ng object ng application sa anyo ng sarili nitong mga uri ng data at nagsasagawa ng conversion sa pagitan ng mga ito kung kinakailangan. Gayunpaman, kung ang nag-develop ng configuration ay nagpapatupad ng sarili niyang algorithm sa pagpoproseso ng data, dapat siyang magsagawa ng conversion ng data (mula sa mga espesyal na uri hanggang sa mga uri ng application at vice versa) nang nakapag-iisa.

Kapag nag-e-edit ng mga detalye ng form sa isang espesyal na editor (para sa higit pang mga detalye, tingnan ang seksyong "Mga Detalye ng Form" ng kabanata ng "Mga Editor"), posibleng maimpluwensyahan ang paglipat ng data sa pagitan ng kliyente at ng server habang tumatakbo ang form. Ginagamit para dito ang column ng details editor. Laging gamitin. Ang epekto ng property na ito ay naiiba para sa tatlong uri ng mga katangian:

  • Para sa isang katangiang nasa ilalim ng isang dynamic na listahan (dynamic na hanay ng listahan):
    • pinagana ang pag-aari - ang katangian ay palaging binabasa mula sa database at kasama sa data ng form;
    • hindi pinagana ang property - binabasa ang attribute mula sa database at isinama lang sa form data kapag may kasalukuyang nakikitang elemento ng form na nauugnay sa attribute o sa subordinate na attribute nito.
  • Para sa mga props na nasa ilalim ng koleksyon ng kilusan:
    • pinagana ang pag-aari - ang mga paggalaw ng dokumento ay binabasa mula sa database at makikita sa data ng form;
    • hindi pinagana ang pag-aari - hindi mababasa ang mga paggalaw ng dokumento mula sa database at hindi isasama sa data ng form (kung walang elemento ng form na tumutukoy sa mga paggalaw ng dokumento).
  • Iba pang mga detalye ng form:
    • naka-enable ang property – ang attribute ay makikita sa form data, hindi alintana kung mayroong kahit isang elemento ng form na nauugnay sa attribute o sa subordinate na attribute nito;
    • hindi pinagana ang property - ang attribute ay makikita lang sa form data kung mayroong form element na nauugnay sa attribute o sa subordinate na attribute nito. Hindi tulad ng mga attribute ng dynamic na listahan, hindi mahalaga dito ang visibility ng elementong nauugnay sa attribute.

Tandaan. Dapat tandaan na ang property na itinakda sa parent attribute ay nakakaapekto sa lahat ng subordinate attribute. Halimbawa, kung ang Use property ay palaging na-clear para sa tabular na bahagi ng dokumento, pagkatapos ay isinasaalang-alang ng system na ang property na ito ay na-clear din para sa lahat ng subordinate na detalye (sa kabila ng aktwal na estado ng property).

Mga pamamaraan para sa pag-convert ng data ng object ng application sa data ng form

Upang i-convert ang mga object ng application sa form na data at pabalik, mayroong isang hanay ng mga pandaigdigang pamamaraan:

  • ValueInFormData(),
  • FormDataInValue(),
  • CopyFormData().

Mahalaga! Ang mga pamamaraan na gumagana sa mga object ng application ay magagamit lamang sa mga pamamaraan ng server. Ang pamamaraan para sa pagkopya ng mga halaga sa pagitan ng data ng form ay magagamit sa server at sa kliyente, dahil hindi ito nangangailangan ng mga object ng application bilang mga parameter.

Kapag nagko-convert ng data ng form sa isang application object, kailangan mong isaalang-alang ang kanilang compatibility.

  • ValueInFormData() – nagko-convert ng object na uri ng application sa form data;
  • FormDataInValue() – nagko-convert ng data ng form sa isang object na uri ng application;
  • CopyFormData() – kinokopya ang form ng data na may katugmang istraktura. Nagbabalik ng True kung matagumpay ang kopya, o False kung hindi tugma ang object structure.

Tandaan. Kapag nagsasagawa ng mga karaniwang aksyon (pagbubukas ng isang form, pagsasagawa ng isang karaniwang utos sa Pagsulat, atbp.) ng isang form na may mga pangunahing detalye, awtomatikong ginagawa ang conversion.

Magbigay tayo ng halimbawa kung paano gamitin ang pagbabago ng data sa sarili mong mga algorithm.

&OnServerProcedure Kapag CreateOnServer(Failure, StandardProcessing)

ObjectProduct = Directories.Products.FindByName("Coffeepot").GetObject(); ValueInFormData(ObjectItem, Object);

EndProcedure

&OnClient Procedure Write()

WriteOnServer();

EndProcedure

&OnServer Procedure WriteOnServer()

ObjectProduct = FormDataValue(Object, Type("DirectoryObject.Products")); ObjectItem.Write();

EndProcedure

Ang ManagedForm object ay mayroon ding mga pamamaraan na magagamit sa server:

  • ValueВFormAttribute() – nagko-convert ng object na uri ng application sa tinukoy na katangian ng form.
  • FormAttributeVValue() – nagko-convert ng attribute ng form ng data sa isang object ng isang uri ng application.

Ang paggamit ng mga pamamaraang ito ay karaniwang mas maginhawa, dahil mayroon silang, halimbawa, impormasyon tungkol sa uri ng mga detalye ng form. Bilang karagdagan, ang paraan ng Form AttributesValue() ay nagtatakda ng pagsusulatan sa pagitan ng data ng form at ng bagay, na ginagamit kapag bumubuo ng mga mensahe. Maaari mong basahin ang higit pa tungkol dito sa kabanata na "Mga kakayahan sa pag-navigate sa serbisyo".

Magbigay tayo ng isang halimbawa ng paggamit ng mga pamamaraang ito.

&OnServer Procedure RecalculateOnServer()

// Kino-convert ang Object attribute sa isang application object. Dokumento = Form AttributesValue("Object"); // Nagsasagawa ng muling pagkalkula gamit ang paraan na tinukoy sa module ng dokumento. Document.Recalculate(); // Kino-convert ang application object pabalik sa isang prop. ValueВFormAttributes(Dokumento, “Object”);

EndProcedure

Interface ng software

FormDataTree

  • FindById
  • GetItems

Paglalarawan:

Idinisenyo upang magmodelo ng isang puno sa pinamamahalaang data ng form.

Ang bagay na ito ay maaaring i-serialize sa/mula sa XDTO. Ang uri ng XDTO na naaayon sa bagay na ito ay tinukoy sa namespace. Pangalan ng uri ng XDTO:

GetItems

Syntax:

GetItems()

Ibinalik na halaga:

Uri: Form DataCollection ng Tree Elements.

Paglalarawan:

Nakakakuha ng koleksyon ng mga nangungunang elemento ng puno.

Availability: client, server, thin client, web client.

FindById

Syntax:

FindById(<Идентификатор>)

Mga Pagpipilian:

<Идентификатор>(kailangan)

Uri: Numero. Tagatukoy ng elemento ng puno.

Ibinalik na halaga:

Uri:FormDataTreeElement.

Paglalarawan:

Nakakakuha ng elemento ng koleksyon sa pamamagitan ng ID.

Availability: client, server, thin client, web client.

FormDataTreeItem

Ari-arian:

<Имя свойства> (<Имя свойства>)

  • GetId (GetId)
  • GetParent
  • GetItems
  • Ari-arian

Paglalarawan:

Form ng data tree element.

FormDataTreeItemCollection

Mga elemento ng koleksyon: DataFormTreeElement

Para sa isang bagay, posibleng daanan ang koleksyon gamit ang operator Para sa bawat... Mula sa... Loop. Pinipili ng traversal ang mga elemento ng koleksyon. Posibleng ma-access ang isang elemento ng koleksyon gamit ang [...] operator. Ang index ng elemento ay ipinasa bilang isang argumento.

  • Ipasok
  • Idagdag
  • Index (IndexOf)
  • Bilangin
  • Maaliwalas
  • Kunin
  • Ilipat
  • Tanggalin

Paglalarawan:

Koleksyon ng mga elemento ng kahoy.

Availability: client, server, thin client, web client.

Tingnan din:

  • FormDataTreeElement, paraan ng GetElements
  • DataFormTree, paraan ng GetItems

Mga tampok ng pagtatrabaho sa isang puno ng halaga

Pag-update ng puno

May problema talon mga platform kapag ina-update ang puno.

Kung ang anumang node sa tree ay pinalawak at isang subordinate node ang napili, pagkatapos ay kapag ina-update ang puno na may function ValueInFormData bumagsak ang plataporma.

Solusyon: Kailangan mong i-clear ang puno bago mag-update.

Halimbawa:

&Sa Pamamaraan ng Server ClearTree(mga elemento) Para sa bawat elemento mula sa mga elemento Loop ClearTree(element.GetElements()); EndCycle; elements.Clear(); EndProcedure

&Sa Pamamaraan ng Server Punan ang Concept Tree() dConcepts = srProperties.Build Concept Tree(OnDate, Meta.CurrentIB()); ClearTree(ConceptTree.GetItems()); ValueInFormData(dConcepts, ConceptTree); EndProcedure

&OnClient Procedure OnDateOnChange(Element) Fill ConceptTree(); EndProcedure

Binibigyang-daan ka ng 1C:Enterprise platform na magdagdag at magbago ng mga elemento ng pinamamahalaang form gamit ang program. Alamin natin kung bakit maaaring kailanganin ito.

Maaaring kailanganin ang pagbabago ng software ng form sa ilang mga kaso:

  • Kapag tinatapos ang mga karaniwang pagsasaayos upang mapadali ang kasunod na pamamaraan ng pag-update. Sa kasong ito, ang form module lamang ang babaguhin. Ang mga module ay mas madaling i-update kaysa sa mga form.
  • Kapag nagpapatupad ng ilang karaniwang algorithm. Halimbawa, sa subsystem na "Pagbabawal sa pag-edit ng mga detalye ng bagay," maaaring gumawa ng isang button sa programmatically para sa lahat ng object na konektado sa subsystem upang paganahin ang kakayahang mag-edit ng mga detalye.
  • Kapag nagpapatupad ng ilang partikular na algorithm. Halimbawa, sa direktoryo ng Nomenclature, ang mga field ay nilikha para sa pag-edit ng mga karagdagang detalye.

Sa isang pinamamahalaang form, maaari kang magdagdag, magbago, at magtanggal ng programmatically:

  • mga kinakailangan;
  • mga lokal na koponan;
  • mga elemento.

Ang lahat ng mga operasyong ito ay posible lamang sa server.

May mga limitasyon ang programmatic reshaping:

  • Maaari mo lamang tanggalin ang mga detalye/utos/elemento na idinagdag ayon sa program. Hindi mo maaaring tanggalin ng programmatically ang mga bagay na nilikha sa configurator.
  • Hindi ka maaaring magtalaga ng isang katangian bilang pangunahing isa.

Pagbabago ng mga utos ng form

Upang pamahalaan ang komposisyon ng mga utos para sa isang bagay ManagedForm may koleksyon Mga koponan

    Idagdag (< ИмяКоманды >)

    Dami ()

    Hanapin (< ИмяКоманды >)

    Tanggalin (< Команда >)

Ang koleksyon ng Mga Koponan ay magagamit sa parehong kliyente at server. Maaari mong baguhin ang mga pamamaraan ng koleksyon (Add() at Delete() sa server lamang. Maaari mong hanapin at makuha ang bilang ng mga elemento (ang Find () at Count () na mga pamamaraan) sa client at sa server.

Bilang halimbawa ng pagtatrabaho sa mga form command, gumawa tayo ng bagong ChangeHistory command na may heading na "ChangeHistory...", na tatawag sa handler DisplayHistory(). Nagaganap ang paglikha kapag binuksan ang form.

&Sa server
Pamamaraan WhenCreatingOnServer(Failure, StandardProcessing)
Koponan = Mga pangkat. Idagdag( "Kasaysayan ng mga Pagbabago");
Koponan . Aksyon = ;
Koponan . Pamagat = "Kasaysayan ng mga pagbabago...";
EndProcedure
&OnClient
Pamamaraan Connectable_DisplayHistory(Command)
// mga aksyong utos
EndProcedure

Ang command handler ay dapat na matatagpuan sa isang form at mayroong isang &OnClient compilation directive.

Pagbabago ng mga detalye ng form

Ang pagbabasa ng komposisyon ng mga detalye ng form ay ginagawa ng function Kumuha ng Mga Detalye(< Путь >) na nagbabalik ng hanay ng uri ng FormAttributes. Tinutukoy ng parameter ng function ang path sa parent attribute (bilang isang string). Kung aalisin ang parameter o tinukoy ang isang walang laman na string, ibabalik ang mga detalye sa pinakamataas na antas.

Ang pagbabago ng mga detalye ay ginagawa gamit ang pamamaraan Baguhin ang mga Detalye(<Nagdagdag ng mga Detalye>, <Mga Detalye ng Matatanggal>) bagay ManagedForm. Sa mga parameter Nagdagdag ng mga Detalye At Mga Detalye ng Matatanggal Ang mga array na may mga elemento ng uri ng Form Attributes ay ipinapadala.

Pansin!

Ang proseso ng pagbabago ng komposisyon ng mga detalye ay medyo masinsinang mapagkukunan. Ang form ay talagang nililikha. Kaugnay nito, ang pagtatrabaho sa mga detalye ng form ay isinasagawa sa batch mode.

Gumawa tayo ng bagong katangian ng form na may pangalang Buyer:


AddedDetails = Bagong Array;
Nagdagdag ng mga Detalye. Magdagdag (Bagong Form Attributes(“Buyer”, Bagong Uri ng Paglalarawan (“DirectoryLink. Counterparties”), “Client”));

// Mga pagbabago sa komposisyon ng mga detalye
);

Pagbabago ng mga elemento ng form

Upang kontrolin ang komposisyon ng mga elemento ng isang bagay ManagedForm may koleksyon Mga elemento. Ang koleksyon ay may ilang mga pamamaraan:

    Ipasok (< Имя>, < ТипЭлемента>, < Родитель>, < Элемент >)

    Idagdag (< Имя>, < ТипЭлемента>, < Родитель >)

    Dami ()

    Hanapin (< Имя >)

    Ilipat(< Элемент>, < Родитель>, < МестоРасположения >)

    Tanggalin (< Элемент >)

Ang koleksyon ng Mga Item ay magagamit sa parehong kliyente at server. Baguhin ang isang koleksyon (Ipasok ang mga pamamaraan () , Magdagdag () , Ilipat () at Tanggalin () ) ay magagamit lamang sa server. Maaari mong hanapin at makuha ang bilang ng mga elemento (ang Find () at Count () na mga pamamaraan) sa client at sa server. Ang mga elemento ng koleksyon ay maaaring:

  • FormGroup;
  • FormTable;
  • FormField;
  • Pindutan ng Form.

Maaari kang magtalaga ng mga tagapangasiwa ng kaganapan sa pamamagitan ng program upang bumuo ng mga elemento. Ang pamamaraan ay inilaan para sa mga layuning ito SetAction(< ИмяСобытия>, < Действие >) .

Tingnan natin ang ilan sa mga pinakakaraniwang halimbawa ng pagtatrabaho sa mga command, detalye, at elemento ng form.

Pagdaragdag ng isang utos at ang nauugnay na pindutan nito:

// Lumikha ng command
Koponan = Mga pangkat. Idagdag( "Kasaysayan ng mga Pagbabago");
Koponan . Aksyon = "Plug-in_DisplayHistory"; // Ang form ay dapat maglaman ng isang pamamaraan na may tinukoy na pangalan
Koponan . Heading = "Kasaysayan ng mga pagbabago...";
// Lumikha ng isang pindutan at iugnay ito sa isang utos
Elemento = Mga bagay. Idagdag( "Kasaysayan ng mga Pagbabago", Type("FormButton" ));
Element.CommandName = "Kasaysayan ng mga Pagbabago";

Pagdaragdag ng attribute at ang nauugnay na input field:

// Paglalarawan ng mga idinagdag na detalye
AddedDetails = Bagong Array;
Nagdagdag ng mga Detalye. Idagdag(Bagong Form Props (“Buyer”, New Type Description ( "DirectoryLink. Counterparties"), "Kliyente"));
// Pagbabago ng komposisyon ng mga detalye
ChangeDetails(Idinagdag na Mga Detalye);
// Paglikha ng input field at pagkonekta sa mga katangian
Elemento = Mga bagay. Add("Buyer" , Type("FormField" ));
Elemento . View = FormFieldView. Patlang ng pagpasok;
Elemento . PathToData= "Mamimili" ;

Pagtatalaga ng event handler sa isang form element:

ItemCustomer. SetAction("Kapag nagbago ito", "Connected_BuyerOnChange");

&OnClient
Pamamaraan Connected_BuyerOnChange(Elemento)
// Mga pagkilos sa kaganapan
EndProcedure

Pansin!

Mga pamamaraan na itinakda bilang mga tagapangasiwa ng kaganapan mula sa code gamit ang pamamaraan SetAction(), inirerekumenda na itakda ang prefix Connectable_.

Pansin!

Maaari mong i-download ang pagpoproseso na may mga halimbawa ng programmatic na paghahanap at pagbabago ng mga detalye, utos at elemento ng isang pinamamahalaang form.

Tinitiyak ng mga detalye ng form ang koneksyon nito sa data. Sa kasong ito, ang isa (at isa lamang) sa mga detalye ay maaaring italaga bilang pangunahing isa; maaaring hindi ito ang uri ng data kung saan namin iginuhit ang form. Ngunit ang pag-uugali ng form ay depende sa uri ng data ng pangunahing katangian. Bilang karagdagan sa pagbabago ng pag-uugali ng form, nagbabago ang konteksto ng module ng form. Kasama ang mga pamamaraan at katangian ng anyo, ang mga pamamaraan at katangian ng bagay, na siyang halaga ng pangunahing katangian, ay magagamit dito. Mahalaga na ang mga anyo ng uri ng Libreng Form ay walang mga pangunahing detalye. Sa kasong ito, ang pag-uugali ng form ay tinutukoy lamang ng mga setting ng user. Isaalang-alang natin ang mga tanong tungkol sa mga pangunahing detalye.

Tanong 10.05 ng pagsusulit 1C: Platform Professional. Ano ang pangunahing katangian ng form na ginamit?

  1. Tinutukoy ang data source para sa form sa kabuuan
  2. Tinutukoy ang mga karaniwang kakayahan ng platform para sa pagtatrabaho sa form na may data ng uri na tinukoy sa pangunahing katangian
  3. Upang magbigay ng kakayahang ma-access ng programmatically ang mga detalye ng bagay mula sa konteksto ng lokal na form
  4. Nagbibigay ng visualization ng mga detalye ng bagay sa dialog ng form
  5. 2 at 3 ay tama
  6. Tama ang 1 at 2

Ang tamang sagot ay numero anim, tingnan sa itaas.


Tanong 10.06 ng pagsusulit 1C: Platform Professional. Para saan ang mga detalye ng form na kailangan?
  1. Upang ilarawan ang nilalaman ng data na ipinapakita, na-edit, o naka-imbak sa isang form
  2. Upang ipakita at i-edit ang data sa isang form
  3. Tama ang 1 at 2

Ang tamang sagot ay ang pangatlo - pareho.

Tanong 10.07 ng pagsusulit 1C: Platform Professional. Upang magtalaga ng mga pangunahing katangian sa isang arbitrary na kinokontrol na form...

  1. Kailangan mong suriin ang checkbox na "Mga pangunahing detalye" sa mga katangian ng mga katangian ng form
  2. kailangan mong punan ang property na “Data” ng form sa pamamagitan ng pagpili sa kinakailangang katangian ng form

Pangalawa ang tamang sagot:

Tanong 10.08 ng pagsusulit 1C: Platform Professional. Upang italaga ang mga pangunahing detalye sa isang arbitraryong regular na anyo...
  1. ang form ay kailangang gawin ang pangunahing isa, ang mga pangunahing detalye ay awtomatikong tinutukoy
  2. Kailangan mong suriin ang checkbox na "Mga pangunahing detalye" sa mga katangian ng mga katangian ng form
  3. kailangan mong pumunta sa menu na "I-edit", "Mga pangunahing detalye" at piliin ang nais na halaga
  4. kailangan mong punan ang property na “Data” ng form sa pamamagitan ng pagpili sa kinakailangang katangian ng form

Ang ikaapat na tamang sagot ay:

Ang mga pangunahing detalye ay naka-highlight sa bold:

Tanong 10.09 ng pagsusulit 1C: Platform Professional. Kung mayroong isang pangunahing katangian ng form, posible bang magdagdag ng isa pang pangunahing katangian?
  1. Ito ay imposible
  2. Ito ay posible sa pamamagitan ng pagtatalaga ng naaangkop na halaga sa katangian ng katangian ng form
  3. Posible lamang sa programmatically, kapag ina-access ang object na "Form".
  4. Ito ay posible sa pamamagitan ng pagdaragdag ng isa pang value sa kaukulang form property

Ang tamang sagot ay ang una, mayroong mahigpit na isang pangunahing kinakailangan, dahil ang koneksyon sa bagay ay dapat na hindi malabo.

Tanong 10.113 ng pagsusulit 1C: Platform Professional. Alin sa mga detalye ng form na ipinakita sa figure ang pangunahing isa?

  1. Listahan ng mga Rate ng Pera
  2. DirectoryObject
  3. Ang mga form ng direktoryo ay walang mga pangunahing detalye
  4. Nasa mga form ng direktoryo ang lahat ng pangunahing detalye
Ang pangalawang tamang sagot ay ang naka-bold.

Ang form ay kinokontrol sa pamamagitan ng iba't ibang elemento ng form, na matatagpuan sa hierarchically sa tab Mga elemento taga-disenyo ng form. Ang pinakamahalagang elemento ay ang mismong anyo, na matatagpuan sa tuktok ng hierarchy ng mga elemento, at ang natitirang mga elemento ay nasa ilalim nito.

Ang lahat ng mga elemento ng form ay maaaring nahahati sa limang pangkat: mga patlang, mga elemento ng pagpapangkat, mga pindutan, mga dekorasyon at mga talahanayan. Sa aking mga artikulo ay susuriin ko ang bawat isa sa mga pangkat. Sa artikulong ito, sisimulan nating pag-aralan ang isa sa mga uri ng elemento ng field - entry field, ngunit bago iyon, matututunan natin kung paano magdagdag ng elemento sa form.

Pagdaragdag ng mga elemento sa isang form

Ginagawa ito nang simple: kailangan mong piliin ang elemento Form sa window ng Form Design Elements at i-click ang “Add” button. Pagkatapos nito, magbubukas ang isang window kung saan kailangan mong piliin ang nais na uri ng elemento

Pagkatapos ng pagpili, ang nais na elemento ay lilitaw sa window Mga elemento.

Pinamamahalaang elemento ng form Patlang

Tingnan natin ang isang pinamamahalaang elemento ng form Patlang. Ang elementong ito ay kailangan para maglagay ng impormasyon sa form. At din upang ipakita ang anumang impormasyon. Pagkatapos mong idagdag ang elementong ito sa form, magbubukas ang palette ng mga katangian ng elemento ng form sa kanan. Sa ngayon, dapat kang maging interesado sa dalawang katangian – DataPath at View.

Sa property ng DataPath, maaaring iugnay ng developer ang isang elemento ng form sa nais na katangian ng form. Pakitandaan na pagkatapos maidagdag ang elemento Patlang ng pagpasok sa form hindi ito ipinakita sa mismong form. Nangyari ito dahil hindi nauugnay ang aming bagong elemento sa . Halimbawa, gumawa ako ng ilang attribute sa processing form na may iba't ibang primitive na uri at isang attribute na may reference na uri.

Ngayon, ikonekta natin ang aming kamakailang idinagdag na elemento ng form sa isa sa mga detalye. Upang gawin ito, piliin ang gustong attribute mula sa PathKData property ng elemento.

Pagkatapos nito, ang mga katangian ng DataPath at View ay pupunan, at ang elemento mismo ay ipapakita sa view ng form.

Bigyang-pansin ang pag-aari ng elemento Tingnan. Tinutukoy ng property na ito ang functionality ng input field. Maaari kang pumili ng iba't ibang mga halaga para sa property na ito.

Depende sa napiling value, matutukoy ang functionality. Sa mga figure sa itaas, ang napiling halaga ay - entry field, ibig sabihin. maaari tayong magpasok ng anumang mga halaga sa field ng input na ito, at kung pipili tayo ng isang halaga patlang ng label, pagkatapos ay wala tayong maipapasok.

Ang halaga ng ari-arian na ito Tingnan Maginhawang piliin ang mga input field kapag kailangan mo lang magpakita ng impormasyon ng tulong sa user.

Ngayon magdagdag tayo ng bagong elemento ng form na may uri Patlang ng pagpasok at ikonekta ito sa mga props Mga Detalye Petsa sa pamamagitan ng pamilyar na sa amin na pag-aari ng DataPath

Tulad ng nakikita mo, ang hitsura ng input field ay nagbago, at ang posibleng pagpili ng mga halaga para sa View property ay magbabago din.

Kaya, napagpasyahan namin na ang functionality ng input field ay depende sa uri ng attribute.

Para sa mga props na may uri Boolean Ang mga sumusunod na View property values ​​ay magiging available.

At para sa mga attribute na may uri ng sanggunian, magiging available ang iba pang value ng property na View.

Ang mas detalyadong gawain sa mga elemento ng form gamit ang mga praktikal na halimbawa ay ibinibigay sa aklat na "Mga Pangunahing Kaalaman sa Pag-unlad sa 1C: Taxi. Pinamamahalaang Pag-unlad ng Application sa 12 Hakbang".

Minsan tila ang pag-aaral ng programming language sa 1C ay kumplikado at mahirap. Sa katunayan, ang programming sa 1C ay madali. Tutulungan ka ng aking mga libro nang mabilis at madaling makabisado ang programming sa 1C: at "Mga pangunahing kaalaman sa pag-unlad sa 1C: Taxi"

Matuto ng programming sa 1C sa tulong ng aking aklat na “Programming in 1C in 11 steps”

  1. Walang kumplikadong teknikal na termino.
  2. Higit sa 700 mga pahina ng praktikal na materyal.
  3. Ang bawat gawain ay sinamahan ng pagguhit (screenshot).
  4. Isang koleksyon ng mga problema para sa takdang-aralin.
  5. Ang aklat ay nakasulat sa malinaw at simpleng wika - para sa isang baguhan.

Ang aklat na ito ay angkop para sa mga nagsimula na sa programming at nakakaranas ng ilang partikular na paghihirap sa paksang ito at para sa mga matagal nang nagprograma, ngunit hindi kailanman nakatrabaho sa 1C na pinamamahalaang mga form.

  1. Nang walang kumplikadong teknikal na termino;
  2. Higit sa 600 mga pahina ng praktikal na materyal;
  3. Ang bawat halimbawa ay sinamahan ng isang pagguhit (screenshot);
  4. Ang aklat ay ipinadala sa pamamagitan ng email sa format na PDF. Maaaring buksan sa anumang device!

Promo code para sa 15% na diskwento - 48PVXHeYu


Kung nakatulong sa iyo ang araling ito na malutas ang anumang problema, nagustuhan mo ito o nakita mong kapaki-pakinabang ito, maaari mong suportahan ang aking proyekto sa pamamagitan ng pagbibigay ng anumang halaga:

Maaari kang magbayad nang manu-mano:

Yandex.Money - 410012882996301
Pera sa Web - R955262494655

Sumali sa aking mga grupo.

At Paglipat ng Data Bagay sa pag-istruktura ng code, kinokontrol na anyo sa 1C 8.2 na kapaligiran.

Panimula

Magsimula tayo sa isang maikling paglalarawan ng konsepto ng "pinamamahalaang form" at mga kaugnay na konsepto ng 1C platform. Maaaring laktawan ng mga platform connoisseurs ang seksyong ito.

Noong 2008, naging available ang isang bagong bersyon ng platform ng 1C: Enterprise 8.2 (simula rito bilang Managed Application), na ganap na nagbabago sa buong layer ng trabaho kasama ang interface. Kabilang dito ang command interface, mga form, at ang window system. Kasabay nito, hindi lamang ang modelo para sa pagbuo ng user interface sa pagsasaayos ay nagbabago, kundi pati na rin ang isang bagong arkitektura para sa paghihiwalay ng functionality sa pagitan ng client application at ng server ay iminungkahi.
Sinusuportahan ng pinamamahalaang application ang mga sumusunod na uri ng mga kliyente:

  • Makapal na kliyente (normal at pinamamahalaang launch mode)
  • Payat na kliyente
  • Web client
Ang pinamamahalaang application ay gumagamit ng mga form na binuo sa bagong teknolohiya. Tinatawag sila Mga Pinamamahalaang Form. Upang mapagaan ang paglipat, sinusuportahan din ang mga nakaraang form (ang tinatawag na Regular na mga form), ngunit hindi binuo ang functionality nito at available lang ang mga ito sa makapal na mode ng paglulunsad ng kliyente.
Ang mga pangunahing pagkakaiba ng mga pinamamahalaang form para sa isang developer:
  • Deklarasyon, hindi "pixel by pixel" na paglalarawan ng istraktura. Ang partikular na paglalagay ng mga elemento ay awtomatikong ginagawa ng system kapag ipinakita ang form.
  • Ang lahat ng pag-andar ng form ay inilarawan bilang mga detalye At mga koponan. Ang mga detalye ay ang data kung saan gumagana ang form, at ang mga utos ay ang mga aksyon na isasagawa.
  • Ang form ay tumatakbo sa parehong server at kliyente.
  • Sa konteksto ng kliyente, halos lahat ng mga uri ng application ay hindi magagamit, at naaayon ay imposibleng baguhin ang data sa infobase.
  • Para sa bawat paraan o variable ng form, dapat itong tukuyin direktiba ng compilation, pagtukoy sa lokasyon ng pagpapatupad (kliyente o server) at pag-access sa konteksto ng form.
Ilista natin ang mga direktiba para sa pag-compile ng mga paraan ng form:
  • &OnClient
  • &Sa server
  • &OnServerWalang Konteksto
  • &OnClientOnServerWalang Konteksto
Ilarawan natin ang nasa itaas. Ang screenshot ay nagpapakita ng isang halimbawa ng pinamamahalaang form at ang module nito sa development mode. Hanapin ang declarative na paglalarawan, props, compilation directive, atbp.

Ang lahat ng karagdagang talakayan ay tungkol sa kanang bahagi ng ilustrasyon, tungkol sa kung paano buuin ang code ng module at kung anong mga prinsipyo ang magbibigay-daan sa iyong ipatupad ang epektibong pakikipag-ugnayan ng client-server.

Tukuyin natin ang problema

Ilang taon na ang lumipas mula noong aktibong ginagamit ang bagong bersyon ng 1C platform at maraming solusyon (mga configuration) ang inilabas ng parehong 1C at ng maraming kasosyo nito.
Sa panahong ito, nakabuo ba ang mga developer ng isang karaniwang pag-unawa sa mga prinsipyo ng pakikipag-ugnayan ng client-server kapag gumagawa ng mga form, at nagbago ba ang diskarte sa pagpapatupad ng mga software module sa mga bagong realidad sa arkitektura?

Tingnan natin ang istraktura ng code (form module) sa ilang mga anyo ng parehong karaniwang pagsasaayos at subukang maghanap ng mga pattern.
Sa pamamagitan ng istraktura, ang ibig naming sabihin ay mga seksyon ng code (madalas na ito ay mga bloke ng komento) na inilalaan ng developer sa mga pamamaraan ng pangkat at mga direktiba ng compilation para sa mga pamamaraang ito.
Halimbawa 1:
Seksyon ng mga tagapangasiwa ng kaganapan Paraan - sa client Paraan - sa server Paraan - sa kliyente Seksyon ng mga pamamaraan ng serbisyo at function Mga pantulong na input control function
Halimbawa 2:
Mga pamamaraan at function ng serbisyo Mga dokumento sa pagbabayad Mga Halaga Mga tagapangasiwa ng kaganapan
Halimbawa 3:
Mga pamamaraan ng serbisyo sa server Mga pamamaraan ng serbisyo sa kliyente Mga pamamaraan ng serbisyo sa server nang walang konteksto Mga tagapangasiwa ng kaganapan sa header Mga tagapangasiwa ng kaganapan ng utos
Halimbawa 4:
Pangkalahatang layunin na mga pamamaraan Bumuo ng mga tagapangasiwa ng kaganapan Mga Pamamaraan ng subsystem ng "impormasyon sa pakikipag-ugnayan".
Sa esensya, ang istraktura ng code ay nawawala, o upang ilagay ito nang mahinahon, ito ay katulad ng kung ano ang nasa Forms 8.1:

  • Mga salitang hindi nagbibigay-kaalaman na "General, Service, Auxiliary".
  • Tinangka ng mahiyain na paghiwalayin ang mga pamamaraan ng kliyente at server.
  • Ang mga pamamaraan ay madalas na pinagsama-sama ng mga elemento ng interface "Paggawa gamit ang tabular na bahagi Mga Produkto, Impormasyon sa pakikipag-ugnay".
  • Arbitrary na pag-aayos ng mga pamamaraan at mga pangkat ng code. Halimbawa, ang Mga Tagapangasiwa ng Kaganapan ay maaaring nasa itaas sa isang anyo, sa ibaba sa isa pa, hindi naka-highlight sa isang pangatlo, atbp.
  • At huwag nating kalimutan na lahat ito ay nasa loob ng isang configuration.
  • Oo, may mga configuration kung saan ang mga salitang "General, Service, Auxiliary" ay palaging nasa parehong lugar ngunit...
Bakit kailangan mo ng istraktura ng code?
  • Pagpapasimple ng pagpapanatili.
  • Pasimplehin ang pag-aaral.
  • Pagtatala ng pangkalahatan/mahalaga/matagumpay na mga prinsipyo.
  • ...ang iyong pagpipilian
Bakit hindi nakakatulong ang umiiral na pamantayan sa pag-unlad mula sa 1C?
Tingnan natin ang mga prinsipyong inilathala sa mga disk ng ITS at sa iba't ibang “Mga Gabay ng Developer...” na inirerekomenda kapag nagsusulat ng pinamamahalaang form.
  • Bawasan ang bilang ng mga tawag sa server.
  • Pinakamataas na pag-compute sa server.
  • Ang mga tawag sa server na hindi ayon sa konteksto ay mas mabilis kaysa sa mga tawag sa konteksto.
  • Programa na nasa isip ang komunikasyon ng client-server.
  • at iba pa.
Ito ay mga slogan na ganap na totoo, ngunit paano ipatupad ang mga ito? Paano bawasan ang bilang ng mga tawag, ano ang ibig sabihin ng programa sa client-server mode?

Mga pattern ng disenyo o karunungan sa henerasyon

Ang pakikipag-ugnayan ng Client-server ay ginamit sa iba't ibang mga teknolohiya ng software sa loob ng mga dekada. Ang sagot sa mga tanong na binalangkas sa nakaraang seksyon ay matagal nang alam at nabuod sa dalawang pangunahing prinsipyo.
  • Malayong harapan(mula dito ay tinutukoy bilang Remote Access Interface)
  • Bagay sa Paglilipat ng Data(mula rito ay tinutukoy bilang Data Transfer Object)
Isang salita mula kay Martin Fowler, ang kanyang paglalarawan sa mga prinsipyong ito:
  • … Ang bawat bagay na posibleng inilaan para sa malayuang pag-access ay dapat mayroon mababang granularity interface, na magpapaliit sa bilang ng mga tawag na kinakailangan upang magsagawa ng isang partikular na pamamaraan. ... Sa halip na humiling ng invoice at lahat ng item nito nang hiwalay, kailangan mong basahin at i-update ang lahat ng item ng invoice sa isang kahilingan. Nakakaapekto ito sa buong istraktura ng object...Tandaan: remote access interface ay hindi naglalaman ng domain logic.
  • ...kung ako ay isang nagmamalasakit na ina, tiyak na sasabihin ko sa aking anak: "Huwag kailanman magsulat ng mga bagay sa paglilipat ng data!" Sa karamihan ng mga kaso, ang mga bagay sa paglilipat ng data ay walang iba kundi bloated field set... Ang halaga ng kasuklam-suklam na halimaw na ito ay nakasalalay lamang sa posibilidad magpadala ng maraming piraso ng impormasyon sa network sa isang tawag- isang pamamaraan na may malaking kahalagahan para sa mga distributed system.
Mga halimbawa ng mga template sa 1C platform
Ang interface ng application programming na magagamit ng developer kapag bumubuo ng pinamamahalaang form ay naglalaman ng maraming halimbawa ng mga prinsipyong ito.
Halimbawa, ang OpenForm() na paraan, isang tipikal na "magaspang" na interface.
OpeningParameters = Bagong Structure("Parameter1, Parameter2, Parameter3", Value1, Value2, Value3); Form = OpenForm(FormName, OpeningParameters);
Ihambing sa istilong pinagtibay sa v8.1.
Form = GetForm(FormName); Form.Parameter1 = Value1; Form.Parameter2 = Value2; Form.Open();

Sa konteksto ng isang pinamamahalaang form, maraming "Mga Bagay sa Paglilipat ng Data". Maaari kang pumili sistematiko At tinukoy ng developer.
Ang mga system ay nagmomodelo ng isang application object sa kliyente, sa anyo ng isa o higit pang mga elemento ng form ng data. Imposibleng likhain ang mga ito nang walang sanggunian sa mga detalye ng form.

  • DataFormsStructure
  • DataFormsCollection
  • DataFormStructureWithCollection
  • DataShapesTree
Ang pag-convert ng mga bagay sa paglilipat ng data ng system sa mga uri ng application at vice versa ay isinasagawa gamit ang mga sumusunod na pamamaraan:
  • ValueInFormData()
  • FormDataValue()
  • CopyFormData()
  • ValueInFormAttributes()
  • FormAttributesValue()
Kadalasan ay ginagamit ang tahasang conversion kapag nag-aangkop ng kasalukuyang solusyon. Maaaring asahan ng mga pamamaraan (gumamit ng mga feature) ang mga parameter ng input, gaya ng ValueTable sa halip na FormDataCollection, o ang pamamaraan ay tinukoy sa konteksto ng isang application object at naging hindi available para sa direktang tawag mula sa form.
Halimbawa 1C v8.1:
// sa kliyente sa konteksto ng form na FillUserCache(DepartmentLink)
Halimbawa 1C v8.2:
// sa server sa konteksto ng form ProcessingObject = Form AttributesValue("Object"); ProcessingObject.FillUserCache(DepartmentRef); ValueВFormAttributes(ProcessingObject, "Object");

Ang mga bagay sa paglilipat ng data, na ang istraktura ay tinutukoy ng developer, ay isang maliit na subset ng mga uri na available sa parehong client at server. Kadalasan, ang mga sumusunod ay ginagamit bilang mga parameter at resulta ng mga pamamaraan ng isang "coarsened" na interface:

  • Mga primitive na uri (string, numero, boolean)
  • Istruktura
  • Korespondensiya
  • Array
  • Mga link sa mga bagay ng application (natatanging identifier at representasyon ng teksto)
Halimbawa: ang pamamaraan ay tumatanggap ng isang listahan ng mga order upang baguhin ang katayuan at nagbabalik ng paglalarawan ng mga error sa kliyente.
&OnServerWithoutContext Function ServerChangeOrderStatus(Mga Order, NewStatus) Errors = New Match(); // [order][error description] Para sa Bawat Order Mula sa Mga Order Cycle StartTransaction(); Subukan ang DocOb = Order.GetObject(); …. iba pang mga aksyon, posible hindi lamang sa utos... Exception CancelTransaction(); Errors.Insert(Order, ErrorDescription()); EndAttempt; EndCycle; Error sa Pagbabalik; EndFunction // ServerChangeOrderStatus()

Pag-istruktura ng code

Ang mga pangunahing layunin na dapat ipakita at lapitan ng pinamamahalaang module ng form sa solusyon.
  • Malinaw na paghihiwalay ng client at server code. Huwag nating kalimutan na sa oras ng pagpapatupad ang mga ito ay dalawang prosesong nakikipag-ugnayan, na ang bawat isa ay may makabuluhang magkakaibang magagamit na pag-andar.
  • Malinaw na pagkakakilanlan ng remote access interface, aling mga pamamaraan ng server ang maaaring tawagan mula sa kliyente at alin ang hindi? Ang mga pangalan ng mga paraan ng malayuang interface ay nagsisimula sa prefix na "Server". Binibigyang-daan ka nitong makita kaagad ang paglipat ng kontrol sa server habang binabasa ang code, at pinapasimple ang paggamit ng tulong sa konteksto. Tandaan na ang opisyal na rekomendasyon (ITS) ay nagmumungkahi ng mga paraan ng pagbibigay ng pangalan na may mga postfix, halimbawa, ChangeOrderStatusOnServer(). Gayunpaman, inuulit namin na hindi lahat ng mga pamamaraan ng server ay maaaring tawagan mula sa kliyente, at samakatuwid ang lohikal na accessibility ay mas mahalaga, kaysa sa lokasyon ng compilation. Samakatuwid, gamit ang prefix na "Server" ay minarkahan lamang namin ang mga pamamaraan na magagamit sa kliyente; tawagan natin ang halimbawang pamamaraan na ServerChangeOrderStatus().
  • Kakayahang mabasa. Isang bagay ng panlasa, tinatanggap namin ang order kapag nagsimula ang module sa mga pamamaraan para sa paglikha ng isang form sa server at mga paraan ng malayuang pag-access.
  • Pagpapanatili. Dapat mayroong isang malinaw na lokasyon para sa pagdaragdag ng bagong code. Ang isang mahalagang punto ay ang mga template ng pamamaraan na awtomatikong nilikha ng configurator ay idinagdag sa dulo ng module. Dahil ang mga tagapangasiwa ng kaganapan para sa mga elemento ng form ay kadalasang awtomatikong nagagawa, ang katumbas na bloke ay matatagpuan sa huli, upang hindi i-drag ang bawat handler sa ibang lugar sa module.
Nasa ibaba ang pangunahing istruktura ng modyul na nagpapatupad ng mga nakalistang layunin.
  • Graphical na opsyon - malinaw na nagpapakita ng pangunahing daloy ng pagpapatupad.
  • Ang opsyon sa teksto ay isang halimbawa ng disenyo ng template para sa mabilis na pagpasok ng isang istraktura sa isang bagong form na module.

//////////////////////////////////////////////////////////////////////////////// // <(c) Автор=""Petsa=""/> // <Описание> // // ////////////////////////////////////////////// ////////////////////////// // MGA VARIABLE NG MODULE //////////////// // /////////////////////////////////////////////// ////////// // SA SERVER //******* MGA PANGYAYARI SA SERVER ******* &Sa Pamamaraan ng Server Kapag Ginawa sa Server (Failure, StandardProcessing) / /Ipasok ang mga nilalaman ng handler End of Procedure //******* REMOTE ACCESS INTERFACE ******* //********** BUSINESS LOGIC SA SERVER ******* ///////////////////////////////////////////// /////// //////////////////// // KARANIWANG PARAAN NG CLIENT AT SERVER ////////////// /////// /////////////////////////////////////// ///// //////// // SA CLIENT //******* BUSINESS LOGIC SA CLIENT ******* //******* TEAM * ****** //********** CLIENT EVENTS ******* ///////////////////////// ///// ///////////////////////////////////////// // / / MGA PANGUNAHING OPERATOR NG PROGRAM

Mga kaugnay na tanong
Sa konklusyon, magbabalangkas kami ng ilang mga lugar na kapaki-pakinabang na pag-isipan kapag nagprograma ng pakikipag-ugnayan ng client-server.
  • Mga opsyon sa pagpapatupad ng remote access interface. Asynchrony, antas ng detalye...
  • Pag-cache. Ang 1C ay gumawa ng isang hindi matagumpay na desisyon sa arkitektura, na ipinakilala ang pag-cache lamang sa antas ng mga pamamaraan ng pagtawag ng mga karaniwang module at hindi nagbibigay ng mga kakayahan sa kontrol (panahon ng kaugnayan, i-reset kapag hinihiling).
  • Mga implicit na tawag sa server. Huwag kalimutan ang tungkol sa mga teknolohikal na tampok; maraming "hindi nakakapinsala" na mga operasyon sa kliyente ang pumukaw sa platform upang makipag-ugnay sa server.


Mga kaugnay na publikasyon