Ինչպես բացել XML փաստաթուղթ - XML ​​ֆայլերի հետ աշխատելու առանձնահատկությունները: XML-ի հետ աշխատելը .NET հավելվածներում Ինչ է XML-ը

Դուք հավանաբար լսել եք XML-ի մասին և գիտեք բազմաթիվ պատճառներ, թե ինչու այն պետք է օգտագործվի ձեր կազմակերպությունում: Բայց կոնկրետ ինչ է XML-ը: Այս հոդվածը բացատրում է, թե ինչ է XML-ը և ինչպես է այն աշխատում:

Այս հոդվածում

Նշումներ, նշումներ և պիտակներ

XML-ը հասկանալու համար օգտակար է հիշել, թե ինչպես կարող եք նշել տվյալները: Փաստաթղթերը ստեղծվել են մարդկանց կողմից շատ դարերի ընթացքում, և այդ ընթացքում մարդիկ գրառումներ են կատարել դրանց վրա: Օրինակ՝ ուսուցիչները հաճախ նշումներ են անում ուսանողների աշխատանքի վերաբերյալ՝ նշելով պարբերությունները տեղափոխելու, նախադասությունն ավելի պարզ դարձնելու կամ ուղղելու անհրաժեշտությունը։ ուղղագրական սխալներև այլն: Նշելով փաստաթուղթը՝ կարող եք որոշել կառուցվածքը, նշանակությունը և տեսքըտեղեկատվություն։ Եթե ​​դուք երբևէ օգտագործել եք թեժ շտկումներ Microsoft Office Word, ապա դուք ծանոթ եք համակարգչային նշագրման ձևին:

աշխարհում տեղեկատվական տեխնոլոգիաներ«Մակնշում» տերմինը դարձել է «նշում»։ Նշագրումն օգտագործում է պիտակներ (կամ երբեմն նշաններ) կոչվող ծածկագրերը, որպեսզի սահմանեն տվյալների կառուցվածքը, տեսողական տեսքը և, XML-ի դեպքում, տվյալների նշանակությունը:

Այս հոդվածի տեքստը HTML ձևաչափէ լավ օրինակհամակարգչային նշագրման կիրառում: Եթե ​​Microsoft-ում Internet Explorerսեղմեք այս էջը սեղմեք աջմկնիկը և ընտրիր հրամանը Դիտեք HTML կոդը, դուք կտեսնեք ընթեռնելի տեքստ և HTML պիտակներ, ինչպիսիք են

ԵՎ

. HTML և XML փաստաթղթերում թեգերը հեշտ է ճանաչել, քանի որ դրանք փակված են անկյունային փակագծերում: Այս հոդվածի սկզբնաղբյուր տեքստում HTML թեգերը կատարում են բազմաթիվ գործառույթներ, օրինակ՝ սահմանելով յուրաքանչյուր պարբերության սկիզբը և վերջը (

...

) և գծագրերի գտնվելու վայրը:

XML-ի առանձնահատկությունները

HTML և XML փաստաթղթերը պարունակում են տվյալներ, որոնք փակցված են պիտակների մեջ, բայց այստեղ ավարտվում են երկու լեզուների միջև եղած նմանությունները: Ձևաչափով HTML պիտակներորոշել տվյալների ձևավորումը՝ վերնագրերի գտնվելու վայրը, պարբերության սկիզբը և այլն: XML ձևաչափում պիտակները որոշում են տվյալների կառուցվածքը և նշանակությունը՝ ինչ է դա:

Տվյալների կառուցվածքն ու նշանակությունը նկարագրելով՝ հնարավոր է դառնում դրանք վերօգտագործել մի քանի ձևով։ Օրինակ, եթե դուք ունեք վաճառքի տվյալների բլոկ, որտեղ յուրաքանչյուր տարր հստակորեն սահմանված է, դուք կարող եք բեռնել միայն անհրաժեշտ տարրերը վաճառքի հաշվետվության մեջ և մյուս տվյալները փոխանցել հաշվապահական տվյալների բազա: Այլ կերպ ասած, դուք կարող եք օգտագործել մեկ համակարգ՝ տվյալների XML ձևաչափով գեներացնելու և հատկորոշելու համար, այնուհետև մշակել այդ տվյալները ցանկացած այլ համակարգերում՝ անկախ հաճախորդի հարթակից կամ օպերացիոն համակարգ. Այս համատեղելիությունը XML-ին դարձնում է տվյալների փոխանակման ամենատարածված տեխնոլոգիաներից մեկի հիմքը:

Աշխատելիս նկատի ունեցեք հետևյալը.

HTML-ը չի կարող օգտագործվել XML-ի փոխարեն: Այնուամենայնիվ, XML տվյալները կարող են փակվել HTML պիտակներում և ցուցադրվել վեբ էջերում:

HTML-ի հնարավորությունները սահմանափակվում են նախապես սահմանված պիտակների մի շարքով, որոնք ընդհանուր են բոլոր օգտագործողների համար:

XML կանոնները թույլ են տալիս ստեղծել ցանկացած պիտակ, որն անհրաժեշտ է տվյալների և դրանց կառուցվածքը նկարագրելու համար: Ենթադրենք, դուք պետք է պահեք և կիսվեք ընտանի կենդանիների մասին տեղեկություններով: Դա անելու համար կարող եք ստեղծել հետևյալ XML կոդը.

Իզի սիամական 6 այո ոչ Իզզ138բոդ Քոլին Ուիլքոքս

Ինչպես տեսնում եք, XML պիտակները ցույց են տալիս, թե ինչ տվյալներ եք դիտում: Օրինակ, պարզ է, որ տվյալները կատվի մասին են, և դուք հեշտությամբ կարող եք որոշել նրա անունը, տարիքը և այլն: Քանի որ կարող եք ստեղծել պիտակներ, որոնք սահմանում են տվյալների գրեթե ցանկացած կառուցվածք, XML-ը ընդարձակելի է:

Բայց մի շփոթեք այս օրինակի պիտակները HTML ֆայլի պիտակների հետ: Օրինակ, եթե վերը նշված XML տեքստը տեղադրվի HTML ֆայլի մեջ և բացվի բրաուզերում, արդյունքները կունենան հետևյալ տեսքը.

Izzy Siamese 6 այո ոչ Izz138bod Colin Wilcox

Վեբ զննարկիչը անտեսելու է XML պիտակները և կցուցադրի միայն տվյալները:

Լավ ձևավորված տվյալներ

Դուք հավանաբար լսել եք, որ ինչ-որ մեկը ՏՏ ոլորտում խոսում է «լավ ձևավորված» XML ֆայլի մասին: Լավ ձևավորված XML ֆայլը պետք է հետևի շատ խիստ կանոններին: Եթե ​​այն չի հետևում այս կանոններին, XML-ը չի աշխատում: Օրինակ, նախորդ օրինակում յուրաքանչյուր բացվող թեգ ունի համապատասխան փակման պիտակ, ուստի այս օրինակը հետևում է լավ ձևավորված XML ֆայլի կանոններից մեկին։ Եթե ​​ֆայլից պիտակ հանեք և փորձեք բացել այն Office ծրագրերից մեկում, սխալի մասին հաղորդագրություն կհայտնվի, և նման ֆայլ օգտագործելն անհնար կլինի։

Պետք չէ իմանալ լավ ձևավորված XML ֆայլ ստեղծելու կանոնները (թեև դրանք դժվար չէ հասկանալ), բայց հիշեք, որ միայն լավ ձևավորված XML տվյալները կարող են օգտագործվել այլ հավելվածներում և համակարգերում: Եթե ​​XML ֆայլը չի ​​բացվում, հավանաբար այն սխալ ձևավորված է:

XML-ը պլատֆորմից անկախ է, ինչը նշանակում է, որ XML-ի օգտագործման համար նախատեսված ցանկացած ծրագիր կարող է կարդալ և մշակել XML տվյալները՝ անկախ սարքաշարից կամ օպերացիոն համակարգից: Օրինակ, եթե կիրառեք ճիշտ XML թեգեր, կարող եք օգտագործել աշխատասեղանի ծրագիր՝ հիմնական համակարգից ստացված տվյալները բացելու և մշակելու համար: Եվ, անկախ նրանից, թե ով է ստեղծել XML տվյալները, տվյալները կարող են մանիպուլյացիայի ենթարկվել Office-ի տարբեր հավելվածներում: Իր համատեղելիության շնորհիվ XML-ը դարձել է տվյալների բազաների և օգտագործողների համակարգիչների միջև տվյալների փոխանակման ամենատարածված տեխնոլոգիաներից մեկը:

Բացի լավ ձևավորված հատկորոշված ​​տվյալներից, XML համակարգերը սովորաբար օգտագործում են երկու լրացուցիչ բաղադրիչ՝ սխեմաներ և փոխակերպումներ: Հետևյալ բաժինները նկարագրում են, թե ինչպես են դրանք աշխատում:

Սխեմաներ

Մի վախեցեք «սխեմա» տերմինից: Սխեման պարզապես XML ֆայլ է, որը պարունակում է XML տվյալների ֆայլի բովանդակության կանոններ: Schema ֆայլերը սովորաբար ունեն XSD ընդլայնում, մինչդեռ XML տվյալների ֆայլերը օգտագործում են XML ընդլայնում:

Սխեմաները թույլ են տալիս ծրագրերին վավերացնել տվյալները: Դրանք ձևավորում են տվյալների կառուցվածքը և ապահովում դրանց հասկանալիությունը ստեղծողի և այլ մարդկանց համար: Օրինակ, եթե օգտատերը մուտքագրում է անվավեր տվյալներ, օրինակ՝ տեքստը ամսաթվի դաշտում, ծրագիրը կարող է օգտվողին հուշել ուղղել այն: Եթե ​​XML ֆայլի տվյալները համապատասխանում են սխեմայի կանոններին, կարող եք օգտագործել XML-ով միացված ցանկացած ծրագիր՝ դրանք կարդալու, մեկնաբանելու և մշակելու համար: Օրինակ, ինչպես ցույց է տրված ստորև նկարում, Excel-ը կարող է վավերացնել տվյալները CAT սխեմային համապատասխանելու համար:

Սխեմաները կարող են բարդ լինել, և այս հոդվածը չի կարող բացատրել, թե ինչպես ստեղծել դրանք: (Նաև, ձեր կազմակերպությունում հավանաբար կան ՏՏ ոլորտի մարդիկ, ովքեր գիտեն, թե ինչպես դա անել:) Այնուամենայնիվ, օգտակար է իմանալ, թե ինչ տեսք ունեն դիագրամները: Հետևյալ դիագրամը սահմանում է պիտակների մի շարք կանոններ ... :

Մի անհանգստացեք, եթե օրինակը պարզ չէ: Պարզապես ուշադրություն դարձրեք հետևյալին.

Օրինակի սխեմայի լարային տարրերը կոչվում են հայտարարագրեր: Եթե ​​կենդանու մասին լրացուցիչ տեղեկություններ պահանջվեին, օրինակ՝ նրա գույնը կամ հատուկ բնութագրերը, ՏՏ բաժինը համապատասխան հայտարարագրեր կավելացներ դիագրամում: XML համակարգը կարող է փոփոխվել, քանի որ բիզնեսի կարիքները զարգանում են:

Հայտարարությունները տվյալների կառուցվածքը շահարկելու հզոր միջոց են: Օրինակ, գովազդ նշանակում է, որ այնպիսի պիտակներ, ինչպիսիք են Եվ , պետք է հետևել վերը նշված կարգով: Գովազդը կարող է նաև հաստատել օգտատերերի մուտքագրման տեսակները: Օրինակ, վերը նշված սխեման պահանջում է դրական ամբողջ թվի մուտքագրում կատվի տարիքի համար և բուլյան արժեքներ (TRUE կամ FALSE) ՓՈՓՈԽՎԱԾ և DECLAWED պիտակների համար:

Եթե ​​XML ֆայլի տվյալները հետևում են սխեմայի կանոններին, ապա ասում են, որ տվյալները վավեր են: XML տվյալների ֆայլի սխեմայի կանոններին համապատասխանությունը ստուգելու գործընթացը կոչվում է (բավական տրամաբանորեն) վավերացում: Սխեմաների օգտագործման մեծ առավելությունն այն է, որ դրանք կարող են կանխել տվյալների կոռուպցիան: Սխեմաները նաև հեշտացնում են կոռումպացված տվյալներ գտնելը, քանի որ XML ֆայլի մշակումը դադարում է, երբ խնդիր է առաջանում:

Փոխակերպումներ

Ինչպես նշվեց վերևում, XML-ը նաև թույլ է տալիս արդյունավետ օգտագործել և վերօգտագործել տվյալները: Տվյալների վերօգտագործման մեխանիզմը կոչվում է XSLT փոխակերպում (կամ պարզապես փոխակերպում):

Դուք (կամ ձեր ՏՏ բաժինը) կարող եք նաև օգտագործել փոխակերպումներ՝ տվյալների փոխանակման հետին համակարգերի միջև, ինչպիսիք են տվյալների բազաները: Ենթադրենք, որ A տվյալների բազան պահում է վաճառքի տվյալները աղյուսակում, որն օգտակար է վաճառքի բաժնի համար: Բ շտեմարանը պահում է եկամուտների և ծախսերի տվյալները աղյուսակում, որը նախատեսված է հատուկ հաշվապահական հաշվառման համար: Տվյալների բազա B-ն կարող է օգտագործել տրանսֆորմացիա՝ A շտեմարանից տվյալներ վերցնելու և համապատասխան աղյուսակներում տեղադրելու համար:

Տվյալների ֆայլի, սխեմայի և փոխակերպման համադրությունը կազմում է հիմնական XML համակարգը: Հետևյալ նկարը ցույց է տալիս նման համակարգերի աշխատանքը: Տվյալների ֆայլը ստուգվում է սխեմայի կանոնների համաձայն, այնուհետև փոխանցվում է ցանկացած հարմար ձևով փոխակերպման համար: Այս դեպքում փոխակերպումը տվյալները տեղադրում է վեբ էջի աղյուսակում:

Հետևյալ օրինակը ցույց է տալիս փոխակերպում, որը բեռնում է տվյալները վեբ էջի աղյուսակի մեջ: Օրինակի իմաստը ոչ թե բացատրելն է, թե ինչպես ստեղծել փոխակերպումներ, այլ ցույց տալ այն ձևերից մեկը, որոնք նրանք կարող են ընդունել:

Այս օրինակը ցույց է տալիս, թե ինչ տեսք կարող է ունենալ փոխակերպման մեկ տեսակի տեքստը, բայց հիշեք, որ դուք կարող եք սահմանափակվել տվյալներից ձեզ անհրաժեշտի հստակ նկարագրությամբ, և այդ նկարագրությունը կարող է կատարվել ձեր մայրենի լեզվով: Օրինակ, դուք կարող եք գնալ ՏՏ բաժին և ասել, որ նրանք պետք է տպեն վաճառքի տվյալները վերջին երկու տարվա համար կոնկրետ տարածաշրջանների համար, և որ տեղեկատվությունը պետք է այսպիսին լինի և այն լինի: Այնուհետև վարչությունը կարող է գրել (կամ փոփոխել) փոխակերպումը՝ ձեր խնդրանքը կատարելու համար:

Microsoft-ը և աճող թվով այլ ընկերություններ ստեղծում են փոխակերպումներ տարբեր նպատակների համար՝ XML-ն ավելի հարմար դարձնելով օգտագործելու համար: Ապագայում, հավանաբար, հնարավոր կլինի ներբեռնել ձեր կարիքներին համապատասխան փոխակերպում՝ քիչ կամ առանց լրացուցիչ հարմարեցման: Սա նշանակում է, որ ժամանակի ընթացքում XML-ի օգտագործումը գնալով ավելի ու ավելի էժան կլինի:

XML Microsoft Office համակարգում

Office-ի պրոֆեսիոնալ հրատարակությունները ապահովում են ընդլայնված XML աջակցություն: Սկսած 2007 թվականի Microsoft Office համակարգից, Microsoft Office-ն օգտագործում է XML-ի վրա հիմնված ֆայլերի ձևաչափեր, ինչպիսիք են DOCX, XLSX և PPTX: Քանի որ XML-ը տվյալները պահում է տեքստային ձևաչափով, այլ ոչ թե սեփական երկուական ձևաչափով, հաճախորդները կարող են սահմանել իրենց սխեմաները և օգտագործել ձեր տվյալները տարբեր ձևերով՝ առանց հոնորար վճարելու: Նոր ձևաչափերի մասին լրացուցիչ տեղեկությունների համար տե՛ս Բաց XML ձևաչափեր և ֆայլերի անունների ընդլայնումներ: Ստորև ներկայացված են այլ առավելություններ:

Այս ամենը հիանալի է, բայց ինչ անել, եթե ունեք XML տվյալներ առանց սխեմայի: Դա կախված է նրանից, թե ինչ Գրասենյակային ծրագիրդուք օգտագործում եք. Օրինակ, երբ բացում եք XML ֆայլ առանց սխեմայի Excel-ում, այն ենթադրում է, որ սխեման գոյություն ունի և թույլ է տալիս բեռնել տվյալները XML աղյուսակում: Տվյալները տեսակավորելու, զտելու և հաշվարկելու համար կարող եք օգտագործել XML ցուցակներն ու աղյուսակները:

Միացնել XML գործառույթները Office-ում

Լռելյայնորեն, Developer ներդիրը տեսանելի չէ: Այն պետք է ավելացվի ժապավենին՝ Office-ում XML հրամաններ օգտագործելու համար:

Նախորդ հոդվածը նկարագրում էր XML-ի վերաբերյալ ընդհանուր հասկացությունները: Այս հոդվածում մենք կսովորենք, թե ինչպես կատարել հիմնական գործողություններ՝ կապված XML ֆայլում փոխելու, ավելացնելու, որոնելու հետ:

XML ֆայլ, որն օգտագործվում է օրինակի համար:

Mazda 2007 BMW 2009

xml dom

IN այս պահին, մեր ֆայլը պարունակում է հետևյալ կառուցվածքը.

Հանգույցների միջև կապը XML DOM, հիմնական կետերը.

1. DOM ծառի ցանկացած հանգույց ունի ծնող ծնողական հանգույց: Մեր օրինակում ավտոտնակը երկու մեքենայի տարրերի մայրն է, և մեքենայի երկու տարրերն էլ իրենց հերթին մոդելի և տարվա տարրերի ծնողներ են:

Ինչպե՞ս ստանալ մեքենայի xml տարրը:

Console.WriteLine(elmRoot["car"].ParentNode.Name); //Արդյունք՝ ավտոտնակ

2. Ծնողը կարող է երեխա ունենալ ChildNodes: Օրինակ, ավտոտնակի հանգույցի համար երեխաները երկուսն էլ մեքենայի տարրեր են: Մեքենայի տարրերն ունեն նաև մանկական մոդել և տարի։

ChildNodes, հավաքածու է, որը պահում է բոլոր մանկական xml տարրերը՝ ցանկալի տարրին մուտք գործելու համար, անհրաժեշտ է նշել դրա ինդեքսը։ (Ցուցանիշը միշտ սկսվում է զրոյից):

Օրինակ՝ ինչպե՞ս ստանալ առաջին երեխայի տարրը:

ElmRoot.ChildNodes;

3. Ինչպես սովորական կյանքում, երեխան կարող է ծնվել առաջինը, կամ վերջինը՝ վերջին երեխային:

Եթե ​​օրինակ վերցնենք մեքենայի տարրը, ապա

FirstChild-ը մոդել է LastChild-ը տարի է

4. Իր հերթին կապեր կան նաև մանկական տարրերի միջև, նրանք կարող են լինել եղբայրներ կամ քույրեր, եթե զուգահեռներ տանենք իրական կյանքի հետ.

Երեխան կարող է ունենալ, օրինակ, նախորդ եղբայր և եղբայր և հաջորդ եղբայր եղբայր

Console.WriteLine (elmRoot.ChildNodes.FirstChild.NextSibling.Name); //Արդյունք՝ տարի Console.WriteLine(elmRoot.ChildNodes.LastChild.PreviousSibling.Name); //Արդյունք՝ մոդել

Եթե ​​տարրը չի գտնվել, ապա բացառություն է բացվում՝ NullReferenceException, այնպես որ xml-ի հետ աշխատելիս միշտ օգտագործեք try catch բլոկները։

Console.WriteLine(elmRoot.ChildNodes. LastChild.NextSibling.Name); Console.WriteLine(elmRoot.ChildNodes. FirstChild.PreviousSibling.Name);

LastChild-ը NextChild-ն է;
FirstChild-ը նախորդ եղբայրն է;

Օգտագործելով վերը նկարագրված մեթոդները, դուք հեշտությամբ կարող եք տեղափոխվել ցանկալի հանգույց և ստանալ ցանկացած արժեք, որն անհրաժեշտ է:

Ինչպե՞ս ստանալ xml տարրի արժեքը:

Տարրի xml արժեքը կարելի է ստանալ օգտագործելով InnerText հատկությունը, օրինակ՝

Console.WriteLine(elmRoot["car"].FirstChild.InnerText); //Արդյունքը՝ Mazda

Նույն xml տարրի արժեքը ստանալու մեկ այլ եղանակ.

Console.WriteLine (elmRoot.FirstChild.FirstChild.InnerText); //Արդյունքը՝ Mazda

DOM ծառի երկայնքով շարժումների հաջորդականությունը.

Ավտոտնակ -> մեքենա -> մոդել -> Mazda

Մենք ստանում ենք տարին.

ElmRoot["car"].LastChild.InnerText; //Արդյունք՝ 2007թ

Հաջորդականություն:

Ավտոտնակ -> մեքենա -> տարի -> 2007թ

Մեկ այլ օրինակ՝ նույն արդյունքը ստանալու 3 եղանակ.

Console.WriteLine (elmRoot.LastChild.FirstChild.InnerText); Console.WriteLine(elmRoot["car"].NextSibling.FirstChild.InnerText); Console.WriteLine(elmRoot.ChildNodes.Item(1).FirstChild.InnerText); //Արդյունք՝ BMW

Եթե ​​Ձեզ անհրաժեշտ է տարին ստանալ Mazda արժեքով տարրի համար.

Console.WriteLine (elmRoot.FirstChild.LastChild.InnerText); //Արդյունք՝ 2007թ

BMW-ի համար (երկու ճանապարհ, ստացեք նույն արդյունքը)

Console.WriteLine(elmRoot.ChildNodes.Item(1).ChildNodes.Item(1).InnerText); Console.WriteLine (elmRoot.ChildNodes.ChildNodes.InnerText); //Արդյունք՝ 2009թ

Ինչպե՞ս փոխել xml տարրերի արժեքները:

Գույքի օգտագործումը Ներքին տեքստ ()Դուք կարող եք և՛ ստանալ, և՛ փոխել xml տարրի արժեքը, օրինակ՝ փոխել տարին։

//Սահմանել նոր արժեք elmRoot.FirstChild.LastChild.InnerText = "2010"; //Ցուցադրել նոր արժեքը վահանակի էկրանին Console.WriteLine(elmRoot.FirstChild.ChildNodes.Item(1).InnerText); //Արդյունք՝ 2010թ

Միևնույն ժամանակ, դուք պետք է հիշեք, որ բոլոր փոփոխությունները տեղի են ունենում վիրտուալ xml ֆայլի հետ, եթե բացեք ֆիզիկական ֆայլը, կտեսնեք, որ դրանում դեռ նշված է 2007 թվականը:

Որպեսզի փոփոխություններն ուժի մեջ մտնեն, դուք պետք է օգտագործեք Save մեթոդը, օրինակ.

ElmRoot.Save («xml ֆայլի անուն կամ հոսք»);

Այժմ տեղեկատվությունը կփոխվի «ֆիզիկական» xml ֆայլում:

Ինչպե՞ս ստանալ մանկական տարրերի քանակը:

ավտոտնակ -> մեքենան պարունակում է 2 երեխա՝ մոդել և տարի

Console.WriteLine(elmRoot.FirstChild.FirstChild.ChildNodes.Count);

ավտոտնակ -> մեքենա -> մոդելը պարունակում է 1 երեխա xml տարր:

Մուտք գործեք մանկական տարրեր

ըստ ցուցանիշի

ElmRoot.ChildNodes.Name; elmRoot.ChildNodes.Name; //Արդյունք՝ մեքենա

Օգտագործելով հանգույց

Foreach (XmlNode nod elmRoot.ChildNodes-ում) ( Console.WriteLine(nod.Name); ) //Արդյունք՝ մեքենա, մեքենա

Ինչպե՞ս ստանալ xml տարրի անունը:

Նոր XML տարրի ստեղծում

Եկեք մեր XML փաստաթղթում ստեղծենք նոր տարր, որպեսզի այն տարբերվի մյուս երկուսից (մեքենա), եկեք այն անվանենք ավտոբուս։

Նոր տարր ստեղծելիս մենք կօգտագործենք msdn կայքի առաջարկությունը և ստանդարտ նոր XmlElement-ի փոխարեն կօգտագործենք CreateElement մեթոդը։

XmlElement elm = xmlDoc.CreateElement("bus");

Նոր xml տարրի ստեղծում և ավելացում

Եկեք ստեղծենք նոր xml տարր՝ «BUS» անունով։

XmlElement elmRoot = xmlDoc.DocumentElement; Console.WriteLine (elmRoot.ChildNodes.Count); //մեքենա, մեքենա XmlElement elmNew = xmlDoc.CreateElement("ավտոբուս"); elmRoot.AppendChild(elmNew); Console.WriteLine (elmRoot.ChildNodes.Count); //3 մեքենա, մեքենա, ավտոբուս xmlDoc.Save («xml ֆայլի անունը»);

Բացատրություն:

1. Նախ ստանում ենք արմատային տարր, որին կկցենք նոր տարրեր։

2. Որպես ստուգում՝ մենք կցուցադրենք ավտոտնակի տարրի մանկական տարրերի ընթացիկ թիվը՝ 2 (մեքենա և մեքենա)

3. Ստեղծեք նոր BUS տարր

4. Օգտագործելով մեթոդը AppendChildծառին նոր տարր ավելացնելով

5. Եկեք նորից օգտագործենք չեկը և ցուցադրենք ավտոտնակի տարրի համար առկա տարրերի քանակը, այժմ դրանք 3-ն են՝ մեքենա, մեքենա, ավտոբուս:

6. Որպեսզի փոփոխություններն ազդեն ֆիզիկական ֆայլի վրա, պահպանեք

XML ֆայլում նոր տարրը կունենա հետևյալ տեսքը.

Ինչպե՞ս ավելացնել նոր xml տարր:

Առաջադրանք՝ ստեղծել նոր XML տարր և դրան ավելացնել տեքստային բովանդակություն, օրինակ՝ արտադրության տարեթիվը:

String strFilename = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = նոր XmlDocument(); xmlDoc.Load (strFilename); XmlElement elmRoot = xmlDoc.DocumentElement; XmlElement elmNew = xmlDoc.CreateElement("bus"); XmlText new_txt = xmlDoc.CreateTextNode("2006"); elmRoot.AppendChild(elmNew); elmRoot.LastChild.AppendChild(new_txt); Console.WriteLine (elmRoot.ChildNodes.Name); //bus Console.WriteLine(elmRoot.ChildNodes.LastChild.InnerText); //2006 Console.Read();

XML ֆայլում.

2006

Պարզության համար

Հիմա եկեք ստեղծենք «ավտոբուս» հանգույց՝ նույն ճարտարապետությամբ, ինչ ավտոմեքենան, այսինքն՝ ավելացնենք հանգույցներ՝ մոդել, տարի և որոշ տեքստային բովանդակություն:

Երեխաների հետ XML տարրի ստեղծում

Արդյունք:

լիազ 2006

Ինչպե՞ս կարող եմ կրճատել այս կոդը: Օրինակ՝ հետևյալ կերպ.

String PathXmlFile = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = նոր XmlDocument(); xmlDoc.Load (PathXmlFile); XmlElement elmRoot = xmlDoc.DocumentElement; XmlElement elmBUS = xmlDoc.CreateElement("bus"); XmlElement elmModel = xmlDoc.CreateElement(«մոդել»); XmlElement elmYear = xmlDoc.CreateElement(«տարի»); //Ավելացրեք արժեքներ մոդելի և տարվա հանգույցներին elmModel.InnerText = «liaz»; elmYear.InnerText = "2006"; elmBUS.AppendChild(elmModel); elmBUS.AppendChild(elmYear); elmRoot.AppendChild (elmBUS); //Եթե ամեն ինչ ճիշտ է, ապա կանչեք Save մեթոդը xmlDoc.Save("xml file name");

Եկեք մի փոքր էլ կրճատենք կոդը, դա անելու համար մենք կօգտագործենք InnerXml հատկությունը.

XmlDocument xmlDoc = նոր XmlDocument(); xmlDoc.Load (PathXmlFile); XmlElement elmXML = xmlDoc.CreateElement("bus"); string txt = " լիազ" + "2006"; //InnerXml! elmXML.InnerXml = txt; //xmlDoc.DocumentElement (հավասար կլինի ավտոտնակին) - սա արմատային տարր մուտք գործելու ևս մեկ միջոց է, նույնը, ինչ XmlElement elmRoot = xmlDoc.DocumentElement; xmlDoc.DocumentElement.AppendChild (elmXML) xmlDoc.Save (PathXmlFile);

Արդյունք

Ստացեք տարրերի ցանկ՝ օգտագործելով GetElementByTagName

GetElementByTagName-ը վերադառնում է XmlNodeList, որը պարունակում է նշված տարրին պատկանող բոլոր ժառանգական տարրերը, օրինակ, մենք պետք է ստանանք բոլոր մեքենաների մոդելները, որոնք պահվում են ավտոտնակում.

XmlDocument xmlDoc = նոր XmlDocument(); xmlDoc.Load (strFilename); XmlNodeList modelName = xmlDoc.GetElementsByTagName(«մոդել»); foreach (XmlNode հանգույց modelName-ում) ( Console.WriteLine(node.InnerText); ) //Արդյունք՝ mazda, bmw, liaz

Մուտք գործեք՝ օգտագործելով ինդեքսը՝

String PathXmlFile = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = նոր XmlDocument(); xmlDoc.Load (PathXmlFile); XmlNodeList modelName = xmlDoc.GetElementsByTagName(«մոդել»); Console.WriteLine (modelName.InnerText); //Արդյունք՝ liaz

Ինչպե՞ս կարող եմ փոխել նոր ստեղծված «ավտոբուսի» տարրի տեքստային բովանդակությունը՝ օգտագործելով GetElementByTagName մեթոդը:

String PathXmlFile = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = նոր XmlDocument(); xmlDoc.Load (PathXmlFile); XmlNodeList modelName = xmlDoc.GetElementsByTagName(«մոդել»); Console.WriteLine (modelName.InnerText); //Ստացել է արժեքը՝ liaz

Կամ կարող եք փոխել liaz անունը Ikarus

Console.WriteLine(modelName.InnerText = «Ikarus»);

Ընդարձակվող նշագրման լեզու (XML): Դա իսկապես պարզ է տեքստային ֆայլեր, որոնք օգտագործում են հատուկ պիտակներ՝ նկարագրելու փաստաթղթի կառուցվածքը և այլ գործառույթները։

Ինչ է XML-ը

XMLՆշման լեզու է, որը ստեղծվել է Համաշխարհային ցանցի կոնսորցիումի (W3C) կողմից՝ փաստաթղթերի կոդավորման համար շարահյուսություն սահմանելու համար, որը կարող է կարդալ մարդիկ և մեքենաները: Դա անում է պիտակների միջոցով, որոնք սահմանում են փաստաթղթի կառուցվածքը, ինչպես նաև այն, թե ինչպես պետք է պահվի և տեղափոխվի փաստաթուղթը:

Այն համեմատելու ամենահեշտ ձևը մեկ այլ նշագրման լեզվի հետ, որին դուք կարող եք ծանոթ լինել հիպերտեքստի նշում(HTML), որն օգտագործվում է վեբ էջերը կոդավորելու համար: HTML-ն օգտագործում է նշագրման նիշերի (կարճ կոդերի) նախապես սահմանված հավաքածու, որոնք նկարագրում են վեբ էջի բովանդակության ձևաչափը:

Այնուամենայնիվ, XML-ի տարբերությունն այն է, որ այն ընդարձակելի է: XML-ը չունի նախապես սահմանված նշագրման լեզու, ինչպիսին HTML-ն է: Փոխարենը, XML-ը թույլ է տալիս օգտվողներին ստեղծել իրենց սեփական նշագրման նիշերը՝ բովանդակությունը նկարագրելու համար՝ ստեղծելով անսահմանափակ և ինքնորոշվող նիշերի շարք:

Ըստ էության, HTML-ը լեզու է, որը կենտրոնանում է բովանդակության ներկայացման վրա, մինչդեռ XML-ը հատուկ տվյալների նկարագրության լեզու է, որն օգտագործվում է տվյալների պահպանման համար:

XML-ը հաճախ օգտագործվում է որպես հիմք այլ փաստաթղթերի ձևաչափերի համար, որոնցից հարյուրավոր են: Ահա մի քանիսը, որոնք դուք կարող եք իմանալ.

• RSS-ը և ATOM-ը նկարագրում են, թե ինչպես պետք է հավելվածները վարվեն վեբ հոսքերի հետ:
• Microsoft .NET-ն օգտագործում է XML-ն իր կազմաձևման ֆայլերի համար:
• Microsoft Office-ը օգտագործում է XML-ը որպես փաստաթղթի կառուցվածքի հիմք:

Այսպիսով, եթե դուք ունեք XML ֆայլ, դա պարտադիր չէ, որ ձեզ ասի, թե ինչ հավելվածի համար է այն: Այնուամենայնիվ, դուք կարիք չունեք անհանգստանալու այս մասին, քանի դեռ չեք մշակում XML ֆայլեր:

Ինչպես բացել XML ֆայլ

XML ֆայլն ուղղակիորեն բացելու մի քանի եղանակ կա: Դուք կարող եք դրանք բացել և խմբագրել ցանկացած տեքստային խմբագրիչով, դիտել դրանք ցանկացած վեբ բրաուզերի միջոցով կամ օգտագործել կայք, որը թույլ է տալիս դիտել, խմբագրել և նույնիսկ փոխարկել դրանք այլ ձևաչափերի:

XML-ով կանոնավոր աշխատելիս օգտագործեք տեքստային խմբագրիչ

Քանի որ XML ֆայլերը պարզապես տեքստային ֆայլեր են, դրանք կարող են բացվել ցանկացած տեքստային խմբագրիչում: Այնուամենայնիվ, շատ տեքստային խմբագրիչներ, ինչպիսիք են Notepad-ը, պարզապես նախատեսված չեն XML ֆայլերը իրենց ճիշտ կառուցվածքով ցուցադրելու համար: Սա կարող է օգտակար լինել XML ֆայլի բովանդակությանը արագ ծանոթանալու համար: Բայց դրանց հետ աշխատելու համար ավելի հարմար գործիքներ կան։

Օգտագործելով վեբ զննարկիչը՝ XML ֆայլը դիտելու համար

Եթե ​​ձեզ հարկավոր չէ խմբագրել XML ֆայլը, այլ պարզապես ցանկանում եք դիտել բովանդակությունը, ձեր զննարկիչը կարող է լուծել այս խնդիրը: Ավելին, ձեր վեբ զննարկիչը, ամենայն հավանականությամբ, արդեն կազմաձևված է որպես ստանդարտ միջոցդիտելով XML ֆայլերը: Այսպիսով, կրկնակի սեղմելով XML ֆայլը, այն պետք է բացվի բրաուզերում:

Եթե ​​ոչ, կարող եք ֆայլի վրա աջ սեղմել՝ այն ցանկացած այլ հավելվածով բացելու տարբերակներ գտնելու համար: Պարզապես ընտրեք ձեր վեբ բրաուզերը ծրագրերի ցանկից:

Երբ ֆայլը բացվում է, դուք պետք է տեսնեք լավ կառուցվածքային տվյալներ: Այն այնքան էլ գեղեցիկ չէ, որքան գունային տեսքը, որը դուք ստանում եք Notepad++-ում, բայց շատ ավելի լավ է, քան notepad-ը:

Օգտագործելով առցանց խմբագրիչ XML ֆայլերի համար

Եթե ​​ցանկանում եք խմբագրել պատահական XML ֆայլ և չեք ցանկանում ներբեռնել նոր տեքստային խմբագիր, կամ ձեզ անհրաժեշտ է. փոխարկել xml ֆայլը այլ ձևաչափիԿան մի քանի պատշաճ առցանց XML խմբագիրներ, որոնք հասանելի են անվճար:

TutorialsPoint.com, XMLGrid.net և CodeBeautify.org - Թույլ են տալիս դիտել և խմբագրել XML ֆայլերը: Խմբագրումն ավարտվելուց հետո կարող եք ներբեռնել փոփոխված XML ֆայլը կամ նույնիսկ փոխարկել այն այլ ձևաչափի:

Օրինակ, մենք օգտագործում ենք CodeBeautify.org: Էջը բաժանված է երեք բաժինների. Ձախ կողմում XML ֆայլն է, որի հետ աշխատում եք: Մեջտեղում դուք կգտնեք մի քանի գործառույթ: Աջ կողմում կտեսնեք որոշ տարբերակների արդյունքները, որոնցից կարող եք ընտրել:

Օրինակ, ստորև նկարում մեր ամբողջական XML ֆայլը ձախ կողմում է, և արդյունքների վահանակը ցույց է տալիս ծառի տեսքը, քանի որ մենք սեղմեցինք ծառի տեսք կոճակը մեջտեղում:

Օգտագործեք «Թերթել» կոճակը՝ ձեր համակարգչից XML ֆայլը բեռնելու համար կամ «Բեռնել URL» կոճակը՝ XML-ն առցանց աղբյուրից առբերելու համար:

Tree View կոճակը արդյունքների վահանակում ցուցադրում է տվյալները լավ ձևաչափված ծառի կառուցվածքով՝ բոլոր պիտակները ընդգծված նարնջագույնով և ատրիբուտները պիտակների աջ կողմում:

Beatify-ը ցուցադրում է ձեր տվյալները կոկիկ, հեշտ ընթեռնելի ձևաչափով:

Minify կոճակը ցուցադրում է ձեր տվյալները՝ օգտագործելով հնարավորինս քիչ բացատներ: Այս ֆունկցիան կտեղադրի յուրաքանչյուր տվյալ մեկ տողի վրա: Սա օգտակար կլինի, երբ փորձում եք ֆայլը փոքրացնել, ինչը որոշակի տարածք կխնայի:

Եվ վերջապես, կարող եք օգտագործել XML դեպի JSON կոճակը XML փոխակերպումներ JSON ձևաչափով և կոճակ Արտահանում դեպի CSV՝ տվյալները պահելու համար որպես ստորակետերով առանձնացված արժեքների ֆայլ, կամ Ներբեռնման կոճակ՝ նոր XML ֆայլում ձեր կատարած ցանկացած փոփոխություն ներբեռնելու համար:

Բավականին երկար ժամանակ է անցել այն պահից, երբ ես խոստացա խոսել XML ձևաչափով տվյալների հետ աշխատելու մասին .NET հավելվածներ մշակելիս։ Խոստումները պետք է կատարվեն. Խնդրում ենք նկատի ունենալ, որ այս հոդվածը ուղղված է ոչ թե պրոֆեսիոնալ .NET ծրագրավորողներին, այլ նրանց, ովքեր դեռևս չունեն .NET հավելվածներ ստեղծելու նշանակալի փորձ:

Ինչու՞ պետք է աշխատենք XML-ի հետ:

Եթե ​​դեռ լավ չեք պատկերացնում, թե ինչ է XML-ը, ապա խորհուրդ եմ տալիս կարդալ «XML-ը լուրջ է և երկար ժամանակ» հոդվածը «KV» թիվ 2007 թ. Ավելի կարևոր բաների համար տարածք խնայելու համար XML ձևաչափն ինքնին այստեղ չի վերլուծվի:

Նախքան ծրագրի կոդի հետ ծանոթանալը, դուք պետք է պատասխանեք մեկ հիմնարար հարցի. ինչու՞ նույնիսկ ձեր հավելվածում ներառեք XML աջակցությունը: Կարծում եմ, շատերն իրենց այս հարցը տվել են բազմաթիվ տեխնոլոգիաների վերաբերյալ, և դրանցից ոչ բոլորն են ներառվել դիմումներում պատասխանից հետո։ Այնուամենայնիվ, XML-ի դեպքում իրավիճակը փոքր-ինչ այլ է, և կան իրական պատճառներ այս ձևաչափը շատ իրավիճակներում օգտագործելու համար:

XML-ի հիմնական առավելությունն այն է, որ իր բնույթով լինելով տեքստային ձևաչափ, այն, այնուամենայնիվ, կատարելապես թույլ է տալիս պահպանել և փոխանցել ցանկացած տվյալ: Քանի որ այս ձևաչափը տեքստ է, դրա միջպլատֆորմի խնդիրն ինքնին լուծվում է, իսկ XML տվյալների փոխանցման խնդիրը նույնքան հեշտությամբ լուծվում է (ինչպես, օրինակ, արվում է SOAP-ում): Բացի այդ, դուք կարող եք հեշտությամբ փոխել տվյալների փոխանցման կամ պահպանման ձևաչափը՝ ավելացնելով նոր ատրիբուտներ և առանց ավելորդ անհանգստանալու ձևաչափի նախորդ տարբերակների հետ համատեղելիության մասին, քանի որ հին տարբերակն օգտագործող հավելվածները կկարողանան կարդալ այն, ինչ անհրաժեշտ է՝ առանց ուշադրություն դարձնելու նորին։ պիտակներ կամ ատրիբուտներ: Շատ հավելվածներ օգտագործում են XML-ի վրա հիմնված ֆայլի ձևաչափեր, տվյալների փոխանցման շատ արձանագրություններ նույնպես հիմնված են XML-ի վրա, և երկուսի ցուցակները շարունակում են աճել:

Իհարկե, մյուս կողմից, XML-ն այնքան էլ խնայող չէ, քանի որ, ինչպես մի անգամ ճիշտ նշել է Computer News ֆորումի այցելուներից մեկը, XML փաստաթղթերը հաճախ բաղկացած են 10% տվյալներից և 90% պիտակներից: Այնուամենայնիվ, սա մեծապես կախված է նրանից, թե ինչ պիտակներ եք ընտրում: Դուք կարող եք գրել սբ. Մելնիկիտ, 2, հնարավո՞ր է . Չնայած, ճիշտն ասած, ինձ թվում է, որ ներկայիս կոշտ սկավառակների և հաստ ալիքների դեպքում առանձնապես սեղմվելու իմաստ չկա:

Այսպիսով, ճիշտ ձեռքերում, XML-ը հզոր և հարմար բան է, և այս ձևաչափի համատարած լինելու պատճառով դուք ընդհանրապես չեք կարող խուսափել դրանից: Այսպիսով, եկեք անցնենք գրելու ծրագրի կոդը.

Ծրագրավորման համար կօգտագործենք .NET հարթակի հիմնական լեզուն՝ C#: Որպեսզի հնարավորինս շատ ընթերցողներ ինքնուրույն պարապեն տվյալ ծրագրի կոդով, ես կօգտագործեմ C#-ի առաջին տարբերակը և .NET Framework-ը։

Տվյալների գրանցում

Նախ խոսենք տվյալներ գրելու մասին, քանի որ, գիտեք, ինչ-որ տեղից ինչ-որ բան կարդալու համար նախ պետք է ինչ-որ տեղ ինչ-որ բան գրել։ Եվ քանի որ ես և դու սկսեցինք ծրագրավորել, մեզ համար տեղին չէ ձեռքով ստեղծել XML տվյալները: Այսպիսով, եկեք նախ սկսենք գրել տվյալները XML-ում:

Նախ ստեղծեք նոր նախագիծ Visual Studio-ում, #Develop-ում կամ C# Builder-ում և ավելացրեք System.Xml ներմուծված անվանատարածքների ցանկում:

Հատուկ դաս՝ XmlTextWriter, պատասխանատու է .NET Framework-ում XML տվյալները գրելու համար, որը թույլ է տալիս գրել XML տվյալները կամայական հոսքի մեջ, այսինքն՝ մենք, ընդհանուր առմամբ, կարող ենք դրանք օգտագործել ֆայլում, տվյալների բազայում , և ուղարկեք ինչ-որ մեկին ինտերնետի միջոցով, բայց հիմա մենք ամեն ինչ կգրենք ֆայլի վրա: Դուք կարող եք վերահղել ելքը՝ փոխելով օբյեկտի կոնստրուկտորը (այսինքն՝ փոխանցելով ոչ թե ֆայլի անունը և դրա կոդավորումը սկզբնավորման ժամանակ, այլ մի օբյեկտ, որը տվյալներ է։ հոսք):

String FileName = "c:\\demo.xml"; XmlTextWriter xml = նոր XmlTextWriter (FileName, System.Text.Encoding.Unicode); xml.Formatting = Formatting.Indented; xml.WriteStartDocument(); xml.WriteStartElement("rootelement"); համար (int i = 0; i< 10; i++) { xml.WriteStartElement("subelement"); xml.WriteAttributeString("attrib1", "value1"); xml.WriteAttributeString("attrib2", i.ToString()); for (int j = 0; j < 10; j++){ xml.WriteStartElement("subsubelement"); xml.WriteAttributeString("attr", j.ToString()); xml.WriteEndElement(); } xml.WriteEndElement(); } xml.WriteEndElement(); xml.WriteEndDocument(); xml.Close();

Առաջին տողը, կարծում եմ, միանգամայն պարզ է. այն պարզապես գրանցում է այն ֆայլի անունը, որում մենք կպահպանենք տվյալները: Հաջորդը, մենք ստեղծում ենք XmlTextWriter տիպի օբյեկտ (այն կոչվում է, ինչպես տեսնում եք, xml), և դրա հետ միասին մենք կկատարենք հետագա բոլոր գործողությունները: Խնդրում ենք նկատի ունենալ, որ օբյեկտ կառուցելիս մենք նաև նշում ենք կոդավորումը, որում գրվելու է XML-ը. մեր օրինակում սա Unicode է: Հաջորդ տողը, ընդհանուր առմամբ, պարտադիր չէ, բայց այն մեր XML փաստաթուղթը, ինչպես ասում են, ընթեռնելի կդարձնի մարդու համար, այսինքն՝ կավելացնի անհրաժեշտ նահանջները և կկոտրի այն տողերի։ Առանց դրա, ամբողջ փաստաթուղթը կգրվեր մեկ տողով, ինչը, թեև խնայում է տարածքը, այն գործնականում ոչ պիտանի է դարձնում ձեռքով խմբագրման համար:

Փաստաթղթերի գրելը սկսվում է՝ կանչելով մեր xml օբյեկտի WriteStartDocument() մեթոդը։ Նրան հաջորդող տողը ավելացնում է «rootelement» արմատային տարրը մեր XML փաստաթղթին (հիշեցնեմ, որ XML փաստաթղթերի համար արմատային տարրը պետք է առկա լինի մեկ օրինակով): Հաջորդը, ցիկլի ընթացքում մենք ավելացնում ենք ևս տասը տարր, որոնք որևէ իմաստային բեռ չեն կրում մեր XML փաստաթղթին, որոնցից յուրաքանչյուրի համար մենք սահմանում ենք երկու հատկանիշ և ևս տասը ենթատարր: Խնդրում ենք նկատի ունենալ, որ մենք կարող ենք թիվ ավելացնել տողին՝ առանց տվյալների հստակ փոխակերպման, բայց եթե թիվը պետք է ամբողջությամբ կազմի տող, ապա այն պետք է բացահայտորեն փոխարկվի ToString() մեթոդի միջոցով: Նկատի ունեցեք նաև, որ մենք պետք է հստակորեն փակենք մեր XML փաստաթղթի յուրաքանչյուր տարր, այնուհետև ամբողջ փաստաթուղթը:

Այժմ, երբ մեր XML փաստաթուղթը հաջողությամբ գրվել է, տեսնենք, թե ինչպես կարող ենք կարդալ դրանից տվյալները:

Տվյալների ընթերցում

Ձեր հավելվածի ձևին ավելացրեք listBox բաղադրիչ (եթե, իհարկե, դա կոնսոլային հավելված չէ), որպեսզի կարողանաք վերահսկել XML ֆայլը կարդալու արդյունքը: Դե, եթե ձեր ծրագիրը կոնսոլային ծրագիր է, ապա դուք կարող եք հեշտությամբ վերահղել ելքը դեպի վահանակ:

Ինչպես միշտ, եկեք նախ ծանոթանանք ծրագրի կոդի հետ, իսկ հետո կնայենք, թե կոնկրետ ինչ է անում այս կոդը։

XmlTextReader xml = նոր XmlTextReader(FileName); xml.WhitespaceHandling = WhitespaceHandling.Ոչ մի; int i = 0; while (xml.Read())( if ((xml.NodeType == XmlNodeType.Element) & (xml.Name == «ենթատարր»)) (listBox1.Items.Add(«ենթահոդ» + i + «գտնվել է») i++ listBox1.Items.Add(" " + xml.GetAttribute("attrib1")); )( listBox1.Items.Add(" " + xml.GetAttribute("attr")); ) ) ) xml.Close();

Ընթերցանության համար, ինչպես նկատեցիք, մենք օգտագործում ենք մեկ այլ դաս՝ XmlTextReader: Այն գտնվում է նույն անվանատարածքում, ինչ դասը, որը մենք օգտագործել ենք տվյալները գրելու համար: Առաջին տողում մենք ստեղծում ենք XmlTextReader-ի օրինակ, որը կոչվում է xml (այստեղ մենք ենթադրում ենք, որ FileName փոփոխականն արդեն սահմանվել է մեր կողմից ավելի վաղ՝ դատարկ տողերը բաց թողնելու համար, եթե դրանք ինչ-որ կերպ անհասկանալի կերպով հայտնվում են մեր նոր ստեղծված XML ֆայլում, մենք օգտագործում ենք հետևյալը): Տողում նշված կոդի հատվածում i փոփոխականն օգտագործվում է XML ֆայլում հայտնաբերված «ենթատարրերի» քանակը հաշվելու համար, որոնցից կարդացվում են տվյալները:

Հաջորդը գալիս է ֆայլից տվյալների ուղղակի ընթերցման ցիկլը: Read() մեթոդը կարդում է XML փաստաթղթի հաջորդ տարրը, և այն կարդալուց հետո մենք ստուգում ենք, թե կոնկրետ ինչ ենք կարդացել։ Եթե ​​դա իսկապես «ենթատարր» տարր է, ապա մենք ավելացնում ենք տեղեկատվություն կարդացված տարրի մասին listBox1-ում, ավելացնում ենք ընթերցված տարրերի քանակը պարունակող փոփոխականը, այնուհետև կարդում ենք տարրի հատկանիշները։ Հատկանիշները կարդալուց հետո մենք կազմակերպում ենք առանձին օղակ՝ ենթատարրերը կարդալու համար (նկատի ունեցեք, որ դրա համար մեզ պետք չէ առանձին XmlTextReader) և այս ենթատարրերի ատրիբուտները, ինչպես նախկինում, մենք մուտքագրում ենք ամբողջ կարդացված տեղեկատվությունը listBox1-ում, որպեսզի վերահսկենք դրա ճշգրտությունը ընթերցանություն.

XML ֆայլերը կարդալիս, ինչպես դրանք գրելիս, XmlTextReader կառուցելիս կարող եք որպես պարամետր նշել հոսքը, որից պետք է կարդալ, այնուհետև կարող եք կարդալ ոչ միայն ֆայլերից, այլև այլ աղբյուրներից, օրինակներ. որը ես արդեն տվել եմ վերևում պետք է նշել XmlTextReader դասի մեկ օգտակար հատկանիշ. կարդալիս այն չի բեռնում ամբողջ XML փաստաթուղթը, որը կարդացվում է հիշողության մեջ, ուստի հարմար է վերլուծել մեծ XML փաստաթղթերը (օրինակ, XML տվյալների բազաները): .

Կուլիսների հետևում

Ընդհանուր առմամբ, օրինակը, որը մենք հենց նոր քննարկեցինք, չափազանց պարզ է իրական նախագծերի համար: Ներկայումս XML փաստաթղթերը կարդալիս դրանք սովորաբար վավերացվում են DTD-ի, XML Schema-ի կամ Relax NG-ի միջոցով: Վավերացումը ստուգում է, որ XML փաստաթղթի նշումը համապատասխանում է որոշ ստանդարտներին, որոնք նկարագրված են արտաքին ֆայլ. Վավերացումն անհրաժեշտ է, որպեսզի փաստաթղթի ստուգումը չմիացվի ծրագրի ալգորիթմին, բայց կարող է կամայականորեն փոփոխվել, երբ տվյալների ձևաչափը փոխվում է՝ առանց տվյալներ կարդացող կամ գրող ծրագրի կոդը թարմացնելու: Ցավոք, այժմ մենք ժամանակ չենք ունենա ստուգելու վավերացումը, քանի որ, ինչպես ինքներդ եք հասկանում, թերթի հոդվածի ծավալը որոշակի սահմանափակումներ ունի:

Մեկ այլ հետաքրքիր և օգտակար գործնական կետ՝ կապված XML տվյալների հետ աշխատելու հետ, XSL տվյալների փոխակերպումն է: Այս փոխակերպումը կիրառվում է տվյալների վրա, երբ դրանք ցուցադրվում են HTML էջերում և, փաստորեն, պարզապես կիրառում է որոշակի վեբ էջի ձևանմուշ XML ֆայլի վրա, որը պարունակում է որոշակի տվյալներ: Քանի որ XML տվյալների ներկայիս օգտագործման առյուծի բաժինն այս կամ այն ​​կերպ գտնվում է Համաշխարհային ցանցում, շատ, շատ լավ կլիներ դիտարկել XSL-ի փոխակերպումները:

Այսպիսով, կարծում եմ, այս հոդվածը կունենա շարունակություն, բայց, իհարկե, միայն այն դեպքում, եթե դուք ինքներդ (այսինքն՝ Computer News-ի ընթերցողները) հարցնեք այդ մասին ֆորումում կամ իմ էլ. հասցեին ուղղված նամակով։ Առայժմ դա, հավանաբար, վերաբերում է XML-ի օգտագործմանը .NET հավելվածներում: Հուսով եմ, որ այս տեղեկատվությունը օգտակար է ձեզ համար:

Այժմ մենք կուսումնասիրենք XML-ով աշխատելը։

XML-ը կայքերի միջև տվյալների փոխանակման ձևաչափ է:

Ի՞նչ է API-ն: Սա գործառույթների մի շարք է, որոնցով կարող եք հարցում ուղարկել այս կայք և ստանալ ցանկալի պատասխանը:

Այս պատասխանը ամենից հաճախ գալիս է XML ձևաչափով: Այսպիսով, եկեք սկսենք ուսումնասիրել այն:

PHP-ում XML-ի հետ աշխատելը

Ենթադրենք, դուք ունեք XML: Այն կարող է լինել տողի մեջ, կամ պահվել ֆայլում, կամ խնդրանքով մատուցվել կոնկրետ URL: Թող XML-ը պահվի տողի մեջ: Այս դեպքում, դուք պետք է ստեղծեք օբյեկտ այս տողից՝ օգտագործելով:

նոր SimpleXMLElement $str = " 25 1000 Կոլյա

$xml = նոր SimpleXMLElement($str); Այժմ մենք ունենք փոփոխականում$xml

վերլուծված XML-ով օբյեկտը պահվում է: Մուտք գործելով այս օբյեկտի հատկությունները, կարող եք մուտք գործել XML թեգերի բովանդակություն: Ստորև մենք կանդրադառնանք, թե կոնկրետ ինչպես: Եթե ​​XML-ը պահվում է ֆայլում կամ ուղարկվում է URL մուտք գործելու միջոցով (ինչն ամենից հաճախ պատահում է), ապա դուք պետք է օգտագործեք գործառույթը. simplexml_load_file Այժմ մենք ունենք փոփոխականում:

$str = " 25 1000

, որը կազմում է նույն առարկան

$xml = simplexml_load_file (ուղի դեպի ֆայլ կամ URL);

Աշխատանքային մեթոդներ

Ստորև բերված օրինակներում մեր XML-ը պահվում է ֆայլում կամ URL-ում:

$str = " 25 1000

Թող տրվի հետևյալ XML-ը.

Եկեք պարզենք աշխատողի անունը, տարիքը և աշխատավարձը.

$xml = simplexml_load_file (ուղի դեպի ֆայլ կամ URL); echo $xml->name; //կցուցադրի «Kolya» echo $xml->age; //կթողարկի 25 echo $xml->աշխատավարձ; //կթողարկի 1000

Ինչպես տեսնում եք, $xml օբյեկտն ունի պիտակներին համապատասխան հատկություններ։ Դուք կարող եք նկատել, որ պիտակը բողոքարկման մեջ ոչ մի տեղ չի հայտնվում:

$str = " 25 1000

Եկեք պարզենք աշխատողի անունը, տարիքը և աշխատավարձը.

Դա պայմանավորված է նրանով, որ դա արմատային պիտակն է: Դուք կարող եք այն վերանվանել, օրինակ, դեպի

- և ոչինչ չի փոխվի.

$str = " 25 1000

XML-ում կարող է լինել միայն մեկ արմատային պիտակ, ինչպես որ

պարզ HTML-ով:

Եկեք մի փոքր փոփոխենք մեր XML-ը.

Այս դեպքում մենք կստանանք հարցումների շղթա.

$xml = simplexml_load_file (ուղի դեպի ֆայլ կամ URL); echo $xml->worker->name; //կցուցադրի «Kolya» echo $xml->worker->age; // կթողարկի 25 echo $xml->աշխատող->աշխատավարձ; //կթողարկի 1000

Աշխատանք ատրիբուտների հետ

Թող որոշ տվյալներ պահվեն ատրիբուտներում.

Թիվ 1

$str = " $xml = simplexml_load_file (ուղի դեպի ֆայլ կամ URL); echo $xml->worker["name"]; //կցուցադրի «Kolya» echo $xml->worker["age"]; //կթողարկի 25 echo $xml->աշխատող["աշխատավարձ"]; // կթողարկի 1000 echo $xml->worker; //կցուցադրվի «Թիվ 1»

Պիտակներ գծիկներով

XML-ը թույլ է տալիս պիտակները (և ատրիբուտները) գծիկով: Այս դեպքում նման պիտակներ մուտք գործելը տեղի է ունենում այսպես.

Իվանովը

$str = " 25 1000 $xml = simplexml_load_file (ուղի դեպի ֆայլ կամ URL); echo $xml->worker->(first-name); //կցուցադրի «Kolya» echo $xml->worker->(last-name); //կցուցադրվի «Իվանով» 26 2000 Looping 27 3000

$xml = simplexml_load_file (ուղի դեպի ֆայլ կամ URL); foreach ($xml որպես $worker) ( echo $worker->name; //կցուցադրի «Kolya», «Vasya», «Petya»)

Օբյեկտից մինչև նորմալ զանգված

Եթե ​​ձեզ հարմար չէ օբյեկտի հետ աշխատելը, կարող եք այն վերածել սովորական PHP զանգվածի՝ օգտագործելով հետևյալ հնարքը.

$xml = simplexml_load_file (ուղի դեպի ֆայլ կամ URL); var_dump (json_decode (json_encode ($ xml), ճշմարիտ));

Լրացուցիչ տեղեկություններ

Վերլուծություն՝ հիմնված sitemap.xml-ի վրա

Հաճախ կայքն ունի sitemap.xml ֆայլ:

Այս ֆայլը պահպանում է կայքի բոլոր էջերի հղումները՝ որոնման համակարգերի կողմից ինդեքսավորման հեշտացման համար (ինդեքսավորումն ըստ էության կայքի վերլուծությունն է Yandex-ի և Google-ի կողմից):

Ընդհանրապես, մենք չպետք է շատ անհանգստանանք այն մասին, թե ինչու է անհրաժեշտ այս ֆայլը, գլխավորն այն է, որ եթե այն գոյություն ունի, դուք ստիպված չեք լինի սողալ կայքի էջերով որևէ բարդ մեթոդներով, այլ պարզապես օգտագործել այս ֆայլը:

Ինչպես ստուգել այս ֆայլի առկայությունը. եկեք վերլուծենք site.ru կայքը, այնուհետև բրաուզերում անցնենք site.ru/sitemap.xml - եթե ինչ-որ բան եք տեսնում, ապա այն այնտեղ է, և եթե չեք տեսնում, ապա ավաղ.

Եթե ​​կա կայքի քարտեզ, ապա այն պարունակում է հղումներ դեպի կայքի բոլոր էջերը XML ֆորմատով։ Հանգիստ վերցրեք այս XML-ը, վերլուծեք այն, առանձնացրեք ձեզ անհրաժեշտ էջերի հղումները ձեզ հարմար ցանկացած ձևով (օրինակ՝ վերլուծելով URL-ը, որը նկարագրված է spider մեթոդով):

Արդյունքում, դուք ստանում եք վերլուծության համար նախատեսված հղումների ցանկ, այն ամենը, ինչ դուք պետք է անեք, գնալ նրանց մոտ և վերլուծել ձեզ անհրաժեշտ բովանդակությունը:

Կարդացեք ավելին sitemap.xml սարքի մասին Վիքիպեդիայում։

Ինչ պետք է անեք հետո.

Սկսեք խնդիրներ լուծել՝ օգտագործելով հետևյալ հղումը՝ խնդիրներ դասի համար։