XObject.BaseUri Proprietà

Definizione

Ottiene l'URI di base per XObject.Gets the base URI for this XObject.

public:
 property System::String ^ BaseUri { System::String ^ get(); };
public string BaseUri { get; }
member this.BaseUri : string
Public ReadOnly Property BaseUri As String

Valore della proprietà

String che contiene l'URI di base per XObject.A String that contains the base URI for this XObject.

Esempi

Nell'esempio seguente vengono caricati l'URI di base e le informazioni sulla riga durante il caricamento del file.The following example loads the base URI and line information as it loads the file. Viene quindi stampato l'URI di base e le informazioni sulla riga.It then prints the base URI and the line information.

Questo esempio usa il documento XML seguente: File XML di esempio: ordine di acquisto tipico (LINQ to XML).This example uses the following XML document: Sample XML File: Typical Purchase Order (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("/"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), _  
        DirectCast(e, IXmlLineInfo).LineNumber.ToString().PadRight(5), _  
        DirectCast(e, IXmlLineInfo).LinePosition)  
Next  

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

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

Con LINQ to XML è possibile deserializzare il codice XML in diversi modi.Using LINQ to XML, you can deserialize XML in a number of fashions. È possibile analizzarlo da una stringa, caricarlo da un file o leggerlo da un TextReader oggetto XmlReadero.You can parse it from a string, load it from a file, or read it from a TextReader or an XmlReader. In tutti questi casi, LINQ to XML usa una o un'altra delle sottoclassi concrete di XmlReader.In all of these cases, LINQ to XML uses one or another of the concrete subclasses of XmlReader.

A volte XmlReader ha l'URI di base e talvolta non lo è.Sometimes the XmlReader has the base URI, and sometimes it does not. Ad esempio, durante il caricamento da un file, XmlReader l'oggetto conosce l'URI di base, ma durante XmlReader la lettura da un creato a causa Parse della chiamata al metodo, non è possibile XmlReader che la segnalazione di un URI di base; il codice XML si trovava in un stringa.For instance, when loading from a file, the XmlReader knows the base URI, but when reading from an XmlReader that was created because of calling the Parse method, there is no possibility of the XmlReader reporting a base URI; the XML was in a string.

Se, durante l'analisi o il caricamento del codice XML, SetBaseUrisi specifica, LINQ to XML richiederà l'URI di base per ogni XmlReader nodo, in quanto restituisce il nodo.If, when parsing or loading the XML, you specify SetBaseUri, LINQ to XML will request the base URI for each node as the XmlReader returns the node. Se il lettore dispone dell'URI di base, LINQ to XML salverà le informazioni con il nodo LINQ to XML.If the reader has the base URI, LINQ to XML will save the information with the LINQ to XML node. Questa proprietà restituisce tali informazioni.This property returns that information. Se l'oggetto XmlReader sottostante non dispone dell'URI di base, questa proprietà restituirà una stringa vuota.If the underlying XmlReader does not have the base URI, then this property will return an empty string.

L' SetBaseUri impostazione durante il caricamento di un albero XML comporterà un'analisi più lenta.Setting SetBaseUri when loading an XML tree will result in slower parsing.

Quando si imposta l'URI di base per un albero XML, LINQ to XML inserisce un'annotazione nella radice dell'albero.When setting the base URI for an XML tree, LINQ to XML puts an annotation on the root of the tree. Questa proprietà è una proprietà calcolata e consente di spostarsi verso l'alto nell'albero per trovare l'URI di base.This property is a computed property, and navigates up the tree to find the base URI.

Si applica a

Vedi anche