LoadOptions LoadOptions LoadOptions LoadOptions Enum

Definizione

Specifica le opzioni di caricamento durante l'analisi del codice XML.Specifies load options when parsing XML.

Questa enumerazione ha un attributo FlagsAttribute che consente una combinazione bit per bit dei valori del relativo membro.

public enum class LoadOptions
[System.Flags]
public enum LoadOptions
type LoadOptions = 
Public Enum LoadOptions
Ereditarietà
Attributi

Campi

None None None None 0

Non conserva spazio vuoto non significativo né carica URI di base e informazioni sulla riga.Does not preserve insignificant white space or load base URI and line information.

PreserveWhitespace PreserveWhitespace PreserveWhitespace PreserveWhitespace 1

Conserva spazio vuoto non significativo durante l'analisi.Preserves insignificant white space while parsing.

SetBaseUri SetBaseUri SetBaseUri SetBaseUri 2

Richiede le informazioni sull'URI di base da XmlReader e le rende disponibili tramite la proprietà BaseUri.Requests the base URI information from the XmlReader, and makes it available via the BaseUri property.

SetLineInfo SetLineInfo SetLineInfo SetLineInfo 4

Richiede le informazioni sulla riga da XmlReader e le rende disponibili tramite la proprietà XObject.Requests the line information from the XmlReader and makes it available via properties on XObject.

Esempi

Questo esempio viene caricato un piccolo albero XML da un file, impostando le opzioni per impostare l'URI di base e mantenere le informazioni sulla riga.This example loads a small XML tree from a file, setting the options to set base URI and retain line information. Aggiunge quindi un altro elemento che non ha le informazioni sulla riga.It then adds another element that does not have line information. Quindi stampa le informazioni sulla riga per ogni elemento nell'albero.It then prints the line information for each element in the tree.

string markup = @"<Root>  
    <Child1 />  
    <Child2 />  
    <Child4 />  
</Root>";  

File.WriteAllText("Test.xml", markup);  

XElement po = XElement.Load("Test.xml",  
    LoadOptions.SetBaseUri | LoadOptions.SetLineInfo);  

// add a node to the tree.  
// the newly added node will not have line information.  
po.Element("Child2").AddAfterSelf(new XElement("Child3"));  

string[] splitUri = po.BaseUri.Split('/');  
Console.WriteLine("BaseUri: {0}", splitUri[splitUri.Length - 1]);  
Console.WriteLine();  
Console.WriteLine("{0}{1}{2}",  
    "Element Name".PadRight(20),  
    "Line".PadRight(5),  
    "Position");  
Console.WriteLine("{0}{1}{2}",  
    "------------".PadRight(20),  
    "----".PadRight(5),  
    "--------");  
foreach (XElement e in po.DescendantsAndSelf())  
    Console.WriteLine("{0}{1}{2}",  
        ("".PadRight(e.Ancestors().Count() * 2) + e.Name).PadRight(20),  
        ((IXmlLineInfo)e).HasLineInfo() ?  
            ((IXmlLineInfo)e).LineNumber.ToString().PadRight(5) :  
            "",  
        ((IXmlLineInfo)e).HasLineInfo() ?  
            ((IXmlLineInfo)e).LinePosition.ToString() :  
            "No Line Information");  
Dim markup As String = _  
    "<Root>" + Environment.NewLine & _  
    "    <Child1 />" + Environment.NewLine & _  
    "    <Child2 />" + Environment.NewLine & _  
    "    <Child4 />" + Environment.NewLine & _  
    "</Root>"  

File.WriteAllText("Test.xml", markup)  

Dim po As XElement = XElement.Load("Test.xml", LoadOptions.SetBaseUri Or LoadOptions.SetLineInfo)  

' add a node to the tree.  
' the newly added node will not have line information.  
po.Element("Child2").AddAfterSelf(New XElement("Child3"))  

Dim splitUri() As String = po.BaseUri.Split("/"c)  
Console.WriteLine("BaseUri: {0}", splitUri(splitUri.Length - 1))  
Console.WriteLine()  
Console.WriteLine("{0}{1}{2}", _  
    "Element Name".PadRight(20), _  
    "Line".PadRight(5), _  
    "Position")  
Console.WriteLine("{0}{1}{2}", _  
    "------------".PadRight(20), _  
    "----".PadRight(5), _  
    "--------")  
For Each e As XElement In po.DescendantsAndSelf()  
    Console.WriteLine("{0}{1}{2}", _  
        ("".PadRight(e.Ancestors().Count() * 2) & e.Name.ToString).PadRight(20), _  
        IIf(DirectCast(e, IXmlLineInfo).HasLineInfo(), _  
            DirectCast(e, IXmlLineInfo).LineNumber.ToString().PadRight(5), _  
            ""), _  
        IIf(DirectCast(e, IXmlLineInfo).HasLineInfo(), _  
            DirectCast(e, IXmlLineInfo).LinePosition.ToString(), _  
            "No Line Information"))  
Next  

Questo esempio produce il seguente output:This example produces the following output:

BaseUri: Test.xml  

Element Name        Line Position  
------------        ---- --------  
Root                1    2  
  Child1            2    6  
  Child2            3    6  
  Child3            No Line Information  
  Child4            4    6  

Commenti

Se si mantiene gli spazi vuoti durante il caricamento, tutti gli spazi vuoti non significativi nell'albero XML viene materializzato nell'albero XML come è.If you preserve white space when loading, all insignificant white space in the XML tree is materialized in the XML tree as is. Se non si mantengono gli spazi vuoti, vengono eliminati tutti gli spazi vuoti non significativi.If you do not preserve white space, then all insignificant white space is discarded.

Si verifica una riduzione delle prestazioni se si imposta il SetBaseUri e i flag di metodo SetLineInfo.There is a performance penalty if you set the SetBaseUri and the SetLineInfo flags.

L'URI di base e le informazioni sulla riga sono accurate immediatamente dopo il caricamento del documento XML.The base URI and the line information are accurate immediately after loading the XML document. Se si modifica l'albero XML dopo il caricamento del documento, le informazioni di base URI e la riga possono diventare significative.If you modify the XML tree after loading the document, the base URI and line information may become meaningless.

Se l'oggetto sottostante XmlReader non dispone di informazioni URI o riga di base, non impostare il SetBaseUri e il metodo SetLineInfo flag avrà alcun effetto.If the underlying XmlReader does not have base URI or line information, setting the SetBaseUri and the SetLineInfo flags will have no effect.

Questo tipo consente di controllare il modo in cui LINQ to XML gestisce spazi vuoti durante il caricamento o l'analisi.This type allows you to control how LINQ to XML handles white space when loading or parsing. Per altre informazioni, vedere conservare lo spazio vuoto durante il caricamento o l'analisi XML e conservare gli spazi vuoti durante la serializzazione.For more information, see Preserving White Space while Loading or Parsing XML and Preserving White Space While Serializing.

Si applica a

Vedi anche