PDF de programación - Manejo de Archivos en C-Sharp

Manejo de Archivos en C#

La manera de almacenar y recuperar información que perdure en el tiempo se
basa en el uso de “memoria secundaria”, compuesta esencialmente por discos
(diskettes, discos duros, CD, DVD, etc.) y ocasionalmente cintas. En cualquiera de
estos medios, la unidad de almacenamiento de información se denomina archivo.

Streams

La lectura y escritura a 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
(como se muestra en la figura de abajo).

Figura 1. Clases del Framework .NET para el uso de Streams.



Un stream es como se denomina a un objeto utilizado para transferir datos. Estos
datos pueden ser transferidos en dos posibles direcciones:

- Si los datos son transferidos desde una fuente externa al programa, entonces se
habla de “leer desde el stream”.

- Si los datos son transferidos desde el programa a alguna fuente externa,
entonces se habla de “escribir al stream”.

Frecuentemente, la fuente externa será un archivo, pero eso no necesariamente
es el caso, por lo que el concepto es utilizado ampliamente con fuentes de
información externas de diversos tipos. Algunas otras posibilidades fuera de los
archivos incluyen:

- Leer o escribir datos a una red utilizando algún protocolo de red, donde la
intención es que estos datos sean recibidos o enviados por otro computador.

- Lectura o escritura a un área de memoria.

- La Consola

- La Impresora

- Otros ...

Algunas clases que C# provee para resolver este acceso a fuentes diversas
incluyen las clases de tipo: Reader y Writer.

BufferedStream

Esta clase se utiliza para leer y para escribir a otro stream.

El uso de streams para la lectura y escritura de archivo es directa pero lenta. Por
esta razón la clase BufferedStream existe y es más eficiente. Puede ser utilizado
por cualquier clase de stream. Para operaciones de archivo es posible utilizar
FileStream, donde el buffering está ya incluido.

Las clases más relacionadas con la escritura y lectura de archivos (File
Input/Output o File I/O) son:


• FileStream, cuyo propósito es lectura y escritura de datos binarios (no de
texto legible), a cualquier archivo de tipo binario, aunque se puede utilizar
para acceder a cualquier tipo de archivo, inclusive los de texto.



• StreamReader y StreamWriter, las cuales están diseñadas para lectura y

escritura de archivos de texto. Estas clases se asumen como de un nivel
más alto que FileStream.


Una observación acerca de la declaración de nombres/rutas de archivos en C#.
Usualmente, la ruta de un archivo contiene el carácter ‘\’, que en C# se utiliza
como caracter de control para símbolos especiales (como el cambio de línea: ‘\n’).
Sin embargo, entendiendo que no es el mismo sentido el que se le quiere dar en la
“C:\Mis
interpretación
documentos\Programas\ejemplo.cs”),
particular,
anteponiendo el símbolo ‘@’ antes del string con la ruta del archivo. Es decir:

archivos
utiliza

rutas

de

(por

ej:
sintaxis

una

de

se



string rutaarchivo = @”C:\Temp\archivo.txt”;


Esta declaración evita la interpretación de los dos caracteres ‘\’ como símbolos
especiales y el string queda correctamente inicializado.

Using System.IO

Para el uso de estas clases, es necesario referenciar el uso del namespace
System.IO, ya que System no contiene los elementos para el manejo de archivos.
Por ello, los programas con acceso a archivos deben incluir la línea:

using System.IO;


Constructores de StreamReader

El más simple de los constructores toma sólo el nombre/ruta del archivo a abrir
para lectura:


StreamReader sr = new StreamReader(@”C:\Temp\archivo.txt”);


Sin embargo, reconociendo que hoy existen diferentes formatos (codificaciones)
de archivos de texto y no solamente el tradicional formato ASCII, es factible
establecer cuál es la codificación especial que este archivo de texto plano puede
tener. Los formatos posibles son: ASCII, Unicode, UTF7, UTF8,
BigEndianUnicode.

El constructor ad-hoc es:



StreamReader sr = new StreamReader(@”C:\Temp\file.txt”,

Encoding.UTF8Encoding);


En términos prácticos, nos será necesario recurrir a este tipo de codificaciones, ya
que usualmente se
trabajará con codificación ASCII.

El constructor deja abierto el stream para poder recuperar la información del
archivo desde la instancia de StreamReader declarada. Para cerrar un stream o
archivo, se invoca el método Close():

sr.Close();

Lectura con StreamReader

Son básicamente tres los métodos propios de StreamReader que permiten
efectuar lectura desde el stream (archivo) declarado.


ReadLine()

Al igual que el conocido Console.ReadLine(), este método lee una línea completa
de un archivo de texto hasta el cambio de línea más próximo. Al igual que su
equivalente de consola, StreamReader.ReadLine() no incluye en el string el
carácter de cambio de línea.


string linea = sr.ReadLine()


ReadToEnd()

Este método, por su parte, se encarga de acumular la información que hay desde
la lectura anterior (que
pudo haberse hecho con ReadLine(), por ejemplo) hasta el final del archivo, todo
en el mismo string.


string linea = sr.ReadToEnd()


Read ()

Finalmente, el método simple Read() se encarga de leer un caracter a la vez, lo
que permite procesar
símbolo por símbolo el contenido del archivo. Convenientemente, este método
reconoce el cambio de línea y se lo salta como si no existiese. Cuando se
encuentra con el fin de archivo, retorna un valor –1, considerando que su retorno
es siempre un int (y no un char).

int SigCaracter = sr.Read();

Este mismo método ofrece una declaración alternativa (sobrecarga), donde es
posible leer una cantidad
específica de caracteres y almacenarlos en un arreglo de enteros.

char[] CharArray = new char[100];
int[] nChars = sr.Read(CharArray, 0, 100);

nChars es un arreglo con los enteros retornados por el método, y será
menor si es que la cantidad de caracteres que quedan en el archivo es
menor de 100.

Escritura: StreamWriter

Esta clase funciona prácticamente de la misma manera que StreamReader,
excepto que su propósito es únicamente para escribir dentro de un archivo (u otro
stream). Es relevante distinguir que en este caso, el proceso de apertura para
escritura considera que:



• Si el archivo no existe lo crea vacío para comenzar a escribir.
• Si el archivo ya existe, lo deja vacío para comenzar a escribir.
• Si el archivo ya existe, es posible abrirlo en forma “Append” (agregar) para

escribir al final.


Constructores de StreamWriter

El más simple de los constructores toma sólo el nombre/ruta del archivo a abrir
para escritura.


StreamWriter sw = new StreamWriter (@”C:\Temp\archivo.txt”);


Este constructor asume por defecto el formato UTF8 de archivos planos, ya que es
el manejado por .NET. Sin embargo, existe el constructor equivalente que permite
abrir un archivo especificando otra codificación de archivo plano, por ejemplo
ASCII.

StreamWriter sw = new StreamWriter (@”C:\doc\file.txt”, Encoding.ASCII);

Un tercer constructor utiliza como segundo parámetro un boolean que indica si el
archivo debe ser abierto para “Agregar”, es decir, en un modo Append.

StreamWriter sw = new StreamWriter (@”C:\Temp\archivo.txt”, true);

De la misma manera que en el caso de la lectura, para cerrar un stream o archivo,
se invoca el método
Close:

sw.Close();


Escritura con StreamWriter

Son básicamente dos los métodos propios de StreamWriter que permiten escribir
hacia el stream (archivo) declarado y son los mismos que se usan para escribir en
la consola: Write() y WriteLine().

WriteLine()

Totalmente equivalente a Console.WriteLine(), se utiliza la misma idea, y el mismo
formato, sabiendo que se estará escribiendo el texto no a la consola, sino que al
stream abierto con el constructor.

string linea = “Texto de prueba”;
sw.WriteLine(linea);
sw.WriteLine(“Los valores posibles son: {0} y {1}”, 3, 5);


Write ()

También presente, el método simple Write(), permite escribir texto en el stream, de
la misma forma que su equivalente método de la clase Console. En este caso se
reconocen las siguientes alternativas de uso:

Imprimir un string

string linea = “Texto de prueba”;
sw.Write(linea);

Imprimir un caracter

char caracter = ‘T’;
sw.Write(caracter);

Imprimir un arreglo de caracteres

char[] caracteres = new char[100];
for(int i=0; i<100; i++) caracteres[i] = ‘+‘;
sw.Write(caracteres);

Imprimir una porción de un arreglo de caracteres

char[] caracteres = new char[100];
for(int i=0; i<100; i++) caracteres[i] = ‘+‘;
sw.Write(caracteres, 25, 50); // Desde posición 25 se escriben 50 caracteres


Ejemplos de Manejo de Archivos en C#

• Leyendo desde un archivo de texto:

using System;
using System.IO;

static void Main(string[] args)
{
string fileName = "temp.txt";
FileStream stream = new FileStream(fileName, FileMode.Open,
FileAccess.Read);
StreamReader reader = new StreamReader(stream);

while (reader.Peek() > -1) Console.WriteLine(reader.ReadLine());
reader.Close();

}


using System;
using System.IO;
/// Permite leer un archivo
/// <param name="sFileName">Nombre del archivo</param>
Private void ReadFile(string sFileName) {

string sPath = "c:\\folder\\";
string sFileName = sPath + "archivo.txt";
//verifico que exista el archivo
if (File.Exists(sFileName)) {
FileStr