Comment créer une copie de fichier à l'aide de StreamReader et StreamWriter

J'ai besoin d'utiliser StreamReader pour lire un .fichier txt sur une application console, puis créer un nouveau fichier ou la sauvegarde avec un nom différent, mais même contenu. Le problème est que je ne peux pas comprendre comment utiliser le contenu à partir du premier fichier à placer dans le nouveau. (C'est pour une école de chose et im nouveau à C#)

using System;
using System.IO;
namespace UserListCopier
{
    class Program
    {
        static void Main()
        {
            string fineName = "zombieList.txt";

            StreamReader reader = new StreamReader(fineName);

            int lineNumber = 0;

            string line = reader.ReadLine();

            while (line != null) {
                lineNumber++;
                Console.WriteLine("Line {0}: {1}", lineNumber, line);
                line = reader.ReadLine();
            }

            StreamWriter writetext = new StreamWriter("zombieListBackup.txt");

            writetext.Close();
            System.Console.Read();
            reader.Close();
        }
    }
}

Avez-vous exploré cette documentation msdn.microsoft.com/en-us/library/8bh11f1k.aspx ?

OriginalL'auteur claraichu | 2015-08-05

c#copy streamreader streamwriter

6

Permet de considérer que vous avez ouvert deux volets, semblable @jeff solution, mais au lieu de ReadToEnd (pas vraiment à la vapeur de manière efficace), vous pourriez tampon de transfert.

_bufferSize est un int définir une taille de mémoire tampon qui vous convient (1024, quelle que soit 4096)
```
private void CopyStream(Stream src, Stream dest)
{
    var buffer = new byte[_bufferSize];
    int len;
    while ((len = src.Read(buffer, 0, buffer.Length)) > 0)
    {
        dest.Write(buffer, 0, len);
    }
}
```
voici l'essentiel, contenant une classe qui calcule la vitesse de transfert
https://gist.github.com/dbones/9298655#file-streamcopy-cs-L36

Je pense que cela devrait être la bonne réponse, car elle est économe en mémoire

OriginalL'auteur dbones

Ce qui fera:

using System;
using System.IO;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            using (var reader = new StreamReader(@"C:\MyOriginalFile.txt"))
            using (var writer = new StreamWriter(@"C:\MyNewFile.txt", append: false))
            {
                writer.Write(reader.ReadToEnd());
            }
            Console.Read();
        }
    }
}

Mais ne sera-ce pas lire la totalité du flux d'entrée dans un aller et puis l'écrire en une seule fois? N'est-ce pas perdre le point de l'utilisation de flux? Si les données de grande envergure (plusieurs giga-octets), alors vous aurez le tout dans la mémoire d'un seul coup, au lieu d'une fenêtre coulissante.

OriginalL'auteur Jeff Prince

2

Pour les fichiers sur le disque, vous avez juste besoin Fichier.Copier(inputPath, outputPath). Je ne suis pas certain que ce flux le contenu de manière efficace, ou si elle lit tous dans la mémoire et l'écrit tous d'un seul coup.

Donc pour les gros fichiers, ou si vous avez un flux qui n'aboutit pas à un chemin d'accès sur le disque, vous pouvez efficacement copie de l'un à l'autre, en utilisant les fonctions suivantes:
```
private void copyFile(string inputPath, string outputPath)
{
    using (var inputStream = StreamReader(inputPath))
    {
        using (var outputStream = StreamWriter(outputPath))
        {
            copyToOutputStream(inputStream, outputStream);
        }
    }
}

private void copyToOutputStream(StreamReader inputStream, StreamWriter outputStream)
{
    string line = null;
    while ((line = inputStream.ReadLine()) != null)
    {
        outputStream.WriteLine(line);
    }
    outputStream.Write(inputStream.ReadToEnd());
}
```
Cette fonction copie à partir du flux d'entrée vers le flux de sortie d'une ligne à la fois jusqu'à ce que le flux d'entrée se termine. Cela signifie qu'il n'a qu'une ligne dans la mémoire à un moment (plutôt que l'ensemble du fichier) et qu'il peut commencer à écrire sur le disque avant que le premier volet a fini de le lire /générée.

Notez que cela va provoquer des problèmes avec les données binaires, ou plus généralement n'importe quel fichier qui ne contient pas de sauts de ligne et est très grand. Il peut aussi changer le type de saut de ligne (LF -> CRLF).

OriginalL'auteur Martin Eden

        public static void ReadFromFile()  
        {
            using(StreamReader sr =File.OpenText(@"D:\new.txt"))
            {
                string line=null;
                while ((line=sr.ReadLine())!= null)
                {
                 //  line = sr.ReadLine;
                    using (StreamWriter sw = File.AppendText(@"D:\output.txt"))
                    {
                        sw.WriteLine(line);


                    }
                }
            }
        }

OriginalL'auteur Sunny K Saini

Vous devez vous connecter pour publier un commentaire.