Ejemplo de lectura de archivo texto

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
namespace Aplicacion_consola_archivo_texto_leer
{
class Program
{
static void Main(string[] args)
{
StreamReader Fr = null;
string cadena;
try
{
Fr = new StreamReader("d:\\datos\\archivo1.txt");
cadena = Fr.ReadLine();
while (cadena != null)
{
Console.WriteLine(cadena);
cadena = Fr.ReadLine();
}
}
catch (IOException e)
{
Console.WriteLine("Error: {0}", e.Message);
}
finally
{
if (Fr != null) Fr.Close();
}


Console.ReadKey();


}
}
}

Ejemplo Escribir un archivo texto

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
namespace Aplicacion_consola_archivo_texto
{
class Program
{
static void Main(string[] args)
{
StreamWriter fw = null;
string cadena;
try
{
fw=new StreamWriter("d:\\datos\\archivo1.txt");
Console.WriteLine("Escriba las lineas de texto a almacenar en el archivo");
Console.WriteLine("Para finalizar cada linea presione enter");
Console.WriteLine("Para terminar solo presione enter en la nueva linea");
cadena=Console.ReadLine();
while(cadena.Length != 0)
{fw.WriteLine(cadena);
cadena=Console.ReadLine();
}
}
catch(IOException e)
{
Console.WriteLine("Error : {0}",e.Message);
}
finally{
if(fw !=null)
{
fw.Close();
}
}
Console.ReadKey();
}
}
}

Clase FileStream

La clase FileStream puede leer o escribir datos de un archivo byte a byte.
Esta clase hereda los métodos de la clase Stream

FileStream(string nombre, FileMode modo)

Este constructor abre un flujo de entrada y salida(leer y escribir) vinculado con el archivo especificado por nombre.

FileStream(string nombre, FileMode modo, FileAccess acceso)

Es similar al primer constructor , pero permite especificar el tipo de acceso(leer, escribir, o leer y escribir)

El nombre es una cadena de caracteres que especifica la ruta donde esta almacenado o se almacenará el archivo.

Esta cadena puede escribirse de dos formas
1) "C:\\datos\\Historial.txt"
2) @""C:\\datos\\Historial.txt"

el parametro modo, del tipo enumerado FileMode, puede tomar uno de los valores siguientes:

CreateNew Crear un nuevo archivo. Si el archivo existe se lanzará una excepción del tipo IOException.

Truncate Abrir un archivo existente. Una vez abierto, sera truncado a cero bytes.

Create Crear un nuevo archivo. Si el archivo existe será sobreescrito.

Open Abrir un archivo existente. Si el archivo no existe se lanzara una excepción del tipo FileNotFoundException.

OpenOrCreate Abrir un archivo si existe, si no , se crea un nuevo archivo.

Append abrir un archivo para añadir datos al final del mismo si existe, o crear un nuevo archivo si no existe.

El parámetro acceso, del tipo enumerado FileAccess puede tomar uno de estos valores:

Read Permite accesar el archivo para realizar la operación de lectura.

Write Permite accesar el archivo para realizar la operación de escritura.

ReadWrite Permite accesar al archivo para realizar la operación de lectura y escritura.


Ejemplo

FileStream F1=new FileStream("D:\\datos\\Listado.Txt",FileMode.Create, FileAccess.Write);

Ejemplo uno de archivos

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace AplicacionArchivo1
{
class Program
{
static void Main(string[] args)
{
string nameFile;
Console.WriteLine("Introduce el nombre del archivo y su trayectoria");
nameFile = Console.ReadLine();

if (File.Exists(nameFile))
{

Console.WriteLine(" Si existe archivo ");
Console.WriteLine("Su creacion fue : {0}", File.GetCreationTime(nameFile));
Console.WriteLine("Su ultimo Modificación fue :{0}", File.GetLastWriteTime(nameFile));
try
{
StreamReader F1 = new StreamReader(nameFile);
Console.WriteLine(F1.ReadToEnd());
}
catch (IOException)
{
Console.WriteLine("error al leer el archivo ");
}
}
else{
if(Directory.Exists(nameFile))
{
string[] listaDirectorios;
listaDirectorios = Directory.GetDirectories(nameFile);
Console.WriteLine("Informacion directorio ");
for (int I = 0; I < listaDirectorios.Length; I++)
{
Console.WriteLine(listaDirectorios[I] + "\r\t");
}
}
else
Console.WriteLine("no existe "+nameFile);
}
Console.ReadLine();

}


}
}

Flujos

Un archivo es un conjunto de datos que se almacenan bajo un nombre y se almacenan en dispositivos secundarios(disco duro, disco flexible, cinta magnetica, etc..)

La comunicación entre un programa y los datos se realiza mediante un flujo de datos (stream) este es un objeto intermediario entre el programa y los datos.

El flujo de datos es una ruta en un sentido para comunicar los datos que estan almacenados en un dispositivo secundaria y el programa.

Cuando el programa necesita datos de entrada almacenados en un unidad de disco, recibe el nombre de flujo de entrada.

Cuando el programa necesita almacenar datos en un dispositivo secunadario , recibe el nombre de flujo de salida.

Para poder realizar la flujo de entrada(el programa lee datos de un archivo y los lleva a la memoria primaria) se realiza el siguiente procedimiento:
1)abrir un flujo desde un archivo
2)mientras exista información, leer datos
3)Cerrar el flujo

Para poder realizar el flujo de salida(el programa escribe datos en el archivo)
a)abrir un flujo hacia un archivo
b)Mientras exista datos , para almacenar , escribir la información
c)Cerrar el flujo.

En C# el espacio de nombres System.IO contiene un conjunto de clases que sirven para leer y escribir datos en el archivo.
La clase FileStream subclase de Stream permite leer o escribir datos a un archivo byte a byte.
La clase StreamReader y StreamWriter subclases de TextReader y TextWriter permite leer y escribir texto a un archivo y las clases BinaryReader y BinaryWriter permite leer y escribir datos de cualquier tipo primitivo en binario y cadena de caracteres

La información que se almacena en archivos, y que se organizan en directorios pueden utilizar la clase File y Directory permiten a los programas manejan archivos y directorios en el disco.

La clase File puede verificar información de los archivos y puede hacer las operaciones de lectura y escritura de archivos.

Metodos static de la clase File

AppendText Devuelve u objeto StreamWriter que agrega texto a un archivo que ya existe, o lo crea sino existe.

Copy Copia un archivo a un archivo nuevo.

Create Crea un archivo y devuelve su objeto FileStream asociado.

CreateText Crea un archivo texto y devuelve su objeto StreamWritee asociado

Delete Elimina un archivo especifico

Exist Devuelve true si el archivo especificado existe y false en caso contrario

GetCreationTime Devuelve un objeto DateTime que representa la fecha y hora en la que se creó el archivo.

GetLastAccessTime Devuelve un objeto DateTime que representa la fecha y hora del último acceso al archivo.

GetLastWriteTime Devuelve un objeto DateTime que representa la fecha y hora de la última modificación del archivo.

Move Mueve el archivo especificado a una ubicación especifica

Open Devuelve un objeto FileStream asociado con el archivo especificado y equipado con los permisos de lectura y escritura especificados.

OpenRead Devuelve un objeto FileStream de solo lectura, asociado con el archivo especificado.

OpenText Devuelve un objeto StreamReader asociado con el archivo especificado.

OpenWrite Devuelve un objeto FileStream de lectura y escritura, asociado con el archivo especificado.




Clase Directory y sus métodos static

CreateDirectory Crea un directorio y devuelve su objeto DirectoryInfo asociado.

Delete Elimina el directorio especificado.

Exists Devuelve true si existe el directorio especificado y false en caso contrario

GetDirectories Devuelve un arreglo string que contiene los nombres de los archivos en el directorio especificado.

GetFiles Devuelve un arreglo string que contiene los nombres de los archivos en el directorio especifico.

GetCreationTime Devuelve un objeto DateTime que representa la fecha y hora de creación del directorio.

GetLastAccessTime Devuelve un objeto DateTime que representa la fecha y hora del último acceso al directorio.

GetLastWriteTime Devuelve un objeto DateTime que representa la fecha y hora en que se escribieron los últimos elementos en el directorio.

Move Mueve el directorio especificado a una ubicación especifica

Practica 17 y 18

Practica 17
Hacer un programa que utilice la clase Array y ArrayList

Practica 18
Hacer una libreria DLL y agregarla a un programa

Ejemplo base generica 2

using System;
using System.Collections.Generic;
using System.Text;

namespace aplicacion_generico_2
{
class ArregloUni
{

T [] elementos;
public ArregloUni(int n)
{
elementos = new T [n];
}
public void asignarDato(int i, T x)
{
elementos[i] = x;
}
public T obtener(int i)
{
return elementos[i];
}
public T [] elem
{
get { return elementos; }
set { elementos = value; }
}



}
}

using System;
using System.Collections.Generic;
using System.Text;

namespace aplicacion_generico_2
{
class Program
{
static void Main(string[] args)
{
int n,i,dato;
Console.Write("Introduce la cantidad de datos : ");
n = int.Parse(Console.ReadLine());
ArregloUni A = new ArregloUni(n);
Console.WriteLine("introduce los siguientes datos ");
for (i = 0; i < n; i++)
{
Console.Write(" Dato {0}:", i + 1);
dato = int.Parse(Console.ReadLine());
A.asignarDato(i, dato);
}
int mayor = A.elem[0];
for (i = 0; i < n; i++)
{
if (A.elem[i] > mayor)
{
mayor = A.elem[i];
}
}
Console.WriteLine(" el dato mayor es {0}", mayor);
Console.ReadKey();
}
}
}