C# XDocument de Charge avec plusieurs racines

J'ai un fichier XML avec pas de racine. Je ne peux pas changer cela. Je suis en train de l'analyser, mais XDocument.Load ne le fera pas. J'ai essayé de mettre ConformanceLevel.Fragment, mais j'ai toujours une exception. Quelqu'un aurait-il une solution à cela?

J'ai essayé avec XmlReader, mais les choses sont foiré et ne peut pas le faire fonctionner à droite. XDocument.Load fonctionne très bien, mais si j'ai un fichier avec plusieurs racines, il ne le fait pas.

XDocument.Load ne fonctionne pas, car ce type de fichier n'est pas un document XML valide.
Pouvez-vous poster le code que vous avez essayé jusqu'à présent?
Autre question, même réponse: stackoverflow.com/a/9378442
Pourquoi ne pouvez-vous pas simplement utiliser XElement analyser
Parce qu'alors, vous obtenez cette exception: élément Racine est manquant.

OriginalL'auteur Darksody | 2013-08-12

c#linq-to-xml xml

16

XmlReader lui-même prend en charge la lecture de fragment xml - c'est à dire
```
var settings = new XmlReaderSettings { ConformanceLevel = ConformanceLevel.Fragment };
using (var reader = XmlReader.Create("fragment.xml", settings))
{
  //you can work with reader just fine
}
```
Cependant XDocument.Load ne prend pas en charge la lecture des fragments xml.

Façon rapide et sale est d'envelopper les nœuds sous une racine virtuelle avant d'appeler la XDocument.Parse. Comme:
```
var fragments = File.ReadAllText("fragment.xml");
var myRootedXml = "<root>" + fragments + "</root>";
var doc = XDocument.Parse(myRootedXml);
```
Cette approche est limitée à de petits fichiers xml - comme vous avez pu le lire fichier dans la mémoire de la première; et la concaténation de la chaîne moyens de transporter de gros objets dans la mémoire - ce qui est préférable d'éviter.

Si la performance est importante, vous devriez lire les nœuds en XDocument un par un via XmlReader comme expliqué dans l'excellent @Martin-Honnen 's réponse (https://stackoverflow.com/a/18203952/2440262)

Si vous utilisez l'API qui prend pour acquis que XmlReader itère sur xml valide, et des questions de rendement, vous pouvez utiliser rejoint flux approche plutôt:
```
using (var jointStream = new MultiStream())
using (var openTagStream = new MemoryStream(Encoding.ASCII.GetBytes("<root>"), false))
using (var fileStream = 
  File.Open(@"fragment.xml", FileMode.Open, FileAccess.Read, FileShare.Read))
using (var closeTagStream = new MemoryStream(Encoding.ASCII.GetBytes("</root>"), false))
{
    jointStream.AddStream(openTagStream);
    jointStream.AddStream(fileStream);
    jointStream.AddStream(closeTagStream);
    using (var reader = XmlReader.Create(jointStream))
    {
        //now you can work with reader as if it is reading valid xml
    }
}
```
Multiflux - voir, par exemple, https://gist.github.com/svejdo1/b9165192d313ed0129a679c927379685

Remarque: XDocument charge l'ensemble de xml en mémoire. Donc ne l'utilisez pas pour les gros fichiers - au lieu d'utiliser XmlReader pour l'itération et de ne charger que les morceaux croustillants comme XElement via XNode.ReadFrom(...)

À l'aide de XDocument.Parse() devrait éliminer la nécessité pour l'emballage de la chaîne dans un StringReader.

OriginalL'auteur Ondrej Svejdar

Le seul dans la mémoire de l'arbre de représentations de dans le .NET framework qui peut traiter avec les fragments sont XmlDocumentFragment.NET du DOM de la mise en œuvre de sorte que vous devez créer un XmlDocument et un fragment avec, par exemple,

XmlDocument doc = new XmlDocument();
XmlDocumentFragment frag = doc.CreateDocumentFragment();
frag.InnerXml = stringWithXml; //for instance 
                               //frag.InnerXml = File.ReadAllText("fragment.xml");

ou est XPathDocument où vous pouvez en créer un à l'aide d'un XmlReader avec ConformanceLevel ensemble de Fragment:

XPathDocument doc;
using (XmlReader xr = 
                 XmlReader.Create("fragment.xml", 
                                   new XmlReaderSettings()
                                   {
                                       ConformanceLevel = ConformanceLevel.Fragment
                                    }))
{
  doc = new XPathDocument(xr);
}

//new create XPathNavigator for read out data e.g.
XPathNavigator nav = doc.CreateNavigator();

Évidemment XPathNavigator est en lecture seule.

Si vous souhaitez utiliser LINQ to XML puis je suis d'accord avec les suggestions que vous avez besoin pour créer un XElement comme un wrapper. Au lieu de tirer dans une chaîne de caractères avec le contenu du fichier vous pouvez, toutefois, utiliser XNode.ReadFrom avec un XmlReader par exemple

public static class MyExtensions
{
    public static IEnumerable<XNode> ParseFragment(XmlReader xr)
    {
        xr.MoveToContent();
        XNode node;
        while (!xr.EOF && (node = XNode.ReadFrom(xr)) != null)
        {
            yield return node;
        }
    }
}

puis

XElement root = new XElement("root", 
                             MyExtensions.ParseFragment(XmlReader.Create(
                                 "fragment.xml", 
                                 new XmlReaderSettings() {
                                 ConformanceLevel = ConformanceLevel.Fragment })));

Qui pourrait fonctionner mieux et plus efficacement que la lecture tout en une chaîne de caractères.

OriginalL'auteur Martin Honnen

Si vous souhaitez utiliser XmlDocument.Load() puis vous devez envelopper le contenu dans un nœud racine.

ou vous pouvez essayer quelque chose comme cela...

while (xmlReader.Read())
{
    if (xmlReader.NodeType == XmlNodeType.Element)
    {
        XmlDocument d = new XmlDocument();
        d.CreateElement().InnerText = xmlReader.ReadOuterXml();
     }
}

OriginalL'auteur Secret Squirrel

0

Document XML ne peut pas avoir plus d'une racine éléments. Un élément root est requis. Vous pouvez faire une seule chose. Obtenez tous les fragment éléments et de les encapsuler dans un élément racine et de l'analyser avec XDocument.

Ce serait la meilleure et la plus facile d'approche que l'on pourrait penser.

OriginalL'auteur Vivek Jain

Vous devez vous connecter pour publier un commentaire.