Quel est le moyen le plus rapide pour charger des données XML dans un XDocument?

Lorsque vous créez un nouveau XDocument à l'aide de XDocument.Load, n'est-il ouvert le fichier XML et en garder une copie locale, ou il continue de lire le document à partir du disque dur? Si elle ne continue de lire, est-il un moyen plus rapide pour parser du XML?

XDocument x = XDocument.Load("file.xml");

InformationsquelleAutor redcodefinal | 2012-12-22

.net c#linq-to-xml xml

Il ya un couple de mesures à envisager:

Linéaire de la traversée de la vitesse (par exemple, de lecture/chargement)
Des requêtes à la demande de la vitesse

Pour répondre à la question immédiate: XDocument utilise un XmlReader de charger le document dans la mémoire par la lecture de chaque élément et de la création d'correspondant XElement cas (voir le code ci-dessous). En tant que tel, il devrait être assez rapide (assez rapide pour la plupart des cas), mais il peut consommer une grande quantité de mémoire lors de l'analyse d'un document volumineux.

Un raw XmlReader est un excellent choix pour la traversée si vos besoins sont limités à ce qui peut être fait sans conserver le document dans la mémoire. Il sera mieux que d'autres méthodes car aucune structure importante est créé ni résolu en relation avec d'autres nœuds (par exemple, en reliant des nœuds parents et enfants). Toutefois, à la demande de requête de capacité est presque inexistant; vous pouvez réagir à des valeurs que l'on retrouve dans chaque nœud, mais vous ne pouvez pas interroger le document dans son ensemble. Si vous avez besoin de regarder le document une deuxième fois, vous avoir à traverser toute chose de nouveau.

Par comparaison, une XDocument prendra plus de temps pour traverser parce qu'il instancie des objets et effectue de base des tâches structurelles. Il permettra également de consommer de la mémoire proportionnelle à la taille de la source. En échange de ces échanges, vous bénéficiez d'un excellent requête capacités.

Il peut être possible de combiner les approches, comme mentionné par Jon Skeet et illustré ici: Streaming En LINQ to XML à l'Aide de C# Personnalisé Itérateurs et XmlReader.

Source pour XDocument Load()

public static XDocument Load(Stream stream, LoadOptions options)
{
XmlReaderSettings xmlReaderSettings = XNode.GetXmlReaderSettings(options);
XDocument result;
using (XmlReader xmlReader = XmlReader.Create(stream, xmlReaderSettings))
{
result = XDocument.Load(xmlReader, options);
}
return result;
}
//which calls...
public static XDocument Load(XmlReader reader, LoadOptions options)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
if (reader.ReadState == ReadState.Initial)
{
reader.Read();
}
XDocument xDocument = new XDocument();
if ((options & LoadOptions.SetBaseUri) != LoadOptions.None)
{
string baseURI = reader.BaseURI;
if (baseURI != null && baseURI.Length != 0)
{
xDocument.SetBaseUri(baseURI);
}
}
if ((options & LoadOptions.SetLineInfo) != LoadOptions.None)
{
IXmlLineInfo xmlLineInfo = reader as IXmlLineInfo;
if (xmlLineInfo != null && xmlLineInfo.HasLineInfo())
{
xDocument.SetLineInfo(xmlLineInfo.LineNumber, xmlLineInfo.LinePosition);
}
}
if (reader.NodeType == XmlNodeType.XmlDeclaration)
{
xDocument.Declaration = new XDeclaration(reader);
}
xDocument.ReadContentFrom(reader, options);
if (!reader.EOF)
{
throw new InvalidOperationException(Res.GetString("InvalidOperation_ExpectedEndOfFile"));
}
if (xDocument.Root == null)
{
throw new InvalidOperationException(Res.GetString("InvalidOperation_MissingRoot"));
}
return xDocument;
}
//which calls...
internal void ReadContentFrom(XmlReader r, LoadOptions o)
{
if ((o & (LoadOptions.SetBaseUri | LoadOptions.SetLineInfo)) == LoadOptions.None)
{
this.ReadContentFrom(r);
return;
}
if (r.ReadState != ReadState.Interactive)
{
throw new InvalidOperationException(Res.GetString("InvalidOperation_ExpectedInteractive"));
}
XContainer xContainer = this;
XNode xNode = null;
NamespaceCache namespaceCache = default(NamespaceCache);
NamespaceCache namespaceCache2 = default(NamespaceCache);
string text = ((o & LoadOptions.SetBaseUri) != LoadOptions.None) ? r.BaseURI : null;
IXmlLineInfo xmlLineInfo = ((o & LoadOptions.SetLineInfo) != LoadOptions.None) ? (r as IXmlLineInfo) : null;
while (true)
{
string baseURI = r.BaseURI;
switch (r.NodeType)
{
case XmlNodeType.Element:
{
XElement xElement = new XElement(namespaceCache.Get(r.NamespaceURI).GetName(r.LocalName));
if (text != null && text != baseURI)
{
xElement.SetBaseUri(baseURI);
}
if (xmlLineInfo != null && xmlLineInfo.HasLineInfo())
{
xElement.SetLineInfo(xmlLineInfo.LineNumber, xmlLineInfo.LinePosition);
}
if (r.MoveToFirstAttribute())
{
do
{
XAttribute xAttribute = new XAttribute(namespaceCache2.Get((r.Prefix.Length == 0) ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value);
if (xmlLineInfo != null && xmlLineInfo.HasLineInfo())
{
xAttribute.SetLineInfo(xmlLineInfo.LineNumber, xmlLineInfo.LinePosition);
}
xElement.AppendAttributeSkipNotify(xAttribute);
}
while (r.MoveToNextAttribute());
r.MoveToElement();
}
xContainer.AddNodeSkipNotify(xElement);
if (r.IsEmptyElement)
{
goto IL_30A;
}
xContainer = xElement;
if (text != null)
{
text = baseURI;
goto IL_30A;
}
goto IL_30A;
}
case XmlNodeType.Text:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
if ((text != null && text != baseURI) || (xmlLineInfo != null && xmlLineInfo.HasLineInfo()))
{
xNode = new XText(r.Value);
goto IL_30A;
}
xContainer.AddStringSkipNotify(r.Value);
goto IL_30A;
case XmlNodeType.CDATA:
xNode = new XCData(r.Value);
goto IL_30A;
case XmlNodeType.EntityReference:
if (!r.CanResolveEntity)
{
goto Block_25;
}
r.ResolveEntity();
goto IL_30A;
case XmlNodeType.ProcessingInstruction:
xNode = new XProcessingInstruction(r.Name, r.Value);
goto IL_30A;
case XmlNodeType.Comment:
xNode = new XComment(r.Value);
goto IL_30A;
case XmlNodeType.DocumentType:
xNode = new XDocumentType(r.LocalName, r.GetAttribute("PUBLIC"), r.GetAttribute("SYSTEM"), r.Value, r.DtdInfo);
goto IL_30A;
case XmlNodeType.EndElement:
{
if (xContainer.content == null)
{
xContainer.content = string.Empty;
}
XElement xElement2 = xContainer as XElement;
if (xElement2 != null && xmlLineInfo != null && xmlLineInfo.HasLineInfo())
{
xElement2.SetEndElementLineInfo(xmlLineInfo.LineNumber, xmlLineInfo.LinePosition);
}
if (xContainer == this)
{
return;
}
if (text != null && xContainer.HasBaseUri)
{
text = xContainer.parent.BaseUri;
}
xContainer = xContainer.parent;
goto IL_30A;
}
case XmlNodeType.EndEntity:
goto IL_30A;
}
break;
IL_30A:
if (xNode != null)
{
if (text != null && text != baseURI)
{
xNode.SetBaseUri(baseURI);
}
if (xmlLineInfo != null && xmlLineInfo.HasLineInfo())
{
xNode.SetLineInfo(xmlLineInfo.LineNumber, xmlLineInfo.LinePosition);
}
xContainer.AddNodeSkipNotify(xNode);
xNode = null;
}
if (!r.Read())
{
return;
}
}
goto IL_2E1;
Block_25:
throw new InvalidOperationException(Res.GetString("InvalidOperation_UnresolvedEntityReference"));
IL_2E1:
throw new InvalidOperationException(Res.GetString("InvalidOperation_UnexpectedNodeType", new object[]
{
r.NodeType
}));
}

InformationsquelleAutor Tim Medora

6

Il analyse le flux entrant (si c'est à partir d'un fichier ou d'une chaîne de caractères n'a pas d'importance) lorsque vous appelez Load() et le conserver à une instance locale du document en mémoire. Depuis la source peut être n'importe quoi (peut être une NetworkStream, un DataReader, une chaîne entrée par l'utilisateur), il ne pouvait pas revenir en arrière et essayer de lire les données à nouveau, car elle ne sais pas l'état de celui-ci (flux en cours de fermeture, etc).

Si vous voulez vraiment de la vitesse sur l'autre main, XDocument n'est pas le fastets (tous bien que c'est plus facile à travailler), puisqu'il faudra d'abord analyser le document et de le conserver en mémoire. Si vous travaillez avec des documents de grande taille à l'aide d'une approche avec Système.Xml.XmlReader est généralement beaucoup plus rapide car il peut lire le document comme un flux et n'a pas besoin de conserver de tout, sauf de l'élément actuel. Cette référence montre quelques chiffres intéressants à ce sujet.
- Merci c'est vraiment utile. Je l'utilise dans XNA, et je pense que j'ai besoin de ton vers le bas la quantité de fois que je l'appelle XDocument.Charge, car je le fais à chaque objet et je n'ai pas besoin de.
- L'indice de référence lien est mort.
- Mise à jour avec le nouveau lien pour le même article.
- Le lien est toujours mort.
- Pas encore, mais elle a disparu à nouveau. Il m'a fallu une minute pour trouver l'article sur Google mais j'ai mis à jour de nouveau le lien.
InformationsquelleAutor Karl-Johan Sjögren
1

Je ne pense pas que c'lit en permanence; la bonne chose à propos de la XDocument.Load méthode est qu'elle utilise XmlReader pour lire le fichier XML dans un arbre XML. Et puisque maintenant vous venez de créer un arbre qui est probablement stocké dans votre mémoire comme un arbre, il ne lit plus le document en permanence. Il manipule l'arbre et depuis c'est un arbre à tous de votre lecture et de modification sont fait beaucoup plus rapidement. Bien qu'il ne pas mettre en œuvre IDisposable il est automatiquement éliminé.

InformationsquelleAutor COLD TOLD

Vous devez vous connecter pour publier un commentaire.