XObject.BaseUri Propriété

Référence

Définition

Espace de noms:: System.Xml.Linq

Assembly:: System.Xml.XDocument.dll

Assembly:: System.Xml.Linq.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Obtient l'URI de base pour ce XObject.

public:
 property System::String ^ BaseUri { System::String ^ get(); };

public string BaseUri { get; }

member this.BaseUri : string

Public ReadOnly Property BaseUri As String

Valeur de propriété

String

String qui contient l'URI de base pour ce XObject.

Exemples

L’exemple suivant charge l’URI de base et les informations de ligne au fur et à mesure qu’il charge le fichier. Il imprime ensuite l’URI de base et les informations de ligne.

Cet exemple utilise le document XML suivant : Exemple de fichier XML : commande fournisseur typique (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

Cet exemple produit la sortie suivante :

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

Remarques

À l’aide de LINQ to XML, vous pouvez désérialiser du code XML de plusieurs manières. Vous pouvez l’analyser à partir d’une chaîne, la charger à partir d’un fichier ou la lire à partir d’un ou d’un TextReader XmlReader. Dans tous ces cas, LINQ to XML utilise l’une ou l’autre des sous-classes concrètes de XmlReader.

Parfois, il XmlReader a l’URI de base, et parfois il ne le fait pas. Par exemple, lors du chargement à partir d’un fichier, l’URI XmlReader de base connaît l’URI de base, mais lors de la lecture à partir d’un XmlReader élément créé en raison de l’appel XmlReader de la Parse méthode, il n’existe aucune possibilité de création d’URI de base ; le code XML était dans une chaîne.

Si, lors de l’analyse ou du chargement du code XML, vous spécifiez SetBaseUri, LINQ to XML demande l’URI de base pour chaque nœud au fur et à mesure que le XmlReader nœud retourne le nœud. Si le lecteur a l’URI de base, LINQ to XML enregistre les informations avec le nœud LINQ to XML. Cette propriété retourne ces informations. Si le sous-jacent XmlReader n’a pas l’URI de base, cette propriété retourne une chaîne vide.

La définition SetBaseUri lors du chargement d’une arborescence XML entraîne une analyse plus lente.

Lorsque vous définissez l’URI de base pour une arborescence XML, LINQ to XML place une annotation à la racine de l’arborescence. Cette propriété est une propriété calculée et navigue vers le haut de l’arborescence pour trouver l’URI de base.

S’applique à

Voir aussi

Vue d’ensemble de LINQ to XML

Partager via