C# Language
Courant

Utiliser des flux

Un flux est un objet qui fournit un moyen de transfert de données de bas niveau. Ils n'agissent pas eux-mêmes comme des conteneurs de données.

Les données que nous traitons sont sous forme de tableau d' byte [] ( byte [] ). Les fonctions de lecture et d'écriture sont toutes orientées octets, par exemple WriteByte() .

Il n'y a pas de fonctions pour traiter les entiers, les chaînes de caractères, etc. Cela rend le flux très général, mais il est moins simple de travailler si, par exemple, vous voulez simplement transférer du texte. Les flux peuvent être particulièrement utiles lorsque vous manipulez de grandes quantités de données.

Nous devrons utiliser différents types de flux sur la base desquels il doit être écrit / lu (c.-à-d. Le magasin de sauvegarde). Par exemple, si la source est un fichier, nous devons utiliser FileStream :

string filePath = @"c:\Users\exampleuser\Documents\userinputlog.txt";
using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
    // do stuff here...

    fs.Close();
}

De même, MemoryStream est utilisé si le magasin de sauvegarde est en mémoire:

// Read all bytes in from a file on the disk.
byte[] file = File.ReadAllBytes(“C:\\file.txt”);

// Create a memory stream from those bytes.
using (MemoryStream memory = new MemoryStream(file))
{
   // do stuff here...
}

De même, System.Net.Sockets.NetworkStream est utilisé pour l'accès au réseau.

Tous les flux sont dérivés de la classe générique System.IO.Stream . Les données ne peuvent pas être directement lues ou écrites à partir de flux. Le .NET Framework fournit des classes d'aide tels que StreamReader , StreamWriter , BinaryReader et BinaryWriter qui convertissent les types natifs et l'interface de flux de bas niveau, et transférer les données vers ou à partir du flux pour vous.

Lecture et écriture aux cours d' eau peuvent se faire via StreamReader et StreamWriter . Il faut être prudent lors de la fermeture de ceux-ci. Par défaut, la fermeture ferme également le flux contenu et le rend inutilisable pour d'autres utilisations. Ce comportement par défaut peut être modifié en utilisant un constructeur ayant le paramètre bool leaveOpen et en définissant sa valeur sur true .

StreamWriter :

FileStream fs = new FileStream("sample.txt", FileMode.Create);
StreamWriter sw = new StreamWriter(fs);
string NextLine = "This is the appended line.";
sw.Write(NextLine);
sw.Close();
//fs.Close(); There is no need to close fs. Closing sw will also close the stream it contains.

StreamReader :

using (var ms = new MemoryStream())
{
    StreamWriter sw = new StreamWriter(ms);
    sw.Write(123);
    //sw.Close();     This will close ms and when we try to use ms later it will cause an exception
    sw.Flush();     //You can send the remaining data to stream. Closing will do this automatically
    // We need to set the position to 0 in order to read 
    // from the beginning.
    ms.Position = 0;
    StreamReader sr = new StreamReader(ms);
    var myStr = sr.ReadToEnd();
    sr.Close();
    ms.Close();
}

Puisque les classes Stream , StreamReader , StreamWriter , etc. mettre en œuvre la IDisposable interface, nous pouvons appeler la Dispose() méthode sur des objets de ces classes.