XObject.BaseUri Proprietà

Definizione

Ottiene l'URI di base per questo XObjectoggetto .

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à

Oggetto String contenente l'URI di base per l'oggetto XObject.

Esempio

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 utilizzato il documento XML 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("/"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

In questo esempio viene generato 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

Usando LINQ to XML, è possibile deserializzare XML in diversi modi. È possibile analizzarlo da una stringa, caricarlo da un file o da un TextReader oggetto XmlReader. In tutti questi casi, LINQ to XML usa una o un'altra delle sottoclassi concrete di XmlReader.

A volte ha XmlReader l'URI di base e a volte non lo fa. Ad esempio, durante il caricamento da un file, conosce XmlReader l'URI di base, ma durante la lettura da un oggetto XmlReader creato a causa della chiamata al Parse metodo, non è possibile segnalare XmlReader un URI di base. Il codice XML si trovava in una stringa.

Se, durante l'analisi o il caricamento del codice XML, si specifica SetBaseUri, LINQ to XML richiederà l'URI di base per ogni nodo come XmlReader restituisce il nodo. Se il lettore ha l'URI di base, LINQ to XML salverà le informazioni con il nodo LINQ to XML. Questa proprietà restituisce tali informazioni. Se l'oggetto sottostante XmlReader non dispone dell'URI di base, questa proprietà restituirà una stringa vuota.

L'impostazione SetBaseUri durante il caricamento di un albero XML comporterà un'analisi più lenta.

Quando si imposta l'URI di base per un albero XML, LINQ to XML inserisce un'annotazione nella radice dell'albero. Questa proprietà è una proprietà calcolata e esplora l'albero per trovare l'URI di base.

Si applica a

Vedi anche