déterminer si le fichier xml contient des données - c#

Comment puis-je savoir si mon fichier XML de données en dehors de l'espace de nom info:

Certains des fichiers qui contiennent ce:

<?xml version="1.0" encoding="UTF-8"?>

Et si je rencontre un tel fichier, je veux placer le fichier dans une erreur répertoire

OriginalL'auteur | 2009-08-11

  1. 4

    Vous pouvez utiliser le XmlReader pour éviter la surcharge de XmlDocument. Dans votre cas, vous recevrez une exception, car l'élément racine est manquant. 

    string xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
using (StringReader strReader = new StringReader(xml))
{
    //You can replace the StringReader object with the path of your xml file.
    //In that case, do not forget to remove the "using" lines above.
    using (XmlReader reader = XmlReader.Create(strReader))
    {
        try
        {
            while (reader.Read())
            {
            }
        }
        catch (XmlException ex)
        {
            //Catch xml exception
            //in your case: root element is missing
        }
    }
}

    Vous pouvez ajouter une condition dans le while(reader.Read()) boucle après que vous avez enregistré les premiers nœuds pour éviter de lire l'intégralité du fichier xml puisque vous voulez juste pour vérifier si l'élément racine est manquant.

    +1 mais prises XmlException dans le bloc catch au lieu de simplement Exception.
    ouais vous avez raison. Je l'ai corrigé.
    Peut aussi simplement utiliser XmlReader.Create('nom du fichier') surcharge au lieu de passer dans StringReader pour éviter d'avoir à charger le corps de xml en mémoire, sinon votre pas de gagner beaucoup plus de commodité de XmlDocument, si tout...même si je suis seul sur ma première tasse o café pour prendre cela avec un grain de sel! 🙂
    Je suis d'accord avec vous. Dans ce cas, je viens d'utiliser le stringreader d'utiliser le xml échantillon fourni par itech.
    Bonham: Ajout d'un commentaire dans le code. 🙂

    OriginalL'auteur Francis B.

  2. 2

    Je pense que le seul moyen est d'attraper une exception quand vous essayez de le charger, comme ceci:

       try
    {
        System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
        doc.Load(Server.MapPath("XMLFile.xml"));
    }
    catch (System.Xml.XmlException xmlEx)
    {
        if (xmlEx.Message.Contains("Root element is missing"))
        {
            //Xml file is empty
        }
    }

    Oui, il y a une surcharge, mais vous devriez effectuer des contrôles d'intégrité comme cela de toute façon. Vous ne devriez jamais faire confiance d'entrée et le seul moyen fiable de vérifier s'il est XML est de le traiter comme XML et voir ce que .NET dit à ce sujet!

    OriginalL'auteur Dan Diplo

  3. 2

    XmlDocument xDoc = new XmlDocument();

    si (xDoc.ChildNodes.Count == 0)
    { //document xml est vide }

    si (xDoc.ChildNodes.Count == 1)
    { //dans le document xml est seulement nœud déclaration. (si vous êtes shure cette déclaration, c'est toujours au début }

    si (xDoc.ChildNodes.Count > 1)
    { //il n'y a déclaration + n nœuds (ce nombre est généralement 2; déclaration + nœud racine) }

    OriginalL'auteur

  4. 1

    N'ai pas essayé...mais devrait fonctionner.

    try
{
    XmlDocument doc = new XmlDocument();
    doc.Load("test.xml");
}
catch (XmlException exc)
{
    //invalid file
}

    EDIT: sur la Base des commentaires des commentaires

    Pour les grands documents XML voir Thomas réponse. Cette approche peut avoir des problèmes de performances.
    Mais, si c'est un xml valide et le programme se veut le traiter ensuite cette approche semble mieux.

    J'ai pensé à cela, mais qu'est-ce que la surcharge différence entre le chargement du XML et de faire ce que j'ai proposé? C'est certainement plus clair, mais je suis juste curieux au sujet de la performance, surtout avec les grands documents XML - pourquoi charger le XML si vous n'en avez pas besoin?
    +1 Thomas, je suis d'accord sur votre point de ne PAS l'utiliser dans mon approche pour les grands documents XML. Mais, si c'est un xml valide et le programme se veut le traiter ensuite cette approche semble mieux.
    C'est très vrai. Je pense que vous devriez ajouter à votre post, je vais ajouter quelque chose de similaire à la mienne.
    PK - qui ne fonctionne pas. Vous obtiendrez une exception dès que vous essayez de charger le document.
    Votre raison à propos de la surcharge de la performance surtout avec des documents >= 85K dans la taille. Mais je parie que poster des besoins pour en savoir plus sur le contenu de ce fichier que s'il existe des données au-delà des instructions de traitement (par exemple, xml valide). XmlReader gardera un plat modèle de mémoire dans cette situation et donner les avantages de facilement déterminer si xml valide.

    OriginalL'auteur P.K

  5. 0

    Si vous n'êtes pas inquiet au sujet de la validité, il suffit de vérifier pour voir si il n'y a rien après le premier ?>. Je ne suis pas entièrement sûr de la syntaxe C# (ça fait trop longtemps que je l'ai utilisé), mais lire le fichier, rechercher la première occurrence de l' ?>, et de voir si il y a quoi que ce soit après que l'indice.

    Cependant, si vous souhaitez utiliser le XML plus tard ou que vous voulez traiter le XML plus tard, vous devriez envisager de PK la réponse de et de charger le XML dans une XmlDocument objet. Mais si vous avez de gros documents XML que vous n'avez pas besoin de processus, puis une solution de plus, comme la mienne, de la lecture du fichier en tant que texte, pourrait avoir moins de frais généraux.

    OriginalL'auteur Thomas Owens

  6. 0

    Vous pouvez vérifier si le document xml est un nœud (le nœud racine) et vérifier que le nœud a intérieure du texte ou d'autres enfants.

    OriginalL'auteur Andrei

  7. 0

    Aussi longtemps que vous n'êtes pas concerné par la validité du document XML, et ne veulent s'assurer qu'il a une étiquette autre que la déclaration, vous pouvez utiliser simple traitement de texte:

    var regEx = new RegEx("<[A-Za-z]");
bool foundTags = false;
string curLine = "";

using (var reader = new StreamReader(fileName)) {
    while (!reader.EndOfStream) {
       curLine = reader.ReadLine();
       if (regEx.Match(curLine)) {
           foundTags = true;
           break;
       }
    }
}

if (!foundTags) {
    //file is bad, copy.
}

    Garder à l'esprit qu'il y a un million d'autres raisons que le fichier est peut-être pas valide et le code ci-dessus permettrait de valider un fichier constitué uniquement de "<a". Si votre intention est de valider que le document XML est capable de lire, vous devez utiliser le XmlDocument approche.

    OriginalL'auteur Ryan Brunner