System.Xml Spazio dei nomi

Classi

Interfacce

Enumerazioni

Delegati

Commenti

Standard supportati

Lo System.Xml spazio dei nomi supporta questi standard:

• XML 1.0, incluso il supporto DTD

• Spazi dei nomi XML, sia a livello di flusso che DOM

• SCHEMI XML

• Espressioni XPath

• Trasformazioni XSLT

• DOM Level 1 Core

• DOM Level 2 Core

Vedere la sezione Differenze dalle specifiche W3C per due casi in cui le classi XML differiscono dalle raccomandazioni W3C.

Spazi dei nomi correlati

.NET fornisce anche altri spazi dei nomi per le operazioni correlate a XML. Per un elenco, descrizioni e collegamenti, vedere spazi dei nomiSystem.Xml.

Elaborazione asincrona di XML

Le System.Xml.XmlReader classi e System.Xml.XmlWriter includono diversi metodi asincroni basati sul modello di programmazione asincrona. Questi metodi possono essere identificati dalla stringa "Async" alla fine dei nomi. Con questi metodi è possibile scrivere codice asincrono simile al codice sincrono ed è possibile eseguire facilmente la migrazione del codice sincrono esistente al codice asincrono.

• Usare i metodi asincroni nelle app in cui è presente una latenza significativa del flusso di rete. Evitare di usare le API asincrone per il flusso di memoria o le operazioni di lettura/scrittura di file locali. Il flusso di input, XmlTextReadere XmlTextWriter deve supportare anche operazioni asincrone. In caso contrario, i thread verranno comunque bloccati dalle operazioni di I/O.

• Non è consigliabile combinare chiamate di funzione sincrone e asincrone, perché è possibile dimenticare di usare la await parola chiave o usare un'API sincrona in cui è necessaria una funzione asincrona.

• Non impostare il XmlReaderSettings.Async flag true o XmlWriterSettings.Async su se non si intende usare un metodo asincrono.

• Se si dimentica di specificare la await parola chiave quando si chiama un metodo asincrono, i risultati non deterministici sono: è possibile ricevere il risultato previsto o un'eccezione.

• Quando un XmlReader oggetto legge un nodo di testo di grandi dimensioni, può memorizzare nella cache solo un valore di testo parziale e restituire il nodo di testo, in modo che il recupero della XmlReader.Value proprietà possa essere bloccato da un'operazione di I/O. Utilizzare il metodo per ottenere il valore di testo in modalità asincrona oppure usare il XmlReader.GetValueAsyncXmlReader.ReadValueChunkAsync metodo per leggere un blocco di testo di grandi dimensioni in blocchi.

• Quando si usa un XmlWriter oggetto, chiamare il metodo prima di chiamare XmlWriter.Close per evitare di XmlWriter.FlushAsync bloccare un'operazione di I/O.

Differenze rispetto alle specifiche W3C

In due casi che comportano vincoli sui componenti dello schema del gruppo di modelli, lo System.Xml spazio dei nomi differisce dalle raccomandazioni W3C.

Coerenza nelle dichiarazioni degli elementi:

In alcuni casi, quando vengono usati gruppi di sostituzione, l'implementazione non soddisfa il System.Xml "Vincolo componente schema: dichiarazioni di elemento coerenti", descritto nella sezione Vincoli sui componenti dello schema del gruppo di modelli della specifica W3C.

Ad esempio, lo schema seguente include elementi con lo stesso nome, ma tipi diversi nello stesso modello di contenuto e vengono usati gruppi di sostituzione. Sebbene tale schema debba generare un errore, System.Xml lo compila e lo convalida senza errori.

<?xml version="1.0" encoding="utf-8" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">

   <xs:element name="e1" type="t1"/>
   <xs:complexType name="t1"/>

   <xs:element name="e2" type="t2" substitutionGroup="e1"/>
      <xs:complexType name="t2">
         <xs:complexContent>
            <xs:extension base="t1">
         </xs:extension>
      </xs:complexContent>
   </xs:complexType>

   <xs:complexType name="t3">
      <xs:sequence>
         <xs:element ref="e1"/>
         <xs:element name="e2" type="xs:int"/>
      </xs:sequence>
   </xs:complexType>
</xs:schema>

In questo schema il tipo t3 contiene una sequenza di elementi. A causa della sostituzione, il riferimento all'elemento e1 della sequenza può restituire un elemento e1 di tipo t1 o un elemento e2 di tipo t2. Quest'ultimo caso comporta una sequenza di due e2 elementi, dove uno è di tipo t2 e l'altro è di tipo xs:int.

Attribuzione di particelle univoca:

Nelle condizioni seguenti l'implementazione non soddisfa il System.Xml "Vincolo componente schema: attribuzione di particelle univoca", descritto nella sezione Vincoli nei componenti dello schema del gruppo di modelli della specifica W3C.

• Uno degli elementi nel gruppo fa riferimento a un altro elemento.

• L'elemento a cui si fa riferimento è un elemento Head di un gruppo di sostituzione.

• Il gruppo di sostituzione contiene un elemento con lo stesso nome di uno degli elementi del gruppo.

• La cardinalità dell'elemento che fa riferimento all'elemento head del gruppo di sostituzione e all'elemento con lo stesso nome di un elemento del gruppo di sostituzione non è fisso (minOccurs < maxOccurs).

• La definizione dell'elemento che fa riferimento al gruppo di sostituzione precede la definizione dell'elemento con lo stesso nome di un elemento di sostituzione.

Sebbene, ad esempio, nello schema seguente il modello di contenuto sia ambiguo e debba generare un errore di compilazione, System.Xml lo compila senza errori.

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">

  <xs:element name="e1" type="xs:int"/>
  <xs:element name="e2" type="xs:int" substitutionGroup="e1"/>

  <xs:complexType name="t3">
    <xs:sequence>
      <xs:element ref="e1" minOccurs="0" maxOccurs="1"/>
      <xs:element name="e2" type="xs:int" minOccurs="0" maxOccurs="1"/>
    </xs:sequence>
  </xs:complexType>

  <xs:element name="e3" type="t3"/>
</xs:schema>

Se si tenta di convalidare il codice XML seguente rispetto allo schema precedente, la convalida avrà esito negativo con il messaggio seguente: "L'elemento 'e3' ha un elemento figlio non valido 'e2'". Verrà generata un'eccezione XmlSchemaValidationException .

<e3>
  <e2>1</e2>
  <e2>2</e2>
</e3>

Per risolvere questo problema, è possibile scambiare dichiarazioni di elemento nel documento XSD. Ad esempio:

<xs:sequence>
  <xs:element ref="e1" minOccurs="0" maxOccurs="1"/>
  <xs:element name="e2" type="xs:int" minOccurs="0" maxOccurs="1"/>
</xs:sequence>

diventa:

<xs:sequence>
  <xs:element name="e2" type="xs:int" minOccurs="0" maxOccurs="1"/>
  <xs:element ref="e1" minOccurs="0" maxOccurs="1"/>
</xs:sequence>

Ecco un altro esempio dello stesso problema:

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
   <xs:element name="e1" type="xs:string"/>
   <xs:element name="e2" type="xs:string" substitutionGroup="e1"/>

   <xs:complexType name="t3">
      <xs:sequence>
         <xs:element ref="e1" minOccurs="0" maxOccurs="1"/>
         <xs:element name="e2" type="xs:int" minOccurs="0" maxOccurs="1"/>
      </xs:sequence>
   </xs:complexType>
   <xs:element name="e3" type="t3"/>
</xs:schema>

Se si tenta di convalidare il codice XML seguente rispetto allo schema precedente, la convalida avrà esito negativo con l'eccezione seguente: "Eccezione non gestita: System.Xml. Schema.XmlSchemaValidationException: l'elemento el 'e2' non è valido - Il valore 'abc' non è valido in base al relativo tipo 'http://www.w3.org/2001/XMLSchema:int' di dati - La stringa 'abc' non è un valore Int32 valido."

<e3><e2>abc</e2></e3>

Considerazioni relative alla sicurezza

I tipi e i membri nello System.Xml spazio dei nomi si basano sul sistema di sicurezza .NET. Le sezioni seguenti illustrano i problemi di sicurezza specifici delle tecnologie XML.

Si noti anche che quando si usano i System.Xml tipi e i membri, se il codice XML contiene dati che hanno potenziali implicazioni sulla privacy, è necessario implementare l'app in modo da rispettare la privacy degli utenti finali.

Accesso esterno

Diverse tecnologie XML consentono di recuperare altri documenti durante l'elaborazione. Ad esempio, una DTD (Document Type Definition) si può trovare nel documento analizzato. La DTD può anche risiedere in un documento esterno a cui fa riferimento il documento analizzato. Le tecnologie XSD (XML Schema Definition Language) e XSLT consentono inoltre di includere informazioni da altri file. Queste risorse esterne possono presentare alcuni problemi di sicurezza. Ad esempio, si vuole assicurarsi che l'app recupera i file solo dai siti attendibili e che il file recuperato non contenga dati dannosi.

La XmlUrlResolver classe viene usata per caricare documenti XML e per risolvere le risorse esterne, ad esempio entità, DTD o schemi, e importare o includere direttive.

È possibile eseguire l'override di questa classe e specificare l'oggetto XmlResolver da usare. Usare la classe XmlSecureResolver se è necessario aprire una risorsa che non si controlla o che non è considerata affidabile. Il tipo XmlSecureResolver include un tipo XmlResolver e consente di limitare le risorse a cui ha accesso il tipo XmlResolver sottostante.

Denial of Service

Gli scenari seguenti sono considerati meno vulnerabili agli attacchi di tipo Denial of Service in quanto le classi System.Xml forniscono un sistema di protezione da tali attacchi.

• Analisi dei dati XML di tipo text.

• Analisi dei dati XML binari se i dati XML binari sono stati generati da Microsoft SQL Server.

• Scrittura di documenti e frammenti XML da origini dati nel file system, flussi, un tipo TextWriter o un tipo StringBuilder.

• Caricamento di documenti nell'oggetto DOM (Document Object Model) se si sta utilizzando un oggetto XmlReader e XmlReaderSettings.DtdProcessing impostato su DtdProcessing.Prohibit.

• Esplorazione dell'oggetto DOM.

Gli scenari seguenti non sono consigliabili se ci si occupa di problemi relativi agli attacchi di tipo Denial of Service o se si lavora in un ambiente non attendibile.

• Elaborazione della DTD.

• Elaborazione dello schema. Ciò include l'aggiunta di uno schema non attendibile alla raccolta di schemi, la compilazione di uno schema non attendibile e la convalida tramite uno schema non attendibile.

• Elaborazione XSLT.

• Analisi di un qualsiasi flusso arbitrario di dati XML binari forniti dall'utente.

• Operazioni DOM quali la creazione di query, la modifica, lo spostamento tra i sottoalberi dei documenti e il salvataggio degli oggetti DOM.

Se si tratta di problemi di servizio denial of service o se si tratta di origini non attendibili, non abilitare l'elaborazione DTD. Questa opzione è disabilitata per impostazione predefinita sugli XmlReader oggetti creati dal XmlReader.Create metodo.

Se l'elaborazione DTD è abilitata, è possibile usare la XmlSecureResolver classe per limitare le risorse a cui è XmlReader possibile accedere. È anche possibile progettare l'app in modo che l'elaborazione XML sia vincolata dalla memoria e dal tempo. Ad esempio, è possibile configurare i limiti di timeout nell'app ASP.NET.

Considerazioni sull'elaborazione

Poiché i documenti XML possono contenere riferimenti ad altri file, è difficile determinare quanta capacità di elaborazione sia necessaria per analizzare un documento XML. Ad esempio, i documenti XML possono includere una DTD. Se la DTD contiene entità annidate o modelli di contenuto complesso, potrebbe essere necessaria una quantità eccessiva di tempo per analizzare il documento.

Quando si utilizza XmlReader, è possibile limitare le dimensioni del documento che è possibile analizzare impostando la proprietà XmlReaderSettings.MaxCharactersInDocument. Per limitare il numero di caratteri risultanti dall'espansione di entità, impostare la proprietà XmlReaderSettings.MaxCharactersFromEntities. Per gli esempi relativi all'impostazione di queste proprietà, vedere gli argomenti di riferimento appropriati.

Le tecnologie XSD e XSLT consentono inoltre di migliorare le prestazioni dell'elaborazione. Ad esempio, è possibile creare un XML Schema che richiede una quantità maggiore di tempo per l'elaborazione quando la valutazione riguarda un documento relativamente breve. È inoltre possibile incorporare blocchi di script in un foglio di stile XSLT. Entrambi i casi rappresentano una potenziale minaccia di sicurezza per l'app.

Quando si crea un'app che usa la XslCompiledTransform classe, è necessario tenere presente gli elementi seguenti e le relative implicazioni:

• Gli script XSLT sono disattivati per impostazione predefinita. Lo script con XSLT deve essere abilitato solo se è necessario il supporto per gli script e solo all'interno di un ambiente completamente attendibile.

• La funzionalità XSLT document() è disattivata per impostazione predefinita. Se si abilita la funzione document(), limitare le risorse a cui è possibile accedere passando un oggetto XmlSecureResolver al metodo XslCompiledTransform.Transform.

• Gli oggetti di estensione sono abilitati per impostazione predefinita. Se un oggetto XsltArgumentList contenente oggetti di estensione viene passato al metodo XslCompiledTransform.Transform, vengono utilizzati gli oggetti di estensione.

• Nei fogli di stile XSLT possono essere inclusi riferimenti ad altri file e a blocchi di script incorporati. Un utente malintenzionato può sfruttare questa situazione fornendo dati o fogli di stile che, quando eseguiti, possono determinare l'elaborazione continua da parte del sistema finché le risorse del computer diventeranno insufficienti.

• Le app XSLT eseguite in un ambiente trust misto possono comportare lo spoofing dei fogli di stile. Ad esempio, un utente malintenzionato può caricare un oggetto con un foglio di stile dannoso e trasferirlo a un altro utente che in un secondo momento chiama il metodo XslCompiledTransform.Transform ed esegue la trasformazione.

I problemi relativi alla sicurezza possono essere limitati non attivando gli script o la funzionalità document(), a meno che il foglio di stile non provenga da un'origine attendibile, e non accettando gli oggetti XslCompiledTransform, i fogli di stile XSLT o i dati di origine XML da un'origine non attendibile.

Gestione delle eccezioni

Le eccezioni generate dai componenti di livello inferiore possono divulgare le informazioni sul percorso che non si desidera esporre all'app. Le app devono intercettare le eccezioni ed elaborarle in modo appropriato.

Vedi anche

• System.Xml.Xsl
• System.Xml.Schema
• System.Xml.Linq
• Documenti e dati XML