martes, 9 de junio de 2009
lunes, 8 de junio de 2009
Archivos y flujos
Jerarquía de datos
Básicamente, todos los elementos de datos que procesan las computadoras se reducen a combinaciones de ceros y unos. Esto ocurre debido a que es simple y económico el construir dispositivos electrónicos que puedan suponer dos estados estables: un estado representa 0 y el otro, 1. Es increíble que las impresionantes funciones realizadas por las computadotas impliquen solamente las manipulaciones más fundamentales de Os y ls.
El elemento más pequeño de datos que soporta las computadoras es el bit (abreviatura de "dígito binario : un dígito que puede asumir uno de dos valores). Cada elemento de datos, o bit, puede asumir ya sea el valor 0 o 1. Los circuitos de la computadora realizan varias manipulaciones simples de bits, cómo examinar el valor de un bit. establecer el valor de un bit e invertir un bit (de 1 a 0 o de 0 a 1).
Es muy difícil para los programadores trabajar con los datos en el formato de bits de bajo nivel. Es preferible programar con datos en formatos como dígitos decimales (es decir, 0, 1, 2, 3, 4, 5, 6, 7, 8 y 9), letras (es decir, A-Z y a-z) y símbolos especiales (es decir, S, @, %, &, C ), -, +, ", :,?,/ y muchos otros). Los dígitos, las letras y ios símbolos especiales se conocen como caracteres. El conjunto de caracteres de una computadora es el conjunto de todos los caracteres que se utilizan para escribir programas y representar elementos de datos en una computadora específica. Debido a que las computadoras sólo pueden procesar Os y ls, cada carácter en el conjunto de caracteres de una computadora se representa como un patrón de Os y ls. Los bytes están compuestos de ocho bits. C# utiliza el conjunto de caracteres Unicode- (www. uni code. org), en el cual los caracteres están compuestos de 2 bytes. Los programadores crean programas y elementos de datos con los caracteres; las computadoras manipulan y procesan estos caracteres como patrones de bits.
Un campo es un grupo de caracteres que transmiten cierto significado. Por ejemplo, un campo que consiste de letras mayúsculas y minúsculas puede representar el nombre de una persona.
Los elementos de datos procesados por las computadoras forman una jerarquía de datos, en la cual los elementos de datos se hacen más grandes y complejos en estructura, a medida que progresamos de bits a caracteres, de caracteres a campos y de campos hasta llegar a conjuntos de datos más grandes. Por lo general un registro esta compuesto por varios campos relacionados.
Archivos y flujos
C# considera a cada archivo como un flujo secuencial de bytes. Cada archivo termina ya sea con un marcador de fin de archivo, o en un número específico de byte que se registra en una estructura de datos administrativa, mantenida por el sistema. Cuando se abre un archivo, se crea un objeto que se asocia con un flujo. Cuando se ejecuta un programa, el entorno en tiempo de ejecución crea tres objetos flujo, a los cuales se puede acceder mediante las propiedades Console.Out, Console.In y Consolé. Error, respectivamente. Estos objetos facilitan la comunicación entre un programa y un archivo o dispositivo específico. Console.In se refiere al objeto flujo de entrada estándar, el cual permite á un programa introducir datos desde el teclado. Consol e.Out se refiere al objeto flujo de salida estándar, el cual permite a un programa imprimir datos en la pantalla. Console. Error se refiere al objeto flujo de error estándar, el cual permite a un programa imprimir mensajes de error en la pantalla.Console.Out y Console.In en consola; los métodos Write y WriteLine utilizan Console.Out para las operaciones de salida, y los métodos Read y ReadLine de Console utilizan Console. In para las operaciones de entrada.
Las clases File y Directory
La información se almacena en archivos, que se organizan en directorios. Las clases File y Directory permiten a los programas manipular archivos y directorios en el disco. La clase File puede determinar información acerca de los archivos y puede usarse para abrir archivos en modo de lectura o de escritura. En las secciones subsiguientes hablaremos sobre las técnicas para escribir hacia, y leer desde, archivos.
Metodos para acceder a la informacion de archivos y directorios:
AppendText: Devuelve un objeto StreamWriter que adjunta texto a un archivo existente, o crea un archivo si no existe.
Copy: Copia un archivo a un archivo nuevo.
Create: Crea un archivo y devuelve su objeto FileStream asociado.
CreateText: Crea un archivo de texto y devuelve su objeto StreamWriter asociado.
Delete: Elimina el archivo especificado.
Exists: Devuelve true si existe el archivo especificado, y false en caso contrario.
GetCreationTime: Devuelve un objeto DateTime que representa la fecha y hora en la que se creó el archivo.
CetLastAccessTime: Devuelve un objetcrDateTime 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 especificada.
Open: Devuelve un objeto Fi 1 eStream asociado con el archivo especificado y equipado con los permisos de lectura/escritura especificados.
OpenRead:Devuelve un objeto FileStream de sólo lectura, asociado con el archivo especificado.
OpenText: Devuelve un objeto StreamReader asociado con el archivo especificado.
OpenWrite: Devuelve un objeto FileStream de lectura/escritura, asociado con el archivo especificado.
CreateDirectory:Crea un directorio y devuelve su objeto Directorylnfo asociado
Delete:Elimina el directorio especificado.
Exists:Devuelve true si existe el directorio especificado y false en caso contrario.
CetDi rectories:Devuelve un arreglo string que contiene los nombres de los subdirectorios en el directorio especificado.
CetFiles:Devuelve un arreglo string que contiene los nombres de los archivos en el directorio especificado.
CetCreationTime:Devuelve un objeto DateTime que representa la fecha y hora de creación del directorio.
CetLastAccessTime:Devuelve un objeto DateTime que representa la fecha y hora del último acceso al directorio.
CetLastWri teTime: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 especificada.
Creación de un archivo de texto de acceso secuencial
no impone una estructura en los archivos. Por ende, el concepto de un "registro" no existe en los archivos de C#. Esto significa que usted debe estructurar los archivos para cumplir con los requerimientos de sus aplicaciones. En el siguientes ejemplo, se usara texto y caracteres especiales para organizar un propio concepto de un "registro".
El siguientee ejemplo demuestran el procesamiento de archivos en una aplicación de mantenimiento de cuentas bancarias. Estos programas tienen interfaces de usuario similares, por lo que creamos la clase reutilizable Banco-UlForm para encapsular la GUI de una clase base. La clase BancoUIForm contiene cuatro controles Label y cuatro controles TextBox. Los métodos BorrarControlesTextBox, EstablecerValoresControlesTextBox v ObtenerValoresControlesTextBox borran, establecen los valores de, y obtienen los valores del texto en los controles TextBox, respectivamente.
1 // Fig. 18.7: BancoUIForm.cs
2 // Un formulario Windows Form reutilizable para los ejemplos en este capitulo.
3 using System;
4 using System.Windows.Forms; 5
6 public partial class BancoUIForm : Form
7 {
8 protected int CuentaTextBox = 4; // número de controles TextBox en el formulario 9
10 // las constantes de la enumeración especifican los Índices de los controles TextBox
11 public enum IndicesTextBox
12 {
13 CUENTA,
14 NOMBRE,
15 APELLIDO,
16 SALDO
17 } // fin de enum
18
19 // constructor sin parámetros
20 public BancoUIForm()
21 {
22 InitializeComponentO;
23 } // fin del constructor24
25 // borra todos los controles TextBox
26 public void BorrarControlesTextBox()
27 {
28 // itera a través de cada Control en el formulario
29 for ( int i = 0; i < Controls.Count; i++ )
30 {
31 Control miControl = Controls[ i ]; // obtiene el control32
33 // determina si el Control es TextBox
34 if ( miControl is TextBox ) « {
36 // borra la propiedad Text ( la establece a una cadena vacía )
37 miControl.Text = "";
38 } // fin de if
39 } // fin de for
40 } // fin del método BorrarControlesTextBox
41
42 // establece los valores de los controles TextBox con el arreglo string valores
43 public void EstablecerValoresControlesTextBox( stringí] valores )
44 {
45 // determina si el arreglo string tiene la longitud correcta
46 if ( valores.Length != CuentaTextBox )
47 {
48 // lanza excepción si no tiene la longitud correcta throvjf nevé ArgumentException ( "Debe haber " +
50 ( CuentaTextBox + 1 ) + " objetos string en el arreglo" ) );
51 } // fin de if
52 // establece el arreglo valores si el arreglo tiene la longitud correcta
53 else
54 {
55 // establece el arreglo valores con los valores de los controles TextBox
56 CuentaTextBox.Text = valores[ ( int ) IndicesTextBox.CUENTA ]; 57 primerNombreTextBox.Text = valores[ ( int ) IndicesTextBox.NOMBRE ]; 58 apellidoPaternoTextBox.Text ■ valores[ ( int ) IndicesTextBox.APELLIDO ]; 59saldoTextBox.Text = valores[ ( int ) IndicesTextBox.SALDO ];
60 } // fin de else
61 } // fin del método EstablecerValoresControlesTextBox
62
63 // devuelve los valores de los controles TextBox como un arreglo string
64 public stringQ ObtenerValoresControlesTextBoxC)
65 {
66 string[~] valores = new stringl CuentaTextBox ];
67
68 // copia los campos de los controles TextBox al arreglo string
69 valores[ ( int ) IndicesTextBox.CUENTA ] = CuentaTextBox.Text;
70 valores[ ( int ) IndicesTextBox.NOMBRE ] = primerNombreTextBox.Text;
71 valores[ ( 7'nt ) Indi cesTextBox. APELLIDO ] = apellidoPaternoTextBox.Text;
72 valores[ ( int ) IndicesTextBox.SALDO ] = saldoTextBox.Text;
73
74 çreturn valores;
75 } // fin del método ObtenerValoresControlesTextBox
76 }// fin de la clase BankilIForm
Lectura de ciatos desde un archivo de texto de acceso secuencial
En el subtitulo anterioir se demostró cómo crear un archivo para usarlo en aplicaciones con acceso secuencial. En esta parte se verá cómo leer (o recuperar) datos de un archivo en forma secuencial.
Cuando el usuario hace clic en el botón Abrir archivo, el programa llama al manejador de eventos abrir-Button_Click (líneas 20-50). La línea 23 crea un cuadro de diálogo OpenFileDialog, y la línea 24 llama a su método ShowDialog para mostrar el cuadro de diálogo Abrir. El comportamiento y la GUI para los tipos de cuadros de diálogo Guardar y Abrir es idéntico, excepto que Guardar se sustituye por Abrir. Si el usuario introduce un nombre de archivo válido, las líneas 41-42 crean un objeto Filestream y lo asignan a la referencia de entrada.
1 // Fig. 18.11: LeerArchivoAcceso5ecuencialForm.es
2 // Lectura de un archivo de acceso secuencial.
3 using System;
4 using System.Windows.Forms;
5 using System.10;
6 using BibliotecaBanco;
7
8 public partial class LeerArchivoAccesoSecuencialForm : BancoUIForm
9 {
10 private FileStream entrada; // mantiene la conexión a un archivo
11 private StreamReader archivoReader; // 7ee datos de un archivo de texto
12
13 // constructor sin parámetros
14 publ ic LeerArchi voAccesoSecuenci al FormO
15 {
16 InitializeComponentO ;
17 } // fin del constructor
18
19 // se invoca cuando el usuario hace clic en el botón Abrir
20 private void abrirButton_Click( object sender, EventArgs e )
21 {
22 // crea un cuadro de diálogo que permite al usuario abrir el archivo
23 OpenFileDialog selectorArchivo = new OpenFileDialog();
24 DialogResult resultado = selectorArchivo.ShowDialogO ;
25 string nombreArchivo; // nombre del archivo que contiene los datos
26
27 // sale del manejador de eventos si el usuario hace clic en Cancelar
28 if ( resultado == DialogResult.Cancel )
29 return;
30
31 nombreArchivo = selectorArchivo.FileName; //obtiene el nombre de archivoespecificado
32 BorrarControlesTextBoxO ;
33
34 // muestra error si el usuario especifica un archivo inválido
35 if ( nombreArchivo == "" nombreArchivo == nuil )
36 MessageBox.Show( "Nombre de archivo inválido", "Error",
37 MessageBoxButtons.OK, MessageBoxIcon.Error );
38 e7se
39 {
40 // crea objeto FileStream para obtener acceso de lectura al archivo
41 entrada = new FileStream( nombreArchivo, FileMode.Open,
42 FileAccess.Read );
43
44 // establece el archivo del que se van a leer los datos
45 archivoReader = new StreamReader( entrada );
46
47 abrirButton.Enabled = fa7se; // deshabilita el botón Abrir archivo
48 siguienteButton.Enabled = true; // habilita el botón Siguiente registro
49 } // fin de el se
50 } // fin del método abrirButton_Click
51
52 // se invoca cuando el usuario hace clic en el botón Siguiente
53 private void siguienteButton_Click( object sender, EventArgs e )
54 {
55 try
56 {
57 // obtiene el siguiente registro disponible en el archivo
58 string regi stroEntrada = archi voReader. ReadLineO ;
59 stringQ camposEntrada; // almacena piezas individuales de datos 60
61 if ( registroEntrada != nuil )
62 {
63 camposEntrada = registrcEntrada.SplitC ',' );
64
65 Registro registro = new RegistroC
66 Convert.ToInt32( camposEntrada[ 0 ] ), camposEntrada[ 1 ],
67 camposEntrada[ 2 ], Convert.ToDecimal( camposEntrada[ 3 ] ) );
68
69 // copia los valores del arreglo string a los valores de los controles
TextBox
70 EstablecerValoresControlesTextBox( camposEntrada );
71 } // fin de if
72 e7se
73 {
74 archivoReader .CloseO; // cierra StreamReader
75 entrada.Close(); // cierra FileStream si no hay registros en el archivo
76 abrirButton.Enabled = true; // habilita el botón Abrir archivo
77 siguienteButton.Enabled = false; // deshabilita el botón Siguiente registro
78 BorrarControlesTextBoxC);
80 // notifica al usuario si no hay registros en el archivo
81 MessageBox.Show( "No hay más registros en el archivo", '"
82 MessageBoxButtons.OK, MessageBoxIcon.Information );
83 } // fin de el se
84 } // fin de try
85 catch ( IOException )
86 {
87 MessageBox.Show( "Error al leer del archivo", "Error"
88 MessageBoxButtons.CK, MessageBoxIcon.Error );
89 } // fin de catch
90 } // fin del método siguienteButton_Click
91 } // fin de 7a clase LeerArchivoAccesoSecuencialForm
Señalización
En un subtitulo anterior creacion de un archivo se demostró cómo escribir los campos individuales de un objeto Registro en un archivo de texto, y la sección siguiente lectura de datos se demostró cómo leer esos campos de un archivo y colocar sus valores en un objeto Regi stro en memoria. En los ejemplos. Registro se utilizó para juntar la información para un solo registro. Cuando las variables de instancia para un Regi stro se enviaron a un archivo en disco, se perdió cierta información como el tipo de cada valor. Por ejemplo, si se lee el valor "3" de un archivo, no hay forma de saber si el valor proviene de un int, de un string o de un decimal. Sólo tenemos datos en el disco, no información sobre el tipo. Si el programa que va a leer estos datos "sabe" a qué tipo de objeto corresponden los datos, entonces pueden leerse directamente en objetos de ese tipo. Por ejemplo, si sabemos que introduciremos un int (el número de cuenta), seguido de dos objetos stri ng (el primer nombre y el apellido paterno) y un decimal (el saldo). También sabemos que estos valores están separados por comas, y sólo hay un registro en cada línea. Por lo tanto, podemos analizar los objetos string y convertir el número de cuenta en ún int y el balance en un decimal. Algunas veces sería más sencillo leer o escribir objetos completos. C# cuenta con un mecanismo así, al cual se le conoce como señalización de objetos. Un objeto serializíido se representa como una secuencia de bytes que incluye los datos de ese objeto, así como información acerca del tipo del objeto y los tipos de los datos almacenados en ese objeto. Una vez que se escribe un objeto serializado en un archivo, puede leerse desde ese archivo y deserializarse, esto es, la información sobre el tipo v los bytes que representan al objeto y sus datos pueden usarse para recrear al objeto en la memoria.
Creación de un archivo de acceso secuencialmediante el uso de la serialización de objetos
Se empieza por crear y escribir objetos serializados en un archivo de acceso secuencial. Definición de la clase RegistroSerial izable
En una clase marcada con el atributo [Seri al i zabl e] o que implementa la interfaz ISeri al izable, debemos asegurarnos que toda variable de instancia de la clase también sea serializable. Todas las variables de .tipos simples y los objetos string son serializables. Para las variables de tipos por referencia, hay que comprobar la declaración de la clase (y posiblemente sus clases basel para asegurarnos que el tipo sea serializable. Los objetos tipo arreglo son serializables de manera predeterminada. No obstante, si el arreglo contiene referencias a otros objetos, esos objetos podrían o no ser serializables.
Bibliografia:
Cómo Programar En C# 2a Edición
Harvey M. Deitel Y Paul J. Deitel (Pearson Educación)
ISBN: 9702610567. ISBN-13: 9789702610564(2007).
Básicamente, todos los elementos de datos que procesan las computadoras se reducen a combinaciones de ceros y unos. Esto ocurre debido a que es simple y económico el construir dispositivos electrónicos que puedan suponer dos estados estables: un estado representa 0 y el otro, 1. Es increíble que las impresionantes funciones realizadas por las computadotas impliquen solamente las manipulaciones más fundamentales de Os y ls.
El elemento más pequeño de datos que soporta las computadoras es el bit (abreviatura de "dígito binario : un dígito que puede asumir uno de dos valores). Cada elemento de datos, o bit, puede asumir ya sea el valor 0 o 1. Los circuitos de la computadora realizan varias manipulaciones simples de bits, cómo examinar el valor de un bit. establecer el valor de un bit e invertir un bit (de 1 a 0 o de 0 a 1).
Es muy difícil para los programadores trabajar con los datos en el formato de bits de bajo nivel. Es preferible programar con datos en formatos como dígitos decimales (es decir, 0, 1, 2, 3, 4, 5, 6, 7, 8 y 9), letras (es decir, A-Z y a-z) y símbolos especiales (es decir, S, @, %, &, C ), -, +, ", :,?,/ y muchos otros). Los dígitos, las letras y ios símbolos especiales se conocen como caracteres. El conjunto de caracteres de una computadora es el conjunto de todos los caracteres que se utilizan para escribir programas y representar elementos de datos en una computadora específica. Debido a que las computadoras sólo pueden procesar Os y ls, cada carácter en el conjunto de caracteres de una computadora se representa como un patrón de Os y ls. Los bytes están compuestos de ocho bits. C# utiliza el conjunto de caracteres Unicode- (www. uni code. org), en el cual los caracteres están compuestos de 2 bytes. Los programadores crean programas y elementos de datos con los caracteres; las computadoras manipulan y procesan estos caracteres como patrones de bits.
Un campo es un grupo de caracteres que transmiten cierto significado. Por ejemplo, un campo que consiste de letras mayúsculas y minúsculas puede representar el nombre de una persona.
Los elementos de datos procesados por las computadoras forman una jerarquía de datos, en la cual los elementos de datos se hacen más grandes y complejos en estructura, a medida que progresamos de bits a caracteres, de caracteres a campos y de campos hasta llegar a conjuntos de datos más grandes. Por lo general un registro esta compuesto por varios campos relacionados.
Archivos y flujos
C# considera a cada archivo como un flujo secuencial de bytes. Cada archivo termina ya sea con un marcador de fin de archivo, o en un número específico de byte que se registra en una estructura de datos administrativa, mantenida por el sistema. Cuando se abre un archivo, se crea un objeto que se asocia con un flujo. Cuando se ejecuta un programa, el entorno en tiempo de ejecución crea tres objetos flujo, a los cuales se puede acceder mediante las propiedades Console.Out, Console.In y Consolé. Error, respectivamente. Estos objetos facilitan la comunicación entre un programa y un archivo o dispositivo específico. Console.In se refiere al objeto flujo de entrada estándar, el cual permite á un programa introducir datos desde el teclado. Consol e.Out se refiere al objeto flujo de salida estándar, el cual permite a un programa imprimir datos en la pantalla. Console. Error se refiere al objeto flujo de error estándar, el cual permite a un programa imprimir mensajes de error en la pantalla.Console.Out y Console.In en consola; los métodos Write y WriteLine utilizan Console.Out para las operaciones de salida, y los métodos Read y ReadLine de Console utilizan Console. In para las operaciones de entrada.
Las clases File y Directory
La información se almacena en archivos, que se organizan en directorios. Las clases File y Directory permiten a los programas manipular archivos y directorios en el disco. La clase File puede determinar información acerca de los archivos y puede usarse para abrir archivos en modo de lectura o de escritura. En las secciones subsiguientes hablaremos sobre las técnicas para escribir hacia, y leer desde, archivos.
Metodos para acceder a la informacion de archivos y directorios:
AppendText: Devuelve un objeto StreamWriter que adjunta texto a un archivo existente, o crea un archivo si no existe.
Copy: Copia un archivo a un archivo nuevo.
Create: Crea un archivo y devuelve su objeto FileStream asociado.
CreateText: Crea un archivo de texto y devuelve su objeto StreamWriter asociado.
Delete: Elimina el archivo especificado.
Exists: Devuelve true si existe el archivo especificado, y false en caso contrario.
GetCreationTime: Devuelve un objeto DateTime que representa la fecha y hora en la que se creó el archivo.
CetLastAccessTime: Devuelve un objetcrDateTime 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 especificada.
Open: Devuelve un objeto Fi 1 eStream asociado con el archivo especificado y equipado con los permisos de lectura/escritura especificados.
OpenRead:Devuelve un objeto FileStream de sólo lectura, asociado con el archivo especificado.
OpenText: Devuelve un objeto StreamReader asociado con el archivo especificado.
OpenWrite: Devuelve un objeto FileStream de lectura/escritura, asociado con el archivo especificado.
CreateDirectory:Crea un directorio y devuelve su objeto Directorylnfo asociado
Delete:Elimina el directorio especificado.
Exists:Devuelve true si existe el directorio especificado y false en caso contrario.
CetDi rectories:Devuelve un arreglo string que contiene los nombres de los subdirectorios en el directorio especificado.
CetFiles:Devuelve un arreglo string que contiene los nombres de los archivos en el directorio especificado.
CetCreationTime:Devuelve un objeto DateTime que representa la fecha y hora de creación del directorio.
CetLastAccessTime:Devuelve un objeto DateTime que representa la fecha y hora del último acceso al directorio.
CetLastWri teTime: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 especificada.
Creación de un archivo de texto de acceso secuencial
no impone una estructura en los archivos. Por ende, el concepto de un "registro" no existe en los archivos de C#. Esto significa que usted debe estructurar los archivos para cumplir con los requerimientos de sus aplicaciones. En el siguientes ejemplo, se usara texto y caracteres especiales para organizar un propio concepto de un "registro".
El siguientee ejemplo demuestran el procesamiento de archivos en una aplicación de mantenimiento de cuentas bancarias. Estos programas tienen interfaces de usuario similares, por lo que creamos la clase reutilizable Banco-UlForm para encapsular la GUI de una clase base. La clase BancoUIForm contiene cuatro controles Label y cuatro controles TextBox. Los métodos BorrarControlesTextBox, EstablecerValoresControlesTextBox v ObtenerValoresControlesTextBox borran, establecen los valores de, y obtienen los valores del texto en los controles TextBox, respectivamente.
1 // Fig. 18.7: BancoUIForm.cs
2 // Un formulario Windows Form reutilizable para los ejemplos en este capitulo.
3 using System;
4 using System.Windows.Forms; 5
6 public partial class BancoUIForm : Form
7 {
8 protected int CuentaTextBox = 4; // número de controles TextBox en el formulario 9
10 // las constantes de la enumeración especifican los Índices de los controles TextBox
11 public enum IndicesTextBox
12 {
13 CUENTA,
14 NOMBRE,
15 APELLIDO,
16 SALDO
17 } // fin de enum
18
19 // constructor sin parámetros
20 public BancoUIForm()
21 {
22 InitializeComponentO;
23 } // fin del constructor24
25 // borra todos los controles TextBox
26 public void BorrarControlesTextBox()
27 {
28 // itera a través de cada Control en el formulario
29 for ( int i = 0; i < Controls.Count; i++ )
30 {
31 Control miControl = Controls[ i ]; // obtiene el control32
33 // determina si el Control es TextBox
34 if ( miControl is TextBox ) « {
36 // borra la propiedad Text ( la establece a una cadena vacía )
37 miControl.Text = "";
38 } // fin de if
39 } // fin de for
40 } // fin del método BorrarControlesTextBox
41
42 // establece los valores de los controles TextBox con el arreglo string valores
43 public void EstablecerValoresControlesTextBox( stringí] valores )
44 {
45 // determina si el arreglo string tiene la longitud correcta
46 if ( valores.Length != CuentaTextBox )
47 {
48 // lanza excepción si no tiene la longitud correcta throvjf nevé ArgumentException ( "Debe haber " +
50 ( CuentaTextBox + 1 ) + " objetos string en el arreglo" ) );
51 } // fin de if
52 // establece el arreglo valores si el arreglo tiene la longitud correcta
53 else
54 {
55 // establece el arreglo valores con los valores de los controles TextBox
56 CuentaTextBox.Text = valores[ ( int ) IndicesTextBox.CUENTA ]; 57 primerNombreTextBox.Text = valores[ ( int ) IndicesTextBox.NOMBRE ]; 58 apellidoPaternoTextBox.Text ■ valores[ ( int ) IndicesTextBox.APELLIDO ]; 59saldoTextBox.Text = valores[ ( int ) IndicesTextBox.SALDO ];
60 } // fin de else
61 } // fin del método EstablecerValoresControlesTextBox
62
63 // devuelve los valores de los controles TextBox como un arreglo string
64 public stringQ ObtenerValoresControlesTextBoxC)
65 {
66 string[~] valores = new stringl CuentaTextBox ];
67
68 // copia los campos de los controles TextBox al arreglo string
69 valores[ ( int ) IndicesTextBox.CUENTA ] = CuentaTextBox.Text;
70 valores[ ( int ) IndicesTextBox.NOMBRE ] = primerNombreTextBox.Text;
71 valores[ ( 7'nt ) Indi cesTextBox. APELLIDO ] = apellidoPaternoTextBox.Text;
72 valores[ ( int ) IndicesTextBox.SALDO ] = saldoTextBox.Text;
73
74 çreturn valores;
75 } // fin del método ObtenerValoresControlesTextBox
76 }// fin de la clase BankilIForm
Lectura de ciatos desde un archivo de texto de acceso secuencial
En el subtitulo anterioir se demostró cómo crear un archivo para usarlo en aplicaciones con acceso secuencial. En esta parte se verá cómo leer (o recuperar) datos de un archivo en forma secuencial.
Cuando el usuario hace clic en el botón Abrir archivo, el programa llama al manejador de eventos abrir-Button_Click (líneas 20-50). La línea 23 crea un cuadro de diálogo OpenFileDialog, y la línea 24 llama a su método ShowDialog para mostrar el cuadro de diálogo Abrir. El comportamiento y la GUI para los tipos de cuadros de diálogo Guardar y Abrir es idéntico, excepto que Guardar se sustituye por Abrir. Si el usuario introduce un nombre de archivo válido, las líneas 41-42 crean un objeto Filestream y lo asignan a la referencia de entrada.
1 // Fig. 18.11: LeerArchivoAcceso5ecuencialForm.es
2 // Lectura de un archivo de acceso secuencial.
3 using System;
4 using System.Windows.Forms;
5 using System.10;
6 using BibliotecaBanco;
7
8 public partial class LeerArchivoAccesoSecuencialForm : BancoUIForm
9 {
10 private FileStream entrada; // mantiene la conexión a un archivo
11 private StreamReader archivoReader; // 7ee datos de un archivo de texto
12
13 // constructor sin parámetros
14 publ ic LeerArchi voAccesoSecuenci al FormO
15 {
16 InitializeComponentO ;
17 } // fin del constructor
18
19 // se invoca cuando el usuario hace clic en el botón Abrir
20 private void abrirButton_Click( object sender, EventArgs e )
21 {
22 // crea un cuadro de diálogo que permite al usuario abrir el archivo
23 OpenFileDialog selectorArchivo = new OpenFileDialog();
24 DialogResult resultado = selectorArchivo.ShowDialogO ;
25 string nombreArchivo; // nombre del archivo que contiene los datos
26
27 // sale del manejador de eventos si el usuario hace clic en Cancelar
28 if ( resultado == DialogResult.Cancel )
29 return;
30
31 nombreArchivo = selectorArchivo.FileName; //obtiene el nombre de archivoespecificado
32 BorrarControlesTextBoxO ;
33
34 // muestra error si el usuario especifica un archivo inválido
35 if ( nombreArchivo == "" nombreArchivo == nuil )
36 MessageBox.Show( "Nombre de archivo inválido", "Error",
37 MessageBoxButtons.OK, MessageBoxIcon.Error );
38 e7se
39 {
40 // crea objeto FileStream para obtener acceso de lectura al archivo
41 entrada = new FileStream( nombreArchivo, FileMode.Open,
42 FileAccess.Read );
43
44 // establece el archivo del que se van a leer los datos
45 archivoReader = new StreamReader( entrada );
46
47 abrirButton.Enabled = fa7se; // deshabilita el botón Abrir archivo
48 siguienteButton.Enabled = true; // habilita el botón Siguiente registro
49 } // fin de el se
50 } // fin del método abrirButton_Click
51
52 // se invoca cuando el usuario hace clic en el botón Siguiente
53 private void siguienteButton_Click( object sender, EventArgs e )
54 {
55 try
56 {
57 // obtiene el siguiente registro disponible en el archivo
58 string regi stroEntrada = archi voReader. ReadLineO ;
59 stringQ camposEntrada; // almacena piezas individuales de datos 60
61 if ( registroEntrada != nuil )
62 {
63 camposEntrada = registrcEntrada.SplitC ',' );
64
65 Registro registro = new RegistroC
66 Convert.ToInt32( camposEntrada[ 0 ] ), camposEntrada[ 1 ],
67 camposEntrada[ 2 ], Convert.ToDecimal( camposEntrada[ 3 ] ) );
68
69 // copia los valores del arreglo string a los valores de los controles
TextBox
70 EstablecerValoresControlesTextBox( camposEntrada );
71 } // fin de if
72 e7se
73 {
74 archivoReader .CloseO; // cierra StreamReader
75 entrada.Close(); // cierra FileStream si no hay registros en el archivo
76 abrirButton.Enabled = true; // habilita el botón Abrir archivo
77 siguienteButton.Enabled = false; // deshabilita el botón Siguiente registro
78 BorrarControlesTextBoxC);
80 // notifica al usuario si no hay registros en el archivo
81 MessageBox.Show( "No hay más registros en el archivo", '"
82 MessageBoxButtons.OK, MessageBoxIcon.Information );
83 } // fin de el se
84 } // fin de try
85 catch ( IOException )
86 {
87 MessageBox.Show( "Error al leer del archivo", "Error"
88 MessageBoxButtons.CK, MessageBoxIcon.Error );
89 } // fin de catch
90 } // fin del método siguienteButton_Click
91 } // fin de 7a clase LeerArchivoAccesoSecuencialForm
Señalización
En un subtitulo anterior creacion de un archivo se demostró cómo escribir los campos individuales de un objeto Registro en un archivo de texto, y la sección siguiente lectura de datos se demostró cómo leer esos campos de un archivo y colocar sus valores en un objeto Regi stro en memoria. En los ejemplos. Registro se utilizó para juntar la información para un solo registro. Cuando las variables de instancia para un Regi stro se enviaron a un archivo en disco, se perdió cierta información como el tipo de cada valor. Por ejemplo, si se lee el valor "3" de un archivo, no hay forma de saber si el valor proviene de un int, de un string o de un decimal. Sólo tenemos datos en el disco, no información sobre el tipo. Si el programa que va a leer estos datos "sabe" a qué tipo de objeto corresponden los datos, entonces pueden leerse directamente en objetos de ese tipo. Por ejemplo, si sabemos que introduciremos un int (el número de cuenta), seguido de dos objetos stri ng (el primer nombre y el apellido paterno) y un decimal (el saldo). También sabemos que estos valores están separados por comas, y sólo hay un registro en cada línea. Por lo tanto, podemos analizar los objetos string y convertir el número de cuenta en ún int y el balance en un decimal. Algunas veces sería más sencillo leer o escribir objetos completos. C# cuenta con un mecanismo así, al cual se le conoce como señalización de objetos. Un objeto serializíido se representa como una secuencia de bytes que incluye los datos de ese objeto, así como información acerca del tipo del objeto y los tipos de los datos almacenados en ese objeto. Una vez que se escribe un objeto serializado en un archivo, puede leerse desde ese archivo y deserializarse, esto es, la información sobre el tipo v los bytes que representan al objeto y sus datos pueden usarse para recrear al objeto en la memoria.
Creación de un archivo de acceso secuencialmediante el uso de la serialización de objetos
Se empieza por crear y escribir objetos serializados en un archivo de acceso secuencial. Definición de la clase RegistroSerial izable
En una clase marcada con el atributo [Seri al i zabl e] o que implementa la interfaz ISeri al izable, debemos asegurarnos que toda variable de instancia de la clase también sea serializable. Todas las variables de .tipos simples y los objetos string son serializables. Para las variables de tipos por referencia, hay que comprobar la declaración de la clase (y posiblemente sus clases basel para asegurarnos que el tipo sea serializable. Los objetos tipo arreglo son serializables de manera predeterminada. No obstante, si el arreglo contiene referencias a otros objetos, esos objetos podrían o no ser serializables.
Bibliografia:
Cómo Programar En C# 2a Edición
Harvey M. Deitel Y Paul J. Deitel (Pearson Educación)
ISBN: 9702610567. ISBN-13: 9789702610564(2007).
domingo, 31 de mayo de 2009
Flujos en C#
Programación nos permite manipular datos realizar infinidad de operaciones con ellos pero algo muy importante es el permitirnos almacenar datos...
Un archivo es una colección de datos guardados en un dispositivo de almacenamiento permanente.
Aunque C# ve a los archivos como un flujo de bytes, es conveniente concebirlos como un conjunto de registros que poseen una marca de fin de archivo (eof ).
La información de un archivo se organiza en registros, los registros en campos, los campos en bytes, y los bytes en bits.
Flujos de E/S
Para que un programa pueda manejar un archivo en un dispositivo de almacenamiento permanente, como por ejemplo un disco, primero debe crearse un flujo. Un flujo es como un conducto a través del cual se transportarán los datos hacia o desde el dispositivo de almacenamiento. Los datos fluirán entre la memoria RAM de la computadora y el dispositivo de almacenamiento.
Si los datos van a enviarse desde la memoria hacia el disco , se trata de un flujo de SALIDA ( Output, en Inglés); si los datos van a enviarse desde el disco hacia la memoria , el flujo es de ENTRADA (Input, en Inglés).
A las operaciones de ENTRADA se les conoce como de LECTURA (Read, en Inglés); a las de SALIDA se les conoce como de ESCRITURA (Write, en Inglés).
En la siguiente figura se esquematiza la relación existente entre los dispositivos de Entrada/Salida y los flujos.
Tipos de archivos.
Dependiendo del tipo de datos que manejan en sus registros, los archivos se clasifican en archivos de texto y archivos binarios.
Archivos de texto.
Los datos en los archivos de texto se graban como secuencias de bytes . Por ejemplo, el dato 123456 se graba como una secuencia de 6 bytes y no como un entero, por lo que no pueden realizarse operaciones matemáticas con él.
El manejo de archivos de texto se puede llevar a cabo por medio de dos tipos de flujos: de bytes y de caracteres.
Archivos binarios.
Cuando se requiere efectuar operaciones con datos de alguno de los tipos primitivos (bool, byte, double, float, int, long, short, etc.), tales datos deberán escribirse y leerse en formato binario.
Las operaciones básicas en archivos son:
Creación
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:
"C: \\ POOISC \\ ARCHIVOS \\ archivo.txt"
o su forma equivalente:
@ "C: \ POOISC \ ARCHIVOS \ archivo.txt"
modo es un valor del tipo enumerado FileMode ; puede tomar uno de los siguientes valores:
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:
Read
Permite leer un archivo.
ReadWrite
Permite leer o escribir en el archivo.
Write
permite escribir en el archivo.
Ejemplo:
// CEscribirBytes.cs
using System;
using System.IO;
public class CEscribirBytes
{
public static void Main ( ) {
FileStream fs = null;byte[] buffer = new byte[81];int nbytes = 0, car;
try{
// Crea un flujo hacia el archivo texto.txt
fs = new FileStream("texto.txt",FileMode.Create, FileAccess.Write);
Console.WriteLine("Escriba el texto que desea almacenar en el archivo:");
while ((car = Console.Read()) != '\r' && (nbytes < buffer.Length)) {
buffer[nbytes] = (byte)car;nbytes++;
}
// Escribe la línea de texto en el archivo.
fs.Write(buffer, 0, nbytes);
}
catch(IOException e){
Console.WriteLine("Error: " + e.Message);
}
finally{
if (fs != null) fs.Close();
}
}
}
Archivos de Texto con Flujos de Caracteres.
En este caso los datos se manejan por medio de flujos de caracteres, utilizando las clases StreamWriter y StreamReader.
Escritura.
StreamWriter es una clase derivada de TextWriter.
Sus constructores son:
StreamWriter (string nombre ) // Abre un nuevo flujo para escribir en un
// archivo especificado por nombre .
StreamWriter (Stream flujo ) // Utiliza un flujo existente para escribir.
Antes de ser escritos, los datos son convertidos automáticamente a un formato portable de 8 bits (UTF-8, UCS Transformation Format 8).
Los objetos de la clase StreamWriter poseen varios métodos, entre los que destacan:
Write( ) ,WriteLine( ) y Flush( ) .
Además, poseen la propiedad BaseStream .
Ejemplo:
// CEscribirCars.cs
using System;using System.IO;
public class CEscribirCars{
public static void Main ( ){
StreamWriter sw = null;String str;
try{
// Crea un flujo hacia el archivo doc.txt// Si el archivo existe se destruye su contenido. sw = new StreamWriter("doc.txt");
Console.WriteLine("Escriba las líneas de texto aalmacenar 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íawhile (str.Length != 0){
// Escribe la línea leída en el archivo
sw.WriteLine(str);
// Lee la línea siguiente
str = Console.ReadLine();
}
}
catch(IOException e){
Console.WriteLine("Error: " + e.Message);
}
finally{
if (sw != null) sw.Close();
}
}
}
Lectura
StreamReader es una clase derivada de TextReader y cuenta con los siguientes constructores:
StreamReader (string nombre ) abre un nuevo flujo para leer de unarchivo especificado por nombre.
StreamReader (Stream flujo ) utiliza un flujo existente para leer.
Algunos de los métodos más importantes de la clase StreamReader son:
Read( ) ,ReadLine( ) , Peek( ) y DiscardBufferData( ) .
Ejemplo:
// 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.txtsr = new StreamReader("doc.txt");
// Lee del archivo una línea de texto
str = sr.ReadLine();
// Mientras la cadena str no esté vacíawhile (str != null){
// Muestra la línea leídaConsole.WriteLine(str);
// Lee la línea siguiente
str = sr.ReadLine();
}
}
catch(IOException e){
Console.WriteLine("Error: " + e.Message);
}
finally{
// Cierra el archivoif (sr != null) sr.Close();
}
}
}
Archivos Binarios
Cuando se requiere efectuar operaciones con datos de alguno de los tipos primitivos, tales datos deberán escribirse y leerse en formato binario.
El espacio de nombres System.IO proporciona las clases:
BinaryWriter y BinaryReader.
Con estas clases se podrán manipular datos de los tipos primitivos y cadenas de caracteres en formato UTF-8.
Los archivos escritos en formato binario no se pueden desplegar directamente en los dispositivos de salida estándar, como el monitor, sino que deben leerse a través de flujos de la clase BinaryReader.
BinaryWriter crea flujos para escribir archivos con datos de los tipos primitivos en formato binario.
Su constructor es:
BinaryWriter ( Stream flujo )
y requiere, como parámetro, un flujo de la clase Stream o sus derivadas.
Ejemplo:
FileStream fs =new FileStream("datos.dat",FileMode. Create ,FileAccess. Write );
BinaryWriter bw=new BinaryWriter( fs );
Un objeto de la clase BinaryWriter actúa como filtro entre el programa y un flujo de la clase FileStream.
En la siguiente tabla se describen algunos de los principales métodos y propiedades de la clase BinaryWriter :
Write(byte)
Escribe un valor de tipo byte.
Write(byte[])
Escribe una cadena como una secuencia de bytes.
Write(char)
Escribe un valor de tipo char.
Write(char[])
Escribe una cadena como una secuencia de caracteres.
Write(short)
Escribe un valor de tipo short.
Write(int)
Escribe un valor de tipo int.
Write(long)
Escribe un valor de tipo long.
Write(Decimal)
Escribe un valor de tipo Decimal.
Write(float)
Escribe un valor de tipo float.
Write(double)
Escribe un valor de tipo double.
Write(string)
Escribe una cadena de caracteres en formato UTF-8.El primero o los dos primeros bytes especifican el número de bytes de datos escritos en la cadena.
BaseStream
Obtiene el flujo base ( fs en el ejemplo mostrado).
Close
Cierra el flujo y libera los recursos adquiridos.
Flush
Limpia el buffer asociado con el flujo.
Seek
Establece el apuntador de Lectura/Escritura en el flujo.
BinaryReader crea flujos para leer archivos con datos de los tipos primitivos en formato binario, escritos por un flujo de la clase Binaryreader.
Su constructor es:
BinaryReader ( Stream flujo )
y requiere, como parámetro, un flujo de la clase Stream o sus derivadas.
Ejemplo:
FileStream fs =new FileStream("datos.dat",FileMode. Open ,FileAccess. Read );
BinaryReader br=new BinaryReader( fs );
Un objeto de la clase BinaryReader actúa como filtro entre un flujo de la clase FileStream y el programa.
En la siguiente tabla se describen algunos de los principales métodos y propiedades de la clase BinaryReader :
Read(byte)
Devuelve un valor de tipo byte.
Read (byte[])
Devuelve una cadena como una secuencia de bytes.
Read (char)
Devuelve un valor de tipo char.
Read (char[])
Devuelve una cadena como una secuencia de caracteres.
Read (short)
Devuelve un valor de tipo short.
Read (int)
Devuelve un valor de tipo int.
Read (long)
Devuelve un valor de tipo long.
Read (Decimal)
Devuelve un valor de tipo Decimal.
Read (float)
Devuelve un valor de tipo float.
Read (double)
Devuelve un valor de tipo double.
Read (string)
Devuelve una cadena de caracteres en formato UTF-8. El primero o los dos primeros bytes especifican el número de bytes de datos que serán leídos.
BaseStream
Obtiene el flujo base ( fs en el ejemplo mostrado).
Close
Cierra el flujo y libera los recursos adquiridos.
Flush
Limpia el buffer asociado con el flujo.
PeekChar
Obtiene el siguiente carácter, sin extraerlo.
Acceso Aleatorio.
Cuando se abre un archivo, se puede acceder a sus registros de manera secuencial o de manera aleatoria .
El acceso aleatorio consiste en posicionar el apuntador de archivo en una localidad específica del archivo. Este tipo de acceso es necesario cuando se requiere modificar alguno de los campos de un registro. En lugar de leer desde el primero hasta el registro elegido, el apuntador se posiciona ,en una especie de salto, hasta dicho registro.
El salto se hace con base al conteo de los bytes existentes entre una posición inicial y el primer byte del registro elegido.
Para el acceso aleatorio a los registros de un archivo, la clase FileStream implementa las propiedades Position y Length , así como el método Seek( )
Position devuelve la posición actual, en bytes, del apuntador de archivo .
El apuntador de archivo marca el byte donde se hará la siguiente operación de lectura o de escritura.
La declaración de la propiedad Position es:
public long Position ;
La propiedad Length devuelve la longitud del archivo en bytes. Está declarada así:
public long Length ;
El método Seek( ) mueve el apuntador de archivo a una ubicación localizada desp bytes, a partir de la posición pos del archivo.
La sintaxis para Seek( ) es:
public long Seek( long desp , SeekOrigin pos )
El desplazamiento desp puede ser positivo o negativo.
La posición pos puede tomar uno de los siguientes valores del tipo enumerado SetOrigin .
Begin ........ El inicio del archivo.
Current ..... Posición actual del apuntador de archivo.
End ........... El final del archivo.
Ejemplos:
1 .- Suponiendo un flujo fs de la clase FileStream .
fs.Seek( desp , SeekOrigin. Begin );
fs.Seek( desp , SeekOrigin. Current );
fs.Seek( -desp , SeekOrigin. End );
El valor almacenado en desp debe calcularse en base al tamaño de registro del archivo.
2 .- Suponiendo un flujo br de la clase BinaryReader .
FileStream fs = new FileStream("datos", FileMode.Open,
FileAccess.Read);
BinaryReader br = new BinaryReader( fs );
Debido a que el flujo br no soporta directamente el método Seek( ) , tiene que acceder a él a través de su propiedad BaseStream , como se muestra a continuación:
br. BaseStream.Seek (desp, SeekOrigin.Current);
Para facilitar el cálculo del desplazamiento desp , es conveniente que todos los registros tengan la misma longitud.
El desplazamiento para acceder al tercer registro se calcula de la siguiente manera:
desp = Numero de registro * tamaño de registro
desp = 2*100
Es difícil recordar el número de registro al que se necesita acceder, por lo que se hace necesario establecer una relación entre el número de registro y el valor almacenado en alguno de los campos del registro.
Por ejemplo, si cada registro tiene un campo denominado clave , de tipo entero en el rango de 1 a N (que corresponde al número de control de un empleado), la relación entre la clave y el número de registro es:
número de registro = clave -1
Así, el calculo del desplazamiento para el empleado con la clave 4 se efectúa de la siguiente manera :
desp = (4-1) * 100 = 300
Esto obliga a que, cuando se introduzcan los datos de un nuevo empleado , el número de su clave deba ser igual al número de registro +1 .
El número de registro que sigue es igual al número de registros existentes.
Bibliografia: Ceballos, Francisco Javier / sistemas.itlp.edu.mx (pagina del Tec. de la Paz).
Un archivo es una colección de datos guardados en un dispositivo de almacenamiento permanente.
Aunque C# ve a los archivos como un flujo de bytes, es conveniente concebirlos como un conjunto de registros que poseen una marca de fin de archivo (eof ).
La información de un archivo se organiza en registros, los registros en campos, los campos en bytes, y los bytes en bits.
Flujos de E/S
Para que un programa pueda manejar un archivo en un dispositivo de almacenamiento permanente, como por ejemplo un disco, primero debe crearse un flujo. Un flujo es como un conducto a través del cual se transportarán los datos hacia o desde el dispositivo de almacenamiento. Los datos fluirán entre la memoria RAM de la computadora y el dispositivo de almacenamiento.
Si los datos van a enviarse desde la memoria hacia el disco , se trata de un flujo de SALIDA ( Output, en Inglés); si los datos van a enviarse desde el disco hacia la memoria , el flujo es de ENTRADA (Input, en Inglés).
A las operaciones de ENTRADA se les conoce como de LECTURA (Read, en Inglés); a las de SALIDA se les conoce como de ESCRITURA (Write, en Inglés).
En la siguiente figura se esquematiza la relación existente entre los dispositivos de Entrada/Salida y los flujos.
Tipos de archivos.
Dependiendo del tipo de datos que manejan en sus registros, los archivos se clasifican en archivos de texto y archivos binarios.
Archivos de texto.
Los datos en los archivos de texto se graban como secuencias de bytes . Por ejemplo, el dato 123456 se graba como una secuencia de 6 bytes y no como un entero, por lo que no pueden realizarse operaciones matemáticas con él.
El manejo de archivos de texto se puede llevar a cabo por medio de dos tipos de flujos: de bytes y de caracteres.
Archivos binarios.
Cuando se requiere efectuar operaciones con datos de alguno de los tipos primitivos (bool, byte, double, float, int, long, short, etc.), tales datos deberán escribirse y leerse en formato binario.
Las operaciones básicas en archivos son:
Creación
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:
"C: \\ POOISC \\ ARCHIVOS \\ archivo.txt"
o su forma equivalente:
@ "C: \ POOISC \ ARCHIVOS \ archivo.txt"
modo es un valor del tipo enumerado FileMode ; puede tomar uno de los siguientes valores:
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:
Read
Permite leer un archivo.
ReadWrite
Permite leer o escribir en el archivo.
Write
permite escribir en el archivo.
Ejemplo:
// CEscribirBytes.cs
using System;
using System.IO;
public class CEscribirBytes
{
public static void Main ( ) {
FileStream fs = null;byte[] buffer = new byte[81];int nbytes = 0, car;
try{
// Crea un flujo hacia el archivo texto.txt
fs = new FileStream("texto.txt",FileMode.Create, FileAccess.Write);
Console.WriteLine("Escriba el texto que desea almacenar en el archivo:");
while ((car = Console.Read()) != '\r' && (nbytes < buffer.Length)) {
buffer[nbytes] = (byte)car;nbytes++;
}
// Escribe la línea de texto en el archivo.
fs.Write(buffer, 0, nbytes);
}
catch(IOException e){
Console.WriteLine("Error: " + e.Message);
}
finally{
if (fs != null) fs.Close();
}
}
}
Archivos de Texto con Flujos de Caracteres.
En este caso los datos se manejan por medio de flujos de caracteres, utilizando las clases StreamWriter y StreamReader.
Escritura.
StreamWriter es una clase derivada de TextWriter.
Sus constructores son:
StreamWriter (string nombre ) // Abre un nuevo flujo para escribir en un
// archivo especificado por nombre .
StreamWriter (Stream flujo ) // Utiliza un flujo existente para escribir.
Antes de ser escritos, los datos son convertidos automáticamente a un formato portable de 8 bits (UTF-8, UCS Transformation Format 8).
Los objetos de la clase StreamWriter poseen varios métodos, entre los que destacan:
Write( ) ,WriteLine( ) y Flush( ) .
Además, poseen la propiedad BaseStream .
Ejemplo:
// CEscribirCars.cs
using System;using System.IO;
public class CEscribirCars{
public static void Main ( ){
StreamWriter sw = null;String str;
try{
// Crea un flujo hacia el archivo doc.txt// Si el archivo existe se destruye su contenido. sw = new StreamWriter("doc.txt");
Console.WriteLine("Escriba las líneas de texto aalmacenar en el archivo.\n" + "Finalice cada línea pulsando la tecla
// Lee una línea de la entrada estándar
str = Console.ReadLine();
// Mientras la cadena str no esté vacíawhile (str.Length != 0){
// Escribe la línea leída en el archivo
sw.WriteLine(str);
// Lee la línea siguiente
str = Console.ReadLine();
}
}
catch(IOException e){
Console.WriteLine("Error: " + e.Message);
}
finally{
if (sw != null) sw.Close();
}
}
}
Lectura
StreamReader es una clase derivada de TextReader y cuenta con los siguientes constructores:
StreamReader (string nombre ) abre un nuevo flujo para leer de unarchivo especificado por nombre.
StreamReader (Stream flujo ) utiliza un flujo existente para leer.
Algunos de los métodos más importantes de la clase StreamReader son:
Read( ) ,ReadLine( ) , Peek( ) y DiscardBufferData( ) .
Ejemplo:
// 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.txtsr = new StreamReader("doc.txt");
// Lee del archivo una línea de texto
str = sr.ReadLine();
// Mientras la cadena str no esté vacíawhile (str != null){
// Muestra la línea leídaConsole.WriteLine(str);
// Lee la línea siguiente
str = sr.ReadLine();
}
}
catch(IOException e){
Console.WriteLine("Error: " + e.Message);
}
finally{
// Cierra el archivoif (sr != null) sr.Close();
}
}
}
Archivos Binarios
Cuando se requiere efectuar operaciones con datos de alguno de los tipos primitivos, tales datos deberán escribirse y leerse en formato binario.
El espacio de nombres System.IO proporciona las clases:
BinaryWriter y BinaryReader.
Con estas clases se podrán manipular datos de los tipos primitivos y cadenas de caracteres en formato UTF-8.
Los archivos escritos en formato binario no se pueden desplegar directamente en los dispositivos de salida estándar, como el monitor, sino que deben leerse a través de flujos de la clase BinaryReader.
BinaryWriter crea flujos para escribir archivos con datos de los tipos primitivos en formato binario.
Su constructor es:
BinaryWriter ( Stream flujo )
y requiere, como parámetro, un flujo de la clase Stream o sus derivadas.
Ejemplo:
FileStream fs =new FileStream("datos.dat",FileMode. Create ,FileAccess. Write );
BinaryWriter bw=new BinaryWriter( fs );
Un objeto de la clase BinaryWriter actúa como filtro entre el programa y un flujo de la clase FileStream.
En la siguiente tabla se describen algunos de los principales métodos y propiedades de la clase BinaryWriter :
Write(byte)
Escribe un valor de tipo byte.
Write(byte[])
Escribe una cadena como una secuencia de bytes.
Write(char)
Escribe un valor de tipo char.
Write(char[])
Escribe una cadena como una secuencia de caracteres.
Write(short)
Escribe un valor de tipo short.
Write(int)
Escribe un valor de tipo int.
Write(long)
Escribe un valor de tipo long.
Write(Decimal)
Escribe un valor de tipo Decimal.
Write(float)
Escribe un valor de tipo float.
Write(double)
Escribe un valor de tipo double.
Write(string)
Escribe una cadena de caracteres en formato UTF-8.El primero o los dos primeros bytes especifican el número de bytes de datos escritos en la cadena.
BaseStream
Obtiene el flujo base ( fs en el ejemplo mostrado).
Close
Cierra el flujo y libera los recursos adquiridos.
Flush
Limpia el buffer asociado con el flujo.
Seek
Establece el apuntador de Lectura/Escritura en el flujo.
BinaryReader crea flujos para leer archivos con datos de los tipos primitivos en formato binario, escritos por un flujo de la clase Binaryreader.
Su constructor es:
BinaryReader ( Stream flujo )
y requiere, como parámetro, un flujo de la clase Stream o sus derivadas.
Ejemplo:
FileStream fs =new FileStream("datos.dat",FileMode. Open ,FileAccess. Read );
BinaryReader br=new BinaryReader( fs );
Un objeto de la clase BinaryReader actúa como filtro entre un flujo de la clase FileStream y el programa.
En la siguiente tabla se describen algunos de los principales métodos y propiedades de la clase BinaryReader :
Read(byte)
Devuelve un valor de tipo byte.
Read (byte[])
Devuelve una cadena como una secuencia de bytes.
Read (char)
Devuelve un valor de tipo char.
Read (char[])
Devuelve una cadena como una secuencia de caracteres.
Read (short)
Devuelve un valor de tipo short.
Read (int)
Devuelve un valor de tipo int.
Read (long)
Devuelve un valor de tipo long.
Read (Decimal)
Devuelve un valor de tipo Decimal.
Read (float)
Devuelve un valor de tipo float.
Read (double)
Devuelve un valor de tipo double.
Read (string)
Devuelve una cadena de caracteres en formato UTF-8. El primero o los dos primeros bytes especifican el número de bytes de datos que serán leídos.
BaseStream
Obtiene el flujo base ( fs en el ejemplo mostrado).
Close
Cierra el flujo y libera los recursos adquiridos.
Flush
Limpia el buffer asociado con el flujo.
PeekChar
Obtiene el siguiente carácter, sin extraerlo.
Acceso Aleatorio.
Cuando se abre un archivo, se puede acceder a sus registros de manera secuencial o de manera aleatoria .
El acceso aleatorio consiste en posicionar el apuntador de archivo en una localidad específica del archivo. Este tipo de acceso es necesario cuando se requiere modificar alguno de los campos de un registro. En lugar de leer desde el primero hasta el registro elegido, el apuntador se posiciona ,en una especie de salto, hasta dicho registro.
El salto se hace con base al conteo de los bytes existentes entre una posición inicial y el primer byte del registro elegido.
Para el acceso aleatorio a los registros de un archivo, la clase FileStream implementa las propiedades Position y Length , así como el método Seek( )
Position devuelve la posición actual, en bytes, del apuntador de archivo .
El apuntador de archivo marca el byte donde se hará la siguiente operación de lectura o de escritura.
La declaración de la propiedad Position es:
public long Position ;
La propiedad Length devuelve la longitud del archivo en bytes. Está declarada así:
public long Length ;
El método Seek( ) mueve el apuntador de archivo a una ubicación localizada desp bytes, a partir de la posición pos del archivo.
La sintaxis para Seek( ) es:
public long Seek( long desp , SeekOrigin pos )
El desplazamiento desp puede ser positivo o negativo.
La posición pos puede tomar uno de los siguientes valores del tipo enumerado SetOrigin .
Begin ........ El inicio del archivo.
Current ..... Posición actual del apuntador de archivo.
End ........... El final del archivo.
Ejemplos:
1 .- Suponiendo un flujo fs de la clase FileStream .
fs.Seek( desp , SeekOrigin. Begin );
fs.Seek( desp , SeekOrigin. Current );
fs.Seek( -desp , SeekOrigin. End );
El valor almacenado en desp debe calcularse en base al tamaño de registro del archivo.
2 .- Suponiendo un flujo br de la clase BinaryReader .
FileStream fs = new FileStream("datos", FileMode.Open,
FileAccess.Read);
BinaryReader br = new BinaryReader( fs );
Debido a que el flujo br no soporta directamente el método Seek( ) , tiene que acceder a él a través de su propiedad BaseStream , como se muestra a continuación:
br. BaseStream.Seek (desp, SeekOrigin.Current);
Para facilitar el cálculo del desplazamiento desp , es conveniente que todos los registros tengan la misma longitud.
El desplazamiento para acceder al tercer registro se calcula de la siguiente manera:
desp = Numero de registro * tamaño de registro
desp = 2*100
Es difícil recordar el número de registro al que se necesita acceder, por lo que se hace necesario establecer una relación entre el número de registro y el valor almacenado en alguno de los campos del registro.
Por ejemplo, si cada registro tiene un campo denominado clave , de tipo entero en el rango de 1 a N (que corresponde al número de control de un empleado), la relación entre la clave y el número de registro es:
número de registro = clave -1
Así, el calculo del desplazamiento para el empleado con la clave 4 se efectúa de la siguiente manera :
desp = (4-1) * 100 = 300
Esto obliga a que, cuando se introduzcan los datos de un nuevo empleado , el número de su clave deba ser igual al número de registro +1 .
El número de registro que sigue es igual al número de registros existentes.
Bibliografia: Ceballos, Francisco Javier / sistemas.itlp.edu.mx (pagina del Tec. de la Paz).
Practica 9 "sumatoria de filas y columnas"
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
int filas;
int colummnas;
int C, D, E;
int I, J;
int suma=0;
int sumatotal;
string arreglillo = "",arreglillo2="";
string articulos = "";
ArregloBidimencional Matriz;
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
filas = int.Parse(textBox1.Text);
colummnas = int.Parse(textBox2.Text);
Matriz = new ArregloBidimencional((filas), (colummnas));
for (J = 0; J < colummnas; J++)
{
articulos = "";
for (J = 0; J < colummnas; J++)
{
articulos += (J + 1) + "\t";
}
listBox5.Items.Add(articulos);
}
for (J = 0; J < filas; J++)
{
listBox6.Items.Add((J+1));
listBox6.Items.Add("");
}
textBox3.Focus();
}
private void button2_Click(object sender, EventArgs e)
{
C = int.Parse(textBox3.Text);
D = int.Parse(textBox4.Text);
E = int.Parse(textBox5.Text);
Matriz.IntroducirDatos((C-1), (D-1), E);
textBox3.Clear();
textBox4.Clear();
textBox5.Clear();
textBox3.Focus();
}
private void button3_Click(object sender, EventArgs e)
{
listBox1.Items.Clear();
listBox2.Items.Clear();
listBox3.Items.Clear();
listBox4.Items.Clear();
arreglillo2 = "";
sumatotal = 0;
for (I = 0; I < filas; I++)
{
listBox4.Items.Add(sumatotal);
for (I = 0; I < filas; I++)
{
arreglillo = "";
for (J = 0; J < colummnas; J++)
{
arreglillo += Matriz.ObtenerDatos(I, J) + "\t";
}
listBox3.Items.Add(arreglillo);
listBox3.Items.Add("");
}
for (J = 0; J < filas; J++)
{
suma = suma + (Matriz.ObtenerDatos(J, I));
}
arreglillo2 += suma + " \t";
}
listBox2.Items.Add(arreglillo2);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace WindowsFormsApplication1
{
class ArregloBidimencional
{
int[,] Tabla;
int[] Filas;
int[] Colummnas;
int[] sumacolumnas;
public ArregloBidimencional(int N, int M)
{
Tabla = new int[N, M];
}
public void IntroducirDatos(int O, int P, int Q)
{
Tabla[O, P] = Q;
}
public int ObtenerDatos(int O, int P)
{
return Tabla[O, P];
}
}
}
Practica 9 "cantidad de accidentes"
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
ArregloBidimencional Reticula = new ArregloBidimencional(10, 29);
int avenida, calle, numacc, I = 0, J = 0;
int mayor1, indice1R=0, indice1C=0;
int mayor2, indice2R=0, indice2C=0;
int mayor3, indice3R=0, indice3C=0;
String salida = "";
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
avenida = int.Parse(textBox1.Text);
calle = int.Parse(textBox2.Text);
numacc = int.Parse(textBox3.Text);
Reticula.numeroaccidentes(avenida-1, calle-30, numacc);
}
private void button2_Click(object sender, EventArgs e)
{
for (I = 0; I < 10; I++)
{
salida = "";
for (J = 0; J < 29; J++)
{
salida += Reticula.ObtenerNum(I, J) + "\t";
}
listBox1.Items.Add(salida);
}
mayor1 = Reticula.DatoMayor(10, 29);
indice1R = Reticula.indRenglon;
indice1C = Reticula.indColumna;
listBox2.Items.Add("Accidentes: "+Reticula.ObtenerNum(indice1R, indice1C));
listBox2.Items.Add("Avenida: "+(indice1R+1));
listBox2.Items.Add("Calle: "+(indice1C+1));
Reticula.numeroaccidentes(indice1R, indice1C,0);
mayor2 = Reticula.DatoMayor(10, 29);
indice2R = Reticula.indRenglon;
indice2C = Reticula.indColumna;
listBox3.Items.Add("Accidentes: " + Reticula.ObtenerNum(indice2R, indice2C));
listBox3.Items.Add("Avenida: " + (indice2R + 1));
listBox3.Items.Add("Calle: " + (indice2C + 1));
Reticula.numeroaccidentes(indice2R, indice2C,0);
mayor3 = Reticula.DatoMayor(10, 29);
indice3R = Reticula.indRenglon;
indice3C = Reticula.indColumna;
listBox4.Items.Add("Accidentes: " + Reticula.ObtenerNum(indice3R, indice3C));
listBox4.Items.Add("Avenida: " + (indice3R + 1));
listBox4.Items.Add("Calle: " + (indice3C + 1));
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace WindowsFormsApplication1
{
class ArregloBidimencional
{
int[,] tabla;
int IndiceRenglon;
int IndiceColumna;
public ArregloBidimencional(int N, int M)
{
tabla = new int[N, M];
IndiceRenglon = 0;
IndiceColumna = 0;
}
public int indRenglon
{
get { return IndiceRenglon; }
set { IndiceRenglon = value; }
}
public int indColumna
{
get { return IndiceColumna; }
set { IndiceColumna = value; }
}
public void numeroaccidentes(int R, int C, int D)
{
tabla[R, C] = D;
}
public int ObtenerNum(int y, int u)
{
return tabla[y,u];
}
public int DatoMayor(int N, int M)
{
int mayor = 0;
int avemay = 0, callemayor = 0, R, C;
for (R = 0; R < N; R++)
{
for (C = 0;C < M; C++)
{
if (tabla[R, C] > mayor)
{
mayor = tabla[R, C];
avemay = R;
callemayor = C;
}
}
}
IndiceRenglon = avemay;
IndiceColumna = callemayor;
return mayor;
}
}
}
Practica 9 "vendedores"
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
int empleado, producto, cantidad;
int I,J=0;
int K;
string articulos="",salida="";
double salario = 0;
double vendidos = 0;
ArregloBidimencional Forma = new ArregloBidimencional(5, 10);
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
empleado=int.Parse(textBox1.Text);
producto=int.Parse(textBox2.Text);
cantidad=int.Parse(textBox3.Text);
Forma.IntroducirDatos((empleado-1), (producto-1), cantidad);
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox1.Focus();
}
private void button2_Click(object sender, EventArgs e)
{
listBox1.Items.Clear();
listBox2.Items.Clear();
listBox3.Items.Clear();
listBox4.Items.Clear();
for (I = 0; I < 5; I++)
{
listBox1.Items.Add((I + 1));
listBox1.Items.Add("");
salario = 0;
for (J = 0; J < 10; J++)
{
salario = salario + (Forma.ObtenerDatos(I, J) * Forma.ObtenerPrecios(J) * 0.05);
Forma.IntroducirSalarios(I, salario);
}
}
for (J = 0; J < 10; J++)
{
articulos = "";
for (J = 0; J < 10; J++)
{
articulos += (J + 1) + "\t";
}
listBox2.Items.Add(articulos);
}
for (K = 0; K < 5; K++)
{
listBox4.Items.Add(Forma.ObtenerSalarios(K));
listBox4.Items.Add("");
}
for (I = 0; I < 5; I++)
{
salida = "";
for (J = 0; J < 10; J++)
{
salida += Forma.ObtenerDatos(I, J) + "\t";
}
listBox3.Items.Add(salida);
listBox3.Items.Add("");
}
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace WindowsFormsApplication1
{
class ArregloBidimencional
{
int[,] Tabla;
double[] Precios;
double[] Salarios;
public ArregloBidimencional (int N, int M)
{
Tabla = new int[N, M];
Precios = new double[] { 1, 2, 3, 4, 5, 6,7,8,9,10 };
Salarios = new double[N];
}
public void IntroducirDatos(int o, int p, int q)
{
Tabla[o, p] = q;
}
public int ObtenerDatos(int O, int P)
{
return Tabla[O, P];
}
public double ObtenerPrecios(int O)
{
return Precios[O];
}
public void IntroducirSalarios(int O, double P)
{
Salarios[O] = P;
}
public double ObtenerSalarios(int O)
{
return Salarios[O];
}
}
}
Practica 8 "formula"
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication3
{
public partial class Form1 : Form
{
Arreglo H;
Arreglo F;
double dat1, dat2;
double s = 0, numerador, denominador;
int I = 1, num;
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
num = int.Parse(textBox1.Text);
H = new Arreglo(num);
F = new Arreglo(num);
}
private void button2_Click(object sender, EventArgs e)
{
if (I < num)
{
dat1 = double.Parse(textBox2.Text);
H.elementos[I] = dat1;
dat2 = double.Parse(textBox3.Text);
F.elementos[I] = dat2;
}
if (I == num)
{
for (I = 0; I < num; I++)
{
s = s + H.elementos[I] * F.elementos[I];
}
numerador = num * s - H.sumadatos(num) * F.sumadatos(num);
denominador = Math.Sqrt((num * H.sumacuadrada(num) - (Math.Pow(H.sumadatos(num), 2))) * (num * F.sumacuadrada(num) - (Math.Pow(F.sumadatos(num), 2))));
listBox1.Items.Add(numerador / denominador);
textBox1.Enabled = false;
textBox2.Enabled = false;
textBox3.Enabled = false;
}
I ++;
textBox2.Clear();
textBox3.Clear();
textBox2.Focus();
}
private void Form1_Load(object sender, EventArgs e)
{
}
}
}
sing System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace WindowsFormsApplication3
{
class Arreglo
{
double[] Elementos;
public Arreglo(int N)
{
Elementos = new double[N];
}
public double[] elementos
{
get { return Elementos; }
set { Elementos = value; }
}
public double sumacuadrada(int N)
{
double sum = 0;
int I;
for (I = 0; I < N; I++)
{
sum = sum + Math.Pow(Elementos[I], 2);
}
return sum;
}
public double sumadatos(int N)
{
double suma = 0;
int I;
for (I = 0; I < N; I++)
{
suma = suma + Elementos[I];
}
return suma;
}
}
}
Practica 8 "Informe anual de ventas"
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication2
{
public partial class Form1 : Form
{
Arreglo VentaAnual = new Arreglo();
double venta; int J;
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
J=int.Parse(comboBox1.Text);
venta = double.Parse(textBox1.Text);
VentaAnual.AcumularDato(J-1, venta);
textBox1.Clear();
}
private void button2_Click(object sender, EventArgs e)
{
int I;
for (I = 0; I < 12; I++)
{
switch (I)
{
case 0: listBox1.Items.Add("Enero="+ VentaAnual.ObtenerDato(I)); break;
case 1: listBox1.Items.Add("Febrero="+ VentaAnual.ObtenerDato(I)); break;
case 2: listBox1.Items.Add("Marzo="+ VentaAnual.ObtenerDato(I)); break;
case 3: listBox1.Items.Add("Abril="+ VentaAnual.ObtenerDato(I)); break;
case 4: listBox1.Items.Add("Mayo="+VentaAnual.ObtenerDato(I)); break;
case 5: listBox1.Items.Add("Junio="+ VentaAnual.ObtenerDato(I)); break;
case 6: listBox1.Items.Add("Julio="+ VentaAnual.ObtenerDato(I)); break;
case 7: listBox1.Items.Add("Agosto="+ VentaAnual.ObtenerDato(I)); break;
case 8: listBox1.Items.Add("Septiembre="+ VentaAnual.ObtenerDato(I)); break;
case 9: listBox1.Items.Add("Octubre="+ VentaAnual.ObtenerDato(I)); break;
case 10: listBox1.Items.Add("Noviembre="+ VentaAnual.ObtenerDato(I)); break;
case 11: listBox1.Items.Add("Diciembre="+ VentaAnual.ObtenerDato(I)); break;
}
}
listBox2.Items.Add(VentaAnual.suma(12));
}
private void button3_Click(object sender, EventArgs e)
{
listBox1.Items.Clear();
listBox2.Items.Clear();
textBox1.Clear();
comboBox1.Items.Clear();
comboBox1.Focus();
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace WindowsFormsApplication2
{
class Arreglo
{double[] Elementos;
public Arreglo()
{
Elementos = new double[12];
}
public void AcumularDato(int J, double N)
{
Elementos[J] = N;
}
public double ObtenerDato(int x)
{
return Elementos[x];
}
public double[] elementos
{
get { return Elementos; }
set { Elementos = value; }
}
public double suma(int N)
{
int I; double suma = 0.0;
for (I = 0; I < N; I++)
{
suma = suma + Elementos[I];
}
return suma;
}
}
}
lunes, 27 de abril de 2009
Practica 8 "vendedores" (visual)
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication2
{
public partial class Form1 : Form
{
int numero,I, i = 0,x;
string nombre;
double total;
Vendedor[] compania = new Vendedor[25];
public Form1()
{
InitializeComponent();
Vendedor vx = new Vendedor(numero, nombre, total);
}
private void button1_Click(object sender, EventArgs e)
{
numero = int.Parse(textBox1.Text);
if (compania[numero-1]!=null)
{
MessageBox.Show("ESTE EMPLEADO YA FUE REGISTRADO");
}
if (numero >= 1 && numero <= 3 && compania[numero-1]==null)
{
nombre = (textBox2.Text);
total = double.Parse(textBox3.Text);
Vendedor vx = new Vendedor(numero, nombre, total);
compania[numero - 1] = vx;
i++;
}
if (numero <> 4)
{
MessageBox.Show("NO EXISTE NUMERO DE VENDEDOR");
}
if (i==3)
{
MessageBox.Show("LISTA LLENA");
listBox1.Items.Clear();
listBox2.Items.Clear();
listBox3.Items.Clear();
for (I = 0; I < 25; I++)
{
if (compania[I] != null)
{
listBox1.Items.Add(compania[I].no_vend);
listBox2.Items.Add(compania[I].nombre);
listBox3.Items.Add(compania[I].totalventa);
}
}
textBox1.Enabled = false;
textBox2.Enabled = false;
textBox3.Enabled = false;
}
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox1.Focus();
}
private void button2_Click(object sender, EventArgs e)
{
listBox1.Items.Clear();
listBox2.Items.Clear();
listBox3.Items.Clear();
for (I = 0; I < 25; I++)
{
if (compania[I] != null)
{
listBox1.Items.Add(compania[I].no_vend);
listBox2.Items.Add(compania[I].nombre);
listBox3.Items.Add(compania[I].totalventa);
}
}
}
}
}
Practica 8 "Vendedores" (consola)
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
int sigue=1,numero,i=0;
string nombre;
double total;
Vendedor[] compania = new Vendedor[25];
do
{
x:
Console.Write("Numero de vendedor:");
numero = int.Parse(Console.ReadLine());
if (numero <> 3)
{
Console.WriteLine("NO EXISTE NUMERO DE VENDEDOR");
Console.Write("Presione 1 para continuar / presione 0 para terminar");
sigue = int.Parse(Console.ReadLine());
}
if (numero >= 1 && numero <= 3)
{
if (compania[numero - 1] != null)
{
Console.WriteLine("Este empleado ya a llenado sus datos");
goto x;
}
Console.Write("Nombre de vendedor:");
nombre = Console.ReadLine();
Console.Write("monto de venta:");
total = double.Parse(Console.ReadLine());
Vendedor vx = new Vendedor(numero, nombre, total);
compania[numero - 1] = vx;
Console.Write("Presione 1 para continuar / presione 0 para terminar:");
sigue = int.Parse(Console.ReadLine());
i++;
}
}
while (sigue == 1&&i<3);
Console.WriteLine(" No de vendedor: Nombre de vendedor: Total de venta:");
int I;
for (I=0;I<25;I++)
{
if (compania[I]!=null)
{
Console.WriteLine (" \t {0} \t\t {1} \t\t\t\t {2}", compania[I].no_vend,compania[I].nombre,compania[I].totalventa);
}
}
Console.ReadLine();
}
}
}
viernes, 13 de marzo de 2009
Manipulacion de clases (consola)
using System;using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Class_rectangulo
{
double ancho;
double largo;
public Class_rectangulo()
{
ancho = 0;
largo = 0;
}
public Class_rectangulo(double w, double h)
{
ancho = w;
largo = h;
}
public double area()
{
return ancho * largo;
}
public double perimetro()
{
return 2 * (largo + ancho);
}
public void asignarlargo(double h)
{
largo = h;
}
public void asignarancho(double w)
{
ancho = w;
}
public double obtenerlargo()
{
return largo;
}
public double obtenerancho()
{
return ancho;
}
}
}
sing System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Circulo
{
double radio;
public Circulo()
{
radio = 0;
}
public Circulo (double r)
{
radio = r;
}
public double area()
{
return Math.PI * Math.Pow(radio, 2);
}
public double perimetro()
{
return 2 * Math.PI + radio;
}
public void asignarradio(double r)
{
radio = r;
}
public double obtenerradio ()
{
return radio;
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Triangulo
{
double lado1, lado2, lado3;
public Triangulo()
{
lado1 = 0; lado2 = 0; lado3 = 0;
}
public Triangulo(double l1, double l2, double l3)
{
lado1 = l1; lado2 = l2; lado3 = l3;
}
public double area()
{
return Math.Sqrt(((lado1 + lado2 + lado3) / 2) * (((lado1 + lado2 + lado3) / 2) - lado1) * (((lado1 + lado2 + lado3) / 2) - lado2) * (((lado1 + lado2 + lado3) / 2) - lado3));
}
public double perimetro()
{
return lado1 + lado2 + lado3;
}
public void asignarlado1(double l1)
{
lado1 = l1;
}
public void asignarlado2(double l2)
{
lado2 = l2;
}
public void asignarlado3(double l3)
{
lado3 = l3;
}
public double obtenerlado1()
{
return lado1;
}
public double asignarlado2()
{
return lado2;
}
public double asignarlado3()
{
return lado3;
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("RECTANGULO:");
Console.ForegroundColor = ConsoleColor.White;
Class_rectangulo r1 = new Class_rectangulo();
double l, a;
Console.Write("introduce largo:");
l = double.Parse(Console.ReadLine());
Console.Write("introduce ancho:");
a = double.Parse(Console.ReadLine());
r1.asignarlargo(l);
r1.asignarancho(a);
Console.WriteLine("area={0}", r1.area());
Console.WriteLine("perimetro{0}", r1.perimetro());
Console.ReadKey();
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("CIRCULO R=10");
Console.ForegroundColor = ConsoleColor.White;
Circulo c1 = new Circulo(10);
Console.WriteLine("area= {0}", c1.area());
Console.WriteLine("perimetro= {0}", c1.perimetro());
Console.ReadKey();
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("CIRCULO ");
Console.ForegroundColor = ConsoleColor.White;
Circulo c2 = new Circulo();
double r;
Console.Write("introduce el radio:");
r = double.Parse(Console.ReadLine());
c2.asignarradio(r);
Console.WriteLine("area= {0}", c2.area());
Console.WriteLine("perimetro= {0}", c2.perimetro());
Console.ReadKey();
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("TRIANGULO:");
Console.ForegroundColor = ConsoleColor.White;
Triangulo t1 = new Triangulo();
double l1, l2, l3;
Console.Write("introduce lado 1:");
l1 = double.Parse(Console.ReadLine());
Console.Write("introduce lado 2:");
l2 = double.Parse(Console.ReadLine());
Console.Write("introduce lado 3:");
l3 = double.Parse(Console.ReadLine());
t1.asignarlado1(l1);
t1.asignarlado2(l2);
t1.asignarlado3(l3);
Console.WriteLine("area= {0}", t1.area());
Console.WriteLine("perimetro= {0}", t1.perimetro());
Console.ReadKey();
}
}
}
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("RECTANGULO:");
Console.ForegroundColor = ConsoleColor.White;
Class_rectangulo r1 = new Class_rectangulo();
double l, a;
Console.Write("introduce largo:");
l = double.Parse(Console.ReadLine());
Console.Write("introduce ancho:");
a = double.Parse(Console.ReadLine());
r1.asignarlargo(l);
r1.asignarancho(a);
Console.WriteLine("area={0}", r1.area());
Console.WriteLine("perimetro{0}", r1.perimetro());
Console.ReadKey();
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("CIRCULO R=10");
Console.ForegroundColor = ConsoleColor.White;
Circulo c1 = new Circulo(10);
Console.WriteLine("area= {0}", c1.area());
Console.WriteLine("perimetro= {0}", c1.perimetro());
Console.ReadKey();
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("CIRCULO ");
Console.ForegroundColor = ConsoleColor.White;
Circulo c2 = new Circulo();
double r;
Console.Write("introduce el radio:");
r = double.Parse(Console.ReadLine());
c2.asignarradio(r);
Console.WriteLine("area= {0}", c2.area());
Console.WriteLine("perimetro= {0}", c2.perimetro());
Console.ReadKey();
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("TRIANGULO:");
Console.ForegroundColor = ConsoleColor.White;
Triangulo t1 = new Triangulo();
double l1, l2, l3;
Console.Write("introduce lado 1:");
l1 = double.Parse(Console.ReadLine());
Console.Write("introduce lado 2:");
l2 = double.Parse(Console.ReadLine());
Console.Write("introduce lado 3:");
l3 = double.Parse(Console.ReadLine());
t1.asignarlado1(l1);
t1.asignarlado2(l2);
t1.asignarlado3(l3);
Console.WriteLine("area= {0}", t1.area());
Console.WriteLine("perimetro= {0}", t1.perimetro());
Console.ReadKey();
}
}
}
Manipulacion de clases (visual)
using System;using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
int s;
s = int.Parse(comboBox1.Text);
switch (s)
{
case 1 :
{
Form2 rect = new Form2();
rect.Show();
break;
}
case 2:
{
Form3 cird = new Form3();
cird.Show();
break;
}
case 3:
{
Form4 cir10 = new Form4();
cir10.Show();
break;
}
case 4:
{
Form5 tri = new Form5();
tri.Show();
break;
}
}
}
}
}
using System;using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace WindowsFormsApplication1
{
class Class_rectangulo
{
double ancho;
double largo;
public Class_rectangulo()
{
ancho = 0;
largo = 0;
}
public Class_rectangulo(double w, double h)
{
ancho = w;
largo = h;
}
public double area()
{
return ancho * largo;
}
public double perimetro()
{
return 2 * (largo + ancho);
}
public void asignarlargo(double h)
{
largo = h;
}
public void asignarancho(double w)
{
ancho = w;
}
public double obtenerlargo()
{
return largo;
}
public double obtenerancho()
{
return ancho;
}
}
}
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form2 : Form
{
Class_rectangulo r1 = new Class_rectangulo();
public Form2()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
double l, a;
l = double.Parse(textBox1.Text);
a = double.Parse(textBox2.Text);
r1.asignarlargo(l);
r1.asignarancho(a);
textBox3.Text = r1.area().ToString();
textBox4.Text = r1.perimetro().ToString();
}
}
}
using System;using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form3 : Form
{
Circulo cir = new Circulo(10);
public Form3()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
textBox3.Text = cir.area().ToString();
textBox4.Text = cir.perimetro().ToString();
}
}
}
using System;using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace WindowsFormsApplication1
{
class Circulo
{
double radio;
public Circulo()
{
radio = 0;
}
public Circulo(double r)
{
radio = r;
}
public double area()
{
return Math.PI * Math.Pow(radio, 2);
}
public double perimetro()
{
return 2 * Math.PI + radio;
}
public void asignarradio(double r)
{
radio = r;
}
public double obtenerradio()
{
return radio;
}
}
}
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form4 : Form
{
Circulo circ = new Circulo();
public Form4()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
double r;
r = int.Parse(textBox2.Text);
circ.asignarradio(r);
textBox3.Text = circ.area().ToString();
textBox4.Text = circ.perimetro().ToString();
}
}
}
using System;using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace WindowsFormsApplication1
{
class Triangulo
{
double lado1, lado2, lado3;
public Triangulo()
{
lado1 = 0; lado2 = 0; lado3 = 0;
}
public Triangulo(double l1, double l2, double l3)
{
lado1 = l1; lado2 = l2; lado3 = l3;
}
public double area()
{
return Math.Sqrt(((lado1 + lado2 + lado3) / 2) * (((lado1 + lado2 + lado3) / 2) - lado1) * (((lado1 + lado2 + lado3) / 2) - lado2) * (((lado1 + lado2 + lado3) / 2) - lado3));
}
public double perimetro()
{
return lado1 + lado2 + lado3;
}
public void asignarlado1(double l1)
{
lado1 = l1;
}
public void asignarlado2(double l2)
{
lado2 = l2;
}
public void asignarlado3(double l3)
{
lado3 = l3;
}
public double obtenerlado1()
{
return lado1;
}
public double asignarlado2()
{
return lado2;
}
public double asignarlado3()
{
return lado3;
}
}
}
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form5 : Form
{
Triangulo tria = new Triangulo();
public Form5()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
double l1, l2, l3;
l1 = double.Parse(textBox1.Text);
l2 = double.Parse(textBox2.Text);
l3 = double.Parse(textBox3.Text);
tria.asignarlado1(l1);
tria.asignarlado2(l2);
tria.asignarlado3(l3);
textBox4.Text = tria.area().ToString();
textBox5.Text = tria.perimetro().ToString();
}
}
}
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form5 : Form
{
Triangulo tria = new Triangulo();
public Form5()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
double l1, l2, l3;
l1 = double.Parse(textBox1.Text);
l2 = double.Parse(textBox2.Text);
l3 = double.Parse(textBox3.Text);
tria.asignarlado1(l1);
tria.asignarlado2(l2);
tria.asignarlado3(l3);
textBox4.Text = tria.area().ToString();
textBox5.Text = tria.perimetro().ToString();
}
}
}
martes, 10 de marzo de 2009
Practica 2 Hoja 4 (visual)
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
double dt = 0, di = 0;
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
double t;
for (t=0; t <= 10; t++)
{
listBox1.Items.Add(t);
di = (1.0/2.0) * (32 * Math.Pow(t, 2));
listBox2.Items.Add(di);
dt = dt + di;
listBox3.Items.Add(di);
}
}
}
}
Practica 1 Hoja 4 (consola)
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
double a, r, n,v,termino,sumatoria=0;
Console.Write("introduce la cantidad de terminos:");
n = double.Parse(Console.ReadLine());
Console.Write("introduce el primer termino:");
a = double.Parse(Console.ReadLine());
Console.Write("introduce la proporcion en comun:");
r = double.Parse(Console.ReadLine());
Console.WriteLine("\t\tsumatoria:");
for (v = 0; v <= n - 1; v++)
{
termino = a * Math.Pow(r, v);
Console.Write(termino);
sumatoria = sumatoria + termino;
if (v == n - 1)
{
Console.Write("=");
}
else
{
Console.Write("+");
}
}
Console.Write(sumatoria);
Console.ReadKey();
}
}
}
lunes, 9 de marzo de 2009
Registrador de pesos de pescados (en visual)
using System;using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication3
{
public partial class Form1 : Form
{
double peso,total=0;
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
textBox2.Enabled = true;
textBox2.Focus();
}
private void button2_Click(object sender, EventArgs e)
{
double limite,excedida;
textBox2.Focus();
limite = double.Parse(textBox1.Text);
peso = double.Parse(textBox2.Text);
textBox2.Clear();
total = total + peso;
textBox3.Text = total.ToString();
if (total > limite)
{
excedida = total - limite;
label5.Visible = true;
label4.Visible = true;
label6.Visible = true;
textBox4.Visible = true;
textBox4.Text = excedida.ToString();
}
if (peso == 0)
{
label7.Visible = true;
textBox2.Enabled = false;
}
}
private void button3_Click(object sender, EventArgs e)
{
total = 0;
peso = 0;
label5.Visible = false;
label6.Visible = false;
textBox4.Visible = false;
label7.Visible = false;
textBox2.Enabled = true;
textBox1.Clear();
textBox3.Clear();
textBox2.Enabled = false;
textBox1.Focus();
}
private void button4_Click(object sender, EventArgs e)
{
Close();
}
}
}
Registrador de pesos de pescados (en consola)
using System;using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
double limite=0,peso=0,total=0,excedida=0;
Console.Write("introduce el limite de pesca en kg:");
Console.WriteLine("");
limite = double.Parse(Console.ReadLine());
do
{
Console.Write("introduce el peso en kg:");
Console.WriteLine("");
peso = double.Parse(Console.ReadLine());
total = total + peso;
if (total > limitepeso>limite)
{
Console.Write("excedio el limite");
Console.WriteLine("");
Console.Write("total= {0}kg", total);
Console.WriteLine("");
excedida = total - limite;
Console.Write("se excedio con: {0}kg", excedida);
}
else if (total == limite peso== limite)
{
Console.Write("termino");
Console.WriteLine("");
Console.Write("total: {0}kg", total);
}
else if (peso == 0)
{
Console.WriteLine("se termino");
Console.WriteLine("total= {0}kg", total);
}
}
while (total < limite&&total!=0); Console.ReadKey();
}
}
}
domingo, 8 de marzo de 2009
Conceptos básicos (Unidad I)
Lenguaje de alto nivel: es aquel con el que la programación se realiza de una forma más cercana al lenguaje humano.
Lenguaje de bajo nivel: es aquel con el que la programación se realiza de una forma mas cercana al lenguaje maquina (lenguaje binario).
Lenguaje ensamblador: es el lenguaje que se utiliza con términos que son más fáciles de manipular por los humanos, pero equivalen al lenguaje maquina.
Traductor: son programas que toman como entrada un texto escrito en un lenguaje el cual es llamado fuente y entrega como salida otro texto en un lenguaje, denominado objeto.
Compilador: es un tipo de traductor este programa traduce código fuente escrito en un lenguaje de alto nivel en código máquina.
Sistemas numéricos: son un conjunto de símbolos y reglas que se utilizan para representar datos numéricos o cantidades. Cuentan con una base que indica los distintos símbolos que utiliza y con un coeficiente que determina el valor de cada símbolo dependiendo de la posición que ocupe. Ejemplos:
Sistema decimal
Sistema binario
Sistema octal
Sistema hexadecimal
Arquitectura de computadoras: la arquitectura de computadoras se refiere al diseño, estructura y el funcionamiento de estas.
Sistema operativo: es el programa o también se puede ver como un conjunto de programas el cual tiene la tarea de facilitar el uso de una computadora.
Tipos de programación:
Programación estructurada (PE): La programación estructurada esta compuesta por un conjunto de técnicas que han ido evolucionando aumentando considerablemente la productividad del programa reduciendo el tiempo de depuración y mantenimiento del mismo. Esta programación estructurada utiliza un número limitado de estructuras de control, reduciendo así considerablemente los errores.
Programación orientada a objetos (POO): Se trata de una técnica que aumenta considerablemente la velocidad de desarrollo de los programas gracias a la reutilización de los objetos. El elemento principal de la programación orientada a objetos es el objeto. El objeto es un conjunto complejo de datos y programas que poseen estructura y forman parte de una organización. Un objeto contiene varios datos bien estructurados y pueden ser visibles o no dependiendo del programador y las acciones del programa en ese momento.
Fuente: DesarrolloWeb.com
Lenguajes de programación: son lenguajes artificiales que pueden ser usados para controlar dispositivos, se componen por reglas de escritura y cada dispositivo responderá de acuerdo a estas reglas.
Lenguaje de bajo nivel: es aquel con el que la programación se realiza de una forma mas cercana al lenguaje maquina (lenguaje binario).
Lenguaje ensamblador: es el lenguaje que se utiliza con términos que son más fáciles de manipular por los humanos, pero equivalen al lenguaje maquina.
Traductor: son programas que toman como entrada un texto escrito en un lenguaje el cual es llamado fuente y entrega como salida otro texto en un lenguaje, denominado objeto.
Compilador: es un tipo de traductor este programa traduce código fuente escrito en un lenguaje de alto nivel en código máquina.
Sistemas numéricos: son un conjunto de símbolos y reglas que se utilizan para representar datos numéricos o cantidades. Cuentan con una base que indica los distintos símbolos que utiliza y con un coeficiente que determina el valor de cada símbolo dependiendo de la posición que ocupe. Ejemplos:
Sistema decimal
Sistema binario
Sistema octal
Sistema hexadecimal
Arquitectura de computadoras: la arquitectura de computadoras se refiere al diseño, estructura y el funcionamiento de estas.
Sistema operativo: es el programa o también se puede ver como un conjunto de programas el cual tiene la tarea de facilitar el uso de una computadora.
Tipos de programación:
Programación estructurada (PE): La programación estructurada esta compuesta por un conjunto de técnicas que han ido evolucionando aumentando considerablemente la productividad del programa reduciendo el tiempo de depuración y mantenimiento del mismo. Esta programación estructurada utiliza un número limitado de estructuras de control, reduciendo así considerablemente los errores.
Programación orientada a objetos (POO): Se trata de una técnica que aumenta considerablemente la velocidad de desarrollo de los programas gracias a la reutilización de los objetos. El elemento principal de la programación orientada a objetos es el objeto. El objeto es un conjunto complejo de datos y programas que poseen estructura y forman parte de una organización. Un objeto contiene varios datos bien estructurados y pueden ser visibles o no dependiendo del programador y las acciones del programa en ese momento.
Fuente: DesarrolloWeb.com
Lenguajes de programación: son lenguajes artificiales que pueden ser usados para controlar dispositivos, se componen por reglas de escritura y cada dispositivo responderá de acuerdo a estas reglas.
lunes, 2 de marzo de 2009
Hoja 3 Problema2 (visual)
using System;using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
int opcion;
opcion=int.Parse(comboBox1.Text);
switch (opcion)
{
case 1:
textBox1.Visible = true;
textBox1.Focus();
break;
case 2:
textBox2.Visible = true;
textBox2.Focus();
break;
case 3:
textBox3.Visible = true;
textBox3.Focus();
break;
case 4:
textBox4.Visible = true;
textBox4.Focus();
break;
case 5:
textBox5.Visible = true;
textBox5.Focus();
break;
}
}
private void Form1_Load(object sender, EventArgs e)
{
textBox1.Text = "0";
textBox2.Text = "0";
textBox3.Text = "0";
textBox4.Text = "0";
textBox5.Text = "0";
}
private void button2_Click(object sender, EventArgs e)
{
int P1, P2, P3, P4, P5;
double total;
P1 = int.Parse(textBox1.Text);
P2 = int.Parse(textBox2.Text);
P3 = int.Parse(textBox3.Text);
P4 = int.Parse(textBox4.Text);
P5 = int.Parse(textBox5.Text);
total = (P1 * 29.80) + (P2 * 45.00) + (P3 * 99.80) + (P4 * 44.90) + (P5 * 68.75);
textBox6.Visible = true;
textBox6.Text = "$"+total.ToString();
}
private void button3_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox4.Clear();
textBox5.Clear();
comboBox1.Focus();
}
private void button4_Click(object sender, EventArgs e)
{
Close();
}
}
}
Hoja 3 Problema1 (visual)
using System;using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
int opcion;
opcion = int.Parse(comboBox1.Text);
switch (opcion)
{
case 1: Form2 f2= new Form2();
f2.Show();
break;
case 2: Form3 f3= new Form3();
f3.Show();
break;
case 3: Form4 f4= new Form4();
f4.Show();
break;
case 4: Form5 f5 = new Form5();
f5.Show();
break;
}
}
}
}
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form2 : Form
{
public Form2()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
int lado, area, perimetro;
lado=int.Parse(textBox1.Text);
area = lado * lado;
perimetro = lado * 4;
textBox2.Visible = true;
textBox2.Text= ( area.ToString());
textBox3.Visible = true;
textBox3.Text=(perimetro.ToString());
}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox1.Focus();
}
private void button3_Click(object sender, EventArgs e)
{
Close();
}
}
}
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form3 : Form
{
public Form3()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
int largo,ancho, area, perimetro;
largo = int.Parse(textBox1.Text);
ancho = int.Parse(textBox2.Text);
area = largo * ancho;
perimetro = (largo * 2)+(ancho*2);
textBox3.Visible = true;
textBox3.Text = (area.ToString());
textBox4.Visible = true;
textBox4.Text = (perimetro.ToString());
}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox4.Clear();
textBox1.Focus();
}
private void button3_Click(object sender, EventArgs e)
{
Close();
}
}
}
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form2 : Form
{
public Form2()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
int lado, area, perimetro;
lado=int.Parse(textBox1.Text);
area = lado * lado;
perimetro = lado * 4;
textBox2.Visible = true;
textBox2.Text= ( area.ToString());
textBox3.Visible = true;
textBox3.Text=(perimetro.ToString());
}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox1.Focus();
}
private void button3_Click(object sender, EventArgs e)
{
Close();
}
}
}
using System;using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form3 : Form
{
public Form3()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
int largo,ancho, area, perimetro;
largo = int.Parse(textBox1.Text);
ancho = int.Parse(textBox2.Text);
area = largo * ancho;
perimetro = (largo * 2)+(ancho*2);
textBox3.Visible = true;
textBox3.Text = (area.ToString());
textBox4.Visible = true;
textBox4.Text = (perimetro.ToString());
}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox4.Clear();
textBox1.Focus();
}
private void button3_Click(object sender, EventArgs e)
{
Close();
}
}
}
using System;using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form4 : Form
{
public Form4()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
double lado1, lado2, lado3,area, perimetro, semiperimetro;
lado1 = double.Parse(textBox1.Text);
lado2 = double.Parse(textBox2.Text);
lado3 = double.Parse(textBox3.Text);
perimetro = (lado1 + lado2 + lado3);
semiperimetro = (perimetro / 2);
area = (Math.Sqrt((semiperimetro) * (semiperimetro - lado1) * (semiperimetro - lado2) * (semiperimetro - lado3)));
textBox4.Visible = true;
textBox4.Text = (area.ToString());
textBox5.Visible = true;
textBox5.Text = (perimetro.ToString());
}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox4.Clear();
textBox5.Clear();
textBox1.Focus();
}
private void button3_Click(object sender, EventArgs e)
{
Close();
}
}
}
using System;using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form5 : Form
{
public Form5()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
double radio, area, perimetro;
radio = int.Parse(textBox1.Text);
area = ((Math.PI)*(Math.Pow(radio,2)));
perimetro = (2*Math.PI*radio);
textBox2.Visible = true;
textBox2.Text = (area.ToString());
textBox3.Visible = true;
textBox3.Text = (perimetro.ToString());
}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox1.Focus();
}
private void button3_Click(object sender, EventArgs e)
{
Close();
}
}
}
jueves, 26 de febrero de 2009
Hoja 3 Problema2 (consola)
using System;using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
int p1, p2, p3, p4, p5, opcion;
char sigue;
double total = 0.0;
Console.Clear();
total = 0.0;
Console.WriteLine("\n\t\tproductos");
Console.WriteLine("\n\t\t 1) producto 1 $29.80................ ");
Console.WriteLine("\n\t\t 2) producto 2 $45.00................. ");
Console.WriteLine("\n\t\t 3) producto 3 $99.80................. ");
Console.WriteLine("\n\t\t 4) producto 4 $44.90................. ");
Console.WriteLine("\n\t\t 5) producto 5 $68.75................. ");
Console.Write("\n\t\tSelecciona opcion : ");
do
{
Console.SetCursorPosition(35, 17);
opcion = int.Parse(Console.ReadLine());
switch (opcion)
{
case 1: Console.SetCursorPosition(55, 3);
p1 = int.Parse(Console.ReadLine());
total = total + p1 * 29.80;
break;
case 2: Console.SetCursorPosition(55, 5);
p2 = int.Parse(Console.ReadLine());
total = total + p2 * 45.00;
break;
case 3: Console.SetCursorPosition(55, 7);
p3 = int.Parse(Console.ReadLine());
total = total + p3 * 99.80;
break;
case 4: Console.SetCursorPosition(55, 9);
p4 = int.Parse(Console.ReadLine());
total = total + p4 * 44.90;
break;
case 5: Console.SetCursorPosition(55, 11);
p5 = int.Parse(Console.ReadLine());
total = total + p5 * 68.75;
break;
default:
Console.SetCursorPosition(55, 17);
Console.WriteLine("Presiono opcion equivocada ");
break;
}
Console.SetCursorPosition(20, 20);
Console.Write("Desea otro producto s/n : ");
sigue = char.Parse(Console.ReadLine());
}
while (sigue == 's' sigue == 'S');
Console.SetCursorPosition(20, 22);
Console.WriteLine("El total es {0}", total);
Console.ReadKey();
}
}
}
Hoja 3: Problema1 (consola)
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
double cuadrado,lado,areacuadrado,perimetrocuadrado;
double rectangulo, lado1, lado2, arearectangulo, perimetrorectangulo;
double triangulo, lado11, lado12, lado13, areatriangulo, perimetrotriangulo, semiperimetro;
double circulo, radio, areacirculo, perimetrocirculo;
char seguir;
do
{
Console.Clear();
Console.WriteLine("de que figura quiere el area y perimetro");
Console.WriteLine("(1)cuadrado");
Console.WriteLine("(2)rectangulo");
Console.WriteLine("(3)triangulo");
Console.WriteLine("(4)circulo");
int opcion = int.Parse(Console.ReadLine());
switch (opcion)
{
case 1: Console.WriteLine("cudarado");
Console.WriteLine("introduce el valor del lado");
lado = double.Parse(Console.ReadLine());
areacuadrado = lado * lado;
perimetrocuadrado = lado * 4;
Console.WriteLine("area" + areacuadrado);
Console.WriteLine("perimetro" + perimetrocuadrado);
break;
case 2: Console.WriteLine("rectangulo");
Console.WriteLine("introduce el valor del largo");
lado1 = double.Parse(Console.ReadLine());
Console.WriteLine("introduce el valor del ancho");
lado2 = double.Parse(Console.ReadLine());
arearectangulo = lado1 * lado2;
perimetrorectangulo = (lado1 * 2) + (lado2 * 2);
Console.WriteLine("area" + arearectangulo);
Console.WriteLine("perimetro" + perimetrorectangulo);
break;
case 3: Console.WriteLine("triangulo");
Console.WriteLine("introduce el valor del lado1");
lado11 = double.Parse(Console.ReadLine());
Console.WriteLine("introduce el valor del lado2");
lado12 = double.Parse(Console.ReadLine());
Console.WriteLine("introduce el valor del lado3");
lado13 = double.Parse(Console.ReadLine());
perimetrotriangulo = (lado11 + lado12 + lado13);
semiperimetro = (perimetrotriangulo / 2);
areatriangulo = (Math.Sqrt((semiperimetro) * (semiperimetro - lado11) * (semiperimetro - lado12) * (semiperimetro - lado13)));
Console.WriteLine("area" + areatriangulo);
Console.WriteLine("perimetro" + perimetrotriangulo);
break;
case 4: Console.WriteLine("circulo");
Console.WriteLine("introduce el valor del radio");
radio = double.Parse(Console.ReadLine());
areacirculo = (Math.PI) * (Math.Pow(radio,2));
perimetrocirculo = 2 * (Math.PI) * (radio);
Console.WriteLine("area" + areacirculo);
Console.WriteLine("perimetro" + perimetrocirculo);
break;
default:
Console.WriteLine("no es opcion valida");
break;
}
Console.WriteLine("desea hacer otro calculo s/n:");
seguir = char.Parse(Console.ReadLine());
}
while (seguir == 's' seguir == 'S');
Console.ReadKey();
}
}
}
}
}
Suscribirse a:
Entradas (Atom)