Aplicaciones con archivos

Aplicaciones con archivos

Crea un archivo desde java, e implementa la entrada de datos al archivo

// CLeercars.cs

using System;
using System.IO;

public class CLeerCars

{

public static void Main (string[] args)
{

StreamReader sr = null;
String str;

try
{

// Crea un flujo desde el archivo doc.txt
sr = new StreamReader("doc.txt");

// Lee del archivo una línea de texto

str = sr.ReadLine();

// Mientras la cadena str no esté vacía
while (str != null)
{

// Muestra la línea leída
Console.WriteLine(str);

// Lee la línea siguiente

str = sr.ReadLine();

}

}

catch(IOException e)
{

Console.WriteLine("Error: " + e.Message);

}

finally
{

// Cierra el archivo
if (sr != null) sr.Close();

}

}

}

El siguiente programa pregunta al usuario si desea sobreescribir los datos existentes en el archivo.

// CEscribirCars2.cs

using System;
using System.IO;

public class CEscribirCars
{

public static void Main ( )
{

StreamWriter sw = null;
String str;

try
{

// Obtiene el nombre del archivo desde la entrada estándar

Console.Write("Nombre del archivo: ");
str = Console.ReadLine();

char resp = 's';
if ( File.Exists(str) )
{

Console.Write("El archivo existe ¿desea sobreescribirlo? (s/n) ");
resp = (char)Console.Read();
// Salta los bytes no leídos del flujo de entrada estándar

Console.ReadLine();

}

if (resp != 's') return;

// Crea un flujo hacia el archivo seleccionado por el usuario.
sw = new StreamWriter(str);

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(UnauthorizedAccessException e)
{

Console.WriteLine("Error: " + e.Message);

}
catch(IOException e)
{

Console.WriteLine("Error: " + e.Message);

}
finally
{

if (sw != null) sw.Close();

}

}

}

Operaciones básicas en archivos de texto y binarios

Operaciones básicas en archivos de texto y

binarios

Las operaciones básicas con archivos son:

Creacion

Apertura

Lectura

Escritura

Recorrido

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 )

donde:

nombre es el nombre del archivo en disco, incluyendo la trayectoria.

Ejemplo:

modo es un valor del tipo enumerado FileMode ; puede tomar uno de los siguientes valores:

Valor	Acción
CreateNew	Crea un nuevo archivo. Si el archivo existe, lanzará una excepción del tipo IOException.
Create	Crea un nuevo archivo. Si el archivo existe, será sobreescrito.
Open	Abre un archivo existente.
OpenOrCreate	Abre un archivo, si existe;en caso contrario, se crea un nuevo archivo.
Truncate	Abre un archivo existente y lo trunca a cero bytes de longitud.
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:

Valor	Acción
Read	Permite leer un archivo.
ReadWrite	Permite leer o escribir en el archivo.
Write	permite escribir en el archivo.

Definicion de archivos de texto y binario

Unidad 8 Flujos y Archivos

Definición Archivos Texto Binarios

Definición de archivos de texto y binarios

Los archivos de texto plano son aquellos que están compuestos únicamente por texto sin formato, solo 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.

Un archivo binario es una archivo informático que contiene información de cualquier tipo, codificada en forma binaria para el propósito de almacenamiento y procesamiento de ordenadores.

Muchos formatos binarios contienen partes que pueden ser interpretados como texto. Un archivo binario que solo contiene información de tipo textual sin información sobre el formato del mismo, se dice que es un archivo de texto plano. Habitualmente se contraponen los términos archivo binario y archivo de texto de forma que los primeros no contienen solamente texto.

Excepciones definidas por el usuario

Excepciones definidas por el usuario

En algunos casos puede ser necesario crear tipos de excepción específicas para los errores que ocurren en los programas, por lo que deben crearse clases de excepción definidas por el programador.

Las clases de excepción definidas por el programador deben derivar directa o indirectamente de la clase ApplicationException del espacio de nombres System.

Antes de crear una clase de excepción definida por el programador, es recomendable verificar la existencia de dicha clase en el .NET Framework, y solamente crear clases de excepción para manejar las nuevas excepciones de manera diferente a otros tipos de excepción existentes.

Ejemplo

using System;

class MiExcepción : ApplicationException
{

public MiExcepción() : base("Este es el mensaje de mi excepción.")
{

}

}

class Principal
{

public static void Main()
{

try
{

Principal miObjeto = new Principal();

miObjeto.lanzaException();

Console.WriteLine("Pulse enter para finalizar...");
Console.Read();

}
catch(MiExcepción e)
{

Console.WriteLine(e.Message);
Console.Read();

}

}

public void lanzaException()
{

throw new MiExcepción();

}

}

Gestion de Excepciones

Gestión de Excepciones

La gestión de excepciones de Java lleva la gestión del error en tiempo de ejecución al mundo orientado a objetos. Una excepción de Java es un objeto que describe una condición excepcional que se ha producido en un fragmento de código.

Excepciones no capturadas

Los objetos de excepción los crea automáticamente el intérprete de Java como respuesta a alguna condición excepcional. Como ejemplo tomamos una división por cero. Cuando el intérprete de Java intenta ejecutar la división, observa que el denominador es cero y construye un nuevo objeto de excepción para que se detenga este código y se trate esta condición de error. Una vez detenido el flujo del código en el operador de división, se buscará en la pila de llamadas actual cualquier gestor de excepciones (pila que contiene un registro de las llamadas a método).
Un gestor de excepciones es algo establecido para tratar inmediatamente la condición excepcional. Si no codificamos un gestor de excepciones, se ejecutara el gestor en tiempo de ejecución por defecto. El gestor por defecto imprime el valor String de la excepción y el trazado de la pila del lugar donde se produjo la excepción.

try y catch

A menudo es más elegante y practico manejar nosotros mismos la excepción. Se puede utilizar la palabra clave try para especificar un bloque de código que se debería proteger frente a todas las excepciones. A continuación inmediatamente del bloque try, se incluye la cláusula catch que especifica el tipo de excepción que se desea captar. Veamos estas construcciones sobre el ejemplo anterior de la división:

class Exc {

        public static void main(String args[])  {

               try  {

                       int d = 0;

                       int a = 42;

                } catch (ArithmeticException e)  {

                       System.out.println("división por cero");

                }

        }

}

ArithmeticException es una subclase especial de Exception, que describe más específicamente el tipo de error que se ha producido. El ámbito de la cláusula catch está restringido a las sentencias especificadas por la sentencia try precedente.

Cláusulas catch múltiples

En algunos casos, la misma secuencia de código puede activar más de una condición excepcional. Se pueden tener varias cláusulas catch en una fila. Se inspecciona cada uno de estos tipos de excepción en el orden en que están y el primero que coincida se ejecuta. Las clases de excepción más especificas se colocaran primero, dado que no se alcanzarán las subclases si están después de unas superclase.

throw

La sentencia throw se utiliza para lanzar explícitamente una excepción. En primer lugar, debe obtener un descriptor de una instancia de Throwable, mediante un parámetro en una cláusula catch, o cerrar una utilizando el operador new. esta es la forma general de una sentencia throw:

throw InstanciaThrowable;

El flujo de la ejecución se detiene inmediatamente después de la sentencia throw, y no se llega a la sentencia siguiente. Se inspecciona el bloque try que la engloba más cercano para ver si tiene una cláusula catch cuyo tipo coincida con el de la instancia Throwable. Si la encuentra, el control se transfiere a esa sentencia. Si no, se inspecciona el siguiente bloque try que la engloba, y así sucesivamente, hasta que le gestor de excepción más externo detiene el programa e imprime el trazado de la pila hasta la sentencia throw.

finally

A veces es necesario estar seguro de que se ejecutará un fragmento de código dado independientemente de que excepciones se provocan y capturan. Se puede utilizar la palabra clave finally par identificar dicho bloque de código. Incluso aunque so coincida ninguna de las cláusulas catch, se ejecutará el bloque finally antes del código que está después del final del bloque try completo.

Excepciones

Unidad 7 Excepciones

Definicion de Excepciones

En todo programa existen errores inesperados en tiempo de ejecución, y también errores que no consideramos debido a nuestra propia inexperiencia como programadores. Unos de estos errores ocurren por ejemplo, al intentar acceder a un elemento del arreglo que está fuera del límite de nuestro arreglo, o cuando intentamos acceder a un archivo inexistente, entre otros. Normalmente estos errores interrumpen el flujo de ejecución de nuestros programas, hasta el extremo de provocar la terminación del programa en forma inmediata. Java hace uso de las excepciones^1.1 para poder controlar los errores en tiempo de ejecución.

En Java, casi todo los tipos de errores que puedan surgir en tiempo de ejecución lanzan excepciones, es decir, cuando ocurre un error dentro de un método de JAva, este método crea un objeto Exception, dicho objeto contiene información sobre la excepción, que incluye su tipo y el estado del programa cuando ocurrió el error. El sistema de ejecución es el responsable de buscar algún código para manejar el error. El manejo de excepciones en Java sigue una estructura como esta:

try {

   //Codigo donde puede ocurrir un error

} 

catch (ExcepcionA ex) { // Que se va a hacer en caso que  se lanze una Excepcion A 

}

...

catch (ExcepcionZ ex) { // Que se va a hacer en caso que se lanze una Excepcion Z 

}

Dentro del bloque try{ } viene encerrado la parte del programa que se desea manejar sus excepciones. El código dentro de algún catch (TipoExcepcion e) se ejecuta en caso se que lanze una excepción TipoExcepcion o que pertenezca al grupo TipoExcepcion. El sistema de ejecución Java busca hacia atrás en la pila de llamadas para encontrar el método que esté interesado en manejar una excepción particular.

Clases genericas (plantillas)

Clases Genéricas (Plantillas)

Las clases genéricas encapsulan operaciones que no son específicas de un tipo de datos concreto. El uso más común de las clases genéricas se da con las colecciones, como listas vinculadas, tablas hash, pilas, colas, árboles, etc., en las que las operaciones tales como agregar y quitar elementos de la colección se realizan de forma similar independientemente del tipo de datos que se almacena.

Normalmente, para crear clases genéricas se empieza a partir de una clase concreta existente y se cambian los tipos, uno a uno, por parámetros de tipo hasta que se obtiene un equilibrio óptimo entre generalización y utilidad. Al crear sus propias clases genéricas, se deben tener en cuenta las siguientes consideraciones importantes:

· Tipos que se generalizan como parámetros de tipo.

Como regla general, cuantos más tipos se puedan parametrizar, más flexible y reutilizable será el código. Sin embargo, un exceso de generalización puede producir código difícil de leer y comprender para otros programadores.

Una buena regla consiste en aplicar las restricciones máximas posibles que sigan permitiendo controlar los tipos que es necesario controlar. Por ejemplo, si sabe que la clase genérica está exclusivamente destinada al uso con tipos de referencia, aplique una restricción de clase. Esto evitará el uso imprevisto de la clase con tipos de valor y permitirá utilizar el operador as en T y comprobar si hay valores nulos.

· Factorizar o no el comportamiento genérico en las clases base y las subclases.

Dado que las clases genéricas pueden actuar como clases base, se aplican las mismas consideraciones de diseño que con las clases no genéricas. Vea más adelante las reglas para la herencia de clases base genéricas.

· Implementar o no una o varias interfaces genéricas.