Condividi tramite


XElement.Load Metodo

Definizione

Crea un nuovo oggetto XElement da un file specificato da un URI, da un oggetto TextReader o da un oggetto XmlReader.

Overload

Load(TextReader, LoadOptions)

Carica XElement da un oggetto TextReader, facoltativamente preservando lo spazio e mantenendo le informazioni sulla riga.

Load(XmlReader, LoadOptions)

Carica XElement da un oggetto XmlReader, facoltativamente preservando lo spazio, impostando l'URI di base e mantenendo le informazioni sulla riga.

Load(String, LoadOptions)

Carica XElement da un file, facoltativamente preservando lo spazio vuoto, impostando l'URI di base e mantenendo le informazioni sulla riga.

Load(Stream, LoadOptions)

Crea una nuova istanza di XElement usando il flusso specificato, conservando facoltativamente lo spazio vuoto, impostando l'URI di base e mantenendo le informazioni sulla riga.

Load(TextReader)

Carica un oggetto XElement da TextReader.

Load(String)

Carica un oggetto XElement da un file.

Load(Stream)

Crea una nuova istanza di XElement usando il flusso specificato.

Load(XmlReader)

Carica un oggetto XElement da XmlReader.

Commenti

È possibile usare uno degli overload di questo metodo per caricare un XElement oggetto da un file, un TextReaderoggetto o un oggetto XmlReader.

Per creare un XElement oggetto da una stringa contenente XML, utilizzare Parse.

Load(TextReader, LoadOptions)

Carica XElement da un oggetto TextReader, facoltativamente preservando lo spazio e mantenendo le informazioni sulla riga.

public:
 static System::Xml::Linq::XElement ^ Load(System::IO::TextReader ^ textReader, System::Xml::Linq::LoadOptions options);
public static System.Xml.Linq.XElement Load (System.IO.TextReader textReader, System.Xml.Linq.LoadOptions options);
static member Load : System.IO.TextReader * System.Xml.Linq.LoadOptions -> System.Xml.Linq.XElement
Public Shared Function Load (textReader As TextReader, options As LoadOptions) As XElement

Parametri

textReader
TextReader

Oggetto TextReader che verrà letto per il contenuto di XElement.

options
LoadOptions

Oggetto LoadOptions che specifica il comportamento dello spazio vuoto e se caricare l'URI di base e le informazioni sulla riga.

Restituisce

XElement

Oggetto XElement contenente il codice XML letto dall'oggetto TextReader specificato.

Esempio

L'esempio seguente carica un oggetto XElement da un StringReader oggetto in due modi diversi: mantenere lo spazio vuoto e non conservare lo spazio vuoto. Usa quindi una query per determinare il numero di nodi di spazio vuoto nell'albero XML risultante.

TextReader sr;  
int whiteSpaceNodes;  

sr = new StringReader("<Root> <Child> </Child> </Root>");  
XElement xmlTree1 = XElement.Load(sr, LoadOptions.None);  
sr.Close();  
whiteSpaceNodes = xmlTree1  
    .DescendantNodesAndSelf()  
    .OfType<XText>()  
    .Where(tNode => tNode.ToString().Trim().Length == 0)  
    .Count();  
Console.WriteLine("Count of white space nodes (not preserving whitespace): {0}", whiteSpaceNodes);  

sr = new StringReader("<Root> <Child> </Child> </Root>");  
XElement xmlTree2 = XElement.Load(sr, LoadOptions.PreserveWhitespace);  
sr.Close();  
whiteSpaceNodes = xmlTree2  
    .DescendantNodesAndSelf()  
    .OfType<XText>()  
    .Where(tNode => tNode.ToString().Trim().Length == 0)  
    .Count();  
Console.WriteLine("Count of white space nodes (preserving whitespace): {0}", whiteSpaceNodes);  
Dim sr As TextReader  
Dim whiteSpaceNodes As Integer  

sr = New StringReader("<Root> <Child> </Child> </Root>")  
Dim xmlTree1 As XElement = XElement.Load(sr, LoadOptions.None)  
sr.Close()  
whiteSpaceNodes = xmlTree1 _  
    .DescendantNodesAndSelf() _  
    .OfType(Of XText)() _  
    .Where(Function(ByVal tNode As XNode) tNode.ToString().Trim().Length = 0) _  
    .Count()  
Console.WriteLine("Count of white space nodes (not preserving whitespace): {0}", whiteSpaceNodes)  

sr = New StringReader("<Root> <Child> </Child> </Root>")  
Dim xmlTree2 As XElement = XElement.Load(sr, LoadOptions.PreserveWhitespace)  
sr.Close()  
whiteSpaceNodes = xmlTree2 _  
    .DescendantNodesAndSelf() _  
    .OfType(Of XText)() _  
    .Where(Function(ByVal tNode As XNode) tNode.ToString().Trim().Length = 0) _  
    .Count()  
Console.WriteLine("Count of white space nodes (preserving whitespace): {0}", whiteSpaceNodes)  

Nell'esempio viene prodotto l'output seguente:

Count of white space nodes (not preserving whitespace): 0  
Count of white space nodes (preserving whitespace): 3  

Nell'esempio seguente vengono caricate le informazioni sulla riga durante il caricamento TextReaderda . Stampa quindi le informazioni sulla riga.

TextReader sr = new StringReader(  
@"<Root>  
  <Child>  
    <GrandChild1/>  
    <GrandChild2/>  
  </Child>  
</Root>");  
XElement po = XElement.Load(sr,  
    LoadOptions.SetLineInfo);  
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).LineNumber.ToString().PadRight(5),  
        ((IXmlLineInfo)e).LinePosition);  
Dim sr As TextReader = New StringReader( _  
    "<Root>" & Environment.NewLine & _  
    "  <Child>" & Environment.NewLine & _  
    "    <GrandChild1/>" & Environment.NewLine & _  
    "    <GrandChild2/>" & Environment.NewLine & _  
    "  </Child>" & Environment.NewLine & _  
    "</Root>")  
Dim po As XElement = XElement.Load(sr, LoadOptions.SetLineInfo)  
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), _  
        (DirectCast(e, IXmlLineInfo)).LineNumber.ToString().PadRight(5), _  
        (DirectCast(e, IXmlLineInfo)).LinePosition)  
Next  

Nell'esempio viene prodotto l'output seguente:

Element Name        Line Position  
------------        ---- --------  
Root                1    2  
  Child             2    4  
    GrandChild1     3    6  
    GrandChild2     4    6  

Commenti

Se il codice XML di origine è rientrato, l'impostazione del PreserveWhitespace flag in options determina la lettura di tutti gli spazi vuoti nel codice XML di origine. I nodi di tipo XText vengono creati per spazi vuoti significativi e insignificanti.

Se il codice XML di origine è rientrato, non impostando il PreserveWhitespace flag in options , il lettore ignora tutti gli spazi vuoti non significativi nel codice XML di origine. L'albero XML viene creato senza nodi di testo per spazi vuoti non significativi.

Se il codice XML di origine non è rientrato, l'impostazione del PreserveWhitespace flag in options non ha alcun effetto. Gli spazi vuoti significativi vengono ancora mantenuti e non sono presenti intervalli di spazi vuoti insignificanti che potrebbero causare la creazione di più nodi di testo di spazio vuoto.

Per altre informazioni, vedere Mantenere lo spazio vuoto durante il caricamento o l'analisi di XML e Mantenere lo spazio vuoto durante la serializzazione.

Utilizzare Parse per creare un XElement oggetto da una stringa contenente XML.

L'impostazione SetBaseUri non avrà alcun effetto durante il caricamento da un oggetto TextReader.

Se si imposta il flag, si verifica una penalità per le SetLineInfo prestazioni.

Le informazioni sulla riga sono accurate immediatamente dopo il caricamento del documento XML. Se si modifica l'albero XML dopo il caricamento del documento, le informazioni sulla riga potrebbero diventare senza significato.

la funzionalità di caricamento di LINQ to XML è basata su XmlReader. Pertanto, è possibile intercettare eventuali eccezioni generate dai XmlReader.Create metodi di overload e dai XmlReader metodi che leggono e analizzano il documento.

Vedi anche

Si applica a

Load(XmlReader, LoadOptions)

Carica XElement da un oggetto XmlReader, facoltativamente preservando lo spazio, impostando l'URI di base e mantenendo le informazioni sulla riga.

public:
 static System::Xml::Linq::XElement ^ Load(System::Xml::XmlReader ^ reader, System::Xml::Linq::LoadOptions options);
public static System.Xml.Linq.XElement Load (System.Xml.XmlReader reader, System.Xml.Linq.LoadOptions options);
static member Load : System.Xml.XmlReader * System.Xml.Linq.LoadOptions -> System.Xml.Linq.XElement
Public Shared Function Load (reader As XmlReader, options As LoadOptions) As XElement

Parametri

reader
XmlReader

Oggetto XmlReader che verrà letto per il contenuto dell'oggetto XElement.

options
LoadOptions

Oggetto LoadOptions che specifica il comportamento dello spazio vuoto e se caricare l'URI di base e le informazioni sulla riga.

Restituisce

XElement

Oggetto XElement contenente il codice XML letto dall'oggetto XmlReader specificato.

Esempio

Nell'esempio seguente vengono caricate le informazioni sulla riga caricate da XmlReader. Stampa quindi le informazioni sulla riga.

string markup =  
@"<Root>  
    <Child>  
        <GrandChild/>  
    </Child>  
</Root>";  

// Create a reader and move to the content.  
using (XmlReader nodeReader = XmlReader.Create(new StringReader(markup)))  
{  
    // the reader must be in the Interactive state in order to  
    // Create a LINQ to XML tree from it.  
    nodeReader.MoveToContent();  

    XElement xRoot = XElement.Load(nodeReader, LoadOptions.SetLineInfo);  
    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 xRoot.DescendantsAndSelf())  
        Console.WriteLine("{0}{1}{2}",  
            ("".PadRight(e.Ancestors().Count() * 2) + e.Name).PadRight(20),  
            ((IXmlLineInfo)e).LineNumber.ToString().PadRight(5),  
            ((IXmlLineInfo)e).LinePosition);  
}  
Dim markup As String = _  
    "<Root>" & Environment.NewLine & _  
    "    <Child>" & Environment.NewLine & _  
    "        <GrandChild/>" & Environment.NewLine & _  
    "    </Child>" & Environment.NewLine & _  
    "</Root>"  

' Create a reader and move to the content.  
Using nodeReader As XmlReader = XmlReader.Create(New StringReader(markup))  

    ' the reader must be in the Interactive state in order to  
    ' Create a LINQ to XML tree from it.  
    nodeReader.MoveToContent()  

    Dim xRoot As XElement = XElement.Load(nodeReader, LoadOptions.SetLineInfo)  
    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 xRoot.DescendantsAndSelf()  
        Console.WriteLine("{0}{1}{2}", _  
            ("".PadRight(e.Ancestors().Count() * 2) & e.Name.ToString).PadRight(20), _  
            (DirectCast(e, IXmlLineInfo)).LineNumber.ToString().PadRight(5), _  
            (DirectCast(e, IXmlLineInfo)).LinePosition)  
    Next  
End Using  

Nell'esempio viene prodotto l'output seguente:

Element Name        Line Position  
------------        ---- --------  
Root                1    2  
  Child             2    6  
    GrandChild      3    10  

Commenti

Creando un XmlNodeReader oggetto da un documento DOM e quindi utilizzando per XmlNodeReader creare un XElementoggetto , questo metodo può essere usato per creare una copia di un documento DOM in un albero LINQ to XML.

Utilizzare Parse per creare un XElement oggetto da una stringa contenente XML.

L'impostazione PreserveWhitespace non è valida durante il caricamento da un oggetto XmlReader. L'oggetto XmlReader verrà configurato in modo da leggere o meno spazi vuoti. L'albero LINQ to XML verrà popolato con i nodi degli spazi vuoti che il lettore espone. Questo sarà il comportamento indipendentemente dal fatto che PreserveWhitespace sia impostato o meno.

XmlReader Può avere o meno un URI di base valido. Se si imposta SetBaseUri, l'URI di base verrà impostato nell'albero XML dall'URI di base segnalato da XmlReader.

L'oggetto XmlReader può avere o meno informazioni sulla riga valide. Se si imposta SetLineInfo, le informazioni sulla riga verranno impostate nell'albero XML dalle informazioni sulla riga segnalate XmlReaderda .

Se si imposta il flag, si verifica una penalità per le SetLineInfo prestazioni.

Le informazioni sulla riga sono accurate immediatamente dopo il caricamento del documento XML. Se si modifica l'albero XML dopo il caricamento del documento, le informazioni sulla riga potrebbero diventare senza significato.

la funzionalità di caricamento di LINQ to XML è basata su XmlReader. Pertanto, è possibile intercettare eventuali eccezioni generate dai XmlReader.Create metodi di overload e dai XmlReader metodi che leggono e analizzano il documento.

Vedi anche

Si applica a

Load(String, LoadOptions)

Carica XElement da un file, facoltativamente preservando lo spazio vuoto, impostando l'URI di base e mantenendo le informazioni sulla riga.

public:
 static System::Xml::Linq::XElement ^ Load(System::String ^ uri, System::Xml::Linq::LoadOptions options);
public static System.Xml.Linq.XElement Load (string uri, System.Xml.Linq.LoadOptions options);
static member Load : string * System.Xml.Linq.LoadOptions -> System.Xml.Linq.XElement
Public Shared Function Load (uri As String, options As LoadOptions) As XElement

Parametri

uri
String

Stringa URI che fa riferimento al file da caricare in XElement.

options
LoadOptions

Oggetto LoadOptions che specifica il comportamento dello spazio vuoto e se caricare l'URI di base e le informazioni sulla riga.

Restituisce

XElement

Oggetto XElement che include il contenuto del file specificato.

Esempio

L'esempio seguente carica un XElement oggetto da un file in due modi diversi: mantenere lo spazio vuoto e non conservare lo spazio vuoto. Usa quindi una query per determinare il numero di nodi di spazio vuoto nell'albero XML risultante.

XElement xmlTree1 = XElement.Parse("<Root> <Child>  </Child> </Root>", LoadOptions.PreserveWhitespace);  
xmlTree1.Save("Tree.xml");  
Console.WriteLine(xmlTree1);  

int whiteSpaceNodes;  
XElement xmlTree2 = XElement.Load("Tree.xml",  
    LoadOptions.None);  
whiteSpaceNodes = xmlTree2  
    .DescendantNodesAndSelf()  
    .OfType<XText>()  
    .Where(tNode => tNode.ToString().Trim().Length == 0)  
    .Count();  
Console.WriteLine("Count of white space nodes (not preserving whitespace): {0}", whiteSpaceNodes);  

XElement xmlTree3 = XElement.Load("Tree.xml",  
    LoadOptions.PreserveWhitespace);  
whiteSpaceNodes = xmlTree3  
    .DescendantNodesAndSelf()  
    .OfType<XText>()  
    .Where(tNode => tNode.ToString().Trim().Length == 0)  
    .Count();  
Console.WriteLine("Count of white space nodes (preserving whitespace): {0}", whiteSpaceNodes);  
Dim xmlTree1 As XElement = XElement.Parse("<Root> <Child>  </Child> </Root>", LoadOptions.PreserveWhitespace)  
xmlTree1.Save("Tree.xml")  
Console.WriteLine(xmlTree1)  

Dim whiteSpaceNodes As Integer  
Dim xmlTree2 As XElement = XElement.Load("Tree.xml", LoadOptions.None)  
whiteSpaceNodes = xmlTree2 _  
                  .DescendantNodesAndSelf() _  
                  .OfType(Of XText)() _  
                  .Where(Function(ByVal tNode As XNode) tNode.ToString().Trim().Length = 0) _  
                  .Count()  
Console.WriteLine("Count of white space nodes (not preserving whitespace): {0}", whiteSpaceNodes)  

Dim xmlTree3 As XElement = XElement.Load("Tree.xml", LoadOptions.PreserveWhitespace)  
whiteSpaceNodes = xmlTree3 _  
                  .DescendantNodesAndSelf() _  
                  .OfType(Of XText)() _  
                  .Where(Function(ByVal tNode As XNode) tNode.ToString().Trim().Length = 0) _  
                  .Count()  
Console.WriteLine("Count of white space nodes (preserving whitespace): {0}", whiteSpaceNodes)  

Nell'esempio viene prodotto l'output seguente:

<Root> <Child>  </Child> </Root>  
Count of white space nodes (not preserving whitespace): 0  
Count of white space nodes (preserving whitespace): 3  

Nell'esempio seguente vengono caricati l'URI di base e le informazioni sulla riga durante il caricamento del file. Stampa quindi l'URI di base e le informazioni sulla riga.

In questo esempio viene usato il file di risorse seguente: File XML di esempio: tipico ordine di acquisto (LINQ to XML).

XElement po = XElement.Load("PurchaseOrder.xml",  
    LoadOptions.SetBaseUri | LoadOptions.SetLineInfo);  
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).LineNumber.ToString().PadRight(5),  
        ((IXmlLineInfo)e).LinePosition);  
Dim po As XElement = XElement.Load("PurchaseOrder.xml", LoadOptions.SetBaseUri Or LoadOptions.SetLineInfo)  
Dim splitUri() As String = 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), _  
    "--------")  
For Each e As XElement In po.DescendantsAndSelf()  
    Console.WriteLine("{0}{1}{2}", _  
        ("".PadRight(e.Ancestors().Count() * 2) & e.Name.ToString()).PadRight(20), _  
        (DirectCast(e, IXmlLineInfo)).LineNumber.ToString().PadRight(5), _  
        (DirectCast(e, IXmlLineInfo)).LinePosition)  
Next  

Nell'esempio viene prodotto l'output seguente:

BaseUri: PurchaseOrder.xml  

Element Name        Line Position  
------------        ---- --------  
PurchaseOrder       2    2  
  Address           3    4  
    Name            4    6  
    Street          5    6  
    City            6    6  
    State           7    6  
    Zip             8    6  
    Country         9    6  
  Address           11   4  
    Name            12   6  
    Street          13   6  
    City            14   6  
    State           15   6  
    Zip             16   6  
    Country         17   6  
  DeliveryNotes     19   4  
  Items             20   4  
    Item            21   6  
      ProductName   22   8  
      Quantity      23   8  
      USPrice       24   8  
      Comment       25   8  
    Item            27   6  
      ProductName   28   8  
      Quantity      29   8  
      USPrice       30   8  
      ShipDate      31   8  

Commenti

Se il codice XML di origine è rientrato, l'impostazione del PreserveWhitespace flag in options determina la lettura di tutti gli spazi vuoti nel codice XML di origine. I nodi di tipo XText vengono creati per spazi vuoti significativi e insignificanti.

Se il codice XML di origine è rientrato, non impostando il PreserveWhitespace flag in options , il lettore ignora tutti gli spazi vuoti non significativi nel codice XML di origine. L'albero XML viene creato senza nodi di testo per spazi vuoti non significativi.

Se il codice XML di origine non è rientrato, l'impostazione del PreserveWhitespace flag in options non ha alcun effetto. Gli spazi vuoti significativi vengono ancora mantenuti e non sono presenti intervalli di spazi vuoti insignificanti che potrebbero causare la creazione di più nodi di testo di spazio vuoto.

Per altre informazioni, vedere Mantenere lo spazio vuoto durante il caricamento o l'analisi di XML e Mantenere lo spazio vuoto durante la serializzazione.

Utilizzare Parse per creare un XElement oggetto da una stringa contenente XML.

Se si impostano e i flag e si verifica una penalità per le SetBaseUri SetLineInfo prestazioni.

L'URI di base e le informazioni sulla riga sono accurati immediatamente dopo il caricamento del documento XML. Se si modifica l'albero XML dopo il caricamento del documento, l'URI di base e le informazioni sulla riga potrebbero diventare senza significato.

la funzionalità di caricamento di LINQ to XML è basata su XmlReader. Pertanto, è possibile intercettare eventuali eccezioni generate dai XmlReader.Create metodi di overload e dai XmlReader metodi che leggono e analizzano il documento.

Vedi anche

Si applica a

Load(Stream, LoadOptions)

Crea una nuova istanza di XElement usando il flusso specificato, conservando facoltativamente lo spazio vuoto, impostando l'URI di base e mantenendo le informazioni sulla riga.

public:
 static System::Xml::Linq::XElement ^ Load(System::IO::Stream ^ stream, System::Xml::Linq::LoadOptions options);
public static System.Xml.Linq.XElement Load (System.IO.Stream stream, System.Xml.Linq.LoadOptions options);
static member Load : System.IO.Stream * System.Xml.Linq.LoadOptions -> System.Xml.Linq.XElement
Public Shared Function Load (stream As Stream, options As LoadOptions) As XElement

Parametri

stream
Stream

Flusso contenente i dati XML.

options
LoadOptions

Oggetto LoadOptions che specifica se caricare l'URI di base e le informazioni sulla riga.

Restituisce

XElement

Oggetto XElement usato per leggere i dati contenuti nel flusso.

Commenti

la funzionalità di caricamento di LINQ to XML è basata su XmlReader. Pertanto, è possibile intercettare eventuali eccezioni generate dai XmlReader.Create metodi di overload e dai XmlReader metodi che leggono e analizzano il documento.

Se è necessario modificare XmlReaderSettings, seguire questa procedura:

  1. Creare un oggetto XmlReader chiamando uno degli Create overload che accettano XmlReaderSettings come parametro.

  2. Passare a XmlReader uno degli XElementoverload di Load che accetta XmlReader come parametro .

Si applica a

Load(TextReader)

Carica un oggetto XElement da TextReader.

public:
 static System::Xml::Linq::XElement ^ Load(System::IO::TextReader ^ textReader);
public static System.Xml.Linq.XElement Load (System.IO.TextReader textReader);
static member Load : System.IO.TextReader -> System.Xml.Linq.XElement
Public Shared Function Load (textReader As TextReader) As XElement

Parametri

textReader
TextReader

Oggetto TextReader che verrà letto per il contenuto di XElement.

Restituisce

XElement

Oggetto XElement contenente il codice XML letto dall'oggetto TextReader specificato.

Esempio

Nell'esempio seguente viene caricato un elemento da un oggetto StringReader.

TextReader sr = new StringReader("<Root><Child/></Root>");  
XElement xmlTree = XElement.Load(sr);  
sr.Close();  
Console.WriteLine(xmlTree);  
Dim sr As TextReader = New StringReader("<Root><Child/></Root>")  
Dim xmlTree As XElement = XElement.Load(sr)  
sr.Close()  
Console.WriteLine(xmlTree)  

Nell'esempio viene prodotto l'output seguente:

<Root>  
  <Child />  
</Root>  

Commenti

Questo metodo legge il codice XML non elaborato nell'albero XML. Elimina tutti gli spazi vuoti insignificanti nel file.

la funzionalità di caricamento di LINQ to XML è basata su XmlReader. Pertanto, è possibile intercettare eventuali eccezioni generate dai XmlReader.Create metodi di overload e dai XmlReader metodi che leggono e analizzano il documento.

Vedi anche

Si applica a

Load(String)

Carica un oggetto XElement da un file.

public:
 static System::Xml::Linq::XElement ^ Load(System::String ^ uri);
public static System.Xml.Linq.XElement Load (string uri);
static member Load : string -> System.Xml.Linq.XElement
Public Shared Function Load (uri As String) As XElement

Parametri

uri
String

Stringa URI che fa riferimento al file da caricare in un nuovo oggetto XElement.

Restituisce

XElement

Oggetto XElement che include il contenuto del file specificato.

Esempio

L'esempio seguente crea un albero XML, lo salva in un file e quindi usa questo metodo per caricare l'oggetto XElement dal file.

XElement xmlTree1 = new XElement("Root",  
    new XElement("Child", "content")  
);  
xmlTree1.Save("Tree.xml");  

XElement xmlTree2 = XElement.Load("Tree.xml");  
Console.WriteLine(xmlTree2.Name);  
Dim xmlTree1 As XElement = _   
        <Root>  
            <Child>Content</Child>  
        </Root>  
xmlTree1.Save("Tree.xml")  

Dim xmlTree2 As XElement = XElement.Load("Tree.xml")  
Console.WriteLine(xmlTree2.Name)  

Nell'esempio viene prodotto l'output seguente:

Root  

Commenti

Questo metodo legge il codice XML non elaborato nell'albero XML. Elimina tutti gli spazi vuoti insignificanti nel file.

la funzionalità di caricamento di LINQ to XML è basata su XmlReader. Pertanto, è possibile intercettare eventuali eccezioni generate dai XmlReader.Create metodi di overload e dai XmlReader metodi che leggono e analizzano il documento.

Vedi anche

Si applica a

Load(Stream)

Crea una nuova istanza di XElement usando il flusso specificato.

public:
 static System::Xml::Linq::XElement ^ Load(System::IO::Stream ^ stream);
public static System.Xml.Linq.XElement Load (System.IO.Stream stream);
static member Load : System.IO.Stream -> System.Xml.Linq.XElement
Public Shared Function Load (stream As Stream) As XElement

Parametri

stream
Stream

Flusso che contiene i dati XML.

Restituisce

XElement

Oggetto XElement usato per leggere i dati contenuti nel flusso.

Commenti

Se si desidera controllare le opzioni di caricamento, usare l'overload Load che accetta LoadOptions come parametro.

la funzionalità di caricamento di LINQ to XML è basata su XmlReader. Pertanto, è possibile intercettare eventuali eccezioni generate dai XmlReader.Create metodi di overload e dai XmlReader metodi che leggono e analizzano il documento.

Se è necessario modificare XmlReaderSettings, seguire questa procedura:

  1. Creare un oggetto XmlReader chiamando uno degli Create overload che accettano XmlReaderSettings come parametro.

  2. Passare a XmlReader uno degli XElementoverload di Load che accetta XmlReader come parametro .

Si applica a

Load(XmlReader)

Carica un oggetto XElement da XmlReader.

public:
 static System::Xml::Linq::XElement ^ Load(System::Xml::XmlReader ^ reader);
public static System.Xml.Linq.XElement Load (System.Xml.XmlReader reader);
static member Load : System.Xml.XmlReader -> System.Xml.Linq.XElement
Public Shared Function Load (reader As XmlReader) As XElement

Parametri

reader
XmlReader

Oggetto XmlReader che verrà letto per il contenuto dell'oggetto XElement.

Restituisce

XElement

Oggetto XElement contenente il codice XML letto dall'oggetto XmlReader specificato.

Esempio

Nell'esempio seguente viene creato un documento DOM, creato un XmlNodeReader oggetto dal documento DOM, viene creata un'istanza di un albero dal lettore. Questo codice copia in modo efficace un documento DOM in un albero LINQ to XML.

// Create a DOM document with some content.  
XmlDocument doc = new XmlDocument();  
XmlElement child = doc.CreateElement("Child");  
child.InnerText = "child contents";  
XmlElement root = doc.CreateElement("Root");  
root.AppendChild(child);  
doc.AppendChild(root);  

// Create a reader and move to the content.  
using (XmlNodeReader nodeReader = new XmlNodeReader(doc)) {  
    // the reader must be in the Interactive state in order to  
    // Create a LINQ to XML tree from it.  
    nodeReader.MoveToContent();  

    XElement xRoot = XElement.Load(nodeReader);  
    Console.WriteLine(xRoot);  
}  
' Create a DOM document with some content.  
Dim doc As XmlDocument = New XmlDocument()  
Dim child As XmlElement = doc.CreateElement("Child")  
child.InnerText = "child contents"  
Dim root As XmlElement = doc.CreateElement("Root")  
root.AppendChild(child)  
doc.AppendChild(root)  

' Create a reader and move to the content.  
Using nodeReader = New XmlNodeReader(doc)  
    ' the reader must be in the Interactive state in order to  
    ' Create a LINQ to XML tree from it.  
    nodeReader.MoveToContent()  

    Dim xRoot As XElement = XElement.Load(nodeReader)  
    Console.WriteLine(xRoot)  
End Using  

Nell'esempio viene prodotto l'output seguente:

<Root>  
  <Child>child contents</Child>  
</Root>  

Commenti

Creando un XmlNodeReader oggetto da un documento DOM e quindi utilizzando per XmlNodeReader creare un XElementoggetto , questo metodo può essere usato per creare una copia di un documento DOM in un albero LINQ to XML.

la funzionalità di caricamento di LINQ to XML è basata su XmlReader. Pertanto, è possibile intercettare eventuali eccezioni generate dai XmlReader.Create metodi di overload e dai XmlReader metodi che leggono e analizzano il documento.

Vedi anche

Si applica a