Anteckning: XML-datascheman (XSD). Skapa ett XSD-schema i Visual Studio .NET. Skapa ett maskinskrivet DataSet-objekt. Få information om strukturen för ett DataSet-objekt. Laddar XML-dokument och XSD-scheman i maskinskrivna och vanliga DataSet-objekt. ReadXml och ReadXmlSchema metoder. Registrera innehållet och strukturen för ett maskinskrivet och vanligt DataSet-objekt. WriteXml och WriteXmlSchema metoder

Skrivet DataSet-objekt. Läsa och skriva XML-dokument

XML-datascheman (XSD)

Datascheman 1 Exakt översättning av XML Schema Document -< XML-dokumentschema> men vi kommer att fortsätta använda termen "XML-dataschema". XSD (XML Schema Document, XSD) är ett alternativt sätt att konstruera regler för XML-dokument. Jämfört med DTD:er är scheman mer kraftfulla för att definiera komplexa datastrukturer, ger ett tydligare sätt att beskriva ett språks grammatik och kan enkelt moderniseras och utökas. Ett XSD-schema kan innehålla följande information:

• representation av relationer mellan dataelement, liknande främmande nyckelrelationer mellan tabeller i en relationsdatabas;
• representation av unika identifierare som liknar en primärnyckel;
• typspecifikation data för varje enskilt element och attribut i ett XML-dokument.

För att skapa ett dataschema i Visual Studio .NET, gå till File\New\File i huvudmenyn och välj XML Schema från listan över mallar (se Fig. 11.3). Ett fönster visas som säger "För att komma igång, dra objekt från Server Explorer eller Toolbox-fönstret till arbetsytan (designområdet) eller högerklicka" (Figur 11.1):

Ris. 11.1.

Poängen är att vi är i designläge. Växla till kodläge genom att klicka på knappen (XML):

Den första raden är den välbekanta indikationen att schemat är ett XML-dokument med ett rotelement xs:schema . Xs-prefixet: prefix för alla schemaelement för att indikera dess namnområde. Den andra raden innehåller en lång, detaljerad och ofta helt onödig beskrivning av schemat (jämför med liknande kod för HTML-sidor). För korrekt drift räcker det att begränsa dig till följande representation:

Studions inbyggda visualiseringsverktyg förutsätter dock närvaron av denna "header", så den bör inte tas bort. Att skapa ett schema som beskriver ett givet XML-dokument i Visual Studio .NET är en ganska enkel uppgift. Låt oss skapa följande XMLEasy.xml-dokument:

1

Vi byter till fliken (Data) och ser bara en post (Fig. 11.2).

Du kan skapa ett schema som beskriver detta dokument på flera sätt: i huvudmenyn, välj alternativet "XML \ Skapa schema" (Fig. 11.3, A), i XML-läge, välj samma objekt i snabbmenyn (Fig. 11.3, B), i XML-läge, välj samma objekt i snabbmenyn (Fig. 11.3, B), i Data, välj detta objekt i snabbmenyn (Fig. 11.3, C), och slutligen, i Data-läge, klicka på knappen XML i verktygsfältet (Fig. 11.3, D).

I alla fall visas dokumentkonturen i form av en tabell (Fig. 11.4). Låt oss lämna Schema-läge för nu och byta till (XML)-läge.

Miljön genererade XML-kod som beskriver strukturen för dokumentet:

Detta inkluderar också den beskrivning som behövs för att ytterligare manipulera schemat med ADO .NET-objekt. I källdokumentet XMLEasy.xml dök en länk till dataschemat upp:

XMLEasy.xsd-dokumentet skapades automatiskt i samma katalog där XMLEasy.xml finns.

För att lära dig förstå XSD-scheman bör du först arbeta med beskrivningen av data i dess rena form, utan ytterligare element. Tabell 11.1 visar flera enkla XML-dokument och deras scheman, genererade utan bindning till ADO .NET-objekt.

I kursmjukvaran hittar du alla filer för denna tabell i XSD-mappen (Code\Glava5\XSD).

Att ställa in en datatyp i ett XML-dokument (Tabell 11.1 är det senaste exemplet) är ett sätt att begränsa innehållet. Ytterligare attribut används för att begränsa värdet av en given typ. I följande schemafragment måste värdet på PRICE-elementet vara mellan 50 och 100:

För att begränsa ett XML-dokument till vissa fasta värden, använd följande konstruktion:

Här kan NAME-elementet endast ta ett fast värde av fem landsnamn.

Att utveckla ett XSD-schema är ganska mycket arbete. De visuella verktygen i Visual Studio .NET gör denna uppgift mycket enklare. För att behärska de grundläggande begreppen är det lämpligt att lära sig flera automatiskt genererade XML-dokumentscheman. Tabellerna 11.2-11.4 ger en beskrivning av huvudelementen och attributen som kan påträffas.

Uppgiften att skapa en XML-fil baserad på ett XSD-schema dök upp. Att söka på forumen ledde till ett stort antal diskussioner relaterade till ett missförstånd av processen, och endast ett par artiklar som förklarade essensen. Folk ställde frågor, kämpade med lösningen, men efter att problemet gav efter för dem försvann de helt enkelt utan att beskriva mekanismen. Detta föranledde skapandet av en enkel beskrivning av processen.
P.S. Svär inte för mycket, mitt mål var inte att skapa någon slags vetenskaplig artikel med strikt korrekt terminologi, utan att helt enkelt hjälpa till att ta det första steget mot att förstå den mycket kraftfulla utbytesmekanismen via XML.
P.P.S. Jag måste omedelbart reservera att uppladdningsfilen som bifogas artikeln endast är en mall som bara skapar en del av den erforderliga XML-filstrukturen, eftersom mitt arbete med den här nedladdningen var ganska lärorikt (att kopiera det tidigare exportdokumentet på FCS-webbplatsen och bara ladda ner den tabellformade delen av produkterna från en Excel-fil verkade vara en mer effektiv lösning), och bristen på tid tillät inte mig att slutföra skapandet av hela strukturen, endast baserat på överväganden om perfektionism.

Så efter att ha registrerats på FCS-webbplatsen blev det klart att för att skapa statistiska rapporteringsdokument om export är det nödvändigt att ladda ner data från handelshanteringsdokumenten för försäljning av varor och tjänster och skapa en fil för nedladdning.

Det finns två möjliga nedladdningsalternativ.

Först: ladda den tabellformade delen med produkter från en Excel-fil (det här alternativet valdes som ett fungerande alternativ, eftersom det hade fördelarna att det inte behövdes bry dig om att bearbeta dokumentets "Header", utan du kunde helt enkelt kopiera föregående, ändra det i "Header" "vad som krävdes).

För det andra: skapa en XML-fil enligt schemat som laddats ner från FCS-webbplatsen i form av ett "Album med format för elektroniska dokumentformulär". Albumet innehåller ett ganska stort antal XSD-scheman. De hittade ett diagram över "Statistisk formulär för redovisning av varurörelser" och ytterligare filer med beskrivningar av typerna för det. Diagrammen bifogas artikeln i arkivet med bearbetning.

För att se XSD-scheman använde vi gratis Microsoft XML Notepad 2007.

Bilden visar huvudfilen med XSD-schemat "Statistisk blankett för redovisning av varurörelser." Bilden belyser de viktigaste blocken i XSD-schemat som vi behöver för att förstå det.

Från diagrammet är det tydligt att vi behöver få en XML-fil fylld med den struktur som anges i "xs:element"-grenen av typen StaticFormType.

Strukturen kan vara ganska komplex (som i vårt fall). Med typbeskrivningar som finns direkt i grenen, placerade i en separat gren, eller till och med placerade i en annan fil.

Denna struktur har en typ StaticFormType, som i sin tur består av en bastyp BaseDocType, en uppsättning objekt av olika typer och textattribut.

Bastypen BaseDocStyle är definierad i en annan fil (och namnutrymme)
.

Den här filen innehåller många typer som inte används i vårt fall.

Låt oss nu gå vidare till att arbeta i 1C. I ett nötskal, vad vi behöver göra kommer ner till följande:

1. XDTO Factory skapas

OurFactoryXDTO = CreateFactoryXDTO(ArrayFullFileNamesWithXSDSchemas);

2. I XDTO-fabriken skapas alla komplexa datatyper som vi sedan fyller i i den skapade XML-filen:

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

Datatyperna som ingår i en viss typ kan erhållas från samlingen av dess egenskaper:

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

3. När alla komplexa datatyper har skapats skapar vi en XML-filstruktur baserad på dem, bestående av XDTO Factory-objekt:

StaticFormType_XDTOObject = MyXDTOFactory.Create(StaticFormType); // samling med dokument NewDocuments = MyFactoryXDTO.Create(DocumentsType); NewDocuments.PrDocumentName = MyFactoryXDTO.Create(PrDocumentNameType, "Waybill"); NewDocuments.PrDocumentNumber = MyFactoryXDTO.Create(PrDocumentNumberType, "123-nummer"); NewDocuments.PrDocumentDate = MyFactoryXDTO.Create(PrDocumentDateType, "2014-10-05"); StaticFormType_XDTO.Documents.Add(NewDocuments);

Fyll samtidigt i de elementära (enkla typerna) detaljerna.

4. Och slutligen laddar vi ner allt från XDTO Factory till en fil:

XML-fil = Ny XML-post(); FileXML.OpenFile(Filnamn); FileXML.WriteXMLDeclaration(); MyXDTOFactory.WriteXML(XMLFile, StaticFormType_XDTOObject); FileXML.Close();

P.S. Arkivet innehåller en uppladdningsmallfil i XML (endast vissa detaljer skapas, vilket återspeglar alla fall där filen är ifylld) och XSD-scheman.

Packa upp alla filer i en viss katalog.

XML kommer att skapas i den.

XML-formatet är mycket populärt vid utbyte av olika textdokument mellan informationssystem. Möjligheten att skapa en unik struktur för dokument gör att den kan användas inom många områden - elektroniska bibliotek, WEB, import/export och många andra. Utan möjligheten att bekvämt arbeta med detta format skulle 1C-system inte ha blivit så populärt. Eftersom 1C aktivt använder WEB-teknik måste varje utvecklare kunna läsa XML och skriva in information i den.

XML-filrepresentation och läsning

En av de viktigaste fördelarna med XML-markeringsspråket är dess ganska bekväma och intuitiva struktur och syntax. När de skapade den satte författarna upp ett mål att skapa ett märkningsspråk som skulle vara lätt att läsa av både människor och datorer. Idag har XML utvecklats i stor utsträckning till andra format, men är fortfarande populärt och flitigt använt. Strukturen för XML-filen är byggd enligt följande schema:

För att överväga ett exempel på att importera data till 1C räcker filen som presenteras ovan. För att den skriftliga proceduren ska kunna läsa XML-filen räcker det med att skicka in sökvägen till själva filen i den. Detta kan göras genom gränssnittet, så att användarna kan specificera filen själva, eller genom hårdkodad bearbetning i texten.

Ett av de populära sätten att arbeta med XML upp till 100 MB i storlek i 1C är att använda Document Object Model (DOM). Dess mening är att sekventiellt bearbeta alla dokumentnoder som representeras i XML. I det inbyggda 1C-språket ser denna algoritm ut så här:

1. Deklaration av de mekanismer genom vilka XML-filen läses; Slinga för att korsa noder;
2. Läsa data och attribut i en nod;
3. Informationsutmatning. Vid behov kan i detta skede skrivning ske i variabler eller direkt i de nödvändiga tabellerna;
4. Färdigställande av mekanismen.

Som ett resultat visar vi meddelanden till användaren med importerad data. Du kan också placera all data i önskad struktur och, baserat på den, programmera skapandet av ett dokument eller poster i katalogen. Hastigheten på 1C-arbete med xml är ganska hög, så det här formatet används i allt större utsträckning vid utbyte av data med andra källor.

För att ladda upp information måste vi också interagera med XML-filer. Låt oss titta på ett exempel på en post som använder 1C-plattformsobjektet XML Record och ladda upp data på objektet. Dess främsta fördelar är kodens enkelhet och databehandlingshastigheten. Algoritmen på serversidan för att skriva en XML-fil kan representeras som flera sekventiella steg:

1. Anslut till xml-filen;
2. Vi skapar huvudelement och skriver data till dem. Om du vill ladda upp en stor mängd information till en XML-fil kommer du i detta skede att använda loopar. Var försiktig och kom ihåg att databegäran måste göras före loopen och inte i den;
3. Stäng filen.

XDTO-mekanism i 1C

1C-företagsutvecklare har skapat sin egen mekanism för att utbyta information via XML - XDTO (XML Data Transfer Objects). Från och med version 8.1 har plattformen möjlighet att utbyta data med andra system utan att fördjupa sig i problematiken med att generera en XML-fil. De flesta tekniska problem hanteras av 1C, och allt vi behöver göra är att ange den data som behövs för att generera XML. Det är sant, för detta måste utvecklaren göra några manipulationer i förväg.

För att ladda en XML-fil med XDTO måste vi berätta för 1C om filens struktur. Det överförs genom en uppsättning diagram som kan skapas i en textredigerare eller med hjälp av ett specialiserat program. Den resulterande filen bör beskriva den allmänna strukturen och datatyperna som används i XML-filen. Innan du läser eller skriver ny XML måste utvecklaren ladda sitt schema i konfigurationen under XDTO-paket.

I det här fallet kommer vi att skapa ett enkelt paket för hand så att 1C förstår strukturen i vår exempelfil. För att filgenereringen ska slutföras framgångsrikt måste vi reflektera i schemat att vi har ett head-element och en bilaga med attribut. Det skapade schemat måste exporteras till en fil i xsd-format och överföras tillsammans med xml, så att den andra parten inte behöver ta itu med strukturen och skapa xdto-paketet igen.

En serveralgoritm som liknar den tidigare hjälper dig att spara den nya XML-filen på din hårddisk. Den enda skillnaden är behovet av att lägga till data för 1 produkt till XDTO-fabriken - en speciell mekanism för 8.3 1C-plattformen. Om det finns ett behov av att skapa fler kapslingsnivåer måste du beskriva varje huvudelement.

De övervägda mekanismerna är ganska universella och kan, om de är korrekt konfigurerade, lösa de flesta problem. Det finns dock ganska många nyanser i interaktionen mellan 1C och XML. Det är mycket mer effektivt att studera dem i verkliga förhållanden, och inte på testuppgifter där bearbetning av en XML-fil löser ganska snäva problem.

Det här kapitlet kommer att visa dig hur du skriver XML-scheman. Du får också lära dig att diagrammet kan skrivas på olika sätt.

XML-dokument

Låt oss titta på detta XML-dokument som heter "shiporder.xml":

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

Ola Nordmann

XML-dokumentet ovan består av ett rotelement, "shiporder", som innehåller ett obligatoriskt attribut som kallas "orderid". Elementet "shiporder" innehåller tre olika underordnade element: "orderperson", "shipto" och "item" . Elementet "item" visas två gånger och det innehåller ett "title"-element, ett valfritt "note"-element, ett "quantity"-element och ett "price"-element.

Raden ovan: Xmlns: XSI="http://www.w3.org/2001/XMLSchema-instance" talar om för XML-tolken att detta dokument bör schemavalideras. Rad: XSI: noNamespaceSchemaLocation = "shiporder.xsd" anger var schemat finns (här finns den i samma mapp som "shiporder.xml") .

Skapa ett XML-schema

Nu vill vi skapa ett schema för XML-dokumentet ovan.

Vi börjar med att öppna en ny fil, som vi kallar "shiporder.xsd". För att skapa ett schema kan vi helt enkelt följa strukturen i XML-dokumentet och definiera varje element som vi hittar det. Vi börjar med en standard XML-deklaration följt av ett xs:schema-element som definierar schemat:

...

I schemat ovan använder vi standardnamnrymder (xs), och den URI som är associerad med denna namnrymd är schemaspråksdefinitionen, som har standardvärdet http://www.w3.org/2001/XMLSchema.

Därefter måste vi definiera ett "shiporder"-element. Detta element har ett attribut och innehåller andra element, så vi behandlar det som en komplex typ. Underordnade element till ett "shiporder"-element omges av ett xs:-sekvenselement som definierar en ordnad sekvens av underelement:

...

Då måste vi definiera "orderperson"-elementet som en enkel typ (eftersom det inte innehåller några attribut eller andra element). Typen (xs:string) har prefixet ett namnområdesprefix som är associerat med XML-schemat, vilket anger en fördefinierad schemadatatyp:

Med hjälp av scheman kan vi bestämma antalet möjliga förekomster för ett element med MaxOccurs- och MinOccurs-attribut. MaxOccurs anger det maximala antalet förekomster för ett element och MinOccurs anger det minsta antalet förekomster för ett element. Standardvärdet för både MaxOccurs och MinOccurs är 1!

Nu kan vi definiera elementet "artikel". Detta element kan förekomma flera gånger i ett "shiporder"-element. Detta bestäms genom att sätta maxOccurs-attributet för elementet "item" till "unbounded", vilket betyder att det kan finnas så många förekomster av elementet "item" som författaren vill. Observera att "note"-elementet är valfritt. Vi definierade detta genom att sätta minOccurs-attributet till noll:

Nu kan vi deklarera elementets "shiporder"-attribut. Eftersom detta är ett obligatoriskt attribut anger vi use="required".

Obs: Attributsatser måste alltid komma sist:

Här är en komplett lista över schemafilen som heter "shiporder.xsd":

Separata kretsar

Den tidigare designmetoden är mycket enkel, men kan vara svår att läsa och underhålla när dokumenten är komplexa.

Nästa designmetod bygger på att definiera alla element och attribut och sedan referera till dem med hjälp av ref-attributet.

Här är den nya designen av den schematiska filen ("shiporder.xsd"):

Använder namngivna typer

Den tredje designmetoden definierar klasser eller typer, vilket gör att elementdefinitioner kan återanvändas. Detta görs genom att namnge elementen simpleTypes och complexTypes, och sedan referera till dem genom elementets type-attribut.

Här är den tredje designen av den schematiska filen ("shiporder.xsd"):

Begränsningselementet indikerar att datatypen härleddes från W3C XML Schema-datatypens namnområde. Så följande kodavsnitt betyder att värdet på elementet eller attributet måste vara värdet på en sträng:

Begränsningselementet används oftare för att tillämpa begränsningar på element. Titta på följande linjer från diagrammet ovan:

Detta anger att värdet på elementet eller attributet måste vara en sträng, det måste vara exakt sex tecken per rad och dessa tecken måste vara ett tal mellan 0 och 9.

XDTO är en 1C-mekanism som behövs när man skapar och använder webbtjänster i 1C.

XDTO 1C-paket låter dig beskriva strukturen för den nödvändiga XML-filen för att konvertera data till och från XML.

För den som är intresserad, låt oss titta på frågan mer i detalj.

XML-filer överförs över Internet och kan läsas av många program.

De uppfattas - det betyder att den är inkopplad i deras kod - om du stöter på ett visst elementnamn i XML-filen - uppfatta det så här och gör så här.

Därför, om vi använder elementnamnet Apple, så finns det en ganska stor chans att något annat program kan "tro" att detta är det Apple det känner till, men vi menade något eget.

För att förhindra att detta händer och tydligt indikera att vårt Apple skiljer sig från alla andra, kan namnet på namnområdet anges i filen - ett prefix som används före namnet på elementen.

Namnutrymmet (på engelska namnutrymme) definieras så här - xmlns:SpaceName = "URL", till exempel:
xmlns:store = "http://store.ru"

Varför behöver du en URL?

Därför anges en viss unik identifierare, som också identifierar namnområdets författare.

Naturligtvis antas det att den som angett namnutrymmet är en extremt ärlig person och angett sin sida och inte använder flera olika namnutrymmen med en sida.

Förresten anger de vanligtvis inte bara webbadressen till webbplatsen, utan webbadressen till en specifik mapp på webbplatsen, så att om något händer kan du skapa ett annat namnområde i en annan mapp på webbplatsen för användning i en annan situation.

Ett objekt är en specifik datastruktur, självförsörjande, som innehåller alla dess data.

Eftersom strukturerad data beskrivs i XML, det vill säga i form av en struktur som har sina egna egenskaper etc., kan de ses som objekt.

I exemplet kan detta vara ett LIST-objekt med en egenskap och ett kapslat element.

DOM är ett sätt att behandla en XML-fil inte som text i ett specifikt format, utan som en samling objekt med egenskaper, fält och så vidare.

Beskrivning av XML-filen

Om vi ​​ständigt använder en fil med en viss struktur för att utbyta mellan två program, skulle vi förmodligen vilja:

• Att få använda vissa namn
• Att ha de element som vi förväntar oss (som "måste finnas där för att användas i vårt utbyte")
• Så att attributen innehåller de typer som vi förväntar oss (sträng, nummer, etc.).

Följande filformatstandarder finns för att beskriva XML-struktur (som också lagras i en vanlig textfil):

• DTD-tillägg – Dokumenttypsdefinition
• XSD-tillägg – XML Shema.

Båda formaten beskriver hur dokumentet ska se ut. Proceduren för att kontrollera om XML överensstämmer med standarden som beskrivs i en sådan fil kallas verifiering.

XDTO 1C är ett verktyg som låter dig lägga till en beskrivning av en XML-fil till konfigurationen. Eller snarare, det är inte filen som beskrivs, utan specifika XML-strukturer.

För att ange vilka typer som kan användas används en lista eller ett typbibliotek som kallas XDTO 1C-fabriken.

Denna fabrik specificerar både enkla typer (sträng, nummer, datum), som vanligtvis används i andra språk, program, etc., men även 1C-typer, som används i 1C och i en specifik konfiguration.

Själva XDTO 1C-fabriken består av flera paket. De grundläggande typerna beskrivs i ett paket som heter www.w3.org

Aktuella konfigurationsdatatyper beskrivs i paketet http://v8.1c.ru/8.1/data/enterprise/current-config

Själva typerna namnges enligt namnet i konfiguratorn med tillägg av en engelskspråkig form (CatalogRef, CatalogObject, DocumentRef, DocumentObject), till exempel:

CatalogObject.Nomenclature

Lägger till XDTO 1C-paketet

Allt detta låter verkligen coolt. Och vi har inte kommit till ämnet XSLT än - ett sätt att omvandla XML-filer till något annat, som HTML. Ämnet XML är extremt stort och svårt att täcka även i en separat bok.

Vår uppgift är att förstå att XDTO 1C tillåter oss att beskriva vilka element ett XML-paket som behöver genereras eller läsas ska ha.

XDTO 1C-paket finns i konfigurationen i grenen Allmänt/XDTO 1C-paket.

Du kan lägga till XDTO-paketet till 1C manuellt (coolt!), men det är bättre att få motsvarande XSD-fil med en färdig beskrivning av schemat.

En beskrivning av XSD-schemat för objekt av valfri konfiguration kan erhållas genom att klicka på grenen Allmänt/XDTO 1C-paket och välja menyalternativet Exportera XML-konfigurationsschema.

Filen är text, du kan redigera den i Windows Notepad, ta bort onödiga objekt som du inte behöver.

Du kan lägga till ett färdigt XSD-schema till 1C genom att högerklicka på grenen Allmänt/XDTO 1C-paket och välja menyalternativet Importera XML-schema.

Använder XDTO 1C-mekanismen

Att arbeta med XDTO 1C innebär att konvertera värden till och från XML.

Arbetet utförs med hjälp av 1C-språkobjekt Läsa XML/Skriva XML.

När du arbetar med XDTO 1C-mekanismen måste du ange vilket paket du arbetar med. Detta kan vara ett standardpaket (diskuterat ovan, se XDTO) eller ett paket som läggs till i konfigurationen. Paketet identifieras av den URL som anges i paketet.

De två huvudsakliga enkla sätten att arbeta är:

• Serialisering - automatisk konvertering av värden från 1C till XML och vice versa
• Skapa ett objekt, fylla i dess fält, skriva till XML (och följaktligen läsa från XML och sedan läsa dess fält).

Exempel på värdeserialisering:
Serializer = New SerializerXDTO(FactoryXDTO);
XML-fil = Ny XML-post();
FileXML.OpenFile("Filnamn");
Serializer.WriteXML(XMLFile, Value1C);

Exempel på att läsa/skriva ett objekt:

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