Znalost moderních nástrojů pro práci s XML. Vytvoření prvku XML s podřízenými prvky. Přístup k podřízeným prvkům
Práce s daty v XML formát v aplikacích ASP.NET 2.0 objekt XmlDataDocument a ovládací prvek XML
Tento modul se zaměřuje na to, jak můžete pracovat s daty XML z aplikací ASP.NET.
XML je zkratka pro Extensible Markup Language, ačkoli XML samo o sobě není jazyk. XML je sada pravidel používaných k vytváření vlastních značkovacích jazyků. Představte si například, že máme o zaměstnanci následující údaje:
Tato data lze samozřejmě prezentovat jakýmkoli způsobem: ve formě tabulky v relační databázeúdaje, ve formuláři Excel tabulky nebo HTML, jako tabulka v Word dokument nebo ve formě textový dokument ASCII, jako soubor *.csv atd. Pokud je představíme ve formátu značkovacího jazyka kompatibilního s XML ABML (Address Book Markup Language), který jsme vynalezli, budou vypadat takto:
Něco málo o tom, jak tento kód dešifrovat. První dva řádky jsou prologem (jeho použití je v zásadě nepovinné, ale vysoce doporučené). Čára
se nazývá deklarace XML a označuje, že soubor odpovídá specifikaci XML 1.0, přijaté jako doporučení konsorciem World Wide Web 10. února 1998. Čára
se nazývá Definice typu dokumentu a znamená, že struktura jazyka, kterému tento dokument odpovídá, je popsána v souboru abml.dtd (můžete také použít interní DTD, když je popis jazyka umístěn přímo v dokumentu). V dnešní době se k popisu struktury jazyků kompatibilních s XML častěji než DTD používá schéma XML – jsou snadněji přístupné a poskytují více možností, zejména při popisu různých datových typů. Stejný řádek využívající schéma XML by mohl vypadat takto:
v závislosti na tom, kde je samotné schéma - popis tohoto jazyka - umístěno v souboru abml.xml nebo na webovém serveru (firemní úložiště schémat od společnosti Microsoft - BizTalk Server).
Příklad schématu XML pro náš jazyk může vypadat takto:
XML je formalizovaná sada pravidel pro „označování“ dokumentu – to znamená zvýraznění jeho logické struktury. Co je uvnitř jakéhokoli dokumentu kompatibilního s XML, lze rozdělit do dvou kategorií: označení a samotný obsah. Všechny informace o značkách musí začínat buď znakem ampersand (&) nebo levou lomenou závorkou (<). В XML существует шесть типов информации разметки: элементы, атрибуты, комментарии, инструкции обработки, ссылки на сущности и разделы CDATA.
· Prvky(prvky) je nejběžnějším typem značkovacích informací. Prvek identifikuje logickou součást dokumentu. Typický dokument se skládá z otevíracích a zavíracích značek, které mohou obklopovat obsah, jiný prvek nebo obojí. Tagy s názvy prvků jsou uzavřeny v lomených závorkách. Zde je příklad prvku:
· Atributy(atributy) se skládají z páru název atributu/hodnota atributu a jsou aplikovány na prvky. Atributy by měly být umístěny za názvem prvku v úvodní značce. Atributy jsou například šířka a výška:
· Komentáře(komentáře) je jakýkoli text, který bude procesor XML ignorovat. Příklad:
· Návod na zpracování(instrukce pro zpracování) slouží k předání informací aplikaci zpracovávající dokument XML. Syntaxe instrukce pro zpracování vypadá takto:
· Reference entit Odkazy na entity se používají k umístění vyhrazených znaků nebo vyhrazených slov do dokumentu. Například potřebujeme vložit levou úhlovou závorku (<), которая является зарезервированным символом XML. Просто так вставить в текст документа мы ее не сможем: приложение, работающее с документом, решит, что она относится к разметке. Поэтому нам необходимо использовать сочетание символов <. lt означает méně než(menší než) a ampersand (&) a středník (;) zvýrazní odkaz na entitu.
· sekce CDATA(část CDATA) je část textu, která se nezpracovává jako zbytek dokumentu XML, ale je předána přímo aplikaci. Tento nástroj se může hodit například při předávání nějakého kódu do aplikace.
Principy syntaxe XML:
· Dokumenty XML se skládají ze znaků Unicode (Unicode je 16bitová znaková sada, která umožňuje zobrazení dokumentů v libovolném jazyce).
· XML rozlišuje velká a malá písmena. Tagy A jsou v něm různé značky.
· Mezery jsou neviditelné znaky, jako je mezera (ASCII 32), tabulátor (ASCII 9), znaky konce řádku (ASCII 13) a posuny řádků (ASCII 10). Bílé místo je v rámci tagů ignorováno, ale je zachováno ve znakových datech (tj. mezi úvodním a uzavíracím tagem). Prázdné místo ve znakových datech je předáno zpracovatelské aplikaci.
· Mnoho komponent XML musí mít názvy (nejviditelnějším příkladem jsou prvky a atributy). Pravidla pro pojmenování XML jsou následující: Název XML musí začínat písmenem nebo podtržítkem, po kterém následuje libovolný počet písmen, číslic, pomlček, podtržítek nebo teček, například:
My_Unique_Tag_Identifier-123 2_This_name_is_incorrect
· Název komponenty XML nemůže začínat znaky xml (velkými ani malými písmeny). Taková jména jsou vyhrazena tvůrcům specifikace pro oficiální účely.
· Hodnoty znaků musí být uzavřeny v jednoduchých nebo dvojitých uvozovkách.
· V XML se musí přesně dodržovat pořadí vnoření značek.
· Jakýkoli úvodní tag v XML musí mít odpovídající uzavírací tag.
· Prázdný tag v XML je zapsán jako úvodní tag, kterému předchází pravoúhlá závorka s lomítkem (/).
· V dokumentu XML může být pouze jeden kořenový prvek.
Jaké jsou výhody ukládání dat v XML oproti tradičním binárním formátům? Proč většina velkých výrobců softwaru v současné době buď zcela přechází na práci s daty ve formátu kompatibilním s XML (například Microsoft Office 2003), nebo plánuje přechod v blízké budoucnosti? Hlavním důvodem je, že XML data se velmi snadno přenášejí mezi širokou škálou aplikací a velmi snadno se transformují. Další body související s výhodami XML:
- Nezávislý formát dat - data ve formátu XML lze otevřít v jakékoli XML kompatibilní (přesněji kompatibilní s konkrétním schématem) aplikaci. Příklad: v každém podniku jsou dokumenty uloženy v různých formátech - formáty různých verzí Wordu, textu, HTML, PDF atd. Vzniká kvůli tomu spousta problémů, které lze radikálně vyřešit pomocí XML.
- Obecným principem je jeden zdroj dat (XML dokument), mnoho zobrazení. To lze jasně demonstrovat na příkladu webové stránky, na kterou je potřeba přistupovat z různých prohlížečů a přes WAP.
- Mnohem jednodušší přenos dat „přes“ aplikace. Příkladem je průchod dokumentů dodavatelským řetězcem nebo průchod dat mezi odlišnými softwarovými produkty v jednom podniku (což je velmi často nutné).
- Vylepšené možnosti vyhledávání dat. Za prvé není potřeba přistupovat k dokumentům různých binárních formátů a za druhé hierarchická struktura XML dokumentů usnadňuje vyhledávání.
- Jednodušší vývoj aplikací – Není potřeba implementovat do aplikací podporu velkého množství různých formátů binárních dat.
- Data v textovém formátu (XML - standard Unicode) se snáze než binárně ukládají na různých platformách a bezpečněji (z pohledu absence škodlivého binárního kódu) se přenášejí po sítích. Celým směrem ve vývoji aplikací jsou webové služby XML.
Správně vytvořený XML je kód XML, který odpovídá syntaktickým požadavkům daného jazyka (například každá úvodní značka má odpovídající uzavírací značku). Platné XML je platné z hlediska logické struktury jazyka (například prvky jsou vnořeny správně), jak je definováno v DTD nebo XML Schema.
Trochu terminologie XML, která bude použita v tomto kurzu:
· XSD - XML Schema Definition, popis struktury dokumentu XML běžně používaného ve VS .NET. Obvykle se nachází v souborech s příponou *.xsd. Uvnitř schématu jsou použity speciální značky
xmlns:od="urn:schemas-microsoft-com:officedata">
Chcete-li definovat prvek řetězce příjmení ve schématu, který se může v dokumentu vyskytnout 0 nebo vícekrát, můžete například použít následující značku:
type="string">
· k popisu transformací dokumentů kompatibilních s XML se používají dokumenty ve speciálním programovacím jazyce XSLT (eXtensible Stylesheet Language Transform). Samotný jazyk je samozřejmě také kompatibilní s XML. XSLT používá tři typy dokumentů:
o zdrojový dokument. Tento dokument XML je „vstupem“ pro transformaci. V našem případě by to mohl být tento dokument:
xml-stylesheet type="text/xsl" href=" Zaměstnanci1.xsl"?>
o Dokument šablony stylů XSLT – dokument kompatibilní s XML, který popisuje pravidla pro provádění transformací. V našem případě by příklad tohoto dokumentu mohl vypadat takto:
xmlns:xsl=" http://www.w3.org/1999/XSL/Transform"
verze=" 1.0 ">
o dokument - výsledek transformací. Například při aplikaci naší transformace bude jméno zaměstnance označeno červeně a jeho pozice bude označena modře.
· XPath je speciální jazyk, který lze použít k procházení stromem prvků XML. Při použití objektového modelu XPath je dokument XML reprezentován jako strom uzlů. Informace jsou obsaženy ve vlastnostech těchto uzlů.
· DOM (Document Object Model) - reprezentace stromu dokumentu XML v paměti RAM. DOM vám umožňuje procházet a upravovat dokument XML. Standardní vlastnosti, metody a události DOM jsou definovány v dokumentu přijatém W3C. V ASP.NET můžete pomocí DOM vytvořit dokument XML a odeslat jej do prohlížeče uživatele. Další možností je pro klientský skript vytvořit XML dokument na klientovi pomocí DOM a odeslat jej na webový server.
· XQuery je specializovaný jazyk pro dotazování na informace uložené v dokumentech XML. XQuery je z velké části založen na XPath.
Nutno říci, že XML je standardní formát pro práci s daty v ADO.NET. O formátu XML a jeho použití s DataSet - níže.
Možnosti použití XML při práci s DataSet jsou následující:
· DataSets mohou serializovat data ve formátu XML. Schéma DataSet (včetně tabulek, sloupců, datových typů a omezení) je definováno ve schématu XML (soubor .xsd).
· výměna dat z DataSetu se vzdálenými klienty musí být provedena ve formátu XML;
· XML lze použít k synchronizaci a transformaci dat do datové sady.
Trochu více o interakci mezi XML a DataSet:
· můžete nejen vytvořit schéma XML založené na DataSet (jak je uvedeno výše, to se provádí pomocí metody WriteXmlSchema), ale také naopak - vygenerovat DataSet na základě informací z jejich schématu XML (k tomu použijte ReadXmlSchema metoda). DataSet je možné vygenerovat i bez schématu – jednoduše na základě XML dokumentu. K tomuto účelu je určena metoda InferXmlSchema.
· je poskytnuta metoda pro objekt DataSet ReadXML, který umožňuje číst textový dokument XML (textový datový proud XML) do DataSet. Další metoda WriteXML, umožňuje uložit obsah DataSet ve formátu kompatibilním s XML. Tato funkce velmi usnadňuje organizaci výměny dat mezi různými aplikacemi a platformami.
· Můžete vytvořit reprezentaci XML (objekt XmlDataDocument) na základě informací z DataSet. Ukazuje se, že s informacemi v DataSet můžete pracovat dvěma způsoby: konvenčními relačními (se samotnou DataSet) a XML metodami. Oba pohledy jsou automaticky synchronizovány (když jsou změny provedeny prostřednictvím kteréhokoli pohledu).
· Transformace XSLT můžete aplikovat na data, která jsou uložena v DataSet.
Nyní si povíme, jak to vše vypadá v praxi.
Dim ds jako nová sada dat ()
ds.ReadXml(Server.MapPath("název souboru.xml"))
Metoda MapPath pro speciální objekt Server umožňuje převést virtuální cestu k souboru ve webové aplikaci na fyzickou cestu.
Zda je struktura DataSet generována automaticky ze souboru XML nebo zůstává stejná, závisí na tom, zda již byla v dané DataSet vygenerována a zda byl zadán volitelný parametr ReadXml XmlReadMode.
Dim ds jako nová sada dat ()
Dim da As New SqlDataAdapter(_
"vybrat * z autorů", conn)
da.Fill(ds)
ds.WriteXml(Server.MapPath("název souboru.xml"))
Existují dvě další metody, které vám umožňují získat data ve formátu XML z DataSet a vložit je do řetězcové proměnné. Jedná se o metody GetXml a GetXmlSchema. Příklad může vypadat takto:
ZtlumitstrXmlDSJakŘetězec =ds.GetXml()
DataSet často obsahuje objekty DataTable vzájemně propojené pomocí DataRelations (tj. tabulky s primárním a cizím klíčem). Při exportu do XML lze informace z nadřazené tabulky doplnit informacemi z podřízené tabulky. Záznamy z podřízené tabulky se zobrazí jako vnořené prvky pro záznamy z hlavní tabulky. Chcete-li implementovat tuto funkci, musíte nastavit vlastnost Nested na hodnotu True pro objekt DataRelation v DataSet (výchozí hodnota je False).
Řekněme, že pouze exportujeme data bez použití této vlastnosti:
Dim ds jako nová sada dat ()
'vyplňte DataSet
...
Dim parentCol As DataColumn = _
ds.Tables("Publishers").Columns("pub_id")
Dim childCol As DataColumn = _
ds.Tables("Tituly").Columns("pub_id")
ds.Relations.Add(dr)
ds.WriteXml(Server.MapPath("PubTitlesNotNested.xml"), _
XmlWriteMode.IgnoreSchema)
XML kód vypadá takto:
a nyní jej použijeme k nastavení vlastnosti Nested pro objekt DataRelation na True:
Dim dr jako nový DataRelation _
("TitlePublishers", parentCol, childCol)
dr. Nested = Pravda
ds.Relations.Add(dr)
ds.WriteXML(Server.MapPath("PubTitlesNested.xml"), _
XmlWriteMode.IgnoreSchema)
XML kód vypadá úplně jinak. Každý prvek typu Pub obsahuje prvky Titles vydané tímto vydavatelem:
XmlDataDocument je v paměti XML reprezentace dat v DataSet. XmlDataDocument je neoddělitelně spojen se sadou dat. Jakékoli změny provedené v XmlDataDocument se okamžitě projeví v DataSet a naopak. Níže si povíme o technikách práce s XmlDataDocument.
DataSet je relační reprezentace dat, zatímco XmlDataDocument je hierarchický. Použití XmlDataDocument je velmi pohodlné, protože práce s daty ve formátu XML pouze prostřednictvím DataSet může být obtížná. Pokud například načtete data ze souboru XML do DataSet a poté je uvolníte zpět, může se stát, že soubor nebude rozpoznatelný: dojde ke ztrátě formátování, dost možná i pořadí prvků, možná prvků, které byly ignorovány kvůli k nekonzistenci se schématem definovaným pro DataSet.
Dokument XML můžete vložit přímo do XmlDataDocument, nebo jej můžete vytvořit na základě DataSet. Kód pro první možnost může vypadat takto:
Dim objXmlDataDoc jako nový XmlDataDocument()
objXmlDataDoc.Load(Server.MapPath("file.xml"))
nebo takhle:
objXmlDataDoc.DataSet.ReadXml(Server.MapPath("soubor.xml"))
Žádný rozdíl v tom nebude.
Nebo můžete nejprve vytvořit sadu DataSet, naplnit ji daty a poté na jejím základě vytvořit XmlDataDocument:
Dim ds jako nová sada dat ()
'vyplňte ds
...
Dim objXmlDataDoc jako nový XmlDataDocument(ds)
Jakmile je objekt XmlDataDocument vytvořen, můžete s ním provádět různé akce:
· navázat na DataGrid a další ovládací prvky:
dg.DataSource = objXmlDataDoc.DataSet
· získat požadovaný řetězec (je vrácen jako objekt XmlElement):
Dim elem As XmlElement
elem = objXmlDataDoc.GetElementFromRow_
(ds.Tables(0).Rows(1))
· používat úplnou sadu vlastností a metod DOM. XmlDataDocument zdědí tyto vlastnosti a metody z objektu XmlDocument
· použít transformace XSLT (k tomuto účelu se používají objekty XslTransform).
Další informace o transformacích XSLT:
XSLT umožňuje transformovat zdrojový dokument XML na jiný dokument, který se liší formátem a strukturou. Například pomocí XSLT lze dokument XML převést na kód HTML pro zobrazení ve webové aplikaci. ASP.NET používá třídu XslTransform k provádění transformací XSLT.
Jaké to je pracovat s ním?
· Chcete-li provést transformace, musíte nejprve vytvořit DataSet a odpovídající XmlDataDocument:
Dim ds jako nová sada dat ()
'vyplňte DataSet
...
Dim xmlDoc jako nový XmlDataDocument(ds)
· další akce - vytvořte objekt XslTransform:
Dim xslTran jako nový XslTransform()
· pomocí metody Load tohoto objektu do něj načtete transformaci:
xslTran.Load(Server.MapPath("PubTitles.xsl"))
· vytvořte objekt XmlTextWriter (bude použit k zobrazení výsledků transformace):
Dim Writer As New XmlTextWriter _
(Server.MapPath("PubTitles_output.html"), _
System.Text.Encoding.UTF8)
· Samotnou transformaci provedeme pomocí metody Transform objektu XslTransform. Tato metoda má několik možností. Jeden způsob použití může vypadat takto:
xslTran.Transform(xmlDoc, Nothing, Writer)
· zavřete objekt Writer:
spisovatel.Zavřít()
Chcete-li pracovat s XML na webovém formuláři, můžete se obejít bez objektu DataSet (a ovládacích prvků určených k zobrazení dat z relačního zdroje). Místo toho můžete použít XML Web Server Control. Umožňuje zobrazit na webové stránce samotné XML dokumenty nebo výsledky jejich transformací. Kód XML lze tomuto ovládacímu prvku předat různými způsoby:
· otevřít je přímo z disku (přes vlastnost DocumentSource). V tomto případě (pokud jste nepoužili transformace XSLT), bude dokument XML vydán ve formě „tak jak je“:
Příklad XML
TransformSource="MyStyle.xsl" runat="server" />
· otevřít je jako objekty a předat je tomuto ovládacímu prvku (přes vlastnost Dokument). V našem případě XML Web Řízení serveru se nazývá Xml1:
Private Sub Page_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Zvládá MyBase.Load
Dim xmlDoc jako System.Xml.XmlDocument = _
Nový System.Xml.XmlDocument()
xmlDoc.Load(Server.MapPath("MySource.xml"))
Dim xslTran As System.Xml.Xsl.XslTransform = _
Nový System.Xml.Xsl.XslTransform()
xslTran.Load(Server.MapPath("MyStyle.xsl"))
Xml1.Document = xmlDoc
Xml1.Transform = xslTran
End Sub
· jednoduše programově vygenerujte kód XML a předejte tento kód XML do Řízení webového serveru (prostřednictvím vlastnosti DocumentContent)
· obecně přímo zadejte kód XML do tagu XML Web Server Control:
provést transformaci a přenést do ní výsledky transformace
Níže je uveden příklad, který ilustruje všechny tyto možnosti:
Document="XmlDocument objekt k zobrazení"
DocumentContent="String of XML"
DocumentSource="Cesta k dokumentu XML"
Transform="XslTransform object"
TransformSource="Cesta k transformačnímu dokumentu XSL"
runat = "server ">
Ovládací prvek webového serveru XML můžete přidat do webového formuláře pouhým přetažením tohoto ovládacího prvku z ToolBoxu nebo programově:
< asp:Xmlid="xmlCtl"runat = "server " />
XmlCtl.Dokument.Uložit (Server.MapPath("xmlResult.xml"))
Od doby, kdy jsem slíbil, že budu mluvit o práci s daty ve formátu XML při vývoji .NET aplikací, uplynula poměrně dlouhá doba. Sliby se musí plnit. Upozorňujeme, že tento článek není zaměřen na profesionální .NET vývojáře, ale na ty, kteří ještě nemají výraznější zkušenosti s tvorbou .NET aplikací.
Proč bychom měli pracovat s XML?
Pokud ještě nemáte moc dobrou představu o tom, co je XML, pak doporučuji přečíst si článek „XML to myslí vážně a na dlouho“ v „KV“ č. za rok 2007. Z důvodu úspory místa na důležitější věci zde nebude analyzován samotný formát XML.
Než se pustíte do seznamování s programovým kódem, musíte si odpovědět na jednu zásadní otázku: proč do své aplikace vůbec zahrnout podporu XML? Myslím, že mnoho lidí si tuto otázku ohledně mnoha technologií položilo a ne všechny byly po odpovědi zahrnuty do aplikací. U XML je však situace poněkud odlišná a v mnoha situacích existují skutečné důvody pro použití tohoto formátu.
Hlavní výhodou XML je to, že je svou povahou textový formát, ale přesto dokonale umožňuje ukládat a přenášet jakákoli data. Vzhledem k tomu, že se jedná o textový formát, je problém jeho multiplatformního řešení vyřešen sám o sobě a stejně snadno je vyřešen problém přenosu XML dat (jako je tomu například v SOAP). Kromě toho můžete snadno změnit formát přenosu dat nebo úložiště přidáním nových atributů a bez přílišných starostí o kompatibilitu s předchozími verzemi formátu, protože aplikace používající starou verzi budou moci číst, co potřebují, aniž by věnovaly pozornost novým značky nebo atributy. Mnoho aplikací používá formáty souborů založené na XML, mnoho protokolů pro přenos dat je také založeno na XML a seznamy obou se stále rozrůstají.
Na druhou stranu XML samozřejmě není příliš ekonomické, protože, jak jednou správně poznamenal jeden z návštěvníků fóra Computer News, XML dokumenty se často skládají z 10 % dat a 90 % značek. To však do značné míry závisí na tom, jaké značky zvolíte. Můžete psát
Takže ve správných rukou je XML výkonná a pohodlná věc a kvůli všudypřítomnosti tohoto formátu mu nemůžete vůbec uniknout. Pojďme tedy k psaní programového kódu.
Pro programování budeme používat hlavní jazyk platformy .NET - C#. Aby si s daným programovým kódem procvičilo co nejvíce čtenářů samo, použiji první verzi C# a .NET Framework.
Záznam dat
Nejprve si povíme něco o zápisu dat, protože, víte, abyste mohli něco odněkud číst, musíte nejprve někam něco napsat. A protože jsme vy a já začali programovat, není pro nás vhodné vytvářet XML data ručně. Začněme tedy nejprve zápisem dat do XML.
Nejprve vytvořte nový projekt v sadě Visual Studio, #Develop nebo C# Builder a přidejte System.Xml do seznamu importovaných jmenných prostorů.
Za zápis XML dat v .NET Frameworku je zodpovědná speciální třída XmlTextWriter, která umožňuje zapisovat XML data do libovolného streamu, tedy obecně řečeno, můžeme je použít k zápisu do souboru, databáze , a poslat někomu přes internet, ale nyní vše zapíšeme do souboru Výstup můžete přesměrovat změnou konstruktoru objektu (tj. předáváním nikoli názvu souboru a jeho kódování při inicializaci, ale objektu, který je datem. stream). Zdá se, že už trochu předbíhám, pojďme se nejprve seznámit s kódem zodpovědným za zápis dat do našeho souboru XML.
Řetězec Název_souboru = "c:\\demo.xml"; XmlTextWriter xml = new XmlTextWriter(Název souboru, System.Text.Encoding.Unicode); xml.Formatting = Formátování.Odsazené; xml.WriteStartDocument(); xml.WriteStartElement("rootelement"); for (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();
První řádek je myslím celkem jasný – prostě zaznamenává název souboru, do kterého data uložíme. Dále vytvoříme objekt typu XmlTextWriter (jmenuje se, jak vidíte, xml) a právě s ním provedeme všechny další operace. Upozorňujeme, že při konstrukci objektu také určujeme kódování, ve kterém bude XML zapsáno: v našem příkladu je to Unicode. Další řádek, obecně řečeno, není vyžadován, ale díky němu bude náš dokument XML, jak se říká, čitelný pro člověka, to znamená, že přidá potřebné odrážky a rozdělí ho na řádky. Bez toho by byl celý dokument napsán na jeden řádek, což sice šetří místo, ale pro ruční úpravy je prakticky nevhodný.
Zápis dokumentu začíná voláním metody WriteStartDocument() našeho xml objektu. Následující řádek přidává kořenový prvek „rootelement“ do našeho dokumentu XML (dovolte mi připomenout, že u dokumentů XML musí být kořenový prvek přítomen v jediné kopii). Dále v cyklu přidáme do našeho XML dokumentu deset dalších prvků, které nenesou žádnou sémantickou zátěž, pro každý z nich nastavíme dva atributy a deset dalších dílčích prvků. Upozorňujeme, že k řetězci můžeme přidat číslo, aniž bychom data explicitně převáděli, ale pokud číslo musí tvořit celý řetězec, musí být převedeno explicitně pomocí metody ToString(). Všimněte si také, že musíme explicitně zavřít každý z prvků našeho dokumentu XML a poté celý dokument.
Nyní, když byl náš dokument XML úspěšně napsán, se podívejme, jak z něj můžeme číst data.
Čtení dat
Přidejte do formuláře své aplikace komponentu listBox (pokud se samozřejmě nejedná o konzolovou aplikaci), abyste mohli sledovat výsledek čtení XML souboru. Pokud je váš program konzolovým programem, můžete výstup snadno přesměrovat do konzole.
Jako obvykle se nejprve seznámíme s kódem programu a poté se podíváme na to, co přesně tento kód dělá.
XmlTextReader xml = new XmlTextReader(NázevSouboru); xml.WhitespaceHandling = WhitespaceHandling.None; int i = 0; while (xml.Read())( if ((xml.NodeType == XmlNodeType.Element) & (xml.Name == "subelement")) ( listBox1.Items.Add("subelement " + i + " nalezen") ; i++; listBox1.Items.Add(" " + xml.GetAttribute("attrib1")); listBox1.Items.Add(" " + xml.Xml.Name == "podprvek")); )( listBox1.Items.Add(" " + xml.GetAttribute("attr")); ) ) ) xml.Close();
Pro čtení, jak jste si mohli všimnout, používáme jinou třídu, a to XmlTextReader. Nachází se ve stejném jmenném prostoru jako třída, kterou jsme použili k zápisu dat. V prvním řádku vytvoříme instanci XmlTextReader, pojmenovanou xml (zde předpokládáme, že proměnná FileName jsme již dříve definovali). řádek v daném fragmentu kódu Proměnná i se používá k počítání počtu prvků "subelement" nalezených v souboru XML, ze kterého jsou data načtena.
Následuje cyklus přímého čtení dat ze souboru. Metoda Read() přečte další prvek XML dokumentu a po jeho přečtení zkontrolujeme, co přesně čteme. Pokud se skutečně jedná o prvek „subelement“, pak přidáme informace o přečteném prvku do listBox1, inkrementujeme proměnnou obsahující počet přečtených prvků a poté přečteme atributy prvku. Po přečtení atributů zorganizujeme samostatnou smyčku pro čtení dílčích prvků (všimněte si, že k tomu nepotřebujeme samostatný XmlTextReader) a atributy těchto dílčích prvků jako dříve zadáme všechny načtené informace do listBox1, abychom kontrolovali jejich správnost čtení.
Při čtení souborů XML, stejně jako při jejich zápisu, můžete při konstrukci XmlTextReaderu zadat jako parametr stream, ze kterého se má číst, a pak můžete číst nejen ze souborů, ale také z jiných zdrojů, jejichž příklady mám Je třeba poznamenat jednu užitečnou vlastnost třídy XmlTextReader: při čtení nenačte celý čtený dokument XML do paměti, takže je vhodné analyzovat velké dokumenty XML (například databáze XML).
V zákulisí
Obecně je příklad, o kterém jsme právě hovořili, příliš jednoduchý pro skutečné projekty. V dnešní době se při čtení XML dokumentů většinou ověřují pomocí DTD, XML Schema nebo Relax NG. Validace je kontrola souladu označení dokumentu XML s nějakým standardem popsaným v externím souboru. Validace je nutná, aby ověření dokumentu nebylo pevně zapojené do programového algoritmu, ale bylo možné jej libovolně změnit, když se změní formát dat, aniž by se aktualizoval programový kód, který čte nebo zapisuje data. Bohužel nyní nebudeme mít čas vyřešit ověření, protože, jak sami chápete, objem novinového článku má určitá omezení.
Dalším zajímavým a užitečným praktickým bodem týkajícím se práce s daty XML je transformace dat XSL. Tato transformace se aplikuje na data, když jsou zobrazena na stránkách HTML, a ve skutečnosti je to jednoduše použití konkrétní šablony webové stránky na soubor XML obsahující nějaká data. Vzhledem k tomu, že lví podíl na současném využití dat XML je tak či onak Celosvětově Web, pak by bylo velmi, velmi hezké zvážit transformace XSL.
Myslím si tedy, že tento článek bude mít pokračování – ale samozřejmě pouze v případě, že se na něj vy sami (tedy čtenáři Computer News) zeptáte na fóru nebo v dopise na moji emailovou adresu. Prozatím je to pravděpodobně vše o používání XML v aplikacích .NET. Doufám, že tyto informace jsou pro vás užitečné.
Jazyk není syn, ale otec myšlenky.
Oscar Wilde
Zkratka XML znamená Extensible Markup Language, v překladu „rozšiřitelný značkovací jazyk“. Stejně jako HTML je podmnožinou SGML (Standard General Markup Language), „praotce“ značkovacích jazyků. S formátem XML jsme se setkali nejednou. Toto je formát konfiguračních souborů, souboru popisujícího zdroje dat objektů.
XML je univerzální, na platformě nezávislý standard pro popis informací, které lze použít k reprezentaci hierarchických dat a sjednocení přenášených informací. Bez jeho znalosti není možné porozumět SOAP a tedy ani webovým službám. XML se stalo de facto standardem pro přenos dat na internetu. Standard pro XML a související formáty definuje W3C (World Wide Web Konsorcium). Aspx stránky vytváříme například ve formátu XHTML - přechod mezi HTML a XML, jehož standard definuje i W3C. Standard XHTML ukládá přísnější pravidla pro správné vytvoření dokumentu, podobně jako pravidla XML.
Pojďme pochopit hlavní rozdíl mezi XML a HTML. XML je navržen tak, aby popisoval data a zaměřil se na to, co přesně to je. HTML je navrženo tak, aby zobrazovalo data a zaměřuje se na to, jak data vypadají. Pokud jsou v tradičním HTML pojmy „prezentace“ a „vizualizace“ často zaměňovány, pak při práci s XML tyto pojmy jasně oddělujeme. XML tagy nejsou na rozdíl od HTML tagů předdefinovány tvůrci jazyka. Každý autor dokumentu definuje své vlastní značky.
Norma vyžaduje, aby se program, který zpracovává dokument XML, musel zastavit, pokud narazí na chybu. A pokud prohlížeč zjistí v HTML nejasnou značku nebo absenci uzavírací značky, jednoduše ji ignoruje.
Na začátku XML dokumentu se vždy objeví jeho deklarace neboli prolog. Určuje verzi standardu XML, kterému odpovídá.
je chyba v XML.
Tagy mohou mít atributy. Hodnoty atributů musí být uzavřeny v uvozovkách. Na pořadí atributů nezáleží. Mezi úvodní a závěrečnou značkou může být text. XML zachovává všechny mezery nalezené v textu. Pokud není žádný text, můžete použít zkrácenou formu zápisu. Příklad značky XML:
| |
Toto je krátká forma značky
| |
Připomíná vám to něco? Pravidla pro popis prvků ASP.NET jsou naprosto stejná.
Existuje atribut xmlns, který definuje jmenný prostor. Jeho hodnotou může být jakýkoli jedinečný název. Existuje dohoda o používání adres URL, protože jsou jedinečné. Jmenné prostory mají význam podobný tomu, jak se používají v .NET Framework – aby nedošlo k záměně podobných názvů používaných různými vývojáři. Název oboru názvů je od názvu oddělen dvojtečkou.
Soubory XML představují hierarchické informace, které lze reprezentovat jako strom s jedním kořenem.
Dokumenty XML, které splňují všechny syntaktické požadavky, se nazývají dobře zformované. K popisu dat používá XML DTD (Document Type Definition) - definice typu dokumentu. Pokud soubor odpovídá DTD, je považován za platný.
Prohlížeče IE 6.0, FireFox 1.5 zobrazují soubory XML se zvýrazněním syntaxe. Nadřazené uzly lze rozšiřovat a zavírat. Například po zavření vypadá kořenový uzel souboru BirthDay.xml takto:
Vývojová prostředí Visual Studio a VWD Express kontrolují správnost xml dokumentů přímo při úpravách.
AdRotator
Ovládací prvek AdRotator umožňuje zobrazovat reklamní bannery a automaticky je nahrazovat jinými. Samotné bannery jsou popsány v souboru XML nebo jiném zdroji dat. Reklama se aktualizuje při každém obnovení stránky. Vlastnost AdvertismentFile určuje název souboru XML. Kostra souboru XML je následující.
|
|
Uvnitř uzlu Reklamy jsou uzly
Tyto uzly mají 5 atributů, z nichž všechny jsou volitelné.
Příklad souboru AdvertismentFile se nazývá ads.xml.
|
|
Na stránku je umístěn ovládací prvek. Jeho vlastnost AdvertisementFile odkazuje na tento soubor.
| |
Pokud je nastavena vlastnost Klíčové slovo, ovládací prvek zobrazí pouze reklamy, které odpovídají jeho obsahu. Protože ji lze dynamicky měnit, můžete reklamu přizpůsobit potřebám uživatele. Klíčové slovo se musí v souboru reklamy objevit alespoň jednou, jinak bude místo reklamy prázdný obdélník.
V předchozích verzích ASP.NET jste mohli pracovat pouze se soubory XML. Nyní můžete použít libovolný zdroj dat navázáním na ovládací prvek zdroje dat. V tomto případě musíte zadat alespoň 3 zdrojová pole ve vlastnostech ImageUrlField, NavigateUrlField a AlternateTextField.
| |
Soubory pro převod dokumentů
Je známo, že CSS (Cascading Stylesheets) se často používají k formátování souborů HTML, i když to není nutné, protože prohlížeče spojují určitý vzhled se všemi značkami. Živel
Nastaví odstavec - tučné písmo - prohlížeč ví, jak je zobrazit.
Protože XML nepoužívá předdefinované značky, jejich význam může být jakýkoli:
|
Pro výstup transformací XSLT pro každý prvek XML použijte značku xsl:for-each XSL. Prvek :for-each vyhledá prvky v dokumentu XML a zopakuje vzor pro každý z nich.
Data lze třídit pomocí značky xsl:sort, která musí být uvnitř prvku xsl:for-each:
Konečný vzhled transformačního souboru:
Slavné citáty
|
Pokud chcete vidět výsledek transformace dokumentu v prohlížeči, zahrňte deklaraci za XML deklaraci
| , |
nebo vyberte Zobrazit výstup XML z nabídky XML a zadejte transformační soubor.
Stejný dokument XML lze transformovat pomocí jiného souboru XSL:
Mistři aforismu |
Výsledkem budou nabídky oddělené vodorovnou čarou.
Soubory definice schématu dokumentu
Podle moderního standardu musí platný dokument odpovídat souboru, který je k němu přidružen XSD(XML Schema Definition) – Soubor definice schématu XML, který definuje konkrétní jazyk, tj. popisuje, jaké prvky a typy se mohou objevit v dokumentu. XSD schémata mají nahradit DTD (Document Type Definition), rozdíl mezi nimi je v tom, že samotné XSD soubory také používají XML syntaxi. Schémata XSD vám umožňují určit, které značky jsou povoleny, zda jsou vyžadovány nebo ne, zda se mohou v dokumentu opakovat a tak dále. XML tedy popisuje data a XSD popisuje strukturu těchto dat nebo metadat. Z programátorského hlediska je XSD popis typů, zatímco soubor XML popisuje objekty těchto typů. Pracovní návrh standardu XSD 1.1 je k dispozici na http://www.w3.org/TR/2003/WD-xmlschema-11-req-20030121/.
Soubor definice schématu začíná popisem prefixu jmenného prostoru, který je pak zahrnut ve všech prvcích souboru. http://tempuri.org se používá k nastavení URI pro jmenné prostory ASP.NET.
Tato definice například určuje, že prvek "Autor" je typu řetězec, musí se objevit pouze jednou, a pokud není zadán, nabývá hodnoty "Pushkin".
| |
Parametr maxOccurs="unbounded" určuje, že se prvek může objevit libovolněkrát.
Parametr ref umožňuje odkazovat na globální prvek nebo atribut již popsaný v daném souboru, aby se předešlo opakování stejných prvků.
- definovat jednoduché a složité typy.
XSD má předdefinované typy – v podstatě stejné jako .NET. Jsou převedeny na typy .NET za běhu aplikace. Na jejich základě můžete stavět složité typy podobné strukturám programovacích jazyků. Komplexní typ se skládá z posloupnosti deklarací prvků. Definujme komplexní typ
| |
Štítek
Štítek
Následující příklad definuje jednoduchý typ vnořený do definice prvku MyValue.
- Přidejte nové skupiny a skupiny atributů.
Komplexní definice typu může zahrnovat atributy. Řekněme, že chceme vytvořit schéma pro soubor, jako je tento:
Atributy mohou být pouze jednoduchých typů.
- Přidejte anotace.
Poznámky vám umožňují vkládat popisy existujících prvků a tím přidávat dokumentaci do souboru.
| |
Soubory XSD můžete v aplikaci Visual Studio 2005 upravovat jak prostřednictvím zdrojového kódu, tak pomocí návrháře. Pro dokument XML můžete automaticky vygenerovat odpovídající schéma. V okně vlastností dokumentu XML můžete zadat soubor schématu i transformační soubor. V tomto případě studio automaticky zkontroluje, zda soubor vyhovuje schématu, a dokonce IntelliSense nahradí tagy z tohoto souboru.
třída XmlReader
Pomocí třídy XmlReader můžete načíst data z dokumentů XML rychleji než jiné metody.
XmlReader je abstraktní třída. Pro zahájení čtení je objekt třídy XmlReaderSettings předán statické metodě Create. Tato funkce počítá počet uzlů v dokumentu.
| pomocí System.Xml; |
pomocí System.IO;
private int CountNodes(string xmlFile) ( int NodesCount=0; nastavení XmlReaderSettings = new XmlReaderSettings(); settings.IgnoreWhitespace = true; settings.IgnoreComments = true; using (XmlReader reader = XmlReader.Create(xmlFile, nastavení)) ( while reader.Read()) ( if (reader.NodeType == XmlNodeType.Element) ( NodesCount++; ) ) return NodesCount;
| Třída XmlReader umožňuje načíst třídy CLR z dokumentu. Dáme si jídelní lístek restaurace. |
Pojďme napsat funkci, která bude počítat součet cen a kalorií v menu.
protected void Page_Load(object sender, EventArgs e) ( int ItemsCount = 0; desítkové DishesTotal = 0; UInt16 CaloriesTotal = 0; XmlReaderSettings settings = new XmlReaderSettings(); settings.IgnoreWhitespace = true; NameTable nt); new = nt.Add("jídlo" cena objektu = nt.Add("cena"); objekt kalorie = nt.Add("kalorie" string MenuFile = Path.Combine(Request.PhysicalApplicationPath , "menu.xml"); ); pomocí (XmlReader reader = XmlReader.Create(MenuFile, nastavení)) ( while (reader.Read()) ( if (reader.NodeType == XmlNodeType.Element && food.Equals(reader.LocalName )) ( ItemsCount++; ) if (reader.NodeType == XmlNodeType.Element && price.Equals(reader.LocalName)) (DishesTotal += (UInt16)reader.ReadElementContentAsDecimal(); ) if (reader.NodeType == XmlNodeType.Equals &(čtečka kalorií. .LocalName)) ( CaloriesTotal += (UInt16)reader.ReadElementContentAsInt(); ) ) Response.Write(String.Format("Objednali jste si (0) jídla v hodnotě (1:C), (2) kalorie", ItemsCount, DishesTotal , Calories Total));
)
| <% XPathDocument doc = new XPathDocument(Server.MapPath("App_Data\\Quotes.xml")); XslCompiledTransform xsl = new XslCompiledTransform(); xsl.Load(Server.MapPath("App_Data\\Quotes.xsl")); xsl.Transform(doc, null, Response.OutputStream); %> |
Třída XPathDocument
Třída poskytuje čtení a ukládání dokumentů XML do paměti pro transformace pomocí XSL. V dokumentu můžete procházet libovolným směrem a získat náhodný přístup k libovolnému prvku pomocí výrazů XPath.
Vezměme si XML dokument „Quotes.xml“ a transformační soubor XSL „Quotes.xsl“. Výsledek transformace dokumentu XML bude odeslán do výstupního proudu stránky.
V předchozím příkladu bylo možné stejného výsledku dosáhnout umístěním ovládacího prvku XML na stránku.
| |
XMLDataSource
Prvek zdroje dat XMLDataSource poskytuje jednoduchý způsob, jak propojit dokumenty XML jako zdroje dat s prvky, které zobrazují informace. Můžete také zadat dotaz XPath pro filtrování dat. Stejně jako SqlDataSource umožňuje upravovat, mazat, přidávat datové záznamy. Chcete-li to provést, musíte přistupovat k objektu XmlDataDocument, který se v něm nachází, voláním metody GetXmlDocument. Po úpravě se dokument uloží pomocí metody Uložit.
Na rozdíl od tabulkových dat v DBMS jsou data v souborech XML hierarchická, takže XMLDataSource je vhodné svázat s hierarchickými ovládacími prvky, jako je Menu.
Syntaxe XML Data Binding
Vzhledem k tomu, že aplikace stále častěji používají data XML, byla zavedena metoda, jak svázat data získaná z XMLDataSource.
Tyto metody fungují stejně jako Bind a Eval, o kterých se hovořilo v 7. přednášce.
Aplikujme tuto syntaxi na prvek DataList, který přijímá data z XmlDataSource:
Závěr
V této přednášce jsme se podívali na práci s XML daty. XML poskytuje univerzální způsob popisu a výměny strukturovaných informací, nezávislý na aplikacích a vývojářích. Tím je úvaha o práci se zdroji dat dokončena.
V prvním článku na blogu .NET „Práce s XML“ lidé v komentářích požadovali článek o LINQ to XML. Nuže, zkusme odhalit principy fungování této nové technologie od Microsoftu.
Vytvořme základnu pro vedení katalogu zvukových nahrávek. Databáze se bude skládat ze skladeb:
- Jméno
- Vykonavatel
- Album
- Trvání
Nejprve si vytvoříme konzolovou aplikaci (své projekty píšu v C#, ale podstata bude obecně každému jasná) a propojíme potřebný jmenný prostor
Pomocí System.Xml.Linq;
Generování XML souborů
Vytvořme XML soubor naší databáze obsahující několik testovacích záznamů pomocí LINQ:
//nastavíme cestu k našemu pracovnímu souboru XML řetězec fileName = "base.xml"; //počítadlo pro číslo stopy int trackId = 1; //Vytvoření vnořenými konstruktory. XDocument doc = new XDocument(new XElement("library", new XElement("track", new XAttribute("id", trackId++), new XAttribute("genre", "Rap")), new XAttribute("time", " 3:24"), nový XElement("název", "Kdo jsme RMX (feat. 2Pac)"), nový XElement("umělec", "DMX"), nový XElement("album", "")), new XElement("track", new XAttribute("id", trackId++), new XAttribute("genre", "Rap"), new XAttribute("time", "5:06"), new XElement("name", "Angel (ft. Regina Bell)")), nový XElement("umělec", "DMX"), nový XElement("album", "...And Then There Was X")), nový XElement("track", nový atribut XAttribute("id", trackId++), nový atribut XAttribute("žánr", "Break Beat"), nový atribut XAttribute("čas", "6:16"), nový prvek XElement("name", "Dreaming Your Dreams") , nový XElement("artist", "Hybrid"), nový XElement("album", "Wide Angle"), nový XElement("track", nový XAttribute("id", trackId++), nový XAttribute("žánr" , "Break Beat"), nový XAttribute("čas", "9:38"), nový XElement("název", "Dokončená symfonie"), nový XElement("umělec", "Hybrid"), nový XElement(" album", "Wide Angle")))); //uložte náš dokument doc.Save(fileName);
Nyní se po spuštění ve složce s naším programem objeví soubor XML s následujícím obsahem:
Chcete-li vytvořit takový soubor pomocí XmlDocument, kód vyžadoval asi 2krát více. Ve výše uvedeném kódu jsme použili konstruktor třídy XDocument, který jako parametr bere seznam podřízených prvků, se kterými chceme dokument zpočátku inicializovat. Použitý konstruktor XElement bere jako parametr název prvku, který vytváříme, a také seznam inicializačních prvků. V těchto prvcích můžeme pohodlně nastavit jak nový XElement, tak XAttribute. Ten bude vykreslen do našeho souboru jako atributy nezávisle. Pokud se vám takové vnořování konstruktorů nelíbí a takový kód považujete za těžkopádný, můžete jej přepsat do tradičnější verze. Níže uvedený kód vygeneruje podobný soubor XML:
XDocument doc = nový XDocument(); Knihovna XElement = new XElement("knihovna"); doc.Add(knihovna); //vytvoří prvek "track" XElement track = new XElement("track"); //přidejte potřebné atributy track.Add(new XAttribute("id", 1)); track.Add(new XAttribute("žánr", "Rap")); track.Add(new XAttribute("time", "3:24")); //vytvoří prvek "name" XElement name = new XElement("name"); name.Value = "Who We Be RMX (feat. 2Pac)";
track.Add(name);
//создаем элемент "artist"
XElement artist = new XElement("artist");
artist.Value = "DMX";
track.Add(artist);
//Для разнообразия распарсим элемент "album"
string albumData = "!}
Samozřejmě musíte zvolit potřebnou metodu v závislosti na situaci.
Čtení dat ze souboru
//nastavíme cestu k našemu pracovnímu souboru XML řetězec fileName = "base.xml"; //přečtení dat ze souboru XDocument doc = XDocument.Load(fileName); //procházíme každý prvek v nové knihovně //(tento prvek je okamžitě přístupný prostřednictvím vlastnosti doc.Root) foreach (XElement el v doc.Root.Elements()) ( //Vypíše název prvku a hodnota atributu id Console.WriteLine(" (0) (1)", el.Name, el.Attribute("id").Value.Console.WriteLine(" Atributy:"); atributy ve smyčce, zároveň vidíme, jak se převádějí na řetězec foreach (XAttribute attr v el.Attributes()) Console.WriteLine(" (0)", attr.WriteLine(" Elements:"); ); // tisk názvů všech podřízených prvků a jejich hodnot ve smyčce foreach (prvek XElement) v el.Elements()) Console.WriteLine(" (0): (1)", element.Name, element .hodnota)
Myslím, že zde v kódu není nic složitého a jsou poskytovány komentáře. Po spuštění našeho programu se v konzole zobrazí následující výsledek:
Skladba 1 Atributy: id="1" žánr="Rap" time="3:24" Prvky: název: Who We Be RMX (feat. 2Pac) interpret: DMX album: The Dogz Mixtape: Who's Next?! skladba 2 Atributy: id="2" Žánr="Rap" time="5:06" Prvky: jméno: Angel (ft. Regina Bell) umělec: DMX album: ...And Then There Was X track 3 Atributy: id= "3" žánr="Break Beat" time="6:16" Prvky: název: Dreaming Your Dreams umělec: Hybridní album: Širokoúhlá skladba 4 Atributy: id="4" žánr="Break Beat" time="9: 38" Elements: název: Hotový Symfonický umělec: Hybridní album: Wide Angle
Změna údajů
Zkusme projít všechny uzly knihovny a zvýšit atribut Id prvku stopy o 1.
(Deklaraci cesty k souboru a výsledek výstupu do konzole dál psát nebudu, abych článek nezahltil zbytečnými informacemi, vše jsem zkompiloval, vše funguje :)):
//Získání prvního podřízeného uzlu z knihovny XNode node = doc.Root.FirstNode; while (node != null) ( //zkontrolujte, zda je aktuální uzel prvkem if (node.NodeType == System.Xml.XmlNodeType.Element) ( XElement el = (XElement)node; //získáte hodnotu atribut id a převeďte jej do Int32 int id = Int32.Parse(el.Attribute("id").Value //zvýšte počítadlo o jedničku a přiřaďte hodnotu zpět id++ el.Attribute("id"); Hodnota = id.ToString() ) ) //přesun na další uzel node = node.NextNode ) doc.Save(název_souboru);
Nyní to zkusme udělat pro naše úkoly správnějším způsobem:
Foreach (XElement el v doc.Root.Elements("track")) ( int id = Int32.Parse(el.Attribute("id").Value); el.SetAttributeValue("id", --id); ) doc.Save(název souboru);
Jak vidíte, tento způsob nám vyhovoval více.
Přidání nového záznamu
Pojďme přidat novou stopu do naší knihovny a zároveň spočítat následující jedinečné ID pro stopu pomocí LINQ:
Int maxId = doc.Root.Elements("track").Max(t => Int32.Parse(t.Attribute("id").Value)); Skladba XElement = new XElement("track", new XAttribute("id", ++maxId), new XAttribute("genre", "Break Beat"), new XAttribute("time", "5:35"), new XElement("jméno", "Vyšší než mrakodrap"), nový XElement("umělec", "Hybrid"), nový XElement("album", "Ranní sci-fi")); doc.Root.Add(track); doc.Save(název souboru);
S takto vzneseným dotazem na všechny prvky se vypočítá maximální hodnota atributu id stop. Při přidávání inkrementujeme výslednou maximální hodnotu. Samotné přidání prvku spočívá ve volání metody Add. Vezměte prosím na vědomí, že přidáváme prvky do kořenového adresáře, protože jinak narušíme strukturu dokumentu XML tím, že tam deklarujeme 2 kořenové prvky. Nezapomeňte také uložit svůj dokument na disk, protože do uložení se žádné změny v našem XDocumentu neprojeví v souboru XML.
Odebírání položek
Pokusme se odstranit všechny prvky DMX umělců:
IEpočetné
V tomto příkladu jsme nejprve vybrali všechny stopy, jejichž podřízený prvek artst splnil kritéria, a poté jsme tyto prvky ve smyčce odstranili. Důležité je volání ToList() na konci výběru. Tímto způsobem zaznamenáme do samostatné oblasti paměti všechny prvky, které chceme vymazat. Pokud se rozhodneme vymazat z množiny záznamů, které procházíme přímo ve smyčce, dostaneme odstranění prvního prvku a následnou NullReferenceException. Je tedy důležité si to pamatovat.
Podle rady xaoccps jej můžete smazat jednodušším způsobem:
IEpočetné
V tomto případě není potřeba převádět náš výsledný výsledek na seznam voláním funkce ToList(). Proč tato metoda nebyla původně popsána v
Představujeme vám nový kurz od týmu The Codeby- "Penetrační testování webových aplikací od nuly." Obecná teorie, příprava pracovního prostředí, pasivní fuzzing a otisky prstů, Aktivní fuzzing, Vulnerabilities, Post-exploitation, Tools, Social Engeneering a mnoho dalšího.
XML DOM 2
Předchozí článek popisoval obecné pojmy týkající se XML. V tomto článku se naučíme, jak provádět základní akce související se změnou, přidáváním, vyhledáváním v XML souboru.
XML soubor, který je použit pro příklad.
xml dom
V tuto chvíli náš soubor obsahuje následující strukturu:
Vztah mezi uzly v XML DOM, hlavní body:
1. Jakýkoli uzel ve stromu DOM má nadřazený uzel ParentNode. V našem příkladu je garáž rodičem obou prvků auta a oba prvky auta jsou zase rodiči prvků modelu a roku.
Jak získat rodič prvku xml car?
Console.WriteLine(elmRoot["auto"].ParentNode.Name); //Výsledek: garáž
2. Rodič může mít děti ChildNodes. Například pro uzel garáže jsou děti oba prvky auta. Prvky vozu mají také dětský model a rok výroby.
ChildNodes, je kolekce, která ukládá všechny podřízené prvky xml, abyste získali přístup k požadovanému prvku, musíte zadat jeho index. (Index vždy začíná od nuly!)
Například: jak získat první podřízený prvek?
ElmRoot.ChildNodes;
3. Stejně jako v běžném životě se dítě může narodit jako první FirstChild, nebo poslední LastChild.
Vezmeme-li jako příklad prvek auta, pak
FirstChild je model LastChild je rok
4. Mezi dětskými elementy zase existují souvislosti, mohou to být bratři nebo sestry, pokud nakreslíme paralely se skutečným životem.
Dítě může mít například bratra předchozího sourozence a bratra dalšího sourozence
Console.WriteLine(elmRoot.ChildNodes.FirstChild.NextSibling.Name); //Výsledek: rok Console.WriteLine(elmRoot.ChildNodes.LastChild.PreviousSibling.Name); //Výsledek: model
Pokud prvek není nalezen, je vyvolána výjimka: NullReferenceException, takže při práci s xml vždy používejte bloky try catch.
Console.WriteLine(elmRoot.ChildNodes. LastChild.NextSibling.Name); Console.WriteLine(elmRoot.ChildNodes. FirstChild.PreviousSibling.Name);
LastChild je NextSibling;
FirstChild je PředchozíSibling;
Pomocí výše popsaných metod se můžete snadno přesunout na požadovaný uzel a získat libovolnou hodnotu, kterou potřebujete.
Jak získat hodnotu prvku xml?
Hodnotu xml prvku lze získat pomocí vlastnosti InnerText, například:
Console.WriteLine(elmRoot["auto"].FirstChild.InnerText); //Výsledek: Mazda
Další způsob, jak získat stejnou hodnotu prvku xml:
Console.WriteLine(elmRoot.FirstChild.FirstChild.InnerText); //Výsledek: Mazda
Posloupnost pohybů podél stromu DOM:
Garáž -> auto -> model -> Mazda
Dostáváme rok:
ElmRoot["auto"].LastChild.InnerText; //Výsledek: 2007
Následná sekvence:
Garáž -> auto -> rok -> 2007
Další příklad: 3 způsoby, jak dosáhnout stejného výsledku.
Console.WriteLine(elmRoot.LastChild.FirstChild.InnerText); Console.WriteLine(elmRoot["auto"].NextSibling.FirstChild.InnerText); Console.WriteLine(elmRoot.ChildNodes.Item(1).FirstChild.InnerText); //Výsledek: BMW
Pokud potřebujete získat rok pro prvek s hodnotou Mazda:
Console.WriteLine(elmRoot.FirstChild.LastChild.InnerText); //Výsledek: 2007
Pro BMW (dva způsoby, získáte stejný výsledek)
Console.WriteLine(elmRoot.ChildNodes.Item(1).ChildNodes.Item(1).InnerText); Console.WriteLine(elmRoot.ChildNodes.ChildNodes.InnerText); //Výsledek: 2009
Jak změnit hodnoty prvků xml?
Použití majetku InnerText() Můžete získat i změnit hodnotu prvku xml, například změnit rok.
//Nastavit novou hodnotu elmRoot.FirstChild.LastChild.InnerText = "2010"; //Zobrazení nové hodnoty na obrazovce konzoly Console.WriteLine(elmRoot.FirstChild.ChildNodes.Item(1).InnerText); //Výsledek: 2010
Zároveň si musíte pamatovat, že všechny změny probíhají s virtuálním xml souborem, pokud otevřete fyzický soubor, uvidíte, že je v něm stále uveden rok 2007;
Aby se změny projevily, musíte použít metodu Uložit, například:
ElmRoot.Save("název xml souboru nebo stream");
Nyní budou informace změněny ve „fyzickém“ souboru xml.
Jak získat počet podřízených prvků?
Console.WriteLine(elmRoot.FirstChild.ChildNodes.Count);garáž -> auto obsahuje 2 děti: model a rok
Console.WriteLine(elmRoot.FirstChild.FirstChild.ChildNodes.Count);
garáž -> auto -> model obsahuje 1 podřízený prvek xml.
Přístup k podřízeným prvkům
podle indexu
ElmRoot.ChildNodes.Name; elmRoot.ChildNodes.Name; //Výsledek: auto
Pomocí smyčky
Foreach (XmlNode nod v elmRoot.ChildNodes) ( Console.WriteLine(nod.Name); ) //Výsledek: auto, auto
Jak získat název prvku xml?
elmRoot.Name; //Výsledek: garážVytvoření nového prvku XML
Vytvořme nový prvek v našem XML dokumentu tak, aby se lišil od ostatních dvou (auto), říkejme mu sběrnice.
Při vytváření nového prvku využijeme doporučení z webu msdn a místo standardního nového XmlElement použijeme metodu CreateElement.
XmlElement elm = xmlDoc.CreateElement("bus");
Vytvoření a přidání nového prvku xml
Vytvořme nový xml prvek s názvem "BUS".
XmlElement elmRoot = xmlDoc.DocumentElement; Console.WriteLine(elmRoot.ChildNodes.Count); //auto, auto XmlElement elmNew = xmlDoc.CreateElement("bus"); elmRoot.AppendChild(elmNew); Console.WriteLine(elmRoot.ChildNodes.Count); //3 auto, auto, autobus xmlDoc.Save("název souboru xml");Vysvětlení:
1. Nejprve získáme kořenový prvek, ke kterému budeme připojovat nové prvky.
2. Pro kontrolu zobrazíme aktuální počet podřízených prvků garážového prvku: 2 (auto a auto)
3. Vytvořte nový prvek BUS
4. Použití metody AppendChild přidání nového prvku do stromu
5. Opět použijeme kontrolu a zobrazíme aktuální počet prvků pro prvek garáž, nyní jsou 3: auto, auto, autobus.
6. Aby změny ovlivnily fyzický soubor, uložte
V samotném XML souboru bude nový prvek vypadat takto:
Jak přidat nový prvek xml?
Úkol: vytvořte nový XML element a přidejte do něj nějaký textový obsah, například rok výroby.
String strFilename = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = new 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();
V souboru XML:
Pro přehlednost
Nyní vytvoříme „autobusový“ uzel se stejnou architekturou jako auto, tedy přidáme uzly: model, rok a nějaký textový obsah.
Vytvoření prvku XML s dětmi
string strFilename = @"C:\lekce\Auto.xml"; //vytvoří nový xml dokument v paměti XmlDocument xmlDoc = new XmlDocument(); //načtení xml souboru do paměti xmlDoc.Load(strFilename); //Získání kořenového prvku XmlElement elmRoot = xmlDoc.DocumentElement; //Vytvoření 3 prvků: sběrnice, model, rok XmlElement elmBUS = xmlDoc.CreateElement("bus"); XmlElement elmModel = xmlDoc.CreateElement("model"); XmlElement elmYear = xmlDoc.CreateElement("rok"); //Nastavte hodnoty pro prvky: model, rok XmlText year_txt = xmlDoc.CreateTextNode("2006"); //XmlText mod_txt = xmlDoc.CreateTextNode("liaz"); přidat jinak //Přidat dva podřízené prvky k prvku sběrnice: model a rok elmBUS.AppendChild(elmModel); elmBUS.AppendChild(elmYear); //Přidání hodnot do uzlů modelu a roku elmModel.InnerText = "liaz"; elmYear.AppendChild(year_txt); //Přidání nové sběrnice prvků xml do stromu elmRoot.AppendChild(elmBUS); //Zkontrolujte, zda je vše přidáno tak, jak má Console.WriteLine(elmRoot.ChildNodes.FirstChild.InnerText); Console.WriteLine(elmRoot.LastChild.LastChild.InnerText); //Pokud je vše v pořádku, pak použijte metodu Uložit xmlDoc.Save("název souboru xml");Výsledek:
Jak mohu zkrátit tento kód? Například takto:
String PathXmlFile = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(PathXmlFile); XmlElement elmRoot = xmlDoc.DocumentElement; XmlElement elmBUS = xmlDoc.CreateElement("sběrnice"); XmlElement elmModel = xmlDoc.CreateElement("model"); XmlElement elmYear = xmlDoc.CreateElement("rok"); //Přidání hodnot do uzlů modelu a roku elmModel.InnerText = "liaz"; elmYear.InnerText = "2006"; elmBUS.AppendChild(elmModel); elmBUS.AppendChild(elmYear); elmRoot.AppendChild(elmBUS); //Pokud je vše v pořádku, zavolejte metodu Save xmlDoc.Save("název souboru xml");
Pojďme kód ještě trochu zkrátit, k tomu použijeme vlastnost InnerXml:
XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(PathXmlFile); XmlElement elmXML = xmlDoc.CreateElement("sběrnice"); řetězec txt = "
Výsledek
Získejte seznam prvků pomocí GetElementByTagName
GetElementByTagName vrátí XmlNodeList, který obsahuje všechny potomkové prvky patřící k zadanému prvku, například potřebujeme získat všechny modely aut, které jsou uloženy v garáži:
XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(strFilename); XmlNodeList modelName = xmlDoc.GetElementsByTagName("model"); foreach (uzel XmlNode v modelName) ( Console.WriteLine(node.InnerText); ) //Výsledek: mazda, bmw, liaz
Přístup pomocí indexu:
String PathXmlFile = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(PathXmlFile); XmlNodeList modelName = xmlDoc.GetElementsByTagName("model"); Console.WriteLine(název modelu.VnitřníText); //Výsledek: liaz
Jak mohu změnit textový obsah nově vytvořeného prvku "sběrnice" pomocí metody GetElementByTagName?
String PathXmlFile = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(PathXmlFile); XmlNodeList modelName = xmlDoc.GetElementsByTagName("model"); Console.WriteLine(název modelu.VnitřníText); //Přijata hodnota: liaz
Nebo můžete změnit název liaz na Ikarus
Console.WriteLine(název modelu.InnerText = "Ikarus");
