¿Qué es el flujo en la programación de computadoras?
En programación informática, una secuencia es un objeto de una clase y las operaciones de entrada y salida de muchos archivos se proporcionan en forma de funciones miembro de la clase.
C # incluye las siguientes clases de E / S (entrada / salida) estándar, que se pueden leer / escribir desde diferentes fuentes (como archivos, memoria, red, almacenamiento aislado, etc.).
Stream: System.IO.Stream es una clase abstracta que proporciona un método estándar para transferir bytes (lectura, escritura, etc.) a la fuente. Transfiera bytes como una clase contenedora. Las clases que necesitan leer / escribir bytes de una fuente específica deben implementar la clase Stream.
Las siguientes clases heredan la clase Stream para proporcionar la capacidad de leer / escribir bytes de una fuente específica:
- FileStream: lee bytes de un archivo físico o escribe bytes en un archivo físico, ya sea .txt, .exe, .jpg o cualquier otro archivo. FileStream se deriva de la clase Stream.
- MemoryStream: MemoryStream lee o escribe bytes almacenados en la memoria.
- BufferedStream: BufferedStream lee o escribe bytes de otros flujos para mejorar el rendimiento de ciertas operaciones de E / S.
- NetworkStream: NetworkStream lee o escribe bytes desde un conector de red.
- PipeStream: PipeStream lee o escribe bytes de diferentes procesos.
- CryptoStream: CryptoStream se utiliza para vincular el flujo de datos a la conversión criptográfica.
Clase C # StreamReader: leer archivos
En el lenguaje C #, la clase StreamReader se usa para leer cadenas de la secuencia. Hereda de la clase TextReader. Hay muchos métodos de construcción para la clase treamReader. A continuación, se muestran algunos métodos de construcción de uso común, como se muestra en la siguiente figura.
Use el método de construcción en la tabla para crear una instancia de la clase StreamReader y llame a los miembros de la clase proporcionados por la instancia para leer archivos. Las propiedades y métodos comunes de la clase StreamReader se muestran en la siguiente figura.
ejemplo:
using System;
using System.IO;
namespace MySpace
{
class Program
{
static void Main(string[] args)
{
//定义文件路径
string path = @"E:\test\test.txt";
//创建StreamReader对象
StreamReader streamReader = new StreamReader(path);
//获取流中的下一个字节的整数，如果没有获取到字符，则返回-1
//获取获取全部字节
while(streamReader.Peek() != -1)
{
//从当前流中读取一行字符并将数据作为字符串返回
string str = streamReader.ReadLine();
Console.WriteLine(str);
}
//关闭流
streamReader.Close();
Console.ReadKey();
}
}
}
resultado de la operación:
Clase C # StreamWriter: escribir archivos
La clase StreamReader corresponde a la clase StreamWriter. La clase StreamWriter se utiliza principalmente para escribir datos en el flujo.
También hay muchos métodos de construcción para la clase StreamWriter. A continuación, se muestran solo algunos métodos de construcción de uso común, como se muestra en la figura siguiente.
Después de crear una instancia de la clase StreamWriter, puede llamar a sus miembros de clase para completar la operación de escribir información en el archivo. Las propiedades y métodos que se utilizan habitualmente en la clase StreamWriter se muestran en la siguiente figura.
Los métodos Write, WriteAsync y WriteLineAsync también tienen muchas sobrecargas para diferentes tipos de escrituras, que no se enumeran aquí.
ejemplo:
using System;
using System.IO;
namespace MySpace
{
class Program
{
static void Main(string[] args)
{
string path = @"E:\test\test.txt";
//创建一个StreamWriter的对象
StreamWriter streamWriter = new StreamWriter(path);
//向文件中写入一个行
streamWriter.WriteLine("QQ：");
streamWriter.WriteLine("845264718");
//刷新缓冲
streamWriter.Flush();
//关闭流
streamWriter.Close();
}
}
}
resultado de la operación:
Clase C # FileStream: lectura y escritura de archivos
En el lenguaje C #, la secuencia de lectura y escritura de archivos está representada por la clase FileStream. La clase FileStream se usa principalmente para leer y escribir archivos. No solo puede leer y escribir archivos de texto ordinarios, sino también leer archivos en diferentes formatos como archivos de imagen y archivos de sonido.
Al crear una instancia de la clase FileStream, se involucran varios valores enumerados, incluidos FileAccess, FileMode, FileShare, FileOptions, etc.
El tipo de enumeración FileAccess se utiliza principalmente para establecer el método de acceso del archivo. Los valores de enumeración específicos son los siguientes.
- Leer: abre el archivo como de solo lectura.
- Escribir: abre el archivo en modo de escritura.
- ReadWrite: abre el archivo en modo lectura-escritura.
El tipo de enumeración FileMode se utiliza principalmente para establecer el método de apertura o creación de archivos. Los valores de enumeración específicos son los siguientes.
-
CreateNew: crea un nuevo archivo. Si el archivo ya existe, se lanzará una excepción. Crear: crea un archivo. Si el archivo no existe, elimine el archivo original y vuelva a crear el archivo.
-
Abrir: abre un archivo existente. Si el archivo no existe, se lanzará una excepción. OpenOrCreate: Abra un archivo existente, si el archivo no existe, cree el archivo.
-
Truncar: abre un archivo existente y borra el contenido del archivo, manteniendo la fecha de creación del archivo. Si el archivo no existe, se lanzará una excepción.
-
Agregar: abre el archivo, se usa para agregar contenido al archivo, si el archivo no existe, crea un nuevo archivo.
El tipo de enumeración FileShare se utiliza principalmente para establecer el control de acceso cuando varios objetos acceden al mismo archivo al mismo tiempo. Los valores de enumeración específicos son los siguientes.
- Ninguno: rechace compartir el archivo actual.
- Leer: Permitir la apertura posterior del archivo para leer información.
- ReadWrite: permite la apertura posterior del archivo para leer y escribir información.
- Escribir: permite la apertura posterior del archivo para escribir información.
- Eliminar: permite la eliminación posterior de archivos.
- Heredable: el proceso hijo puede heredar el identificador de archivo.
El tipo de enumeración FileOptions se utiliza para establecer las opciones avanzadas del archivo, incluido si el archivo está encriptado, si se debe eliminar después del acceso, etc. Los valores de enumeración específicos son los siguientes.
- WriteThrough: indica que el sistema debe escribir directamente en el disco a través de cualquier caché intermedia.
- Ninguno: indica que no se deben utilizar otras opciones al generar objetos System.IO.FileStream.
- Cifrado: indica que el archivo está cifrado y que solo puede descifrarlo la misma cuenta de usuario utilizada para el cifrado.
- DeleteOnClose: indica que un archivo se elimina automáticamente cuando ya no se utiliza.
- SequentialScan: Indique para acceder a los archivos en orden de principio a fin. RandomAccess: indica el acceso aleatorio a los archivos.
- Asincrónico: indica que el archivo se puede utilizar para lectura y escritura asincrónicas.
Hay muchos métodos de construcción para la clase FileStream. A continuación, se muestran algunos métodos de construcción de uso común, como se muestra en la figura siguiente.
Después de crear una instancia de la clase FileStream, puede llamar a los miembros de la clase para completar la operación de lectura y escritura de datos. Las propiedades y métodos de uso común en la clase FileStream se muestran en la siguiente figura.
Ejemplo 1:
using System;
using System.IO;
using System.Text;// byte[] bytes = Encoding.UTF8.GetBytes(msg);所用到的名字空间
namespace MySpcae
{
class Program
{
static void Main(string[] args)
{
//定义文件路径
string path = @"E:\test\QQ.txt";
///创建FileStream类的对象
///第一参数path是文件路径
///第二个参数FileMode.OpenOrCreate 打开已存在的文件，不存在就创建
///第三个参数FileAccess.ReadWrite 以读写打开文件
///第四个参数FileShare.ReadWrite 允许随后打开文件读写信息
FileStream fileStream = new FileStream(path, FileMode.OpenOrCreate,
FileAccess.ReadWrite, FileShare.ReadWrite);
string msg = "845264718";
//如果是中文，那么string长度不够用，将数据从字符串类型装换成字节类型
byte[] bytes = Encoding.UTF8.GetBytes(msg);
//从流中读取字节快并将该数据写入给定的缓冲区
//bytes是字节块
//0是位置
//bytes.Length是字节块的大小
fileStream.Write(bytes, 0, bytes.Length);
//刷新缓冲区
fileStream.Flush();
//关闭流
fileStream.Close();
}
}
}
Resultado de la operación:
Ejemplo 2 :
using System;
using System.IO;
using System.Text;
namespace MySpace
{
class Program
{
static void Main(string[] args)
{
//指定文件路径
string path = @"E:\test\QQ.txt";
//判断是否含有指定文件
if(File.Exists(path))
{
FileStream fileStream = new FileStream(path,
FileMode.Open, FileAccess.Read);
//定义存放文件信息的字节数组
byte[] bytes = new byte[fileStream.Length];
fileStream.Read(bytes, 0, bytes.Length);
//将得到的字节类型数组重写编码为字符型数组
char[] c = Encoding.UTF8.GetChars(bytes);
Console.WriteLine("My QQ:");
Console.WriteLine(c);
//关闭流
fileStream.Close();
}
else
{
Console.WriteLine("您查看的文件不存在！");
}
Console.ReadKey();
}
}
}
resultado de la operación:
Clase C # BinaryReader: leer archivos binarios
La clase BinaryReader se usa al leer datos en forma binaria en C #. Hay tres métodos de construcción proporcionados en la clase BinaryReader, y las formas de sintaxis específicas son las siguientes.
La primera forma:
BinaryReader(Stream input) //其中，input 参数是输入流。
La segunda forma:
BinaryReader(Stream input, Encoding encoding) //其中，input 是指输入流，encoding 是指编码方式。
La tercera forma:
BinaryReader(Stream input, Encoding encoding, bool leaveOpen) //其中，input 是指输入流，encoding 是指编码方式，leaveOpen 是指在流读取后是否包括流的打开状态。
Después de completar la creación de la instancia de la clase BinaryReader, el archivo se puede leer en forma binaria.
Las propiedades y métodos comunes de la clase BinaryReader se muestran en la siguiente figura.
El método proporcionado en la clase BinaryReader no lee directamente el valor del tipo de datos especificado en el archivo, pero lee el valor escrito en el archivo por la clase BinaryWriter.
Entre los métodos anteriores, solo el método Read no requiere que la clase BinaryWriter escriba el valor leído en el archivo.
Ejemplo 1:
using System;
using System.IO;
namespace MySpace
{
class Program
{
static void Main(string[] args)
{
//只读方式创建文件流
FileStream fileStream = new FileStream(@"E:\test\test.txt",
FileMode.Open);
//创建一个BinaryRead的对象
BinaryReader binaryReader = new BinaryReader(fileStream);
//从指定的流中读取字符
int a = binaryReader.Read();
//判断文件中是否含有字符，若不含字节，a的值为-1
while(a != -1)
{
//输出读取到的字符
Console.Write((char)a);
a = binaryReader.Read();
}
Console.WriteLine();
Console.ReadKey();
}
}
}
Resultado en ejecución:
además de usar el método Read para leer un carácter a la vez, también puede usar otros métodos sobrecargados del método Read para leer caracteres en una matriz de bytes o matriz de caracteres.
Ejemplo 2:
using System;
using System.IO;
using System.Text;
namespace MySpace
{
class Program
{
static void Main(string[] args)
{
//创建一个文件流对象，设定了打开方式，和只读权限
FileStream fileStream = new FileStream(@"E:\test\test.txt",
FileMode.Open, FileAccess.Read);
//创建一个BinaryReader对象
BinaryReader binaryReader = new BinaryReader(fileStream);
//获取文件长度
long length = fileStream.Length;
byte[] bytes = new byte[length];
//读取的文件内容并保存到字节数组中
binaryReader.Read(bytes, 0, bytes.Length);
//将字节数组转换为字符串
String str = Encoding.Default.GetString(bytes);
Console.WriteLine(str);
Console.ReadKey();
}
}
}
resultado de la operación:
Clase C # BinaryWriter: escribir datos binarios
La clase BinaryWriter se utiliza para escribir contenido en la secuencia. La forma gramatical específica de su método de construcción es la siguiente.
La primera forma:
BinaryWriter(Stream output)
La segunda forma:
BinaryWriter(Stream output, Encoding encoding)
La tercera forma:
BinaryWriter(Stream output, Encoding encoding, bool leaveOpen)
Las propiedades y métodos que se utilizan comúnmente en la clase BinaryWriter se muestran en la siguiente figura.
Además de los métodos anteriores, el método Write también proporciona varios tipos de métodos sobrecargados.
ejemplo:
using System;
using System.IO;
namespace MySpace
{
class Program
{
static void Main(string[] args)
{
//创建一个文件写入流对象，存在就打开，权限是写
FileStream fileStream = new FileStream(@"E:\test\test.txt",
FileMode.Open, FileAccess.Write);
//创建一个写入二进制流
BinaryWriter binaryWriter = new BinaryWriter(fileStream);
//向文件写入
binaryWriter.Write("一起来学习啊");
binaryWriter.Write(8456264718);
//刷新缓冲区，将缓冲区内容写入文件中
binaryWriter.Flush();
binaryWriter.Close();
//关闭二进制流
fileStream.Close();
//创建一个文件读取流，存在就打开，权限只读
fileStream = new FileStream(@"E:\test\test.txt",
FileMode.Open, FileAccess.Read);
//创建一个二进制读取流
BinaryReader binaryReader = new BinaryReader(fileStream);
//读取数据显示到屏幕
Console.WriteLine(binaryReader.ReadString());
Console.WriteLine(binaryReader.ReadInt64());
//关闭流
binaryReader.Close();
fileStream.Close();
}
}
}
resultado de la operación:
