Tecnológico Nacional de México Instituto Tecnológico de Tijuana

SUBDIRECCIÓN ACADÉMICA

DEPARTAMENTO DE SISTEMAS Y COMPUTACIÓN

SEMESTRE SEPTIEMBRE 2020 – ENERO 2021

Ingeniería en Sistemas Computacionales

AED-1286 SC2A Programación Orientada a Objetos

Evaluación Unidad 6

Unidad 6 – Flujos y Archivos.

Osorio Cuevas Daniel Alejandro #20210607

M.C.C. LUZ ELENA CORTEZ GALVAN

Fecha de entrega 7 de enero del 2021

 CONTENIDO DEL TRABAJO:
Contenido
6.1 – Definiciones........................................................................................................................................3
Qué es un archivo en C#..........................................................................................................................3
Cuál es su utilidad....................................................................................................................................3
Qué es un flujo en C#...............................................................................................................................3
Cómo se clasifican...................................................................................................................................3
6.2 – Clasificación........................................................................................................................................3
Archivos de texto.....................................................................................................................................3
Archivos binarios.....................................................................................................................................3
6.3.1 – Operaciones básicas en Archivos de Texto con Flujos de Bytes.......................................................4
Escritura...................................................................................................................................................5
LECTURA..................................................................................................................................................5
Ejemplo:...................................................................................................................................................6
6.3.2 – Operaciones básicas en Archivos de Texto con Flujos de Caracteres..............................................7
Lectura y escritura de flujos.....................................................................................................................8
Compresión de flujos...............................................................................................................................8
Flujos personalizados..............................................................................................................................8
6.4 – Operaciones básicas en Archivos Binarios..........................................................................................8
c) Anexos (solo si aplica)............................................................................................................................11
Programa ejemplo 6.4............................................................................................................................11
Programa ejemplo 6.3.2.........................................................................................................................13
Programa ejemplo 6.3.1.........................................................................................................................15
d) Fuentes de Información........................................................................................................................16

2
6.1 – Definiciones
Qué es un archivo en C#
Los archivos tienen como finalidad guardar datos de forma permanente. Una vez que acaba la
aplicación los datos almacenados están disponibles para que otra aplicación pueda recuperarlos
para su consulta o modificación.
Cuál es su utilidad
Un archivo define la forma en la que se estructuran u organizan los datos.
Qué es un flujo en C#
La lectura y escritura de un archivo son hechas usando un concepto genérico llamado stream. La
idea detrás del stream existe hace tiempo, cuando los datos son pensados como una transferencia
de un punto a otro, es decir, como un flujo de datos. En el ambiente .NET se puede encontrar
muchas clases que representan este concepto que trabaja con archivos o con datos de memoria.
Cómo se clasifican

6.2 – Clasificación
Archivos de texto
Los archivos de texto plano son aquellos
que están compuestos únicamente por texto
sin formato, sólo caracteres. estos
caracteres se pueden codificar de distintos
modos dependiendo de la lengua usada. Se
les conoce también como archivos de texto
llano o texto simple por carecer de
información destinada a generar formatos y tipos de letra.
Archivos binarios
Un archivo binario es un archivo informático que contiene información de cualquier tipo,
codificada en forma binaria para el propósito de almacenamiento y procesamiento de
ordenadores.

6.3.1 – Operaciones básicas en Archivos de Texto con Flujos de Bytes.

Las operaciones básicas en archivos son:
1. Creación
2. Apertura
3. Lectura

3
 4. Escritura
5. Recorrido
6. Cierre
Archivos De Texto
El manejo de archivos de texto se puede llevar a cabo por medio de dos tipos de flujos: de bytes
y de caracteres.
Archivos De Texto Con Flujos De Bytes.
Para escribir o leer datos de tipo byte en un archivo se declara un flujo de la clase FileStream,
cuyos constructores son:
FileStream (string nombre , FileMode modo )
FileStream (string nombre , FileMode modo , FileAccess acceso )
Modo es un valor del tipo enumerado FileMode; puede tomar uno de los siguientes valores:
1. CreateNew
Crea un nuevo archivo. Si el archivo existe, lanzará una excepción del tipo IOException.
2. Create
Crea un nuevo archivo. Si el archivo existe, será sobreescrito.
3. Open
Abre un archivo existente.
4. OpenOrCreate
Abre un archivo, si existe;en caso contrario, se crea un nuevo archivo.
5. Truncate
Abre un archivo existente y lo trunca a cero bytes de longitud.
6. Append
Abre un archivo para agregarle datos al final.Si el archivo no existe, lo crea.
ACCESO es un valor del tipo enumerado FileAccess ; puede tomar uno de los siguientes
valores:
1. Read
Permite leer un archivo.
2. ReadWrite
Permite leer o escribir en el archivo.
3. Write
Permite escribir en el archivo.

4
Archivos De Texto Con Flujos De Caracteres
En este caso los datos se manejan por medio de flujos de caracteres, utilizando las clases
StreamWriter y StreamReader.

Escritura
StreamWriter es una clase derivada de TextWriter.
Sus constructores son:
StreamWriter (string nombre ) // Abre un nuevo flujo para escribir en un archivo especificado
por nombre .
StreamWriter (Stream flujo ) // Utiliza un flujo existente para escribir.
Antes de ser escritos, los datos son convertidos automáticamente a un formato portable de 8 bits
(UTF-8, UCS Transformation Format 8).
Los objetos de la clase StreamWriter poseen varios métodos, entre los que destacan:
1. Write()
2. WriteLine()
3. Flush()

LECTURA
StreamReader es una clase derivada de TextReader y cuenta con los siguientes constructores:
StreamReader (string nombre ) abre un nuevo flujo para leer de un archivo especificado por
nombre.
StreamReader (Stream flujo ) utiliza un flujo existente para leer.
Algunos de los métodos más importantes de la clase StreamReader son:
1. Read( )
2. ReadLine( )
3. Peek( )
DiscardBufferData( )
Ejemplo:
using System;
using System.IO;
public class CEscribirCars

5
{
public static void Main( )
{
StreamWriter sw = null;
String str;
try
{

// Crea un flujo hacia el archivo doc.txt

// Si el archivo existe se destruye su contenido.
sw = new StreamWriter("doc.txt");

Console.WriteLine("Escriba las líneas de texto a

almacenar en el archivo.\n" + "Finalice cada línea
pulsando la tecla .\n" +
"Para finalizar pulse sólo la tecla .\n")
// Lee una línea de la entrada estándar
str = Console.ReadLine();
// Mientras la cadena str no esté vacía
while (str.Length != 0)
{
// Escribe la línea leída en el archivo
sw.WriteLine(str);

// Lee la línea siguiente

str = Console.ReadLine();
}
}

6
 catch(IOException e)
{
Console.WriteLine("Error: " + e.Message);
}
finally
{
if (sw != null) sw.Close();
}
}
}

6.3.2 – Operaciones básicas en Archivos de Texto con Flujos de

Caracteres.
Los flujos de datos son secuencias de bytes. Es decir, un conjunto de bytes en un orden
específico que pueden representar cualquier cosa: texto, un archivo, un objeto, una imagen.
Bytes en general. Un flujo de dato sirve de puente entre la fuente de datos y la aplicación (por
ejemplo, lectura de un archivo desde el disco duro), o entre la aplicación y el destino (escritura
hacia un archivo del disco duro).
La clase base para los flujos es System.IO.Stream, y es abstracta. Esta clase define el
comportamiento básico de cualquier flujo en .NET. En esencia, define:
Si un flujo puede leer bytes (CanRead, Read).
Si un flujo puede escribir bytes (CanWrite, Write).
El desplazamiento hacia atrás y hacia adelante en el flujo de bytes (Seek, Position).
El tamaño del flujo (Length, SetLength).
La forma de descargar los datos en el destino final (Flush).
Lectura y escritura de flujos
Por mucho, los métodos más importantes de un Stream son Read y Write, para leer y escribir
bytes (que a final de cuentas es el principal propósito de un flujo). Alternativamente existen
BeginRead, EndRead, BeginWrite y EndWrite para leer y escribir de forma asíncrona, pero estos
métodos al final se basan en Read y Write, respectivamente.

7
Compresión de flujos
Muchas veces nuestros flujos alcanzan dimensiones muy grandes y a veces es necesario
comprimirlos mientras no sean utilizados, para ahorrar espacio en memoria o en disco. El .NET
Framework nos provee dos flujos adicionales para comprimir y descomprimir flujos:
GZipStream y DeflateStream, ambas clases ubicadas en el espacio de
nombres System.IO.Compression. La primera clase utiliza el formato GZip, mientras que la
segunda utiliza un formato propio de .NET. Ambas clases se utilizan de igual forma. Si uno
necesita compatibilidad con alguna otra herramienta externa (como WinZip) entonces
GZipStream es la opción. Si esto no es necesario, podemos utilizar DeflateStream sin problema
alguno. Dado que este apunte ya es muy largo, solo trataré GZipStream, pero creeme que utilizar
DeflateStream es exactamente igual.
Flujos personalizados
Una técnica que suele utilizarse es derivar de Stream, adaptar los métodos necesarios y en el
constructor tomar como parámetro un Stream que será nuestra fuente o destino.
La clase GZipStream es un muy buen ejemplo de ello: dado un flujo, actúa como puente entre
éste y los datos, y se le pasa comprimidos o los lee y los regresa descomprimidos. La técnica que
utiliza es tomar cualquier flujo e interceptar las llamadas de lectura y escritura e interpretarlas a
su conveniencia.
Para hacer eso, primero hereda una clase de Stream. Como ésta es abstracta, tendrás que
sobreescribir las propiedades CanRead, CanWrite, CanSeek, Length y Position, así como los
métodos Flush, Read, Seek, SetLength, Write, y opcionalmente Close. Si utilizas la misma
técnica que GZipStream (tomar un Stream como base y actuar como puente) usualmente
relegarás CanRead, CanWrite, CanSeek, Length, Flush, Position Seek y SetLength al flujo base,
e implementarás la lógica en Read, Write. No olvides cerrar el flujo base Close.

6.4 – Operaciones básicas en Archivos Binarios.

Archivos Binarios
Cuando se requiere efectuar operaciones con datos de alguno de los tipos primitivos, tales datos
deberán escribirse y leerse en formato binario.
El espacio de nombres System.IO proporciona las clases:
1. • BinaryWriter
2. • BinaryReader
Con estas clases se podrán manipular datos de los tipos primitivos y cadenas de caracteres en
formato UTF-8.
Los archivos escritos en formato binario no se pueden desplegar directamente en los dispositivos
de salida estándar, como el monitor, sino que deben leerse a través de flujos de la clase
BinaryReader.

8
BINARYWRITER crea flujos para escribir archivos con datos de los tipos primitivos en
formato binario.
Su constructor es:
BinaryWriter ( Stream flujo )
Y requiere, como parámetro, un flujo de la clase Stream o sus derivadas.
Ejemplo
FileStream fs =new FileStream("datos.dat",FileMode. Create ,FileAccess. Write );
BinaryWriter bw=new BinaryWriter( fs );
Un objeto de la clase BinaryWriter actúa como filtro entre el programa y un flujo de la clase
FileStream.
En la siguiente tabla se describen algunos de los principales métodos y propiedades de la clase
BinaryWriter:
 Write(byte)
Escribe un valor de tipo byte.
 Write(byte[])
Escribe una cadena como una secuencia de bytes.
 Write(char)
Escribe un valor de tipo char.
 Write(char[])
Escribe una cadena como una secuencia de caracteres.
 Write(short)
Escribe un valor de tipo short.
 Write(int)
Escribe un valor de tipo int.
 Write(long)
Escribe un valor de tipo long.
 Write(Decimal)
Escribe un valor de tipo Decimal.
 Write(float)
Escribe un valor de tipo float.
 Write(double)
Escribe un valor de tipo double.

9
  Write(string)
Escribe una cadena de caracteres en formato UTF-8.El primero o los dos primeros bytes
especifican el número de bytes de datos escritos en la cadena.
 BaseStream
Obtiene el flujo base ( fs en el ejemplo mostrado).
 Close
Cierra el flujo y libera los recursos adquiridos.
 Flush
Limpia el buffer asociado con el flujo.
 Seek
Establece el apuntador de Lectura/Escritura en el flujo.

BINARYREADER crea flujos para leer archivos con datos de los tipos primitivos en formato
binario, escritos por un flujo de la clase Binaryreader.
Su constructor es:
BinaryReader ( Stream flujo )
Y requiere, como parámetro, un flujo de la clase Stream o sus derivadas.
Ejemplo
FileStream fs =new FileStream("datos.dat",FileMode. Open ,FileAccess. Read );
BinaryReader br=new BinaryReader( fs );
Un objeto de la clase BinaryReader actúa como filtro entre un flujo de la clase FileStream y el
programa.
En la siguiente tabla se describen algunos de los principales métodos y propiedades de la clase
BinaryReader:
o Read(byte)
Devuelve un valor de tipo byte.
o Read (byte[])
Devuelve una cadena como una secuencia de bytes.
o Read (char)
Devuelve un valor de tipo char.
o Read (char[])
Devuelve una cadena como una secuencia de caracteres.

10
 o Read (short)
Devuelve un valor de tipo short.
o Read (int)
Devuelve un valor de tipo int.
o Read (long)
Devuelve un valor de tipo long.
o Read (Decimal)
Devuelve un valor de tipo Decimal.
o Read (float)
Devuelve un valor de tipo float.
o Read (double)
Devuelve un valor de tipo double.
o Read (string)
Devuelve una cadena de caracteres en formato UTF-8. El primero o los dos primeros
bytes especifican el número de bytes de datos que serán leídos.
o BaseStream
Obtiene el flujo base ( fs en el ejemplo mostrado).
o Close
Cierra el flujo y libera los recursos adquiridos.
o Flush
Limpia el buffer asociado con el flujo.
o PeekChar
Obtiene el siguiente carácter, sin extraerlo.

c) Anexos (solo si aplica)

Programa ejemplo 6.4
using
System
;
using System.IO;

namespace Ejemplo 6.4

{
public class LecturaEscrituraArchivoBinario

11
 {
public static void Main()
{
Console.WriteLine(Environment.NewLine);

// Crea objeto `FileStream` para referenciar un archivo binario

-ArchivoBinario.bin-:
using (FileStream fs = new FileStream("ArchivoBinario.bin",
FileMode.Create))
{
// Escritura sobre el archivo binario `ArchivoBinario.bin` usando un
// objeto de la clase `BinaryWriter`:
using (BinaryWriter bw = new BinaryWriter(fs))
{
// Escritura de datos de naturaleza primitiva:
bw.Write(9517.35M);
bw.Write("OrtizOL");
bw.Write("OrtizOL - xCSw");
bw.Write('!');
}
}

Console.WriteLine("Los datos han sido escritos en el archivo

`ArchivoBinario.bin`.");
Console.WriteLine("Presione Enter para iniciar el proceso de lectura.\n");
Console.ReadLine();

// Apertura del archivo `ArchivoBinario.bin` en modo lectura:

using (FileStream fs = new FileStream("ArchivoBinario.bin",
FileMode.Open))
{
// Muestra la información tal cual está escrita en el archivo binario:
using (StreamReader sr = new StreamReader(fs))
{
Console.WriteLine(sr.ReadLine());
Console.WriteLine();

// Lectura y conversión de los datos binarios en el tipo de

// correspondiente:

// Posiciona el cursor desde se iniciara la lectura del

// archivo `ArchivoBinario`:
fs.Position = 0;

12
 using (BinaryReader br = new BinaryReader(fs))
{
Console.WriteLine(br.ReadDecimal());
Console.WriteLine(br.ReadString());
Console.WriteLine(br.ReadString());
Console.WriteLine(br.ReadChar());
}
}
}

Console.WriteLine(Environment.NewLine);
}
}
}

Programa ejemplo 6.3.2

using System;
using System.IO;

public class CEscribirCars

{
public static void Main( )
{
StreamWriter sw = null;
String str;

try
{

// Crea un flujo hacia el archivo doc.txt

// Si el archivo existe se destruye su contenido.
sw = new StreamWriter("doc.txt");

13
 Console.WriteLine("Escriba las líneas de texto a
almacenar en el archivo.\n" + "Finalice cada línea
pulsando la tecla .\n" +
"Para finalizar pulse sólo la tecla .\n");

// Lee una línea de la entrada estándar

str = Console.ReadLine();

// Mientras la cadena str no esté vacía

while (str.Length != 0)
{
// Escribe la línea leída en el archivo
sw.WriteLine(str);

// Lee la línea siguiente

str = Console.ReadLine();
}
}
catch(IOException e)
{
Console.WriteLine("Error: " + e.Message);
}
finally
{
if (sw != null) sw.Close();
}
}

14
}

Programa ejemplo 6.3.1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace Ejemplo_6._3
{
class Archivo
{
StreamReader sr;
bool abierto = false;
// Constructor: Recibe el nombre del archivo y lo abre (con control errores)
public Archivo(string filename)
{
try
{
sr = new StreamReader(filename);
abierto = true;
}
catch (Exception e)
{
Console.WriteLine("Error en la apertura de \"{0}\": {1}",
filename, e.ToString());
}
}

15
 public void Mostrar()
{
string linea;
if (!abierto) return; // Si no se pudo abrir, no hay nada que leer
linea = sr.ReadLine();
while (linea != null)
{ // Lee líneas mientras haya (mientras sean !=null)
Console.WriteLine(linea);
linea = sr.ReadLine();
}
sr.Close(); abierto = false;
}
}
static void Main(string [] args)
{
string nombre;
Console.Write("Nombre del archivo: ");
nombre = Console.ReadLine();
Archivo archivo = new Archivo(nombre);
archivo.Mostrar();
Console.ReadLine();
}
}

d) Fuentes de Información.
http://csharp-facilito.blogspot.com/2013/07/archivos-en-c-sharp.html
https://docs.microsoft.com/es-es/dotnet/standard/parallel-programming/dataflow-task-parallel-
library
https://itslr.edu.mx/archivos2013/TPM/temas/s2u6.html
https://fermasmas.wordpress.com/2010/05/08/todo-sobre-flujos-de-datos/

16
https://itslr.edu.mx/archivos2013/TPM/temas/s2u6.html

17