Laboratorio 1: Gestión de Archivos

publicado a la‎(s)‎ 24 abr 2012, 8:56 por Hernan Nina Hanco   [ actualizado el 22 may 2012, 14:13 ]
I) OBJETIVOS
  • Conocer el almacenamiento de datos de forma persistente utilizando librerias de gestión de archivos en un lenguaje de programación.
II) MARCO CONCEPTUAL

Streams

Los streams son la forma en la que se realizan operaciones de lectura/escritura desde/hacia medios de almacenamiento como pueden ser un disco o la propia memoria. Todas las clases que representan a streams heredan de la clase Stream (System.io.Stream).

Clase Stream ( sus subclases) ofrecen un punto de vista sobre las distintas fuentes de datos, repositorios, etc… y aislan a los programadores de los detalles específicos del sistema operativo y los dispositivos.

  • Los streams nos permiten realizar los siguientes tipos de operaciones:

    • Realizar lecturas de los streams: Extraer datos del stream.

    • Realizar escrituras en los streams: Escribir datos en el stream.

    • Realizar posicionamientos en los streams: Dependiendo del tipo de almacenamiento, permitiran modificar la posición sobre el stream

Algunas de las operaciones básicas de la implementación del stream son:

  • Read – CanRead

  • Write – CanWrite

  • Seek, SetLength – CanSeek, Position, Length


El espacio de nombres System.io contiene:

  • BufferedStream: Emplea un buffer para las lecturas y escrituras mejorando el rendimiento. No permite herencias.

  • MemoryStream: Crea streams utilizando la memoria como almacenamiento, no usa ni disco ni red.

  • FileStream: Lectura y escritura en ficheros. Aunque trabaja en modo síncrono, provee de un constructor para abrir ficheros en modo asíncrono.


Readers y Writers

Las clases que se derivan de System.IO.Stream realizan la operaciones de entrada/salida basada en bytes. Los Readers y los Writers pueden tomar otros tipos de datos y leerlos o escribirlos en streams o cadenas.

Clases:

  • BinaryReader y BinaryWriter: Leen y escriben tipos primitivos en un stream

  • TextReader y TextWriter: Diseñadas para la entrada/salida de caracteres

  • StreamReader y StreamWriter: Se derivan de TextReader y TextWriter. Pensadas para la lectura y escritura en un stream.

  • StringReader y StringWriter: Se derivan de TextReader y TextWriter. Leen los caracteres de un string y escriben en un StringBuilder.


Entrada y salida basica a ficheros: Clase FileStream

Utilizada para leer y escribir en ficheros. Su constructor posee tres parámetros (además del

nombre):

  • FileMode: Open, Append, Create

  • FileAccess: Read, Write, ReadWrite

  • FileShare: Enumeración con constantes útiles para controlar el tipo de acceso que tendrán otros FileStream al archivo. Esta enumeración es útil cuando más de dos procesos acceden al mismo archivo simultaneamente:

    • Read → Permite a los otros procesos leer

    • Write → Permite a los otros procesos escribir

    • None → Rechaza las peticiones de apertura por otros procesos

    • ReadWrite → Permite a los otros procesos leer y escribir


Crear un nuevo FileStream

FileStream fs = new FileStream (nombre_archivo, FileMode.Open, FileAccess.Read, FileShare.Read)


El Método Seek para ficheros de acceso aleatorio:

  • Los objetos FileStream soportan acceso aleatorio a los ficheros mediante el método Seek.

  • El método Seek permite mover la posición actual de lectura/escritura dentro del fichero.

  • El cambio de posición se realiza mediante un offset o desplazamiento basado en el número de byte.

  • El offset es relativo a un punto de referencia dado. Este punto de referencia viene por la enumeración SeekOrigin.

  • SeekOrigin posee tres miembros:

    • Begin: Hace referencia a la posición inicial del fichero

    • Current: Hace referencia a la posición actual del fichero

    • End: Hace referencia a la posición final del fichero


III) Practicas de laboratorio

Practica 1: Acceso de lectura y escritura de un archivo

La siguiente aplicación muestra la forma de crear un archivo de tipo binario y poder escribir datos como su contendo y luego hacer la lectura del contenido, para ello se utiliza librerias de gestión de Archivos de la plataforma .Net Framework en el lenguaje de programación C#


   class Program
   {
       private const string NOMBRE_ARCHIVO = "prueba.txt";
       static void Main(string[] args)
       {
           // Creamos el archivo de datos
           if (File.Exists(NOMBRE_ARCHIVO)){
               Console.WriteLine(

"El Archivo {0} ya existe", NOMBRE_ARCHIVO);

               return;
           }

           FileStream fs = new

FileStream(NOMBRE_ARCHIVO,FileMode.CreateNew);

           // Se crea el Writer para escribir los datos
           BinaryWriter bw = new BinaryWriter(fs);
           // Escribir los datos
           for (int i = 0; i <= 10; i++)
           {
               Console.WriteLine("Escribiendo {0}",i);
               bw.Write(i);
           }
           // cerramos el stream de escritura y el archivo
           bw.Close();
           fs.Close();
           
           // volvemos a abrir el archivo
           fs = new FileStream(NOMBRE_ARCHIVO,FileMode.Open,

FileAccess.Read);

           // Creamos el Stream de lectura
           BinaryReader br = new BinaryReader(fs);
           // Recorremos los datos del archivo
           for (int i = 0; i <= 10; i++)
           {
               Console.WriteLine("Leyendo {0}",

br.ReadInt32());

           }
           // Cerramos el stream y el archivo
           br.Close();
           fs.Close();
       }
   }



Practica 2: Ejercicio de estructura de directorios y archivos

La estructura de directorios y archivos es una aplicación de la estructura de datos árbol. Los sistemas de archivos de los Sistemas Operativos manejan este tipo de estructuras. En el código siguiente se muestra un método para mostrar el contenido de un directorio, se considera solo archivos pudiendo también listar los subdirectorios. Se utiliza las Clases de información DirectoryInfo, FileInfo.

      public static void MostrarContenidoDirectorio()
      {


           // Información de un determinado directorio
          DirectoryInfo di = new DirectoryInfo("c:/");
          // Arreglo de archivos que se encontraban en el

// directorio

          FileInfo[] diar1 = di.GetFiles();
          // Mostrar todos los archivos encontrados
          foreach (FileInfo f in diar1)
          {
              Console.WriteLine(f.Name + "\n");
          }
      }

Practica 3: Leer un archivo de texto

using System.IO;

class LecturaArchivo
{
    private const string ARCHIVO = "lineas.txt";
    static void main(string[] args)
    {
        string linea;
        if (!File.Exists(ARCHIVO))
        { 
            Console.WriteLine("El archivo {0} no existe", ARCHIVO);
            return;
        }
        // StreamReader derivado de TextReader para leer un archivo
        StreamReader sr = File.OpenText(ARCHIVO);
        // leer linea a línea un archivo hasta que no exista líneas
while ((linea = sr.ReadLine()) != null)
        {
            Console.WriteLine(linea);
        }
        Console.WriteLine("Fin de archivo");
        sr.close();
    }
}



IV) Trabajo para casa:

Ejercicio propuesto 1:
  • Programar dos pequeños programas que permitan leer y escribir registros en dos Archivos.
    • Campos de registro_1:
      • <nombre><apellido1><apellido2><teléfono>
    • Campos de registro_1:
      • <dd/mm/aaaa><Título_cita><hh:mm>
  • Sugerencia: Crear métodos que realicen la escritura de registros de manera atómica. Ej: escribirPersona, leerPersona, etc.
  • Sugerencia: Crear clases que representen los objetos denotados por los registros e incluir en éstas la responsabilidad de la escritura/lectura de los registros.
Ejercicio propuesto 2:

Escriba una aplicación para mostrar el contenido de un directorio considerando los archivos y subdirectorios del mismo, también mostrar el contenido de los subdirectorios. Puedes considerar como modelo de la aplicación el comando tree de Windows.


V) Referencias bibliograficas
Comments