L'ajout d'un texte de début et de fin de fichier en C#

J'ai un processus qui prend une série de "xml" des fichiers. La raison j'ai mis xml entre guillemets, c'est que le texte dans le fichier n'est pas un élément racine qui fait en xml non valide. Dans mon traitement, je tiens à corriger ce problème et d'ouvrir chaque fichier ajouter un nœud racine au début et à la fin de chaque fichier, puis le refermer. Voici ce que j'avais en tête, mais cela implique l'ouverture du fichier, la lecture de tout fichier de marquage sur les nœuds, et puis l'écriture de l'ensemble du fichier. Ces fichiers peuvent être de plus de 20 MO en taille.

        foreach (FileInfo file in files)
        {
            //open the file
            StreamReader sr = new StreamReader(file.FullName);

            //add the opening and closing tags
            string text = "<root>" + sr.ReadToEnd() + "<root>";
            sr.Close();

            //now open the same file for writing
            StreamWriter sw = new StreamWriter(file.FullName, false);
            sw.Write(text);
            sw.Close();
        }

Toutes les recommandations?

Juste être curieux: à l'Aide d'une chaîne de ici va être mauvais pour la performance, ou C# string classe assez bon pour cela?
La principale raison de ne pas utiliser des chaînes de caractères, c'est qu'il est immuable, ce qui signifie que chaque fois que vous ajoutez des choses à cordes, vous devez faire un nouvel objet de type String. Depuis son code a seulement 2 précédents, je ne vois pas l'avantage de l'utilisation des StringBuilder, mais je suis peut-être raté quelque chose. Comme Earwicker noter toutefois, il existe une meilleure méthode.
Je suis tombé sur cette question, parce que je voulais que mes fichiers journaux pour avoir le dernier message en haut. J'ai maintenant déménagé l'enregistrement à une table, et un tri par type DateTime.. 🙂

InformationsquelleAutor adeel825 | 2009-06-17

c#file-io xml

15

Pour éviter de tenir tout le fichier en mémoire, renommez le fichier d'origine, puis de l'ouvrir avec StreamReader. Ensuite, ouvrez le nom de fichier d'origine avec StreamWriter pour créer un nouveau fichier.

Écrire le <root> préfixe du fichier, puis copier les données en grande-ish morceaux du lecteur à l'écrivain. Lorsque vous avez transféré toutes les données, écrire la clôture </root> (notez la barre oblique si vous voulez qu'il soit XML). Fermez les deux fichiers et de supprimer la renommé d'origine.
```
char[] buffer = new char[10000];

string renamedFile = file.FullName + ".orig";
File.Move(file.FullName, renamedFile);

using (StreamReader sr = new StreamReader(renamedFile))
using (StreamWriter sw = new StreamWriter(file.FullName, false))
{
    sw.Write("<root>");

    int read;
    while ((read = sr.Read(buffer, 0, buffer.Length)) > 0)
        sw.Write(buffer, 0, read);

    sw.Write("</root>");
}

File.Delete(renamedFile);
```
- C'est une bonne amélioration, mais il vaut la peine de noter que les objets de Flux donneront de meilleurs résultats que le StreamReader/Écrivain classes.
InformationsquelleAutor Daniel Earwicker
4

20 MO n'est pas terriblement bien, mais quand vous lisez comme une chaîne de caractères, on utilise environ 40 MO de mémoire. Ce n'est pas très bien non plus, mais c'est le traitement que vous n'avez pas besoin de le faire. Vous pouvez le manipuler comme des brutes octets afin de réduire l'utilisation de la mémoire, et pour éviter de décodage et ré-encodage des données:
```
byte[] start = Encoding.UTF8.GetBytes("<root>");
byte[] ending = Encoding.UTF8.GetBytes("</root>");

byte[] data = File.ReadAllBytes(file.FullName);

int bom = (data[0] == 0xEF) ? 3 : 0;

using (FileStream s = File.Create(file.FullName)) {
   if (bom > 0) {
      s.Write(data, 0, bom);
   }
   s.Write(start, 0, start.Length);
   s.Write(data, bom, data.Length - bom);
   s.Write(ending, 0, ending.Length);
}
```
Si vous avez besoin de recude l'utilisation de la mémoire beaucoup plus, utiliser un deuxième fichier que Earwicker suggéré.

Edit:

Ajouté le code pour gérer BOM (byte order mark).
- "40 MO de mémoire ... C'est pas très bien non plus ..." la toux.
InformationsquelleAutor Guffa
3

Je ne peux pas voir une réelle amélioration sur ce...qui est une sorte de déception. Car il n'y a aucun moyen de "shift" un fichier que vous aurez toujours à déplacer les octets dans l'ensemble du fichier à injecter quoi que ce soit en haut.

Vous peut trouver un certain avantage en termes de performances en utilisant des flux plutôt que le StreamReader qui a fait analyser le flux de texte.
- La dégradation des performances est que la totalité du fichier est chargé en mémoire, puis jetés. Le point de ruisseaux et de déplacer un flux de caractères à partir d'un endroit à un autre et d'éviter ce genre de situations. L'optimisation possibilité est d'utiliser un fichier de travail pour écrire la première de la nouvelle entrée, puis de le transmettre dans l'ancien contenu, et enfin échange de fichier avec l'original. 20 mo n'est pas trop pour la RAM, mais "ou plus" peut-être.
InformationsquelleAutor Paul Alexander
3

Si vous ne voulez pas le faire c'est le C#, il serait facile de gérer à la ligne de commande ou dans un fichier de commandes.
```
ECHO ^<root^> > outfile.xml
TYPE temp.xml >> outfile.xml
ECHO ^</root^> >> outfile.xml
```
Cela suppose que vous avez certains processus pour obtenir les fichiers de données que cela pourrait être accroché dans.
- Le code pour gérer l'appel à ce fichier de commandes dans l'enfermant programme C# serait susceptible d'être significativement plus long que le code pour faire la même chose directement dans C#.
- En supposant toujours que le traitement par lots ne peuvent pas être ajoutés quelque part d'autre dans le processus d'obtenir le fichier, Processus p = Processus.Début("fixup.chauve-souris", "temp.xml"); p.WaitForExit(); qui Ne semble pas si mauvaise pour moi. Le scintillement de la fenêtre de commande est ennuyeux.
- Vous devez également indiquer le fichier de commandes les fichiers à regarder, ce qui signifie que vous avez à construire la chaîne de ligne de commande, avec le bon devis, et vous aurez besoin de trouver le chemin pour le fichier de commandes, et vous devez supprimer le fichier temporaire (une seule ligne, où vous le dit). Je suis étonné que vous serais même d'envisager cette option! Il serait trivial à écrire quelques neat little helper méthodes qui vous permettent d'exprimer ce genre de flux de concaténation élégamment dans C#, et n'ont donc pas de processus de création au-dessus de tous.
- Le C# est un grand marteau, n'est-ce pas? Vous avez supposé que le fichier comme par magie est là, et il n'y a pas de place dans le processus d'obtention du dossier que vous ne pouvez pas ajouter dans le fichier de commandes. BTW, il est trivial de créer et de supprimer le fichier temporaire dans le fichier de commandes. Pas besoin d'encombrer le code C# avec elle.
- Je suis en supposant que, compte tenu de la question du titre, que ce mec est l'écriture d'une application en C#. Si votre demande est en C#, il est préférable d'éviter un processus de création, de synchronisation et de toute la complexité que cela implique, pour le feu jusqu'à une autre langue sans une bonne raison. Je dirais que, dans ce contexte, vous êtes à la recherche d'une excuse pour utiliser des fichiers batch, et n'ai pas trouvé un. Lot de fichiers, en général, sont très insuffisante, environnement de programmation.
- Non, pas une excuse pour utiliser le traitement par lots de fichiers, tout en proposant une alternative à faire strictement en C#. Vous avez déjà parcouru le en C# répondre assez bien (j'ai même upvoted) mais à croire qu'il va couvrir toutes les situations semble un peu obtus. Il ne semble pas possible que quelqu'un d'autre peut trouver cette question et de trouver que ma solution est peut-être même utile...Maintenant, si seulement je pouvais le faire avec LINQ, je parie que je voudrais obtenir de nombreux upvotes;->
- Je suis sûr qu'il sera utile, et surtout à tous ceux qui envisagent d'écrire toute une application en C# juste pour ce faire une tâche, qui je suis d'accord serait un gaspillage total de temps. Lot de shell ou des outils sont un idéal et prêt-à-utiliser d'autres, si tout ce que vous faites est de one-shot de traitement de flux et rien d'autre. Mais si vous travaillez déjà dans C#, et de faire ce genre de chose beaucoup, il suffit d'écrire une simple classe helper qui est basé sur une Liste<Flux>, et vous serez en mesure de faire la version C# look élégant (probablement plus) que le lot de version de fichier. 🙂
- Les fichiers Batch. Beurk. Comment faire un script shell? Une ligne, et pas de fichiers temporaires: vim -e -s -c $'1 i\n<root>\n.\n$ a\n</root>\n.\nwq' fileToXmlify.txt
InformationsquelleAutor Jack Bolding

Vous devez vous connecter pour publier un commentaire.