Elementen en attributen in XML-schema
Naast de rijke mogelijkheden voor het definiëren van typen XML-gegevens Schema bevat een rijke woordenschat voor het definiëren van de documentstructuur en toegestane elementen en attributen.
– Eenvoudige inhoud. Het element bevat alleen tekst (hoewel tekst, zoals besproken in de vorige paragraaf, beperkt kan worden tot gegevens aparte soort, zoals datum of numerieke waarde). Inhoud van dit type wordt gedefinieerd met behulp van het element simpleContent.
– Alleen elementen. Het element bevat alleen geneste elementen. De inhoud van dit type wordt gedefinieerd met behulp van het complexType-element.
– Gemengde inhoud . Een element kan zowel tekstinhoud als geneste elementen bevatten. XML Schema vereist dat de volgorde van elementen en tekstinhoud strikt wordt gedefinieerd, en geldige documenten moeten aan die volgorde voldoen.
– Lege inhoud . Het element bevat alleen attributen en geen tekstinhoud. XML Schema interpreteert elementen zoals speciaal geval inhoud die alleen uit elementen bestaat, zonder gedeclareerde elementen.
– Elke inhoud . Het element kan leeg zijn, geneste elementen en/of tekst bevatten. De inhoud van dit type wordt gedefinieerd met behulp van het anyType-element.
Deze basistypen elementen kunnen worden gespecificeerd in schema-elementdeclaraties. U kunt ook opgeven dat een element meerdere keren in een document mag voorkomen, en het minimum en instellen maximale hoeveelheid gebeurtenissen. Net als SQL ondersteunt XML Schema NULL-elementwaarden, wat aangeeft dat de inhoud van het element onbekend is. In XML-terminologie wordt deze waarde nul genoemd , maar de betekenis ervan is hetzelfde. Ondersteuning voor deze waarde maakt het gemakkelijker om gegevens over te dragen tussen XML en databasekolommen die NULL-waarden kunnen bevatten.
XML-schema Hiermee kunt u een logische groep elementen definiëren die doorgaans samen worden gebruikt en die groep een aangepaste naam geven. Deze groep kan als geheel worden opgenomen in daaropvolgende elementdeclaraties. Het groeperen van elementen maakt hun structuur nog flexibeler. De groep mag bepalen vervolg elementen die in een bepaalde volgorde in een document aanwezig moeten zijn. Of het kan een reeks elementen definiëren waarvan slechts één element in het document aanwezig mag zijn.
Soortgelijke opties zijn beschikbaar voor het beheren van attributen. Een individueel attribuut kan worden gedefinieerd als vereist of optioneel. U kunt een standaardwaarde instellen voor een attribuut, die wordt gebruikt als er geen waarde voor dat attribuut is opgegeven. U kunt een vaste attribuutwaarde opgeven, wat een constante waarde is voor dat attribuut. U kunt de naam definiëren van een groep attributen die daarna altijd samen worden gebruikt. Om een groep attributen voor het volgende element van het schema te definiëren, volstaat het om alleen de naam van deze groep op te geven.
Op het werk worden we gevraagd om XML-bestanden te maken om gegevens naar een ander over te dragen zelfstandige applicatie, waarmee vervolgens een tweede XML-bestand wordt gemaakt dat kan worden geretourneerd om enkele van onze gegevens bij te werken. Tijdens het proces hebben we met het team van een andere applicatie besproken XML-structuur bestand.
Het voorbeeld dat ik tegenkwam ziet er ongeveer zo uit:
Een ander team stelde dat dit geen industriestandaard is en dat attributen alleen voor metadata mogen worden gebruikt. Zij stelden voor:
De reden dat ik van de eerste uitging, is vanwege de grootte aangemaakt bestand veel minder. Tijdens de overdracht zullen er ongeveer 80.000 elementen in het bestand aanwezig zijn. Sterker nog, het aanbod is eigenlijk drie keer zo groot als wat ik heb aangeboden. Ik was op zoek naar de mysterieuze ‘industriestandaard’ die werd genoemd, maar deze kwam het dichtst in de buurt XML-attributen die alleen voor metadata mag worden gebruikt, maar zei dat het debat ging over wat nu eigenlijk metadata is.
Hoe definieer je, na een lange uitleg (sorry), wat metadata is, en hoe moet je bij het ontwerpen van de structuur van een XML-document beslissen wanneer je een attribuut of element gebruikt?
20 antwoorden
Ik gebruik deze regel:
- Een attribuut is iets dat zelfvoorzienend is, d.w.z. kleur, id, naam.
- Een element is iets dat zijn eigen attributen heeft of kan hebben of andere elementen kan bevatten.
Dus die van jou is dichtbij. Ik zou zoiets doen als:
BEWERKING: bijgewerkt origineel voorbeeld gebaseerd op feedback onderstaand.
Enkele problemen met attributen:
- attributen kunnen niet meerdere waarden bevatten ( kind elementen kan)
- attributen zijn niet alleen uitbreidbaar (voor toekomstige wijzigingen)
- attributen kunnen geen structuren beschrijven (kindelementen kunnen dat wel)
- attributen zijn moeilijker te manipuleren door code Attribuutwaarden
- niet eenvoudig te testen tegen DTD
Als je attributen gebruikt als containers voor gegevens, krijg je documenten die moeilijk te lezen en te onderhouden zijn. Probeer elementen te gebruiken om gegevens te beschrijven. Gebruik attributen alleen om niet-gegevensinformatie te verstrekken.
Eindig niet zo (dit is niet hoe XML gebruikt zou moeten worden):
"XML" staat voor "uitbreidbare opmaaktaal". De opmaaktaal gaat ervan uit dat de gegevens tekst zijn, getagd met metagegevens over de structuur of opmaak.
XHTML is een voorbeeld van XML die wordt gebruikt zoals het bedoeld was:
El Jefe dringt erop aan dat u MOETEN voltooi uw project vóór vrijdag.
Hier wordt het onderscheid gemaakt tussen elementen en attributen. Tekstelementen worden in de browser weergegeven en attributen zijn instructies over hoe ze moeten worden weergegeven (hoewel er een paar tags zijn die niet op deze manier werken).
Er ontstaat verwarring wanneer XML niet als opmaaktaal wordt gebruikt, maar als een dataserialisatietaal, waarin het onderscheid tussen "data" en "metadata" vager is. De keuze tussen elementen en attributen is dus min of meer willekeurig, behalve voor dingen die niet door attributen kunnen worden weergegeven (zie het antwoord van Feenster).
XML is een conventie. Zet eerst alle bestaande XML-schema's of gevestigde conventies binnen uw gemeenschap of branche opzij.
Als u zich echt in een situatie bevindt waarin u uw circuit helemaal opnieuw moet definiëren, volgen hier enkele algemene overwegingen die u bij uw keuze moeten betrekken element versus:
Dit kan afhankelijk zijn van uw gebruik. XML die wordt gebruikt om gegevens weer te geven die uit een database zijn gegenereerd, kan goed werken en uiteindelijk de veldwaarden als attributen plaatsen.
XML die als berichtentransport wordt gebruikt, is echter vaak beter te gebruiken meer elementen.
Laten we bijvoorbeeld zeggen dat we deze XML hadden, zoals voorgesteld in het antwoord: -
Nu willen we het ITEM naar het apparaat voor het afdrukken van streepjescodes sturen, maar er is keuze uit verschillende coderingstypen. Hoe geven we het vereiste type codering weer? Onverwachts realiseren we ons enigszins laat dat een barcode niet een enkele automatische waarde is, maar eerder kan worden gekwalificeerd met de codering die nodig is bij het afdrukken.
Het punt is dat tenzij je een soort XSD of DTD samen met een naamruimte bouwt om de structuur in steen vast te leggen, je misschien het beste je opties open kunt houden.
IMO XML is het nuttigst als het kan worden verbogen zonder de bestaande code te verbreken.
De voorkeursattributen zijn als volgt:
- uniek (attribuut kan niet meerdere keren voorkomen)
- de volgorde maakt niet uit
- de bovenstaande eigenschappen worden overgenomen (dit is iets dat "alle" het inhoudsmodel niet ondersteunt in de huidige schemataal)
- bonus - ze zijn minder uitgebreid en gebruiken minder bandbreedte, maar dit is geen reden om attributen boven elementen te verkiezen.
Ik heb toegevoegd wanneer dit technisch mogelijk is, omdat er momenten zijn waarop het gebruik van attributen niet mogelijk is. Bijvoorbeeld het kiezen van een set attributen. Het gebruik van (startDate en endDate) xor (startTS en endTS) is bijvoorbeeld niet mogelijk met de huidige schemataal
Als het XML-schema het beperkte of uitgebreide 'alle' inhoudsmodel begint toe te staan, zou ik het waarschijnlijk opnieuw instellen
Er is geen universeel antwoord op deze vraag (ik was actief betrokken bij de totstandkoming van de W3C-specificatie). XML kan voor vele doeleinden worden gebruikt; tekstdocumenten, gegevens en declaratieve code zijn de drie meest voorkomende. Ik gebruik het ook als datamodel. Er zijn aspecten van deze toepassingen waarbij attributen vaker voorkomen en bij andere waarbij onderliggende elementen natuurlijker zijn. Er zijn ook kenmerken van verschillende tools die ze gemakkelijker of gemakkelijker te gebruiken maken.
XHTML is een gebied waar attributen een natuurlijk gebruik hebben (bijvoorbeeld in class="foo"). De attributen zijn niet in orde, en dit kan de ontwikkeling van tools voor sommige mensen gemakkelijker maken. OTOH-attributen zijn moeilijker in te voeren zonder schema. Ik merk ook dat benoemde attributen (foo:bar="zork") vaak moeilijker te beheren zijn in verschillende toolkits. Maar kijk eens naar enkele van de W3C-talen om de gebruikelijke mix te zien. SVG, XSLT, XSD, MathML zijn enkele voorbeelden van bekende talen en ze hebben allemaal een rijk aanbod aan attributen en elementen. Sommige talen laten zelfs meer dan één manier toe, b.v.
Merk op dat ze NIET syntactisch equivalent zijn en expliciete ondersteuning vereisen in de verwerkingstools)
Mijn advies zou zijn om te kijken naar de gangbare praktijk in jouw omgeving en ook te overwegen welke instrumenten je kunt toepassen.
Zorg er ten slotte voor dat u naamruimten onderscheidt van attributen. Sommige XML-systemen (zoals Linq) stellen naamruimten bloot als API-attributen. IMO is het lelijk en mogelijk verwarrend.
Anderen hebben gekeken naar de manier waarop attributen van elementen kunnen worden onderscheiden, maar vanuit een algemener perspectief: alles in attributen stoppen, omdat dit de resulterende XML minder foutgevoelig maakt.
XML is niet ontworpen om compact te zijn, maar om draagbaar en voor mensen leesbaar te zijn. Als u de omvang van de gegevens tijdens de overdracht wilt verkleinen, gebruikt u iets anders (zoals de protocolbuffers van Google).
Het is op de een of andere manier discutabel, maar uw collega's hebben gelijk in de zin dat XML moet worden gebruikt om de feitelijke gegevens te 'verpakken' of metagegevens te gebruiken. U heeft gelijk dat het soms moeilijk is om te beslissen waar de grens ligt tussen metadata en data bij het modelleren van uw domein in XML. In de praktijk doe ik alsof iets in de markup verborgen is en dat alleen de gegevens buiten de markup worden gelezen. Heeft dit document enige betekenis?
XML is notoir log. Voor transport en opslag wordt compressie ten zeerste aanbevolen als u zich de verwerkingskracht kunt veroorloven. XML kan goed worden gecomprimeerd, soms fenomenaal, vanwege de herhaalbaarheid. Ik heb grote bestanden laten comprimeren tot minder dan 5% van hun oorspronkelijke grootte.
Een ander punt om uw punt kracht bij te zetten is dat terwijl het andere team ruzie maakt over de stijl (in die zin dat de meeste XML-tools een document dat uit alle attributen bestaat net zo gemakkelijk behandelen als een document dat uit slechts # PCDATA bestaat), u beweert dat het praktisch is. Hoewel stijl niet volledig kan worden genegeerd, moeten de technische voordelen zwaarder wegen.
Gebruik elementen voor gegevens en attributen voor metadata (gegevens over de gegevens van het element).
Als het element als predikaat in uw geselecteerde regels verschijnt, heeft u een goed teken dat het een attribuut moet zijn. Als een attribuut nooit als predikaat wordt gebruikt, is het mogelijk ook geen bruikbare metadata.
Houd er rekening mee dat XML machinaal leesbaar moet zijn en niet door mensen leesbaar, en dat XML voor grote documenten zeer goed kan worden gecomprimeerd.
Hoe zit het met het gebruiken van onze intuïtie voor een solide salaris? Meestal vind ik het eenvoudig om na te denken over wat een object is en wat een attribuut is van het object of object waarnaar het verwijst.
Hoe intuïtief het ook is, want objecten moeten in elementen passen. De attributen (of eigenschappen) ervan zullen de attributen zijn voor die elementen in het XML- of onderliggende element met het attribuut.
Ik denk dat voor eenvoudiger gevallen, zoals in het voorbeeld, de objectoriëntatie-analogie prima werkt om te bepalen wat een element is en wat een attribuut van het element is.
De vraag van een miljoen dollar!
Maak je in eerste instantie geen zorgen over de prestaties. u zult verbaasd zijn hoe snel een geoptimaliseerde XML-parser uw XML-bestand kopieert. Belangrijker nog: wat is uw ontwerp voor de toekomst: hoe kunt u, naarmate XML evolueert, de losse koppeling en interoperabiliteit behouden?
meer specifiek kunt u het inhoudsmodel van het element complexer maken, maar het is moeilijker om het attribuut uit te breiden.
Het is vooral een kwestie van voorkeur. Ik gebruik waar mogelijk Elementen voor groepering en attributen voor gegevens, omdat ik het compacter vind dan het alternatief.
Ik heb bijvoorbeeld liever.....
In plaats van....
Als ik echter gegevens heb die niet gemakkelijk binnenin kunnen worden weergegeven, zoals 20-30 tekens of die veel aanhalingstekens of andere tekens bevatten die moeten worden geëscaped, zou ik zeggen dat het tijd is om de elementen op te splitsen... misschien met CData-blokken.
XML-elementen kunnen net als HTML attributen hebben.
Attributen zijn ontworpen om gegevens te bevatten die specifiek zijn voor een specifiek element.
XML-attributen moeten tussen aanhalingstekens staan
Attribuutwaarden moeten altijd tussen aanhalingstekens staan. Ofwel alleenstaand of dubbele aanhalingstekens kan worden gebruikt.
Voor iemands geslacht dus
of zoals dit:
Als de attribuutwaarde zelf dubbele aanhalingstekens bevat, kunt u enkele aanhalingstekens gebruiken, zoals in dit voorbeeld:
of u kunt karakterentiteiten gebruiken:
XML-elementen versus attributen
Kijk eens naar deze voorbeelden:
In het eerste voorbeeld is geslacht een attribuut. In dat laatste is seks een element. Beide voorbeelden geven dezelfde informatie.
Er zijn geen regels over wanneer attributen moeten worden gebruikt of wanneer elementen in XML moeten worden gebruikt.
Mijn favoriete manier
De volgende drie XML-documenten bevatten exact dezelfde informatie:
In het eerste voorbeeld wordt het datumattribuut gebruikt:
Uitgebreid
XML-attributen vermijden?
Enkele zaken waarmee u rekening moet houden bij het gebruik van attributen:
- attributen kunnen niet meerdere waarden bevatten (elementen kunnen dat wel)
- attributen kunnen geen boomstructuren bevatten (elementen wel)
- attributen zijn niet gemakkelijk uitbreidbaar (voor toekomstige wijzigingen)
Eindig niet zo:
body="Vergeet mij dit weekend niet!">
XML-attributen voor metadata
Vergeet mij niet dit weekend!
Dat zal ik niet doen
id-attributen hierboven om verschillende notities te identificeren. Het maakt geen deel uit van de notitie zelf.
Wat ik hier probeer te zeggen is dat metadata (gegevens over gegevens) moeten worden opgeslagen als attributen en dat de gegevens zelf moeten worden opgeslagen als elementen.
Net als in HTML, XML-elementen kan attributen hebben. In dit geval de waarde attributen in XML en de regels voor het maken ervan zijn in veel opzichten vergelijkbaar met .
Kenmerken bieden aanvullende informatie over het onderdeel.
XML-attributen
IN HTML-attributen geef wat aanvullende informatie over het element:
Attributen bieden vaak informatie die geen deel uitmaakt van de gegevens. In het onderstaande voorbeeld is het bestandstype onafhankelijk van de gegevens, maar deze informatie kan belangrijk zijn voor toepassingen die dit element manipuleren:
XML-attributen moeten tussen aanhalingstekens staan
De attribuutwaarde moet altijd tussen aanhalingstekens staan. Deze kunnen dubbel of dubbel zijn enkele aanhalingstekens. Het geslacht van een personage kan bijvoorbeeld als volgt worden geschreven:
of zoals dit:
Als de attribuutwaarde zelf dubbele aanhalingstekens bevat, kunnen enkele aanhalingstekens worden gebruikt. Bijvoorbeeld:
of gebruik entiteitssymbolen:
XML-elementen of attributen
Kijk naar de volgende voorbeelden:
Voorbeeld nr. 1
Voorbeeld nr. 2
In het eerste voorbeeld wordt geslacht gespecificeerd in het attribuut. In het tweede geval wordt geslacht als element vastgelegd. Beide voorbeelden bieden dezelfde informatie.
Er zijn geen regels die bepalen wanneer attributen moeten worden gebruikt en wanneer elementen moeten worden gebruikt. Attributen worden veel gebruikt in HTML. In XML is het naar mijn mening beter om ze te vermijden en in plaats daarvan elementen te gebruiken.
Welke is beter?
Volgende drie XML-document bevatten precies dezelfde informatie:
De datum wordt geregistreerd als attribuut:
De datum wordt als een element geschreven:
De datum wordt geschreven als een uitgebreid element(Naar mijn mening beste optie):
XML-attributen vermijden?
Er zijn enkele problemen bij het gebruik van attributen:
- attributen kunnen niet meerdere waarden bevatten (elementen kunnen dat wel)
- attributen kunnen geen boomstructuren bevatten (elementen wel)
- attributen zijn moeilijk uit te breiden (voor toekomstige wijzigingen)
Gebruik nooit de volgende constructies:
XML-attributen voor metadata
Soms krijgen elementen een identificatie toegewezen. Deze identifiers worden gebruikt om XML-elementen op precies dezelfde manier te identificeren als identificatieattributen in HTML. Het volgende voorbeeld laat dit zien:
In het bovenstaande voorbeeld wordt het id-attribuut gebruikt om verschillende notities te identificeren. Deze informatie maakt geen deel uit van de notitie zelf.
Het belangrijkste idee van alles wat er is gezegd, is dat metadata (gegevens over gegevens) moeten worden geschreven als attributen, en de gegevens zelf als elementen.
Wij presenteren onder uw aandacht nieuwe cursus van het team De Codeby- "Penetratietesten van webapplicaties vanaf nul." Algemene theorie, voorbereiding van de werkomgeving, passieve fuzzing en vingerafdrukken, actieve fuzzing, kwetsbaarheden, post-uitbuiting, Hulpmiddelen, Sociale Techniek en nog veel meer.
XML-bestandskenmerken
In het vorige artikel heb je geleerd hoe je kunt werken met elementen en knooppunten van een XML-bestand. In dit artikel leer je wat attributen zijn, en we zullen ook de basisbewerkingen ermee analyseren, zoals het aanmaken, wijzigen, verwijderen en toevoegen van een attribuut met behulp van de taal C#.
Zoals eerder in eerdere artikelen vermeld, kunnen XML-bestandselementen een willekeurig aantal niet-herhalende attributen hebben waarin u ze kunt opslaan diverse informatie. Dat wil zeggen dat één element bijvoorbeeld niet twee “id”-attributen kan hebben, maar wel meerdere attributen tegelijk: “id”, “name”, “code” enzovoort. Het is ook de moeite waard om dat te onthouden attributen xml-bestand staan tussen dubbele aanhalingstekens.
Het auto-element bevat 1 id-attribuut, dat de waarde 1 heeft.
Het auto-element bevat 2 attributen: id en code.
Onjuist, er wordt een dubbel attribuut gebruikt.
Als u er niet bekend mee bent XML-taal of weet niet wat het is xml-dom, dan raad ik je aan het artikel te lezen: .
Laten we verder gaan met oefenen.
Eerst moet u een leeg bestand maken dat één hoofdelement bevat
Het resultaat zou er zo uit moeten zien
Laten we nu eens overwegen basisbewerkingen met attributen.
Hoe u een XML-bestandskenmerk maakt
Om te creëren nieuw attribuut U kunt de SetAttribute-methode van de klasse System.Xml.XmlElement gebruiken, waarmee u elementattributen kunt maken en wijzigen.
In het eerste voorbeeld maken we een element “garage” aan met het attribuut “id”, waaraan we de waarde 3 toekennen.
Class Program ( statische string bestandsnaam = @"C:\atr\1.xml"; static void Main(string args) ( XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(bestandsnaam); XmlElement elmGarage = xmlDoc.CreateElement(" garage"); elmGarage.SetAttribute("id", "3"); xmlDoc.DocumentElement.AppendChild(elmGarage); xmlDoc.Save(bestandsnaam); ) )
resultaat
Hoe u meerdere attributen kunt maken
Als u meer dan één attribuut voor één element moet maken, voegen we in het vorige voorbeeld eenvoudigweg de volgende regels toe.
ElmGarage.SetAttribute("id", "3"); elmGarage.SetAttribute("telling", "1"); // elmGarage.SetAttribute("shortCode", "456"); //Toegevoegd
Nu worden er 3 attributen aangemaakt: “id”, “count”, “shortCode” en 3 waarden: 3, 1, 456.
Een andere manier.
Omdat xml-attributen elementen een naam en waarde hebben, is SortedList zeer geschikt voor het opslaan van dergelijke gegevens
Klasseprogramma (statische tekenreeks bestandsnaam = @"C:\atr\1.xml"; statische SortedList
resultaat
Hoe u de waarde van een XML-bestandskenmerk kunt wijzigen
Om de waarden van het attribuut van een element te wijzigen, kun je de SetAttribute-methode gebruiken die we eerder hebben gebruikt om het attribuut te maken.
Class Program ( statische string bestandsnaam = @"C:\atr\1.xml"; static void Main(string args) ( XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(bestandsnaam); //If van dit attribuut id niet aanwezig is, dan wordt deze gemaakt xmlDoc.DocumentElement["garage"].SetAttribute("id", "5"); xmlDoc.Save(bestandsnaam); ))
Een andere manier om met attributen te werken is door met de klasse te werken. In ons voorbeeld halen we eerst alle attributen van het garage-element op en gebruiken dan de GetNamedItem-methode, die het attribuut vindt dat we nodig hebben. Vervolgens wijzigen we met behulp van de eigenschap InnerText de attribuutwaarde.
Class Program ( static string fileName = @"C:\atr\1.xml"; static void Main(string args) ( XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(fileName); // Haal alle attributen van de garage op element XmlAttributeCollection atrCol; atrCol = xmlDoc.DocumentElement["garage"].Attributes; //wijzig de waarde van het id-attribuut atrCol.GetNamedItem("id").InnerText = "5";
resultaat
Het volgende voorbeeld laat zien hoe u aan alle attributen van één element dezelfde waarde kunt toekennen. Eerst krijgen we ook alle attributen, en vervolgens kun je met behulp van de Item(i)-methode door de attributen bladeren met behulp van de index, zoals in een gewone array.
Class Program ( statische string bestandsnaam = @"C:\atr\1.xml"; static void Main(string args) ( XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(bestandsnaam); XmlAttributeCollection atrCol = xmlDoc. DocumentElement[" garage"].Attributen; for (int i = 0; i< atrCol.Count; i++) { atrCol.Item(i).InnerText = "8"; } xmlDoc.Save(fileName); } }
resultaat
Als u elk attribuut moet toewijzen verschillende betekenissen, dan kun je dit doen.
Laten we bijvoorbeeld een array maken, die twee getallen bevat. Elk getal is een nieuwe waarde voor het attribuut: “id” en “count” van het element “garage”.
Klasseprogramma ( statische string bestandsnaam = @"C:\atr\1.xml"; static int arValues = (77, 76); static void Main(string args) ( XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load (bestandsnaam); XmlAttributeCollection atrCol = xmlDoc. DocumentElement["garage"].Attributen;< atrCol.Count; i++) { atrCol.Item(i).InnerText = arValues[i].ToString(); } xmlDoc.Save(fileName); } }
resultaat
Hoe u een elementattribuut in een XML-bestand verwijdert
We hebben geleerd hoe we attributen kunnen maken en wijzigen. Als je sommige regels code niet begrijpt, kun je het artikel lezen: waar alles in detail wordt beschreven.
Naar attribuut verwijderen, moet u de RemoveAt-methode uitvoeren, waarbij u de index van het attribuut dat moet worden verwijderd als parameter doorgeeft.
Class Program ( static string fileName = @"C:\atr\1.xml"; static void Main(string args) ( XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(fileName); // Haal alle attributen van de garage op element XmlAttributeCollection atrCol = xmlDoc. DocumentElement["garage"].Attributen;
resultaat
Meerdere attributen verwijderen
Als u zowel de kenmerken “id” als “count” in één keer of zelfs vaker wilt verwijderen, dan is de RemoveAll-methode geschikt voor dit geval.
Class Program ( static string fileName = @"C:\atr\1.xml"; static void Main(string args) ( XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(fileName); // Haal alle attributen van de garage op element XmlAttributeCollection atrCol = xmlDoc. DocumentElement["garage"].Attributen; // verwijder zowel id- als count-attributen atrCol.RemoveAll();
resultaat
Een nieuw attribuut toevoegen
Aan het einde is er nog een voorbeeld dat het werk van twee methoden laat zien: InsertBefore en InsertAfter, die dit toestaan nieuw attribuut toevoegen element van het XML-bestand, vóór of na een bestaand attribuut.
Class Program ( static string strFilename = @"C:\atr\1.xml"; static void Main(string args) ( XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(strFilename); // Haal alle attributen van de garage op element XmlAttributeCollection atrCol = xmlDoc. DocumentElement["garage"].Attributes; //Maak een nieuw attribuut XmlAttribute atrDate = xmlDoc.CreateAttribute("date"); ; //Verwijder de opmerking naast de gewenste methode //Voeg het datumattribuut in na het id-attribuut //atrCol.InsertBefore(atrCol["id"], atrDate //Voeg het datumattribuut in vóór het id-attribuut // atrCol. InsertAfter(atrCol["id"], atrDate); xmlDoc.Save(strBestandsnaam) )
resultaat
Toevoegen aan collectie 
Hoe u de waarde van een XML-bestandsattribuut voor verschillende knooppunten kunt verkrijgen
Gegeven een xml-bestand dat twee knooppunten bevat met de naam car, die op hun beurt elk één id-attribuut hebben.
Taak: haal de waarde op van het id-attribuut van alle autoknooppunten.
Class Program ( static string fileName = @" C:\example\garage.xml"; static void Main(string args) ( XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(fileName); // Haal alle knooppunten op die de naam car XmlNodeList nodeList= xmlDoc.GetElementsByTagName("car"); Voer de waarden uit van het id-attribuut van alle gevonden knooppunten car foreach (XmlNode xmlnode in nodeList) ( Console.WriteLine(xmlnode.Attributes["id"] .InnerText); ) Console .ReadLine() //Geen opslaan vereist)
Resultaat:
Hoe u de waarde van een xml-bestandsattribuut voor meerdere knooppunten kunt wijzigen
Taak: verhoog de huidige waarde van het id-attribuut voor elk knooppunt met een bepaalde waarde.
Class Program ( static string fileName = @"C:\example\garage.xml"; static void Main(string args) ( //De waarde waarmee we de huidige waarde van het attribuut int changeValue = 900 zullen verhogen; //temporary variabele om de nieuwe waarden op te slaan int newValue = 0; XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(fileName); / Haal de huidige waarde van het id-attribuut op // en verhoog deze bijvoorbeeld met 900. newValue = int.Parse(xmlnode.Attributes["id"].InnerText) + changeValue //Voeg een nieuwe waarde toe xmlnode.Attributes; .InnerText = newValue.(); ) //Wijzigingen opslaan xmlDoc.Save(bestandsnaam);
* Voor de Attributen-verzameling kunt u tussen haakjes zowel de attribuutnaam Attributes[“id”] als de index Attributes opgeven
