C# Language
Corriente

Usando Streams

Un flujo es un objeto que proporciona un medio de bajo nivel para transferir datos. Ellos mismos no actúan como contenedores de datos.

Los datos con los que tratamos están en forma de matriz de bytes ( byte [] ). Las funciones para leer y escribir están todas orientadas a bytes, por ejemplo, WriteByte() .

No hay funciones para tratar con enteros, cadenas, etc. Esto hace que el flujo sea muy general, pero menos fácil de trabajar si, por ejemplo, solo desea transferir texto. Las transmisiones pueden ser particularmente útiles cuando se trata de una gran cantidad de datos.

Tendremos que usar diferentes tipos de Stream en función de dónde se debe escribir / leer (es decir, la tienda de respaldo). Por ejemplo, si la fuente es un archivo, necesitamos usar 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 manera similar, MemoryStream se usa si el almacén de respaldo es memoria:

// 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...
}

Del mismo modo, System.Net.Sockets.NetworkStream se utiliza para el acceso a la red.

Todos los flujos se derivan de la clase genérica System.IO.Stream . Los datos no se pueden leer ni escribir directamente desde secuencias. .NET Framework proporciona clases auxiliares como StreamReader , StreamWriter , BinaryReader y BinaryWriter que convierten entre los tipos nativos y la interfaz de flujo de bajo nivel, y transfieren los datos hacia o desde el flujo para usted.

La lectura y escritura de secuencias se puede hacer a través de StreamReader y StreamWriter . Se debe tener cuidado al cerrar estos. De forma predeterminada, el cierre también cerrará el flujo contenido y lo hará inutilizable para usos posteriores. Este comportamiento predeterminado se puede cambiar utilizando un constructor que tenga el parámetro bool leaveOpen y establezca su valor como 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();
}

Dado que Classes Stream , StreamReader , StreamWriter , etc. implementan la interfaz IDisposable , podemos llamar al método Dispose() en objetos de estas clases.