Sauvegarde et chargement de MemoryStream vers/depuis un fichier

Question

Je suis en train de sérialiser une structure dans un MemoryStream et je veux sauvegarder et charger la structure sérialisée.

Alors, comment sauver un MemoryStream dans un fichier et le charger à nouveau à partir du fichier ?

Answer 1

Vous pouvez utiliser MemoryStream.WriteTo ou Stream.CopyTo (supporté dans le framework version 4.5.2, 4.5.1, 4.5, 4) méthodes pour écrire le contenu d'un flux mémoire vers un autre flux.

memoryStream.WriteTo(fileStream);

Mise à jour :

fileStream.CopyTo(memoryStream);
memoryStream.CopyTo(fileStream);

Answer 2

En supposant que le nom du MemoryStream est ms .

Ce code écrit le MemoryStream dans un fichier :

using (FileStream file = new FileStream("file.bin", FileMode.Create, System.IO.FileAccess.Write)) {
   byte[] bytes = new byte[ms.Length];
   ms.Read(bytes, 0, (int)ms.Length);
   file.Write(bytes, 0, bytes.Length);
   ms.Close();
}

et ceci lit un fichier dans un MemoryStream :

using (MemoryStream ms = new MemoryStream())
using (FileStream file = new FileStream("file.bin", FileMode.Open, FileAccess.Read)) {
   byte[] bytes = new byte[file.Length];
   file.Read(bytes, 0, (int)file.Length);
   ms.Write(bytes, 0, (int)file.Length);
}

Dans .Net Framework 4+, vous pouvez simplement copier FileStream vers MemoryStream et inversement, aussi simple que cela :

MemoryStream ms = new MemoryStream();
using (FileStream file = new FileStream("file.bin", FileMode.Open, FileAccess.Read))
    file.CopyTo(ms);

Et l'inverse (MemoryStream vers FileStream) :

using (FileStream file = new FileStream("file.bin", FileMode.Create, System.IO.FileAccess.Write))
    ms.CopyTo(file);

Answer 3

Le flux doit vraiment être éliminé même s'il y a une exception (très probablement lors d'une entrée/sortie de fichier) - les clauses d'utilisation sont mon approche préférée pour cela, donc pour écrire votre MemoryStream, vous pouvez utiliser :

using (FileStream file = new FileStream("file.bin", FileMode.Create, FileAccess.Write)) {
    memoryStream.WriteTo(file);
}

Et pour l'avoir relu :

using (FileStream file = new FileStream("file.bin", FileMode.Open, FileAccess.Read)) {
    byte[] bytes = new byte[file.Length];
    file.Read(bytes, 0, (int)file.Length);
    ms.Write(bytes, 0, (int)file.Length);
}

Si les fichiers sont volumineux, il convient de noter que l'opération de lecture utilisera deux fois plus de mémoire que la taille totale du fichier. . Une solution à cela est de créer le MemoryStream à partir du tableau d'octets - le code suivant suppose que vous n'écrirez pas ensuite dans ce flux.

MemoryStream ms = new MemoryStream(bytes, writable: false);

Mes recherches (ci-dessous) montrent que le tampon interne est le même tableau d'octets que celui que vous lui passez, ce qui devrait donc permettre d'économiser de la mémoire.

byte[] testData = new byte[] { 104, 105, 121, 97 };
var ms = new MemoryStream(testData, 0, 4, false, true);
Assert.AreSame(testData, ms.GetBuffer());

Answer 4

La réponse combinée pour l'écriture dans un fichier peut être ;

MemoryStream ms = new MemoryStream();    
FileStream file = new FileStream("file.bin", FileMode.Create, FileAccess.Write);
ms.WriteTo(file);
file.Close();
ms.Close();

Answer 5

Pour le chargement d'un fichier, j'aime beaucoup mieux ceci

MemoryStream ms = new MemoryStream();
using (FileStream fs = File.OpenRead(file))
{
    fs.CopyTo(ms);
}