Saltar al contenido

Manejo de archivos en C#.

El manejo de archivos en C# a la hora de programar, nos da una ventaja respeto a lo que se ha hecho hasta el momento. Hasta ahora hemos estado manejando información en una aplicación de consola. Esta información se guardaba en variables y podía ser utilizada y modificada mientras el programa estaba en ejecución. Esto quiere decir que toda la información guardada en variables o constantes, se borra una vez que la aplicación se cierra.

Por que manejar archivos en C#.

La necesidad de manejar archivos a la hora de programar es importante. Esto nos va a permitir guardar toda la información que guardamos en variables. Como dijimos anteriormente, cuando guardamos la información en variables, esta se pierde una vez que la aplicación se cierra.

Esto no va a pasar con los archivos. Una vez que la aplicación se cierre, más adelante, podremos hacer uso de la información que hemos utilizado. En nuestro caso vamos a utilizar archivos de texto plano (un archivo de bloc de notas con extensión txt).

El uso de archivos y su manipulación.

Un archivo, puede ser manipulado, puede abrirse, cerrarse, eliminarse, modificarse, leerse, escribirse, etc. El proceso que se debe seguir para la manipulación de archivos es el siguiente:

  • Abrir el archivo: Tanto para leer, para escribir o modificar un archivo, éste debe abrirse.
  • Manipular el archivo: En esta fase, se lee, se escribe o se modifica el contenido del archivo.
  • Cerrar el archivo: Una vez finalizada la modificación del archivo, se debe cerrar y guardar el archivo correspondiente.

Como manejamos los archivos en C#.

Para poder realizar operaciones con archivos y poder utilizarlos debemos importar una librería específica.

Cuando programamos, todo programa debe estar dentro de al menos una clase. Dentro de esta clase, tenemos un espacio de nombres o namespace. En este espacio de nombres importaremos todas las clases necesarias para la entrada y salida de datos.

Estas clases se encuentran dentro del espacio de nombres System.IO. Estas siglas IO significan In Out. Dentro de este espacio de nombre podemos encontrar multitud de clases y métodos para la manipulación de archivos y carpetas, en este caso, vamos a ver solo aquellas que vamos a necesitar.

System.IO: Clases y objetos para el manejo de archivos.

  • StreamWritter: Es un objeto que permite poder escribir datos dentro de un archivo. Este objeto crea una clase llamada TextWritter.
  • StreamReader: Es un objeto que permite poder leer datos de un archivo. Este objeto crea una clase llamada TextReader.
  • File: Es una clase del espacio de nombres System.IO. Esta clase posee en su interior diferentes métodos para crear, copiar, pegar, eliminar, mover y abrir archivos.

Ejemplos de manejo de archivos en C#.

En este primer ejemplo veremos como escribir en un archivo txt.

using System;
using System.IO; // Importamos la clase para manejar archivos

namespace Operaciones_con_Archivos
{
    class Program
    {
       
        static void Main(string[] args)
        {
            // Creamos o abrimos el archivo:
            // Para ello creamos un nuevo objeto StreamWritter
            // al cual llamamos miEscritura. Con CreateText le,
            // decimos que queremos escribir texto en UFT-8. Le
            // passaamos por parámetro en nombre del archivo donde
            // queremos escribir, si no existe lo va a crear.
            // Si existe, directamente lo abre. Si crea el archivo
            // lo va a hacer dentro de la carpeta debug del directorio bin
            StreamWriter miEscritura = File.CreateText("ejemplo.txt");

            // Escribimos en el archivo. El tipo de objeto Streamwritter
            // tiene una clase llamada Write y otra llamada WriteLine.
            // Para escribir en el archivo solo tenemos que hacer uso
            // del objeto creado anteriormente llamado miEscritura
            miEscritura.WriteLine("Esta frase se escribe en el archivo.");

            // Cerramos el archivo. Al cerrarlo, se guardará en la carpeta
            // debug del directorio bin.
            miEscritura.Close();
        }
    }
}

De esta forma hemos escrito en un archivo y al cerrarlo, se guarda y se cierra perfectamente. En este caso tenemos un pequeño inconveniente. con el código anterior, si queremos seguir introduciendo datos, estos se sobreescribirán. Imaginaros que en un archivo tenemos 100 líneas y al actualizarlo lo actualizamos con dos líneas más. El archivo se abriría y se actualizaría. Se guardarían las dos ultimas líneas pero desaparecerían las 100 anteriores.

¿Cómo guardar datos en un archivo sin perder los anteriores?

Esto lo haremos de la misma manera que en el código anterior, la diferencia es que en lugar de usar el método CreateText, usaremos el método AppendText. Este método escribirá en un archivo conservando lo anterior.

using System;
using System.IO; // Importamos la clase para manejar archivos

namespace Operaciones_con_Matrices
{
    class Program
    {
        static void Main(string[] args)
        {
            // Creamos una variable para almacenar nombre y edad.
            string nombre = "";
            byte edad = 0;

            // Pedimos datos al usuario
            Console.WriteLine("Inroduce tu nombre");
            nombre = Console.ReadLine();

            Console.WriteLine("Introduce tu edad:");
            edad = byte.Parse(Console.ReadLine());

            // Creamos o abrimos el archivo:
            StreamWriter miEscritura = File.AppendText("ejemplo.txt");

            // Escribimos en el archivo. Cada vez que se ejecute
            // esta aplicación, pedirá los datos y guardará los datos
            // en el archivo llamado ejemplo.txt pero conservando los
            // datos de usuario anteriores.
            miEscritura.WriteLine("Nombre: " + nombre + "," + "Edad: " + edad);

            // Cerramos el archivo. Al cerrarlo, se guardará en la carpeta
            // debug del directorio bin.
            miEscritura.Close();
        }
    }
}

Como leer archivos en CSharp

Para escribir en archivos, hemos hecho uso del objeto StreamWritter. En este caso como lo que queremos es leer el archivo, haremos uso del objeto StreamReader. Vamos a ver un ejemplo.

using System;
using System.IO; // Importamos la clase para manejar archivos

namespace Operaciones_con_Archivos
{
    class Program
    {
        static void Main(string[] args)
        {
            // Creamos una variable para almacenar la cadena a leer
            string lineaLeida = "";

            // Como estamos leyendo el archivo ya tiene que existir.
            // Pero, ¿y si no existe? Entonces nos dará un error. Por
            // lo tanto debemos envolver nuestro código en un bloque
            // que nos permita controlar errores. Así que nuestro código
            // lo meteremos en un bloque try - catch.

            try
            {
                // Creamos un objeto para leer el archivo.
                StreamReader miLectura = File.OpenText("ejemplo.txt");

                // Leemos la primera linea del archivo.
                lineaLeida = miLectura.ReadLine();

                // Un archivo puede tener tantas líneas como sea
                // necesario pero hasta este punto solo nos va a leer
                // la primera linea y se va a quedar ahí....
                // ¿Como leemos el resto del archivo? Pues creamos
                // un bucle While de la siguiente manera.

                // Mientras la linea leida
                //sea diferente de una cadena nula
                while (lineaLeida != null)
                {
                    // La podemos mostrar por consola.
                    Console.WriteLine(lineaLeida);

                    // Una vez leida y mostrada en consola
                    // volvemos a hacer una lectura.
                    miLectura.ReadLine();
                }

                // Cerramos el archivo
                miLectura.Close();

            }
            catch (Exception msg) // Si no se puede leer mostramos el error
            {
                Console.WriteLine("No se encuentra el archivo " + msg);
            }

            // Paudamos la consola
            Console.ReadKey();
        }
    }
}