Anotasyon: XML Data Schemas (XSD). Paglikha ng XSD schema sa Visual Studio .NET. Paglikha ng na-type na object ng DataSet. Pagkuha ng impormasyon tungkol sa istruktura ng isang object ng DataSet. Naglo-load ng mga XML na dokumento at XSD schema sa mga na-type at regular na DataSet object. Mga pamamaraan ng ReadXml at ReadXmlSchema. Pagre-record ng nilalaman at istraktura ng isang na-type at regular na object ng DataSet. Mga pamamaraan ng WriteXml at WriteXmlSchema

Nag-type ng object ng DataSet. Pagbasa at pagsulat ng mga XML na dokumento

XML Data Schemas (XSD)

Mga schema ng data 1 Eksaktong pagsasalin ng XML Schema Document -< XML na schema ng dokumento>, gayunpaman, patuloy naming gagamitin ang terminong "XML data schema". Ang XSD (XML Schema Document, XSD) ay isang alternatibong paraan ng pagbuo ng mga panuntunan para sa mga XML na dokumento. Kung ikukumpara sa mga DTD, mas makapangyarihan ang mga schema para sa pagtukoy ng mga kumplikadong istruktura ng data, nagbibigay ng mas malinaw na paraan upang ilarawan ang grammar ng isang wika, at madaling ma-moderno at mapalawak. Ang XSD schema ay maaaring maglaman ng sumusunod na impormasyon:

• representasyon ng mga relasyon sa pagitan ng mga elemento ng data, katulad ng mga dayuhang pangunahing relasyon sa pagitan ng mga talahanayan sa isang relational database;
• representasyon ng mga natatanging identifier na katulad ng isang pangunahing key;
• pagtutukoy ng uri data para sa bawat indibidwal na elemento at katangian sa isang XML na dokumento.

Upang lumikha ng schema ng data sa Visual Studio .NET, pumunta sa File\New\File sa pangunahing menu at piliin ang XML Schema mula sa listahan ng mga template (tingnan ang Fig. 11.3). Lumilitaw ang isang window na nagsasabing "Upang magsimula, i-drag ang mga bagay mula sa Server Explorer o Toolbox window papunta sa workspace (design area) o right-click" (Figure 11.1):

kanin. 11.1.

Ang punto ay nasa design mode tayo. Lumipat sa code mode sa pamamagitan ng pag-click sa button (XML):

Ang unang linya ay ang pamilyar na indikasyon na ang schema ay isang XML na dokumento na may root element xs:schema . Ang xs prefix: prefix ang lahat ng elemento ng schema upang isaad ang namespace nito. Ang pangalawang linya ay naglalaman ng mahaba, detalyado at kadalasang ganap na hindi kinakailangang paglalarawan ng schema (ihambing sa katulad na code para sa mga HTML na pahina). Para sa tamang operasyon, sapat na upang limitahan ang iyong sarili sa sumusunod na representasyon:

Gayunpaman, ipinapalagay ng mga built-in na visualization tool ng studio ang pagkakaroon ng "header" na ito, kaya hindi ito dapat alisin. Ang paggawa ng schema na naglalarawan sa isang naibigay na XML na dokumento sa Visual Studio .NET ay isang medyo simpleng gawain. Gawin natin ang sumusunod na XMLEasy.xml na dokumento:

1

Lumipat kami sa tab na (Data) at nakikita lamang ang isang entry (Fig. 11.2).

kanin. 11.2.

Maaari kang lumikha ng isang schema na naglalarawan sa dokumentong ito sa maraming paraan: sa pangunahing menu, piliin ang item na "XML \ Lumikha ng Schema" (Larawan 11.3, A), sa XML mode, piliin ang parehong item sa menu ng konteksto (Fig. 11.3, B), sa XML mode, piliin ang parehong item sa menu ng konteksto (Fig. 11.3, B), sa Data, piliin ang item na ito sa menu ng konteksto (Fig. 11.3, C), at sa wakas, sa Data mode, mag-click sa pindutan ng XML toolbar (Larawan 11.3, D).

kanin. 11.3.

Sa anumang kaso, lumilitaw ang balangkas ng dokumento sa anyo ng isang talahanayan (Larawan 11.4). Umalis tayo sa Schema mode sa ngayon at lumipat sa (XML) mode.

kanin. 11.4.

Ang kapaligiran ay nakabuo ng XML code na naglalarawan sa istraktura ng dokumento:

Kasama rin dito ang paglalarawang kailangan upang higit pang manipulahin ang schema gamit ang ADO .NET objects. Sa pinagmumulan ng XMLEasy.xml na dokumento, lumitaw ang isang link sa schema ng data:

Ang XMLEasy.xsd na dokumento ay awtomatikong ginawa sa parehong direktoryo kung saan matatagpuan ang XMLEasy.xml.

Upang matutunang maunawaan ang mga XSD schema, dapat mo munang gamitin ang paglalarawan ng data sa purong anyo nito, nang walang karagdagang mga elemento. Ang talahanayan 11.1 ay nagpapakita ng ilang simpleng XML na dokumento at ang kanilang mga schema, na nabuo nang hindi nagbubuklod sa ADO .NET na mga bagay.

Talahanayan 11.1. Mga halimbawa ng paggawa ng XSD schema

Mga nilalaman ng XML na dokumento	Mga Nilalaman ng XSD Schema
1
Paglalarawan
Sa isang XMLEasy.xml na dokumento, ang TOUR element ay ang root element na naglalaman ng IDTOUR child element. Ang pangkalahatang pamamaraan para sa elemento ng ugat ay ang mga sumusunod: : Nilalaman ng elemento... Ang mga elemento ng bata ay inilarawan tulad nito:
Mga nilalaman ng XML na dokumento	Mga Nilalaman ng XSD Schema
1 Cyprus RUB 25,000.00 Kasama sa presyo ng dalawang adult voucher ang presyo ng isang bata (hanggang 7 taong gulang) 2 Greece RUB 32,000.00 May mga espesyal na diskwento sa Agosto at Setyembre 3 Thailand RUB 30,000.00 Hindi kasama ang airfare 4 Italya RUB 26,000.00 Ang almusal sa hotel ay kasama sa presyo ng paglilibot 5 France RUB 27,000.00 Ang mga karagdagang excursion ay hindi kasama sa presyo ng tour
Paglalarawan
Ang root na elemento ng TABLE ay naglalaman ng elemento ng TOUR, na binubuo naman ng isang pangkat ng mga elemento ng bata. Kinokontrol ng pagpipiliang elemento ang pagpili ng iba pang mga elemento, na may "unbounded" na halaga ng maxOccurs attribute na nagsasaad na ang mga pangkat ng TOUR ay maaaring walang limitasyon. : :
Mga nilalaman ng XML na dokumento	Mga Nilalaman ng XSD Schema
1 Cyprus RUB 25,000.00 1 Kasama sa presyo ng dalawang adult voucher ang presyo ng isang bata (hanggang 7 taong gulang)	kanin. 11.5.
Paglalarawan
Ang uri ng data ng elemento ng IDTOUR ay itinakda sa int , ang uri ng data ng CLOSED na elemento ay itinakda sa boolean , at ang iba ay itinakda sa default na uri ng data ng string. Maaari mong baguhin ang uri ng data nang direkta sa XML data schema mode, ngunit mas maginhawang gamitin ang Schema mode (sa kasong ito ang mode ay tatawaging DataSet) piliin ang uri ng data mula sa drop-down list (Fig. 11.5) :

Sa software ng kurso ay makikita mo ang lahat ng mga file para sa talahanayang ito sa XSD folder (Code\Glava5\XSD).

Ang pagtatakda ng uri ng data sa isang XML na dokumento (Ang Talahanayan 11.1 ay ang pinakabagong halimbawa) ay isang paraan upang limitahan ang nilalaman. Ginagamit ang mga karagdagang katangian upang hadlangan ang halaga ng isang partikular na uri. Sa sumusunod na fragment ng schema, ang halaga ng elemento ng PRICE ay dapat nasa pagitan ng 50 at 100:

Upang limitahan ang isang XML na dokumento sa ilang mga fixed value, gamitin ang sumusunod na construct:

Dito ang elemento ng NAME ay maaari lamang kumuha ng isang nakapirming halaga sa limang pangalan ng bansa.

Ang pagbuo ng XSD schema ay medyo maraming trabaho. Ang mga visual na tool sa Visual Studio .NET ay ginagawang mas madali ang gawaing ito. Upang makabisado ang mga pangunahing konsepto, ipinapayong matuto ng ilang awtomatikong nabuong XML na mga schema ng dokumento. Ang mga talahanayan 11.2-11.4 ay nagbibigay ng paglalarawan ng mga pangunahing elemento at katangian na maaaring makatagpo.

Talahanayan 11.2. Mga Elemento ng XSD Schema

Elemento	Paglalarawan
lahat	Maaaring tukuyin ang mga nested na elemento sa anumang pagkakasunud-sunod
anotasyon	Magulang na elemento ng mga elemento ng komento At
anuman	Anumang mga nested na elemento
anumangKatangian	Anumang mga katangian
appInfo	Elemento ng komento. Tinutukoy ang pamagat ng schema
katangian	Katangian
attributeGroup	Pangkat ng katangian
pagpili	Pagpili ng iba pang mga elemento. Analogue ng operator na "|" sa DTD
kumplikadong Nilalaman	Mga paghihigpit o mga extension ng modelo kumplikadong uri ng nilalaman
complexType	Kumplikadong elemento
dokumentasyon	Elemento ng komento. Nagbibigay ng impormasyon tungkol sa schema
elemento	Elemento
extension	Mga extension ng elemento
patlang	Deklarasyon sa larangan. Nalalapat sa loob ng isang elemento upang tukuyin ang mga patlang
pangkat	Grupo ng mga elemento
angkat	Pag-import ng uri ng deklarasyon mula sa isa pang schema
isama	Kasama ang ibang schema sa isang umiiral nang namespace
susi	Pagtukoy ng elemento o katangian na may susi na tumuturo sa isa pang elemento
keyref	Pagtukoy sa elemento o katangian na itinuturo ng susi
listahan	Isang elemento na maaaring maglaman ng isang listahan ng mga halaga
muling tukuyin	Ino-override ang mga naideklara nang elemento
paghihigpit	Element constraint
schema	Elemento ng ugat ng scheme
tagapili	Selector para sa pagpili ng mga elemento ng XML
pagkakasunod-sunod	Pagkakasunud-sunod ng iba pang mga elemento. Analog ng operator "," sa DTD
simpleng Nilalaman	Isang modelo na ang mga nilalaman ay kumakatawan lamang sa data ng character
simpleType	Simpleng elemento
unyon	Isang elemento o katangian na maaaring magkaroon ng maraming kahulugan
kakaiba	Isang elemento o katangian na dapat ay may natatanging halaga

Talahanayan 11.3. Mga Katangian - Mga Limitasyon ng XSD Schema

Katangian	Paglalarawan
enumeration Listahan ng mga halaga
haba	Ang haba
maxLength	Pinakamataas na haba
minLength	Minimum na haba
maxExclusive	Pinakamataas na halaga
maxInclusive	Kasama ang maximum na halaga
minExclusive	Pinakamababang halaga
minInclusive	Kasama ang minimum na halaga
fractionDigits	Bilang ng mga decimal na lugar sa mga fractional na numero
kabuuangDigit	Bilang ng mga digit
pattern	Sample (pattern) ng mga nilalaman ng elemento
default	Default na elemento o value ng attribute
elementFormDefault	Pagtatakda ng mga katangian ng isang lokal na elemento bilang globally na tinukoy
nakapirming	Nakapirming halaga ng elemento o katangian
anyo	Ang mga lokal na ipinahayag na elemento ay tinukoy sa mga partikular na pagkakataon ng dokumento
itemType	Uri ng Item ng Listahan
memberTypes	Uri ng mga miyembro na ginagamit sa unyon
maxOccurs	Pinakamataas na bilang ng mga paglitaw ng isang elemento
minNangyayari	Minimum na bilang ng mga paglitaw ng isang elemento
magkakahalo	Pagtukoy ng elementong may halo-halong uri
pangalan	Pangalan ng elemento o katangian
namespace	Namespace
walangNamespace	Tinutukoy ang lokasyon ng dokumentong eskematiko,
SchemaLocation	walang nagreresultang mga namespace
nillable	Ang pagtukoy na ang isang elemento ay maaaring magkaroon ng walang laman na NULL value (nil)
ref	Pagtatakda ng isang reference sa isang globally tinukoy na elemento
schemaLocation	Paghanap ng circuit
substitutionGroup	Pagtukoy sa pagpapalit ng mga elemento sa iba pang mga elemento
targetNamespace	Nagreresultang schema namespace
uri	Uri ng item
gamitin	Kinakailangan ba ang elemento o hindi?
halaga	Halaga ng elemento ng eskematiko
xsi:wala	Pagtatakda ng aktwal na nilalaman ng isang null (NULL) na elemento sa isang XML na dokumento
xsi:schemaLocation	Ang aktwal na lokasyon ng elemento sa XML na dokumento
xsi:type	Ang aktwal na uri ng elemento sa XML na dokumento

Ang gawain ng paglikha ng isang XML file batay sa isang XSD schema ay lumitaw. Ang paghahanap sa mga forum ay humantong sa isang malaking bilang ng mga talakayan na may kaugnayan sa isang hindi pagkakaunawaan sa proseso, at lamang ng ilang mga artikulo na nagpapaliwanag ng kakanyahan. Ang mga tao ay nagtanong, nakipaglaban sa solusyon, ngunit pagkatapos ng problema ay sumuko sa kanila, sila ay nawala nang hindi inilalarawan ang mekanismo. Nag-udyok ito sa paglikha ng isang simpleng paglalarawan ng proseso.
P.S. Huwag masyadong manumpa, ang layunin ko ay hindi lumikha ng ilang uri ng siyentipikong artikulo na mahigpit na gumagamit ng tamang terminolohiya, ngunit tumulong lamang na gawin ang unang hakbang patungo sa pag-unawa sa napakalakas na mekanismo ng palitan sa pamamagitan ng XML.
P.P.S. Kailangan kong magpareserba kaagad na ang pag-upload ng file na naka-attach sa artikulo ay isang template lamang na lumilikha lamang ng bahagi ng kinakailangang istruktura ng XML file, dahil ang aking trabaho sa pag-download na ito ay medyo pang-edukasyon sa kalikasan (pagkopya ng nakaraang dokumento sa pag-export sa website ng FCS at ang pag-download lamang ng tabular na bahagi ng Mga Produkto mula sa isang Excel file ay tila isang mas epektibong solusyon), at ang kakulangan ng oras ay hindi nagpapahintulot sa akin upang kumpletuhin ang paglikha ng buong istraktura, batay lamang sa mga pagsasaalang-alang ng pagiging perpekto.

Kaya, nang nakarehistro sa website ng FCS, naging malinaw na upang lumikha ng mga dokumento ng Pag-uulat ng Istatistika sa mga pag-export, kinakailangan na mag-download ng data mula sa mga dokumento ng Pamamahala ng Kalakal ng Mga Pagbebenta ng Mga Kalakal at Serbisyo at lumikha ng isang file para sa pag-download.

Mayroong dalawang posibleng opsyon sa pag-download.

Una: pag-load ng tabular na bahagi ng Mga Produkto mula sa isang Excel file (ang opsyon na ito ay pinili bilang isang gumaganang opsyon, dahil mayroon itong mga pakinabang na hindi na kailangang mag-abala sa pagproseso ng "Header" ng dokumento, ngunit maaari mo lamang kopyahin ang nauna, binabago ito sa "Header" "kung ano ang kinakailangan).

Pangalawa: paglikha ng isang XML file ayon sa scheme na na-download mula sa website ng FCS sa anyo ng isang "Album ng mga format para sa mga form ng electronic na dokumento". Ang album ay naglalaman ng medyo malaking bilang ng mga XSD scheme. Nakakita sila ng diagram ng "Statistical Form for Accounting for the Movement of Goods" at mga karagdagang file na may mga paglalarawan ng mga uri para dito. Ang mga diagram ay naka-attach sa artikulo sa archive na may pagproseso.

Upang tingnan ang mga XSD schema, ginamit namin ang libreng Microsoft XML Notepad 2007.

Ipinapakita ng larawan ang pangunahing file na may XSD schema na "Statistical form para sa accounting para sa paggalaw ng mga kalakal." Itinatampok ng larawan ang mga pangunahing bloke ng XSD scheme na kailangan nating maunawaan ito.

Mula sa diagram, malinaw na kailangan nating kumuha ng XML file na puno ng istraktura na tinukoy sa "xs:element" na sangay ng uri ng StaticFormType.

Ang istraktura ay maaaring medyo kumplikado (tulad ng sa aming kaso). Sa mga paglalarawan ng uri na naroroon nang direkta sa sangay, inilagay sa isang hiwalay na sangay, o kahit na matatagpuan sa ibang file.

Ang istrakturang ito ay may isang uri ng StaticFormType, na kung saan ay binubuo ng isang baseng uri na BaseDocType, isang hanay ng mga bagay na may iba't ibang uri at mga katangian ng teksto.

Ang baseng uri na BaseDocStyle ay tinukoy sa ibang file (at namespace)
.

Ang file na ito ay naglalaman ng maraming uri na hindi ginagamit sa aming kaso.

Ngayon, magpatuloy tayo sa pagtatrabaho sa 1C. Sa madaling sabi, ang kailangan nating gawin ay bumaba sa mga sumusunod:

1. Ginagawa ang XDTO Factory

OurFactoryXDTO = CreateFactoryXDTO(ArrayFullFileNamesWithXSDSchemas);

2. Sa pabrika ng XDTO, nilikha ang lahat ng kumplikadong uri ng data, na pagkatapos ay pupunan namin ang nilikhang XML file:

StaticFormType = MyFactoryXDTO.Type("urn:customs.ru:Information:CustomsDocuments:StaticForm:5.4.0", "StaticFormType");

Ang mga uri ng data na kasama sa isang partikular na uri ay maaaring makuha mula sa koleksyon ng mga katangian nito:

CUOrganizationType = StaticFormType.Properties.Get("Consignee").Type; NameType = CUOrganizationType.Properties.Get("OrganizationName").Type; ShortNameType = CUOrganizationType.Properties.Get("ShortName").Type; LanguageCodeType = CUOrganizationType.Properties.Get("OrganizationLanguage").Type;

3. Kapag nagawa na ang lahat ng kumplikadong uri ng data, lumikha kami ng istraktura ng XML file batay sa mga ito, na binubuo ng mga bagay ng XDTO Factory:

StaticFormType_XDTOObject = MyXDTOFactory.Create(StaticFormType); // collection with documents NewDocuments = MyFactoryXDTO.Create(DocumentsType); NewDocuments.PrDocumentName = MyFactoryXDTO.Create(PrDocumentNameType, "Waybill"); NewDocuments.PrDocumentNumber = MyFactoryXDTO.Create(PrDocumentNumberType, "123-number"); NewDocuments.PrDocumentDate = MyFactoryXDTO.Create(PrDocumentDateType, "2014-10-05"); StaticFormType_XDTO.Documents.Add(NewDocuments);

Kasabay nito, punan ang elementarya (mga simpleng uri) na detalye.

4. At sa wakas, ibinababa namin ang lahat mula sa XDTO Factory sa isang file:

XML File = Bagong XML Entry(); FileXML.OpenFile(FileName); FileXML.WriteXMLDeclaration(); MyXDTOFactory.WriteXML(XMLFile, StaticFormType_XDTOObject); FileXML.Close();

P.S. Naglalaman ang archive ng upload template file sa XML (ilang mga detalye lang ang ginawa, na sumasalamin sa lahat ng kaso kung saan napunan ang file) at XSD schema.

I-unzip ang lahat ng mga file sa isang partikular na direktoryo.

Ang XML ay malilikha sa loob nito.

Ang format ng XML ay napakapopular kapag nagpapalitan ng iba't ibang mga dokumento ng teksto sa pagitan ng mga sistema ng impormasyon. Ang kakayahang lumikha ng isang natatanging istraktura para sa mga dokumento ay nagpapahintulot na magamit ito sa maraming lugar - mga electronic na aklatan, WEB, import/export, at marami pang iba. Kung wala ang kakayahang maginhawang gumana sa format na ito, ang mga 1C system ay hindi magkakaroon ng ganoong katanyagan. Dahil ang 1C ay aktibong gumagamit ng mga teknolohiya ng WEB, dapat na mabasa ng bawat developer ang XML at magsulat ng impormasyon dito.

XML File Representation at Pagbasa

Ang isa sa mga pangunahing bentahe ng XML markup language ay ang medyo maginhawa at intuitive na istraktura at syntax nito. Kapag nililikha ito, nagtakda ang mga may-akda ng layunin na lumikha ng isang markup language na madaling basahin ng parehong mga tao at mga computer. Ngayon, ang XML ay malawakang binuo sa iba pang mga format, ngunit nananatiling popular at malawakang ginagamit. Ang istraktura ng XML file ay binuo ayon sa sumusunod na pamamaraan:

Upang isaalang-alang ang isang halimbawa ng pag-import ng data sa 1C, ang file na ipinakita sa itaas ay magiging sapat. Upang mabasa ng nakasulat na pamamaraan ang XML file, sapat na upang ipasa ang path sa mismong file dito. Magagawa ito sa pamamagitan ng interface, na nagpapahintulot sa mga user na tukuyin ang file mismo, o sa pamamagitan ng hard-coded processing sa text.

Ang isa sa mga sikat na paraan upang gumana sa XML hanggang sa 100 MB ang laki sa 1C ay ang paggamit ng Document Object Model (DOM). Ang kahulugan nito ay sunud-sunod na iproseso ang lahat ng mga node ng dokumento na kinakatawan sa XML. Sa built-in na 1C na wika, ganito ang hitsura ng algorithm na ito:

1. Deklarasyon ng mga mekanismo kung saan binabasa ang XML file; I-loop upang tumawid sa mga node;
2. Pagbabasa ng data at mga katangian sa isang node;
3. Output ng impormasyon. Kung kinakailangan, sa yugtong ito ang pagsulat ay maaaring mangyari sa mga variable o direkta sa mga kinakailangang talahanayan;
4. Pagkumpleto ng mekanismo.

&OnServer Procedure ReadOnServer(PathToFile) //deklarasyon ng mga mekanismo Reading Mechanism = New ReadingXML; Reader.OpenFile(PathToFile); Tagabuo = Bagong BuilderDOM; Dokumento = Builder.Read(Reader); //loop to traverse nodes Para sa bawat elemento Mula sa Document.DocumentElement.ChildrenNodes Loop //pagbabasa ng data Kung element.NodeName = "Produkto" Pagkatapos product = element; Para sa bawat halaga Mula sa produkto.ChildrenNodes Cycle If values.NodeName = "Pangalan" pagkatapos Name = values; Kulay = Name.Attributes.GetNamedElement("Kulay"); ElseIf values.NodeName = "Price" then Cost = values; Currency = Cost.Attributes.GetNamedItem("Currency"); tapusin kung; EndCycle; //output messages Notify("Pangalan: " + Name.TextContent + "; color: "+Color.Value +"; Presyo: "+Cost.TextContent + "; Currency: "+Currency.Value); tapusin kung; EndCycle; //closing the mechanism Non-MechanismReading.Close(); EndProcedure

Bilang resulta, nagpapakita kami ng mga mensahe sa user na may na-import na data. Maaari mo ring ilagay ang lahat ng data sa nais na istraktura at, batay dito, i-program ang paglikha ng isang dokumento o mga entry sa direktoryo. Ang bilis ng 1C na gumana sa xml ay medyo mataas, kaya ang format na ito ay lalong ginagamit kapag nakikipagpalitan ng data sa iba pang mga mapagkukunan.

Upang mag-upload ng impormasyon, kakailanganin din naming makipag-ugnayan sa mga XML file. Tingnan natin ang isang halimbawa ng isang talaan gamit ang 1C platform object XML Record at mag-upload ng data sa item. Ang pangunahing bentahe nito ay ang pagiging simple ng code at ang bilis ng pagproseso ng data. Ang server-side algorithm para sa pagsusulat ng XML file ay maaaring katawanin bilang ilang sunud-sunod na mga hakbang:

1. Kumonekta sa xml file;
2. Lumilikha kami ng mga elemento ng ulo at sumulat ng data sa kanila. Kung nais mong mag-upload ng isang malaking halaga ng impormasyon sa isang XML file, pagkatapos ay sa yugtong ito ay gagamit ka ng mga loop. Mag-ingat at tandaan na ang kahilingan ng data ay dapat gawin bago ang loop, at hindi sa loob nito;
3. Isara ang file.

//buksan ang file na Nomenclatura.xml at isulat ang head element RecordVFile = New RecordXML(); WriteToFile.OpenFile("D:\Nomenclatura.xml", "UTF-8"); WriteInFile.3writeStartItem("Mga Produkto"); //select data for the record SelectionFromDirectory = Directories.Nomenclature.Select(); //cycle kung saan nagaganap ang pagre-record Habang SelectingFromDirectory.Next() cycle //writing new data RecordToFile.RecordStartofElement("Product"); RecordInFile.RecordAttribute("Pangalan", SelectionFromDirectory.Name); WriteToFile.WriteAttribute("InitialPrice", Line(SelectionFromDirectory.InitialPrice)); WriteToFile.WriteEndElement(); EndCycle; //Isara ang head element at ang file na WriteVFile.WriteEndElement(); WriteInFile.Close();

XDTO mekanismo sa 1C

Ang mga developer ng kumpanya ng 1C ay lumikha ng kanilang sariling mekanismo para sa pagpapalitan ng impormasyon sa pamamagitan ng XML - XDTO (XML Data Transfer Objects). Simula sa bersyon 8.1, ang platform ay may kakayahang makipagpalitan ng data sa iba pang mga system nang hindi nagsasaliksik sa mga isyu ng pagbuo ng XML file. Karamihan sa mga teknikal na isyu ay inaasikaso ng 1C, at ang kailangan lang nating gawin ay ipahiwatig ang data na kinakailangan upang makabuo ng XML. Totoo, para dito ang developer ay kailangang gumawa ng ilang mga manipulasyon nang maaga.

Upang mag-load ng XML file gamit ang XDTO, dapat nating sabihin sa 1C ang istraktura ng file. Ito ay ipinadala sa pamamagitan ng isang hanay ng mga diagram na maaaring malikha sa isang text editor o gamit ang isang dalubhasang programa. Dapat ilarawan ng resultang file ang pangkalahatang istraktura at mga uri ng data na ginagamit sa XML file. Bago magbasa o magsulat ng bagong XML, dapat i-load ng developer ang schema nito sa configuration sa ilalim ng XDTO Packages.

Sa kasong ito, gagawa kami ng isang simpleng pakete sa pamamagitan ng kamay upang maunawaan ng 1C ang istraktura ng aming halimbawang file. Upang matagumpay na makumpleto ang pagbuo ng file, kailangan nating ipakita sa schema na mayroon tayong head element at isang attachment na may mga attribute. Ang ginawang schema ay dapat na i-export sa isang file sa xsd na format at ilipat kasama ng xml, upang ang kabilang partido ay hindi na kailangang harapin ang istraktura at likhain muli ang xdto package.

Ang isang algorithm ng server na katulad ng nauna ay makakatulong sa iyong i-save ang bagong XML sa iyong hard drive. Ang pagkakaiba lamang ay ang pangangailangan na magdagdag ng data para sa 1 produkto sa pabrika ng XDTO - isang espesyal na mekanismo ng 8.3 1C platform. Kung may pangangailangan na lumikha ng higit pang mga antas ng nesting, kakailanganin mong ilarawan ang bawat elemento ng ulo.

//Buksan ang XML file RecordVFile = Bagong RecordXML; WriteToFile.OpenFile("D:\Nomenclatura.xml", "UTF-8"); //Ipahiwatig sa 1C kung anong uri ng data ang dapat gawin - head element AllProducts = FactoryXDTO.Create(FactoryXDTO.Type("http://wiseadviceXML.org","Products")); //select data para sa pag-upload ng SelectionFromDirectory = Directories.Nomenclature.Select(); //Add individual products to the head element While Select from the Directory.Next() cycle Product = FactoryXDTO.Create(FactoryXDTO.Type("http://wiseadviceXML.org","Product")); Product.Name = Pumili mula sa Directory.Name; Product.InitialPrice = String(SelectionFromDirectory.InitialPrice); AllProducts.Add(Product); EndCycle; //isulat ang data at isara ang file FactoryXDTO.WriteXML(WriteToFile, AllProducts); WriteInFile.Close();

Ang mga mekanismo na isinasaalang-alang ay medyo pangkalahatan at, kung maayos na na-configure, maaaring malutas ang karamihan sa mga problema. Gayunpaman, mayroong maraming mga nuances sa pakikipag-ugnayan sa pagitan ng 1C at XML. Mas epektibong pag-aralan ang mga ito sa totoong mga kundisyon, at hindi sa mga pagsubok na gawain kung saan ang pagpoproseso ng isang XML file ay malulutas ang medyo makitid na mga problema.

Ipapakita sa iyo ng kabanatang ito kung paano magsulat ng mga XML schema. Matututuhan mo rin na ang diagram ay maaaring isulat sa iba't ibang paraan.

XML na Dokumento

Tingnan natin ang XML na dokumentong ito na tinatawag na "shiporder.xml":

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="shiporder.xsd">
John Smith

Ola Nordmann

Langgt 23

4000 Stavanger
Norway



Espesyal na Edisyon
1
10.90



1
9.90

Ang XML na dokumento sa itaas ay binubuo ng root element, "shiporder", na naglalaman ng kinakailangang attribute na tinatawag na "orderid". Ang elementong "shiporder" ay naglalaman ng tatlong magkakaibang elemento ng bata: "orderperson" , "shipto" at "item" . Ang elementong "item" ay lilitaw nang dalawang beses, at naglalaman ito ng elemento ng "pamagat", isang opsyonal na elemento ng "tala", isang elemento ng "dami", at isang elemento ng "presyo".

Ang linya sa itaas: Xmlns: XSI="http://www.w3.org/2001/XMLSchema-instance" ay nagsasabi sa XML parser na ang dokumentong ito ay dapat ma-validate ang schema. Line: XSI: noNamespaceSchemaLocation = "shiporder.xsd" ay nagpapahiwatig kung saan matatagpuan ang mga schematics (narito ito sa parehong folder bilang "shiporder.xml") .

Paglikha ng XML Schema

Ngayon gusto naming lumikha ng isang schema para sa XML na dokumento sa itaas.

Magsisimula tayo sa pagbubukas ng bagong file, na tatawagin nating "shiporder.xsd". Upang lumikha ng isang schema, maaari lang nating sundin ang istruktura sa XML na dokumento at tukuyin ang bawat elemento habang nakikita natin ito. Magsisimula tayo sa isang karaniwang deklarasyon ng XML na sinusundan ng isang elemento ng xs:schema na tumutukoy sa schema:

...

Sa schema sa itaas ay gumagamit kami ng mga karaniwang namespace (xs), at ang URI na nauugnay sa namespace na ito ay ang schema language definition, na mayroong karaniwang value na http://www.w3.org/2001/XMLSchema.

Susunod, kailangan nating tukuyin ang isang "shiporder" na elemento. Ang elementong ito ay may katangian at naglalaman ng iba pang elemento, kaya itinuturing namin ito bilang isang kumplikadong uri. Ang mga child element ng isang "shiporder" na elemento ay napapalibutan ng isang xs: sequence element na tumutukoy sa isang ordered sequence ng mga subelement:

...

Pagkatapos ay dapat nating tukuyin ang elementong "orderperson" bilang isang simpleng uri (dahil hindi ito naglalaman ng anumang mga katangian o iba pang elemento). Ang uri (xs:string) ay may prefix na namespace na prefix na nauugnay sa XML Schema, na tumutukoy sa isang paunang natukoy na uri ng data ng schema:

Sa tulong ng mga scheme matutukoy namin ang bilang ng mga posibleng paglitaw para sa isang elementong may mga katangian ng MaxOccurs at MinOccurs. Tinutukoy ng MaxOccurs ang maximum na bilang ng mga paglitaw para sa isang elemento at ang MinOccurs ay tumutukoy sa pinakamababang bilang ng mga paglitaw para sa isang elemento. Ang default na halaga para sa parehong MaxOccurs at MinOccurs ay 1!

Ngayon ay maaari nating tukuyin ang "item" na elemento. Maaaring lumitaw ang elementong ito nang maraming beses sa loob ng elementong "shiporder". Natutukoy ito sa pamamagitan ng pagtatakda ng maxOccurs attribute ng "item" na elemento sa "unbounded" , na nangangahulugang maaaring magkaroon ng maraming paglitaw ng "item" na elemento ayon sa gusto ng may-akda. Tandaan na ang elementong "tala" ay opsyonal. Tinukoy namin ito sa pamamagitan ng pagtatakda ng katangian ng minOccurs sa zero:

Ngayon ay maaari na nating ideklara ang katangiang "shiporder" ng elemento. Dahil ito ay isang kinakailangang katangian, tinukoy namin ang use="required".

Tandaan: Ang mga pahayag ng katangian ay dapat palaging nasa huli:

Narito ang kumpletong listahan ng schema file na tinatawag na "shiporder.xsd":

Mga hiwalay na circuit

Ang nakaraang paraan ng disenyo ay napaka-simple, ngunit maaaring mahirap basahin at panatilihin kapag ang mga dokumento ay kumplikado.

Ang susunod na paraan ng disenyo ay batay sa pagtukoy sa lahat ng mga elemento at katangian at pagkatapos ay i-refer ang mga ito gamit ang katangian ng ref.

Narito ang bagong disenyo ng schematic file ("shiporder.xsd"):

Paggamit ng Mga Pinangalanang Uri

Ang ikatlong paraan ng disenyo ay tumutukoy sa mga klase o uri, na nagpapahintulot sa mga kahulugan ng elemento na muling magamit. Ginagawa ito sa pamamagitan ng pagbibigay ng pangalan sa mga elemento na simpleTypes at complexTypes, at pagkatapos ay tinutukoy ang mga ito sa pamamagitan ng attribute ng uri ng elemento.

Narito ang pangatlong disenyo ng schematic file ("shiporder.xsd"):

Isinasaad ng constraint element na ang uri ng data ay nagmula sa W3C XML Schema data type namespace. Kaya ang sumusunod na snippet ay nangangahulugan na ang halaga ng elemento o katangian ay dapat na ang halaga ng isang string:

Ang elemento ng pagpilit ay mas madalas na ginagamit upang maglapat ng mga paghihigpit sa mga elemento. Tingnan ang mga sumusunod na linya mula sa diagram sa itaas:

Tinutukoy nito na ang value ng elemento o attribute ay dapat na isang string, dapat itong eksaktong anim na character bawat linya, at ang mga character na iyon ay dapat na isang numero sa pagitan ng 0 at 9.

Ang XDTO ay isang 1C na mekanismo na kailangan kapag gumagawa at gumagamit ng mga serbisyo sa web sa 1C.

Binibigyang-daan ka ng mga pakete ng XDTO 1C na ilarawan ang istruktura ng kinakailangang XML file para sa pag-convert ng data sa at mula sa XML.

Para sa mga interesado, tingnan natin ang tanong nang mas detalyado.

Ang mga XML file ay ipinapadala sa Internet at maaaring basahin ng maraming mga programa.

Ang mga ito ay pinaghihinalaang - nangangahulugan ito na ito ay naka-hardwired sa kanilang code - kung makakita ka ng isang tiyak na pangalan ng elemento sa XML file - maramdaman ito nang ganito at gawin ito.

Samakatuwid, kung gagamitin namin ang pangalan ng elemento na Apple, kung gayon mayroong isang medyo mataas na pagkakataon na ang ibang programa ay maaaring "mag-isip" na ito ang Apple na alam nito, ngunit ang ibig naming sabihin ay isang bagay sa aming sarili.

Upang maiwasang mangyari ito at upang malinaw na ipahiwatig na ang aming Apple ay naiiba sa lahat ng iba, ang pangalan ng namespace ay maaaring tukuyin sa file - isang prefix na ginagamit bago ang pangalan ng mga elemento.

Ang namespace (sa English namespace) ay tinukoy tulad nito - xmlns:SpaceName = "URL", halimbawa:
xmlns:store = "http://store.ru"

Bakit kailangan mo ng URL?

Samakatuwid, ang isang natatanging identifier ay tinukoy, na kinikilala din ang may-akda ng namespace.

Natural, ipinapalagay na ang taong nagpahiwatig ng namespace ay isang napakatapat na tao at ipinahiwatig ang kanyang site at hindi gumagamit ng maraming iba't ibang namespace sa isang site.

Sa pamamagitan ng paraan, karaniwan nilang ipinapahiwatig hindi lamang ang URL ng site, ngunit ang URL ng isang partikular na folder sa site, upang kung may mangyari, maaari kang lumikha ng isa pang namespace sa isa pang folder sa site para magamit sa ibang sitwasyon.

Ang isang bagay ay isang tiyak na istraktura ng data, sapat sa sarili, na naglalaman ng lahat ng data nito.

Dahil ang nakabalangkas na data ay inilarawan sa XML, iyon ay, sa anyo ng isang istraktura na may sariling mga katangian, atbp., maaari silang tingnan bilang mga bagay.

Sa ibinigay na halimbawa, maaaring ito ay isang LIST object na may property at nested na elemento.

Ang DOM ay isang paraan ng pagtrato sa isang XML file hindi bilang teksto sa isang partikular na format, ngunit bilang isang koleksyon ng mga bagay na may mga katangian, field, at iba pa.

Paglalarawan ng XML file

Kung patuloy kaming gumagamit ng isang file ng isang tiyak na istraktura upang makipagpalitan sa pagitan ng dalawang programa, malamang na gusto naming:

• Upang magkaroon ng ilang mga pangalan na ginamit
• Upang magkaroon ng mga elementong iyon na inaasahan namin (na "dapat naroroon upang magamit sa aming palitan")
• Upang ang mga katangian ay naglalaman ng mga uri na inaasahan namin (string, numero, atbp.).

Ang mga sumusunod na pamantayan ng format ng file ay umiiral upang ilarawan ang istraktura ng XML (na nakaimbak din sa isang plain text file):

• DTD extension – Kahulugan ng Uri ng Dokumento
• XSD extension – XML Shema.

Ang parehong mga format ay naglalarawan kung ano dapat ang dokumento. Ang pamamaraan para sa pagsuri kung ang XML ay sumusunod sa pamantayang inilarawan sa naturang file ay tinatawag na pagpapatunay.

Ang XDTO 1C ay isang tool na nagbibigay-daan sa iyong magdagdag ng paglalarawan ng isang XML file sa configuration. O sa halip, hindi ang file ang inilarawan, ngunit ang mga partikular na istruktura ng XML.

Upang ipahiwatig ang mga uri na maaaring gamitin, isang listahan o isang uri ng library ay ginagamit, na tinatawag na XDTO 1C factory.

Tinutukoy ng pabrika na ito ang parehong mga simpleng uri (string, numero, petsa), na karaniwang ginagamit sa ibang mga wika, programa, atbp., ngunit pati na rin ang mga uri ng 1C, na ginagamit sa 1C at sa isang partikular na pagsasaayos.

Ang pabrika mismo ng XDTO 1C ay binubuo ng ilang mga pakete. Ang mga pangunahing uri ay inilarawan sa isang pakete na tinatawag na www.w3.org

Ang kasalukuyang mga uri ng data ng configuration ay inilarawan sa package http://v8.1c.ru/8.1/data/enterprise/current-config

Ang mga uri mismo ay pinangalanan ayon sa pangalan sa configurator na may pagdaragdag ng isang form sa wikang Ingles (CatalogRef, CatalogObject, DocumentRef, DocumentObject), halimbawa:

CatalogObject.Nomenclature

Pagdaragdag ng XDTO 1C package

Ang lahat ng ito ay tiyak na mukhang cool. At hindi pa kami nakakarating sa paksa ng XSLT - isang paraan upang gawing ibang bagay ang mga XML file, gaya ng HTML. Ang paksa ng XML ay napakalaki at mahirap saklawin kahit sa isang hiwalay na aklat.

Ang aming gawain ay unawain na ang XDTO 1C ay nagbibigay-daan sa amin na ilarawan kung anong mga elemento ang isang XML package na kailangang mabuo o basahin.

Ang XDTO 1C packages ay matatagpuan sa configuration sa General/XDTO 1C Packages branch.

Maaari mong idagdag ang XDTO package sa 1C nang manu-mano (cool!), ngunit mas mahusay na makuha ang kaukulang XSD file na may handa na paglalarawan ng scheme.

Ang isang paglalarawan ng XSD schema para sa mga object ng anumang configuration ay maaaring makuha sa pamamagitan ng pag-click sa General/XDTO 1C Packages branch at pagpili sa menu item I-export ang XML configuration schema.

Ang file ay teksto, maaari mong i-edit ito sa Windows Notepad, alisin ang mga hindi kinakailangang bagay na hindi mo kailangan.

Maaari kang magdagdag ng handa na XSD schema sa 1C sa pamamagitan ng pag-right click sa General/XDTO 1C packages branch at pagpili sa Import XML Schema menu item.

Gamit ang mekanismo ng XDTO 1C

Ang pagtatrabaho sa XDTO 1C ay nangangahulugan ng pag-convert ng mga halaga sa at mula sa XML.

Ang gawain ay isinasagawa gamit ang 1C language objects Pagbabasa ng XML/Pagsusulat ng XML.

Kapag nagtatrabaho sa mekanismo ng XDTO 1C, dapat mong ipahiwatig ang pakete na iyong ginagamit. Ito ay maaaring isang karaniwang pakete (tinalakay sa itaas, tingnan ang XDTO) o isang pakete na idinagdag sa pagsasaayos. Nakikilala ang package sa pamamagitan ng URL na tinukoy sa package.

Ang dalawang pangunahing simpleng paraan upang magtrabaho ay:

• Serialization - awtomatikong pag-convert ng mga halaga mula 1C hanggang XML at vice versa
• Paglikha ng isang bagay, pagpuno sa mga patlang nito, pagsulat sa XML (at, nang naaayon, pagbabasa mula sa XML at pagkatapos ay binabasa ang mga patlang nito).

Halimbawa ng serialization ng halaga:
Serializer = Bagong SerializerXDTO(FactoryXDTO);
XML File = Bagong XML Entry();
FileXML.OpenFile("FileName");
Serializer.WriteXML(XMLFile, Value1C);

Halimbawa ng pagbabasa/pagsusulat ng isang bagay:

DirectoryObjectXDTO = FactoryXDTO.Create(FactoryXDTO.Type("http://v8.1c.ru/8.1/data/enterprise/current-config", "CatalogObject.Warehouses"));
FillPropertyValues(DirectoryObjectXDTO, DirectoryLink1C);