librodec# 2015 i

Microsoft C# - Archivo de datos

CAPÍTULO 1

ARCHIVOS DE DATOS DE

ACCESO DIRECTO CON C#

Ing. Javier Alberto Manrique Quiñonez / Rudy Alvino Penadillo Lirio Página 1


ARCHIVOS DE DATOSEl almacenamiento en variables, objetos, arreglos o colecciones de datos es temporal; los datos se pierden cuando una variable local queda fuera del alcance o cuando la aplicación llega a su término. {Las computadoras utilizan archivos de datos para la retención a largo plazo de grandes cantidades de datos, incluso hasta después de que terminan las aplicaciones que crean esos datos. Se denominan datos persistentes a aquellos que duran más allá de la duración de la ejecución de la aplicación. Las computadoras almacenan archivos en dispositivos de almacenamiento secundario como disco duros, USB, discos ópticos y cintas magnéticas, entre otros.

El procesamiento de archivos es una de las herramientas más importantes que debe tener un lenguaje de programación para soportar las aplicaciones comerciales que generalmente procesan grandes cantidades de datos persistentes. C# posee pose poderosas características de procesamiento de archivos de datos, las cuales permiten a una aplicación leer y escribir datos en memoria interna y/o memoria externa o en archivos a través de la red. Entre las operaciones que se pueden realizar con archivos de datos tenemos:

Agregar registros de datos (Alta) Eliminar registros de datos (Baja) Acceder a registros, siguiendo algún método (secuencial, directo, secuencial indexado, etc) Consultar la información almacenada en los registros de datos (Consulta) Modificar la información de los registros de datos (Modificación)

ORGANIZACIÓN DE LOS ARCHIVOS DE DATOSLos archivos de datos se organizan de la siguiente forma:

Campo Es el agrupamiento de caracteres o números para formar una palabra o una cifra completa, como el código o nombre de un producto.

Registro Es un grupo de campos relacionados considerados como una unidad.Archivo/tabla Es un grupo de registros relacionados del mismo tipo.Base de datos Es un grupo de archivos/tablas relacionados que almacenan la información de una

organización.

ORGANIZACIÓN SECUENCIALEs el método para almacenar registros de datos, en el cual los registros se deben recuperar en el mismo orden en que se almacenaron.

ORGANIZACIÓN DIRECTA O ALEATORIAEs el método para almacenar registros de datos en un archivo de modo que se pueda acceder a ellos en cualquier secuencia sin importar su orden físico real en los medios de almacenamiento.

ORGANIZACIÓN SECUENCIAL INDEXADAEl método utiliza un índice de campo clave para buscar y localizar físicamente un registro, como pueden localizarse los temas clave en un libro. Utiliza un arreglo de índices en la memoria RAM donde se almacena en forma ordenada el campo clave y la dirección física de los registros. Después de operaciones de mantenimiento este arreglo de índices puede ser grabado en forma separada en el medio magnético para luego ser utilizado en la próxima sesión previa carga de los índices en la memoria RAM. Un índice es una tabla o lista que contiene las claves de registros con las posiciones físicas en archivo de acceso indexado.

JERARQUÍA DE DATOSLa jerarquía se refiera a la organización de los datos para su almacenamiento en medios de almacenamiento externo. La máxima jerarquía es la base de datos. Luego tenemos los archivos de datos que se conocen también como tablas, los registros, los campos, los bytes y los bits. El campo es considerado como la unidad mínima de información. Para visualizar la jerarquía de datos se presenta la Figura 1.1.



Figura 1.1: Jerarquía de datos

ARCHIVOS DE ACCESO DIRECTO O ALEATORIO EN C# (BINARIOS)Todos los lenguajes de programación tienen alguna forma de interactuar con los sistemas de archivos de datos y C# no es la excepción. Si se está desarrollando una aplicación C# para uso interno, probablemente será necesario el acceso directo a archivos. Antes de realizar acciones sobre un archivo, necesitamos un poco de información sobre ese archivo. A menudo, no se desea leer un archivo de principio a fin; sino acceder al archivo como una base de datos, donde se salta de un registro a otro; cada uno en diferentes partes del archivo. C# proporciona una clase RandomAccessFile para este tipo de archivo de entrada/salida.

FLUJOSLa comunicación entre una aplicación y el origen o el destino de cierta información se realiza mediante un flujo de información (stream), que no es más que un objeto que hace de intermediario entre la aplicación y el origen o el destino de datos de la información. De esta forma la aplicación leerá o escribirá en el flujo sin importarle desde donde vienen los datos o donde se va.

El espacio de nombres System.IO de la Biblioteca.Net contiene una colección de clases que soportan estos algoritmos para leer y escribir datos. La clase System.IO permite leer y escribir caracteres en secuencias o en grupos contiguos de datos, mediante el uso de codificación específica para convertir caracteres a bytes y viceversa. La clase FileStream subclase de Stream permite escribir y leer datos de un archivo byte a byte; analógicamente, las clases StreamWriter y StreamReader subclases de TextWriter y textReader permiten escribir y leer caracteres. Las clases BinaryWriter y BinaryReader permiten escribir y leer datos de cualquier tipo primitivos en binario y cadena de caracteres.

FLUJO DE BYTESLos datos pueden ser escritos o leídos de un archivo byte a byte utilizando un flujo de la clase FileStream

FileStreamUn flujo de la clase FileStream permite leer y escribir bytes en un archivo. Esta clase además de los métodos que hereda de la clase Stream, proporciona el constructor siguiente:

FileStream(string nombre, FileMode , FileAccess acceso)


Base de datos

Archivo/tabla

Registro

Campo

Byte

Bit 1 1

10000011 Letra C en ASCII

idProducto Nombre del idMarca stockMinimo stock precio de Precio de Fecha de producto compra Venta Alta 1 Camisa 1 20 25 40.00 65.00 02/04/2016

idProducto Nombre del idMarca stockMinimo stock precio de Precio de Fecha de producto compra Venta Alta 1 Camisa 1 20 25 40.00 65.00 02/04/2016 2 Polo 2 25 20 30.00 40.00 02/02/2016

Nombre delproducto Camisa

Archivo de producto

Archivo de Marca

https://msdn.microsoft.com/es-es/library/system.io(v=vs.71).aspx


El constructor abre el flujo de entrada y salida (para leer y escribir) vinculando con el archivo especificado por el nombre y especificando el tipo de acceso (leer, escribir o leer y escribir). El parámetro nombre es una cadena de caracteres que especifica la ruta donde se guarda o se guardará el archivo. El parámetro modo, del tipo enumerado FileMode, puede tomar diferentes tipos de valores. En la tabla 1.1 se muestra los tipos de valores que puede tomar el parámetro FileMode.

Tabla 1.1: Tipo de valores del parámetro FileMode

CreateNew Crear un nuevo archivo. Si el archivo existe se lanzará una excepción del tipo IOExceptionCreate Crea un nuevo archivo. Si el archivo existe será sobreescritoOpen Abre un archivo existenteOpenOrCreate Abre un archivo si existe; si no, se crea un nuevo archivoTruncate Abre un archivo existente. Una vez abierto, el archivo será truncado a cero bytes de longitudAppend Abre un archivo para añadir datos al final del mismo si existe o crea uno nuevo sino existeRead Permite abrir un archivo para operaciones de lecturaReadWrite Permite abrir un archivo para operaciones de lectura / escrituraWrite Permite abrir un archivo para operaciones de escritura

FLUJOS DE DATOS PRIMITIVOSMuchas aplicaciones requieren escribir en un archivo datos de tipos primitivos (bool, double, float, long, int, short, etc) no como cadena de caracteres, sino en formato binario para posteriormente recuperarlos como tal. Para estos casos el espacio de nombres System.IO proporciona las clases BinaryReader y BinaryWriter, las cuales permiten leer y escribir datos de cualquier tipo primitivo en formato binario y cadena de caracteres en formato UTF-8. Un flujo BinaryReader sólo puede leer datos almacenados en un archivo a través de un flujo BinaryWriter.

BinaryWriterUn flujo de la clase BinaryWriter permite a una aplicación escribir datos de cualquier tipo primitivo. Se puede crear un flujo de esta clase utilizando el siguiente constructor:

BinaryWriter(Stream flujo)

Este constructor abre un flujo de salida (para escribir) hacia el archivo vinculado con otro flujo existente de la clase Stream o de sus derivadas. Ejemplo:

public static Boolean escribirRegistro(Producto oProducto, int posicion){ try

{ String archivo = Properties.Settings.Default.nombreDeArchivoProducto; int longitudDeRegistro = Properties.Settings.Default.longitudDeRegistroProducto; FileStream oFileStream = new FileStream(archivo, FileMode.OpenOrCreate, FileAccess.ReadWrite); BinaryWriter oBinaryWriter = new BinaryWriter(oFileStream); oBinaryWriter.BaseStream.Seek(posicion * longitudDeRegistro, SeekOrigin.Begin); oBinaryWriter.Write(oProducto.idProducto); oBinaryWriter.Write(oProducto.nombreDelProducto); oBinaryWriter.Write(oProducto.idMarca); oBinaryWriter.Write(oProducto.stockMinimo); oBinaryWriter.Write(oProducto.stock); oBinaryWriter.Write(oProducto.precioDeCompra); oBinaryWriter.Write(oProducto.precioDeVenta); oBinaryWriter.Write(oProducto.fechaDeAlta); oBinaryWriter.Close(); oFileStream.Close(); return true; }



catch (Exception e) { MessageBox.Show("No se pudo grabar el registro ... error de tipo " + e); return false; } }

Los métodos más utilizados de esta clase se resumen en la Tabla 1.2:

Tabla 1.2: Resumen del Método Write

Write (byte) Escribe un valor de tipo byteWrite (byte[]) Escribe una cadena como una secuencia de bytesWrite (char) Escribe un valor de tipo charWrite (char[]) Escribe una cadena como una secuencia de caracteresWrite (short) Escribe un valor de tipo shortWrite (int) Escribe un valor de tipo intWrite (long) Escribe un valor de tipo longWrite (Decimal) Escribe un valor de tipo DecimalWrite (float) Escribe un valor de tipo floatWrite (double) Escribe un valor de tipo double

Write (string) Escribe una cadena de caracteres en formato UTF-8; el primer byte o los dos primeros bytes especifican el número de bytes de datos escritos a continuación

BaseStream() Obtiene el flujo subyacente (fs en la figura anterior)Close Cierra el flujo y libera los recursos adquiridosFlush Limpia el buffer asociado con el flujoSeek Establece movimiento del puntero de Lectura/Escritura en el flujo

BinaryReaderUn flujo de la clase BinaryReader, permite a una aplicación leer datos de cualquier archivo datos de tipo primitivos escritos por un flujo de la clase BinaryWriter. Se puede crear un flujo de esta clase utilizando el siguiente constructor:

BinaryReader(Stream flujo)

Este constructor abre un flujo de entrada (para leer) desde el archivo vinculando con otro flujo existente de la clase Stream o de sus derivadas. Ejemplo:

public static Producto leerRegistro(Producto oProducto, int posicion) { string archivo = Properties.Settings.Default.nombreDeArchivoProducto; int longitudDeRegistro = Properties.Settings.Default.longitudDeRegistroProducto; FileStream oFileStream = new FileStream(archivo, FileMode.Open, FileAccess.Read); BinaryReader oBinaryReader = new BinaryReader(oFileStream); oBinaryReader.BaseStream.Seek(posicion * longitudDeRegistro, SeekOrigin.Begin); oProducto = new Producto( oBinaryReader.ReadInt32(), oBinaryReader.ReadString(), oBinaryReader.ReadInt32(), oBinaryReader.ReadInt32(), oBinaryReader.ReadInt32(), oBinaryReader.ReadDouble(), oBinaryReader.ReadDouble(), oBinaryReader.ReadString() ); oBinaryReader.Close(); oFileStream.Close(); return oProducto; }



Los métodos más utilizados de la clase BinaryReader se resumen en la Tabla 1.3.

PROPIEDADES Y MÉTODO PARA ACCESO ALEATORIOLa clase FileStream, que se deriva directamente de Stream, implementa las propiedades Position y Length y el método Seek que combinados entre sí facilitan el acceso aleatorio a un archivo.

Position : Devuelve la posición actual en bytes del puntero de lectura/escritura en un archivoLength : Devuelve la longitud del archivo en bytesSeek : Mueve el puntero de lectura/escritura a una nueva localización desplazada desp bytes de la

posición pos del archivo

La posición pos es un valor de tipo SeekOrigin que define las siguientes constantes:

Begin : Hace referencia a la primera posición en el archivoCurrent : Hace referencia a la posición actual del puntero de lectura/escrituraEnd : Hace referencia a la última posición en el archivo.

Tabla 1.3: Resumen de la clase BinaryReader

ReadByte Devuelve un valor de tipo byteReadBytes Devuelve un valor de tipo byte[ ]ReadChar Devuelve un valor de tipo charReadChars Devuelve un valor de tipo char[ ]ReadInt16 Devuelve en valor de tipo shortReadInt32 Devuelve un valor de tipo intReadInt64 Devuelve un valor de tipo longReadDecimal Devuelve un valor de tipo decimalReadSingle Devuelve una valor de tipo floatReadDouble Devuelve un valor de tipo double

ReadString Devuelve una cadena de caracteres en formato UTF-8; el primer o dos primeros bytes especifican el número de bytes de datos que serán leídos a continuación

BaseStream Obtiene el flujo subyacente Close Cierra el flujo y libera los recursos adquiridosPeekChar Obtiene el siguiente carácter sin extraerlo

A continuación se presenta un ejemplo de una aplicación que administra un archivo de acceso aleatorio que tiene las siguientes características:

a) Presenta un formulario para un Sistema de Mantenimiento ABCM de productos.b) La letra ABCM significan Altas, Bajas, Consultas y Modificación respectivamente.c) La estructura de la clase Alumno es la siguiente:

public int idProducto public string nombreDelProducto public int idMarca public int stockMinimo public int stock public double precioDeCompra public double precioDeVenta public string fechaDeAlta d) La longitud del registro es 150 bytes.e) Utiliza una clase de acceso a datos (DAO) que permite interactuar la aplicación con el archivo de datos

almacenado externamente. f) Utiliza un clase denominada ABCMAction para almacenar las constantes de las operaciones posibles.g) La Figura 1.2 visualiza el diagrama de clases de clase de la aplicación ejemplo.



h) En la Figura 1.3, Figura 1.4, Figura 1.5, Figura 1.6, Figura 1.7, Figura 1.8 y Figura 1.9 se visualizan los formularios de la aplicación ejemplo.

i) La Figura 1.10 visualiza la aplicación en el Explorador de Soluciones.J) La Figura 1.11 visualiza las propiedades seteadas para la aplicación.k) La Figura 1.12 presenta el código de la aplicación – ABCMActionl) La Figura 1.13 presenta el código de la aplicación – Programa principal.m)La Figura 1.14 presenta el código de la aplicación – Clase Alumno.n) La Figura 1.15 presenta el código de la aplicación – Clase Alumno DAO.o) La Figura 1.16 presenta Código de la aplicación – Clase FormularioABCM

Figura 5.2: Diagrama de clases



Figura 1.3: Formulario Sistema de Mantenimiento ABCM de alumnos – No action

Figura 5.4: Formulario Sistema de Mantenimiento ABCM de alumnos – Action Insertar-Buscar



Figura 1.5: Formulario Sistema de Mantenimiento ABCM de alumnos – Action Insertar-Guardar

Figura 5.6: Formulario Sistema de Mantenimiento ABCM de alumnos – Action Modificar-Guardar



Figura 5.7: Formulario Sistema de Mantenimiento ABCM de alumnos – Action Modificar-Confirmar

Figura 5.8: Formulario Sistema de Mantenimiento ABCM de alumnos – Consultar registro



Figura 5.9: Formulario Sistema de Mantenimiento ABCM de alumnos – Eliminar - Confirmar

Figura 5.10: Aplicación en el Explorador de soluciones

Figura 5.11: Propiedades seteadas para la aplicación



Figura 5.12: Código de la aplicación – ABCMAction

namespace ABCMyDAO { public class ABCMAction

{ public static int NO_ACTION = 1;public static int ACTION_BUSCAR = 2;public static int ACTION_INSERTAR = 3;public static int ACTION_MODIFICAR = 4;public static int ACTION_CANCELAR = 5;public static int ACTION_ELIMINAR = 6;public static int ACTION_CONSULTA = 7;

} }

Figura 5.13: Código de la aplicación – Programa principal

using System;using System.Windows.Forms;namespace ABCMyDAO { static class Program

{ [STAThread] static void Main()

{ Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new FormularioAlumnoABCM());

} }

}

Figura 5.14: Código de la aplicación – Clase Alumnonamespace ProyectoProducto { public class Producto { public int idProducto { get; set; } public string nombreDelProducto { get; set; } public int idMarca { get; set; } public int stockMinimo { get; set; } public int stock { get; set; } public double precioDeCompra { get; set; }



public double precioDeVenta { get; set; } public string fechaDeAlta { get; set; }

public Producto() { idProducto = 0; nombreDelProducto = ""; stockMinimo = 0; stock = 0; precioDeCompra = 0; precioDeVenta = 0; fechaDeAlta = ""; }

public Producto(int idProducto) { this.idProducto = idProducto; }

public Producto( int idProducto, string nombreDelProducto, int idMarca, int stockMinimo, int stock, double precioDeCompra, double precioDeVenta, string fechaDeAlta ) { this.idProducto = idProducto; this.nombreDelProducto = nombreDelProducto; this.idMarca = idMarca; this.stockMinimo = stockMinimo; this.stock = stock; this.precioDeCompra = precioDeCompra; this.precioDeVenta = precioDeVenta; this.fechaDeAlta = fechaDeAlta; }

public override string ToString() { return nombreDelProducto; } } }

Figura 5.15: Código de la aplicación – Clase Alumno DAOusing System;using System.Collections.Generic;using System.IO;using System.Windows.Forms;namespace ProyectoProducto { public class ProductoDAO { public static Boolean insertarRegistro(Producto oProducto) {



int posicion = numeroDeRegistros(); if (escribirRegistro(oProducto, posicion)) { return true; } else { return false; } }

public static Producto consultarRegistro(Producto oProducto ) { int posicion = buscarRegistro(oProducto.idProducto); if (posicion != -99) { oProducto = leerRegistro(oProducto, posicion); return oProducto; } else { return null; } }

public static Boolean modificarRegistro(Producto oProducto) { int posicion = buscarRegistro(oProducto.idProducto); if (posicion != -99) { if (escribirRegistro(oProducto, posicion)) { return true; } else { return false; } } else { return false; } }

public static Boolean eliminarRegistro(Producto oProducto) { int posicion = buscarRegistro(oProducto.idProducto); if (posicion != -99) { oProducto = leerRegistro(oProducto, posicion); oProducto.idProducto = 0; if (escribirRegistro(oProducto, posicion)) { return true; } else { return false; } } else { return false;



} }

public static int buscarRegistro(int busqueda) { Producto oProducto = new Producto(); int encontrado = 0; int posicion = 0; while (posicion < numeroDeRegistros() && (encontrado == 0)) { oProducto = leerRegistro(oProducto, posicion); if (busqueda == oProducto.idProducto) { encontrado = 1; } else { posicion = posicion + 1; } } if (encontrado == 1) { return posicion; } else { return -99; } }

public static Producto leerRegistro(Producto oProducto, int posicion) { string archivo = Properties.Settings.Default.nombreDeArchivoProducto; int longitudDeRegistro = Properties.Settings.Default.longitudDeRegistroProducto; FileStream oFileStream = new FileStream(archivo, FileMode.Open, FileAccess.Read); BinaryReader oBinaryReader = new BinaryReader(oFileStream); oBinaryReader.BaseStream.Seek(posicion * longitudDeRegistro, SeekOrigin.Begin); oProducto = new Producto( oBinaryReader.ReadInt32(), oBinaryReader.ReadString(), oBinaryReader.ReadInt32(), oBinaryReader.ReadInt32(), oBinaryReader.ReadInt32(), oBinaryReader.ReadDouble(), oBinaryReader.ReadDouble(), oBinaryReader.ReadString() ); oBinaryReader.Close(); oFileStream.Close(); return oProducto; }

public static Boolean escribirRegistro(Producto oProducto, int posicion) { try { String archivo = Properties.Settings.Default.nombreDeArchivoProducto; int longitudDeRegistro = Properties.Settings.Default.longitudDeRegistroProducto;

FileStream oFileStream = new FileStream(archivo, FileMode.OpenOrCreate, FileAccess.ReadWrite); BinaryWriter oBinaryWriter = new BinaryWriter(oFileStream);

oBinaryWriter.BaseStream.Seek(posicion * longitudDeRegistro, SeekOrigin.Begin);



oBinaryWriter.Write(oProducto.idProducto); oBinaryWriter.Write(oProducto.nombreDelProducto); oBinaryWriter.Write(oProducto.idMarca); oBinaryWriter.Write(oProducto.stockMinimo); oBinaryWriter.Write(oProducto.stock); oBinaryWriter.Write(oProducto.precioDeCompra); oBinaryWriter.Write(oProducto.precioDeVenta); oBinaryWriter.Write(oProducto.fechaDeAlta); oBinaryWriter.Close(); oFileStream.Close(); return true; } catch (Exception e) { MessageBox.Show("No se pudo grabar el registro ... error de tipo " + e); return false; } }

public static List<Producto> obtenerDatosEnList() { Producto oProducto = new Producto(); List<Producto> oListProducto = new List<Producto>(); for (int posicion = 0; posicion < numeroDeRegistros(); posicion = posicion + 1) { oProducto = leerRegistro(oProducto, posicion); if (oProducto.idProducto != 0) { oListProducto.Add(oProducto); } } return oListProducto; }

public static int numeroDeRegistros() { string nombreDelArchivo = Properties.Settings.Default.nombreDeArchivoProducto; int longitudDeRegistro = Properties.Settings.Default.longitudDeRegistroProducto; FileStream oFileStream = new FileStream(nombreDelArchivo, FileMode.OpenOrCreate, FileAccess.Read); int numeroDeRegistros = (int)(Math.Ceiling((double) oFileStream.Length / (double) longitudDeRegistro)); oFileStream.Close(); return numeroDeRegistros; } } }

Figura 5.16: Código de la aplicación – Clase FormularioABCM

using System;using System.Collections.Generic;using System.Windows.Forms;namespace ProyectoProducto{ public partial class FormularioProductoABCM : Form { private int action = ABCMAction.NO_ACTION; public FormularioProductoABCM()



{ InitializeComponent(); formatearTabla(); controladorDeEventosBotonesABCM(); actualizarDataGridViewProducto(); }

public void formatearTabla() { dataGridViewProducto.SelectionMode = DataGridViewSelectionMode.FullRowSelect; dataGridViewProducto.AllowUserToAddRows = false; }

public void limpiarCuadrosDeTexto() { textBoxNombreDelProducto.Text = ""; textBoxIdMarca.Text = ""; textBoxStockMinimo.Text = ""; textBoxStock.Text = ""; textBoxPrecioDeCompra.Text = ""; textBoxPrecioDeVenta.Text = ""; dateTimePickerFechaDeAlta.Text = ""; }

public void ponerProducto(Producto oProducto) { textBoxIdProducto.Text = oProducto.idProducto + ""; textBoxNombreDelProducto.Text = oProducto.nombreDelProducto; textBoxIdMarca.Text = oProducto.idMarca + ""; textBoxStockMinimo.Text = oProducto.stockMinimo + ""; textBoxStock.Text = oProducto.stock + ""; textBoxPrecioDeCompra.Text = oProducto.precioDeCompra + ""; textBoxPrecioDeVenta.Text = oProducto.precioDeVenta + ""; dateTimePickerFechaDeAlta.Text = oProducto.fechaDeAlta; }

public Producto recuperarProducto(Producto oProducto) { oProducto.idProducto = int.Parse(textBoxIdProducto.Text); oProducto.nombreDelProducto = textBoxNombreDelProducto.Text; oProducto.idMarca = int.Parse(textBoxIdMarca.Text); oProducto.stockMinimo = int.Parse(textBoxStockMinimo.Text); oProducto.stock = int.Parse(textBoxStock.Text); oProducto.precioDeCompra = double.Parse(textBoxPrecioDeCompra.Text); oProducto.precioDeVenta = double.Parse(textBoxPrecioDeVenta.Text); oProducto.fechaDeAlta = dateTimePickerFechaDeAlta.Text; return oProducto; }

public void actualizarDataGridViewProducto() { limpiarDataGridViewProducto(); List<Producto> oListProducto = ProductoDAO.obtenerDatosEnList(); for (int posicion = 0; posicion < oListProducto.Count; posicion = posicion + 1)



{ dataGridViewProducto.Rows.Add(oListProducto[posicion].idProducto, oListProducto[posicion], oListProducto[posicion].idMarca, oListProducto[posicion].stockMinimo, oListProducto[posicion].stock, oListProducto[posicion].precioDeCompra, oListProducto[posicion].precioDeVenta, oListProducto[posicion].fechaDeAlta); } }

private void habilitarBotonesABCM(Boolean cBuscar, Boolean cNuevo, Boolean cGuardar, Boolean cEditar, Boolean cEliminar, Boolean cConsultar, Boolean cCancelar, Boolean cSalir) { buttonBuscar.Enabled = cBuscar; buttonNuevo.Enabled = cNuevo; buttonGuardar.Enabled = cGuardar; buttonModificar.Enabled = cEditar; buttonEliminar.Enabled = cEliminar; buttonConsultar.Enabled = cConsultar; buttonCancelar.Enabled = cCancelar; buttonSalir.Enabled = cSalir; }

private void habilitarCajasDeTexto(Boolean activaDesactiva) { textBoxNombreDelProducto.Enabled = activaDesactiva; textBoxIdMarca.Enabled = activaDesactiva; textBoxStockMinimo.Enabled = activaDesactiva; textBoxStock.Enabled = activaDesactiva; textBoxPrecioDeCompra.Enabled = activaDesactiva; textBoxPrecioDeVenta.Enabled = activaDesactiva; dateTimePickerFechaDeAlta.Enabled = activaDesactiva; }

private void limpiarCajasDeTexto() { textBoxNombreDelProducto.Text = ""; textBoxIdMarca.Text = ""; textBoxStockMinimo.Text = ""; textBoxStock.Text = ""; textBoxPrecioDeCompra.Text = ""; textBoxPrecioDeVenta.Text = ""; dateTimePickerFechaDeAlta.Text = ""; }

private void buttonBuscar_Click(object sender, EventArgs e) { if (action == ABCMAction.ACTION_BUSCAR) { Producto oProducto = new Producto(); oProducto.idProducto = int.Parse(textBoxIdProducto.Text); oProducto = ProductoDAO.consultarRegistro(oProducto); if (oProducto != null) { MessageBox.Show("Registro existente !!!"); action = ABCMAction.NO_ACTION;



controladorDeEventosBotonesABCM(); } else { action = ABCMAction.ACTION_INSERTAR; textBoxIdProducto.Enabled = false; habilitarCajasDeTexto(true); controladorDeEventosBotonesABCM(); textBoxNombreDelProducto.Focus(); } } else { if (action == ABCMAction.ACTION_CONSULTA) { Producto oProducto = new Producto(); oProducto.idProducto = int.Parse(textBoxIdProducto.Text); oProducto = ProductoDAO.consultarRegistro(oProducto); if (oProducto != null) { action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); ponerProducto(oProducto); } else { MessageBox.Show("No se encuentra !!!"); action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); } } } }

private void buttonNuevo_Click(object sender, EventArgs e) { dataGridViewProducto.Enabled = false; textBoxIdProducto.Text = ""; limpiarCajasDeTexto(); action = ABCMAction.ACTION_BUSCAR; controladorDeEventosBotonesABCM(); textBoxIdProducto.Enabled = true; textBoxIdProducto.Focus(); }

private void buttonGuardar_Click(object sender, EventArgs e) { if (action == ABCMAction.ACTION_INSERTAR) { if (MessageBox.Show("¿Desea guardarlo?", "Confirme el guardado", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes) { Producto oProducto = new Producto(); oProducto = recuperarProducto(oProducto);



if (ProductoDAO.insertarRegistro(oProducto)) { MessageBox.Show("Operación exitosa ... !!!"); } else { MessageBox.Show("No se pudo guardar el registro ... !!!"); } action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); actualizarDataGridViewProducto(); buttonNuevo.Focus(); } else { limpiarCajasDeTexto(); action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); actualizarDataGridViewProducto(); } } else { if (action == ABCMAction.ACTION_MODIFICAR) { if (MessageBox.Show("Está seguro de guardar los datos?", "Confirme el guardado", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes) { Producto oProducto = new Producto(); oProducto = recuperarProducto(oProducto); if (ProductoDAO.modificarRegistro(oProducto)) { MessageBox.Show("Operación exitosa ... !!!"); action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); actualizarDataGridViewProducto(); actualizarDataGridViewProducto(); } else { MessageBox.Show("No se pudo guardar el registro ...!!!"); } } else { action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); } } } }

private void buttonModificar_Click(object sender, EventArgs e) {



if (dataGridViewProducto.RowCount >= 1) { int filaSeleccionada = dataGridViewProducto.CurrentRow.Index; if (filaSeleccionada != -1 && (textBoxIdProducto.Text.Length) > 0) { textBoxNombreDelProducto.Focus(); action = ABCMAction.ACTION_MODIFICAR; controladorDeEventosBotonesABCM(); } else { MessageBox.Show("No se ha seleccionado un registro ...!!!"); } } else { MessageBox.Show("No existen registros ...!!!"); } }

private void buttonEliminar_Click(object sender, EventArgs e) { if (dataGridViewProducto.RowCount >= 1) { int filaSeleccionada = dataGridViewProducto.CurrentRow.Index; if (filaSeleccionada != -1 && (textBoxIdProducto.Text.Length) > 0) { if (MessageBox.Show("Está seguro de eliminar los datos?", "Confirme la eliminación", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes) { Producto oProducto = new Producto(); oProducto = recuperarProducto(oProducto); oProducto = ProductoDAO.consultarRegistro(oProducto); if (oProducto != null) { if (ProductoDAO.eliminarRegistro(oProducto)) { MessageBox.Show("Se eliminó el registro ...!!!"); action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); actualizarDataGridViewProducto(); } else { MessageBox.Show("No se pudo eliminar el registro ...!!!"); action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); } } else { MessageBox.Show("No se pudo eliminar el registro ...!!!"); action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM();



} } else { action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); } } else { MessageBox.Show("Se tiene que seleccionar un registro ...!!!"); } } else { MessageBox.Show("No existen registros ...!!!"); } }

private void buttonCancelar_Click(object sender, EventArgs e) { action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); buttonNuevo.Focus(); }

private void buttonSalir_Click(object sender, EventArgs e) { Dispose(); }

private void limpiarDataGridViewProducto() { dataGridViewProducto.Rows.Clear(); }

private void controladorDeEventosBotonesABCM() { if (action == ABCMAction.NO_ACTION) { textBoxIdProducto.Text = ""; limpiarCajasDeTexto(); textBoxIdProducto.Enabled = false; habilitarCajasDeTexto(false); habilitarBotonesABCM(false, true, false, true, true, true, false, true); dataGridViewProducto.Enabled = true; buttonNuevo.Focus(); } else { if (action == ABCMAction.ACTION_BUSCAR) { habilitarCajasDeTexto(false);



limpiarCajasDeTexto(); habilitarBotonesABCM(true, false, false, false, false, false, true, false); } else { if (action == ABCMAction.ACTION_INSERTAR) { limpiarCajasDeTexto(); textBoxIdProducto.Enabled = false; habilitarBotonesABCM(false, false, true, false, false, false, true, false); } else { if (action == ABCMAction.ACTION_MODIFICAR) { habilitarCajasDeTexto(true); habilitarBotonesABCM(false, false, true, false, false, false, true, false); textBoxIdProducto.Enabled = false; } else { if (action == ABCMAction.ACTION_ELIMINAR) { actualizarDataGridViewProducto(); } else { if (action == ABCMAction.ACTION_CONSULTA) { habilitarCajasDeTexto(false); habilitarBotonesABCM(true, false, false, false, false, false, true, false); textBoxIdProducto.Enabled = true; } } } } } } }

private void buttonConsultar_Click(object sender, EventArgs e) { dataGridViewProducto.ClearSelection(); limpiarCajasDeTexto(); textBoxIdProducto.Text = ""; textBoxIdProducto.Enabled = true; textBoxIdProducto.Focus(); action = ABCMAction.ACTION_CONSULTA; controladorDeEventosBotonesABCM(); }

private void textBoxIdProducto_KeyPress(object sender, KeyPressEventArgs e) {



if (e.KeyChar == Convert.ToChar(Keys.Enter)) { int numero = 0; if (int.TryParse(textBoxIdProducto.Text, out numero) != true) { MessageBox.Show("Error de entrada de datos"); } else { buttonBuscar.Focus(); } } }

private void dataGridViewProducto_KeyDown(object sender, KeyEventArgs e) { if (e.KeyCode == Keys.Down) { int filaSeleccionada = dataGridViewProducto.CurrentRow.Index + 1; if (filaSeleccionada >= dataGridViewProducto.RowCount) { filaSeleccionada = filaSeleccionada - 1; } else { Producto oProductoSeleccionado = (Producto)dataGridViewProducto.Rows[filaSeleccionada].Cells[1].Value; ponerProducto(oProductoSeleccionado); } } if (e.KeyCode == Keys.Up) { int filaSeleccionada = dataGridViewProducto.CurrentRow.Index - 1; if (filaSeleccionada <= -1) { filaSeleccionada = filaSeleccionada + 1; } else { Producto oProductoSeleccionado = (Producto)dataGridViewProducto.Rows[filaSeleccionada].Cells[1].Value; ponerProducto(oProductoSeleccionado); } } }

private void dataGridViewProducto_MouseClick(object sender, MouseEventArgs e) { if (e.Clicks == 1 && dataGridViewProducto.RowCount >= 1) { int filaSeleccionada = dataGridViewProducto.CurrentRow.Index; if (filaSeleccionada != -1) {



Producto oProductoSeleccionado = (Producto)dataGridViewProducto.Rows[filaSeleccionada].Cells[1].Value; ponerProducto(oProductoSeleccionado); } } }

private void FormularioProductoABCM_FormClosing(object sender, FormClosingEventArgs e) { DialogResult dialogo = MessageBox.Show("¿Desea cerrar el formulario?", "Cuidado", MessageBoxButtons.YesNo); if (dialogo == DialogResult.No) { e.Cancel = true; } else { if (dialogo == DialogResult.No) { e.Cancel = false; } } } }}

El código de la aplicación se presenta en el Cd que acompaña el libro con el nombre de FormularioABCM - Archivo de datos Propiedades.



CAPÍTULO 6

ARCHIVOS DE DATOS CON REPORTES CON C#



ARCHIVOS DE DATOS Y REPORTES CON CRYSTAL REPORTCrystal Reports es una aplicación de inteligencia empresarial utilizada para diseñar y generar informes desde una amplia gama de fuentes de datos (archivo de datos y bases de datos). Varias aplicaciones, como Microsoft Visual Studio, incluyen una versiónOEM de Crystal Reports como una herramienta de propósito general para informes/reportes. Crystal Reports se convirtió en el escritor de informes estándar cuando Microsoft lo liberó con Visual Basic.

Para el desarrollo de ejemplo se utilizará la aplicación desarrollada en el Capítuo 3 - Sistema de mantenimiento ABCM de alumnos por lo que no se la describirá en forma repetida. Se debe construir sistema de menú principal (FormSistemaDeMenu) con las opciones Alumnos y Reporte. La Figura 5.1 y la Figura 5.2 muestra el Formulario que contiene el sistema de menú principal con las opciones Formulario ABCM y Reporte de alumnos. El código del Formulario FormSistema de menú se visualiza en la Figura 5.3.

Figura 6.1: Sistema de Menú Principal – Opción Formulario ABCM

Figura 6.2: Sistema de Menú Principal – Opción Reporte de alumnos


http://es.wikipedia.org/wiki/Visual_Basic

http://es.wikipedia.org/wiki/Microsoft

http://es.wikipedia.org/wiki/OEM

http://es.wikipedia.org/wiki/Microsoft_Visual_Studio

http://es.wikipedia.org/wiki/Microsoft_Visual_Studio

http://es.wikipedia.org/wiki/Base_de_datos

http://es.wikipedia.org/wiki/Inteligencia_empresarial

http://es.wikipedia.org/wiki/Software


Figura 6.3: Código del Formulario Sistema de Menú

La Figura 6.4 muestra la aplicación en el explorador de aplicaciones. Note algunos objetos nuevos como DataSetAlumno.xsd y CrystalReporte.rpt que son un DataSet (Conjunto de datos) y un reporte diseñado utilizando Crystal Report.

Figura 6.4: Aplicación en el explorador de soluciones



La Figura 6.5 muestra la configuración de proyecto, la cual tiene que ser personalizada utilizando como versión de .NET Framework destino el .NET Framework 4

Para crear el DataSetAlumno (Conjunto de datos alumno) se debe seguir el siguiente procedimiento:

Hacer clic derecho en el proyecto ABCMyDAO y seleccionar Agregar- NuevoElemento. En la Figura 6.5 nuestra lo indicado.

Figura 6.5: Agregar nuevo elemento



Seleccione Datos – Conjunto de datos. Escriba DataSetAlumno como nombre del Conjunto de datos. En la Figura 6.6 nuestra lo indicado.

Figura 6.6: Selección de datos – Conjunto de datos

Verifique que se muestra el diseñador de DataSet. La Figura 6.7 muestra el diseñador de DataSet.

Figura 6.7: Diseñador de DataSet



En el área de diseño de DataSet haga clic derecho y seleccione del menú conceptual Agregar – Tabla de datos. En la Figura 6.8 nuestra lo indicado.

Figura 6.8: Selección Agregar – Tabla de datos

En el área de diseño de DataSet seleccione el DataTable y haga clic derecho y seleccione del menú conceptual Agregar – Columna. En la Figura 6.9 nuestra lo indicado.

Figura 6.9: Selección Agregar – Columna



Verifique que el diseñador de DataSet se visualice como en la Figura 6.10, en la cual se se observa que se ha creado un DataTable con dos columnas (DataComun1 y DataColumn2)

Figura 6.10: DataTable1

Para crear un reporte utilizando Crystal report se debe seguir el siguiente procedimiento:



.



Seleccione Reporting – Crystal Reports. Escriba CrystalReporte como nombre del Reporte. En la Figura 6.12 nuestra lo indicado.

Figura 6.12: Selección Reporting – Crystal Reports

Seleccione Estándar y haga clic en el botón de comando Aceptar. En la Figura 6.13 nuestra lo indicado.

Figura 6.13: Selección Estándar – Botón de comando Aceptar



Seleccione en datos del proyecto ADO.NET DataSets - ABCMyDAO.DataSetAlumno - DataTable1. Luego haga

clic en el botón de comando . En la Figura 6.14 nuestra lo indicado.

Figura 6.14: Datos del proyecto ADO.NET DataSets-ABCMyDAO.DataSetAlumnoDataTable1

Verifique que la ventana del asistente para la creación de informes estándar se visualice como en la Figura 6.15. Luego haga clic en el botón de comando siguiente.

Figura 6.15: Asistente para la creación de informes estándar



Seleccione todos los campos del DataTable1 haciendo clic en el botón de comando . La Figura 6.16. muestra el asistente en la selección de campos a mostrar.

Figura 6.16: Selección de campos a mostrar

Verifique que la ventana del asistente para la creación de informes estándar se visualice como en la Figura 6.17. Luego haga clic en el botón de comando Finalizar.




Verifique que la ventana del reporte se visualice como en la Figura 6.18.

Figura 6.18: Ventana de reporte

Para crear un formulario para desplegar el reporte se debe seguir el siguiente procedimiento:



.



Seleccione Windows Forms – Windows Forms. Escriba FormularioReporte como nombre del Formulario. En la Figura 6.20 nuestra lo indicado.

Figura 6.20: Selección Windows Forms- Windows Forms

Del cuadro de herramientas arrastre el control CrystalReportViewer. En la Figura 6.21 nuestra lo indicado.

Figura 6.21: Selección de control CrystalReportViewer al FormularioReporte



Verifique que el FormularioReporte se visualice como en la Figura 6.22. y el icono señalado por la fecha. Este icono activa el menú conceptual Tareas del CrystalReportViewer

Figura 6.22: Ventana FormularioReporte

Del menú conceptual Tareas del CrystalReportViewer seleccione “Elegir un informe en Crystal…” tal como se presenta en la Figura 6.23.

Figura 6.23 Menú conceptual tareas de CrystaReportViewer



En elegir un informe de Crystal – cristalReportViewer1 seleccione Crystalreport1.rpt tal como se presenta en la Figura 6.24.

Figura 6.24: Menú conceptual tareas de CrystalreportViewer con selección de reporte

Verifique que el FormularioReporte.cs se presente como en la Figura 6.25

Figura 6.25: Ventana FormularioReporte



Pulse F7 ingrese el código del FormularioReporte el cual se presenta en la Figura 6.26.

Figura 6.26: Código del FormularioReporte

Haga docle clic en el objeto app.config del Explorador de soluciones. En la Figura 6.27. se visualiza el objeto app.Config.

Figura 6.27: Objeto app.Config en el explorador de soluciones



Agregue el siguiente código en el objeto app.config. En la Figura 6.28. el código a agregarse en el objeto app.Config.

Figura 6.28: Código a agregar en el Objeto app.Config

Ejecute el proyecto y verifique que el reporte se visualice como en la Figura 6.29.

Figura 6.29: Ejecución del reporte

El código de la aplicación se presenta en el Cd que acompaña el libro con el nombre de FormularioABCM-ArchivoDeDatos_y_ReporteConCrystal.



CAPÍTULO 7

ARCHIVOS DE DATOS DE

ACCESO SECUENCIAL CON C#



ARCHIVOS DE DATOS DE ACCESO SECUENCIALComo ya se ha dicho en el capítulo anterior, el almacenamiento en variables, arreglos o colecciones es temporal; los datos se pierden cuando una variable local queda fuera del alcance del método o cuando la aplicación termina. La organización secuencial es una alternativa a la organización directa. La organización secuencial es el método en el cual los registros se deben acceder (leer) en el mismo orden en que se almacenaron, por lo que su acceso se realiza utilizando el proceso secuencial. Para su manejo eficiente se puede combinar la organización secuencial con el uso de arreglos de objetos. Esto permitiría almacenar los datos en archivos de datos y para el mantenimiento los datos se cargarían en la memoria. Al terminar la ejecución de la aplicación los datos actualizados se regrabarían en el archivo secuencial utilizando la organización secuencial.

FLUJOSLos ejemplos posteriores utilizarán archivos de texto y por lo que la comunicación entre una aplicación y el origen o el destino del archivo se realizará de forma similar a los archivos binarios. Esto es, mediante el uso de flujos de información (stream), que no es más que un objeto que hace de intermediario entre la aplicación y el origen o el destino de datos. De esta forma la aplicación leerá o escribirá en el flujo sin importarle desde donde vienen o van los datos. Los archivos de texto utilizan el espacio de nombres System.IO de la biblioteca .Net que contiene una colección de clases que soportan la lectura y escritura en archivos. La clase FileStream subclase de Stream permite escribir y leer datos de un archivo byte a byte; analógicamente, las clases StreamWriter y StreamReader subclases de TextWriter y TextReader permiten escribir y leer caracteres o texto.

FLUJO DE BYTES EN ARCHIVO DE TEXTOLos datos pueden ser escritos o leídos de un archivo byte a byte utilizando un flujo de la clase FileStream

FileStreamUn flujo de la clase FileStream permite leer y escribir bytes en un archivo. Esta clase además de los métodos que hereda de la clase Stream, proporciona el constructor siguiente:

FileStream(string nombre, FileMode , FileAccess acceso)

El constructor abre el flujo de entrada y salida (para leer y escribir) vinculando con el archivo especificado por el nombre y especificando el tipo de acceso (leer, escribir o leer y escribir). El parámetro nombre es una cadena de caracteres que especifica la ruta donde se guarda o se guardará el archivo. El parámetro modo, del tipo enumerado FileMode, puede tomar diferentes tipos de valores. En la tabla 5.1 se muestra los tipos de valores que puede tomar el parámetro FileMode.

Tabla 5.1: Tipo de valores del parámetro FileModeCreateNew Crear un nuevo archivo. Si el archivo existe se lanzará una excepción del tipo IOExceptionCreate Crea un nuevo archivo. Si el archivo existe será sobreescritoOpen Abre un archivo existenteOpenOrCreate Abre un archivo si existe; si no, se crea un nuevo archivoTruncate Abre un archivo existente. Una vez abierto, el archivo será truncado a cero bytes de longitudAppend Abre un archivo para añadir datos al final del mismo si existe o crea uno nuevo sino existeRead Permite abrir un archivo para operaciones de lecturaReadWrite Permite abrir un archivo para operaciones de lectura / escrituraWrite Permite abrir un archivo para operaciones de escritura

FLUJOS DE CARACTERESLos datos pueden ser escritos y leídos de un archivo carácter por carácter den forma portable (UTF-8: UCS Transformation Format, formato 8 de bits en el que cada carácter Unicode emplea 1 o más bytes) utilizando flujos de las clases StreamWriter y StreamReader, subclases de TextWriter y textReader respectivamente.

StreamWriterUn flujo de la clase StreamWriter permite escribir caracteres en un archivo. Esta clase, además de los métodos que hereda de la clase TextWriter, proporciona los siguientes constructores:



StreamWriter(string flujo)

Este constructor abre un flujo de salida (para escribir) hacia el archivo vinculado con otro flujo existente de la clase Stream o de sus derivadas. El flujo de la clase StreamWriter actúa como un filtro; los datos enviados al destino son transformados en formato portable UTF-8 y viceversa si son recuperados a través de un flujo de la clase StreamReader, los cual hace que la aplicación lea o escriba datos a través del filtro.

StreamWriter posee métodos como Write, Writeline y Flush. Write permite escribir cualquier tipo de datos primitivos, arreglo de caracteres, objetos String con o sin formato en forma de cadena. Estos datos escritos (grabados) se caracterizan porque ocupan bastante espacio en el disco. Writeline hace lo mismo, pero añade los caracteres ‘\r\n’. Flush limpia el buffer de salida volcando los datos en el archivo vinculado al flujo. Además, en la utilización de Write o WriteLine se puede utilizar una salida formateada. Esto se puede realizar a través de String.Format, que convierte el valor de un objeto en una representación de cadena basada en un formato personalizado (plantilla) que se encribe entre llaves ("{}"). La sintaxis de un plantilla de formato es la siguiente:

String cadena = String.Format("{indice1,longitud1}{indice2, longitud2, …}”, objeto1,objeto2, …);

cadena : Objeto de tipo string que se grabará utilizando Write o WriteLine.índiceN : Posición del objeto que inicia en cero en la lista de argumentos que se van a dar formato. longitudN : Número mínimo de caracteres de la representación de cadena del parámetro. Si su valor es

positivo, el objeto se alineará a la derecha; si es negativo el objeto se alineará a la izquierda.objetoN : Variable numérica o variable de cadena.

A continuación se presenta un ejemplo de utilización de flujo de caracteres para escritura:

public void grabarArchivoDeTexto(SaveFileDialog oSaveFileDialog, Alumno[] oArregloAlumno){ FileStream oFileStream=new FileStream(oSaveFileDialog.FileName, FileMode.Create, FileAccess.Write);

StreamWriter oStreamWriter = new StreamWriter(oFileStream); try { for (int i = 0; i<FormularioSistemaDeMenu.numeroDeAlumno; i=i+1) { String output = String.Format("{0,-5} {1,-25} {2,-5} {3,-5} {4,-5} {5,-5}", oArregloAlumno[i].alumno_id.ToString(),

oArregloAlumno[i].apellidoNombre, oArregloAlumno[i].evaluacionParcial1.ToString(), oArregloAlumno[i].evaluacionParcial2.ToString(), oArregloAlumno[i].promedioDeTrabajo.ToString(), oArregloAlumno[i].promedioFinal.ToString() ); oStreamWriter.WriteLine(output); } } . . . }

StreamReaderUn flujo de la clase StreamReader, permite a una aplicación leer caracteres desde cualquier archivo datos grabados en formato texto. Se puede crear un flujo de esta clase utilizando el siguiente constructor:

StreamReader(Stream flujo)

Este constructor abre un flujo de entrada (para leer) desde el archivo vinculando con otro flujo existente de la clase Stream o de sus derivadas. La funcionalidad de esta clase está soportada por varios métodos entre los que cabe destacar Read, ReadLine, Peek y DiscardBufferedData. Read permite leer un carácter o un conjunto de caracteres. Readline permite leer una línea. Una línea está definida como una secuencia de caracteres seguidos por ‘\r, ’\n’ , o bien por ‘\r ’\n’. Peek permite obtener el siguiente carácter a leer pero sin extraerlo del buffer



asociado con el flujo. DiscardBufferedData permite eliminar los caracteres que actualmente hay en el buffer asociado con el flujo. Ejemplo:

public Alumno[] CargarArchivoDeTexto(OpenFileDialog oOpenFileDialog, Alumno[] oArregloAlumno) { int tamañoDelRegistro=51; int numeroDeRegistros; FileStream oFileStream=new FileStream(oOpenFileDialog.FileName, FileMode.Open, FileAccess.Read); StreamReader oStreamReader = new StreamReader(oFileStream); FileInfo oFileInfo = new FileInfo(oOpenFileDialog.FileName); int tamañoDelArchivo = (int) oFileInfo.Length; numeroDeRegistros=tamañoDelArchivo/tamañoDelRegistro; try { String linea; int i=0; while (i<numeroDeRegistros) { linea=oStreamReader.ReadLine(); Alumno oAlumno=new Alumno(); oAlumno.alumno_id = Int32.Parse(linea.Substring(0,5).Trim()); oAlumno.apellidoNombre = linea.Substring(5, 25).Trim(); oAlumno.evaluacionParcial1 = double.Parse(linea.Substring(30,5).Trim()); oAlumno.evaluacionParcial2 = double.Parse(linea.Substring(35,5).Trim()); oAlumno.promedioDeTrabajo = double.Parse(linea.Substring(40,5).Trim()); oAlumno.promedioFinal = double.Parse(linea.Substring(45,5).Trim()); oArregloAlumno[i] = oAlumno; i=i+1; } return oArregloAlumno; } . . . }

Para la selección del archivo para abrir o guardar se utiliza la Clase OpenFileDialog y SaveFileDialog respectivamente. OpenFileDialog permite al usuario examinar una unidad de disco, carpetas y visualizar archivos con extensión especificada y finalmente seleccionar el nombre de un archivo. Una vez realizada la selección, la propiedad FileName contendrá la ruta y el nombre del archivo seleecionado. Además se tiene las siguientes propiedades:

OpenFileDialog.ShowDialogMuestra un OpenFileDialog que es modal con respecto al formulario que hace la llamada.

DialogResultObtiene o establece el resultado del cuadro de diálogo. El valor de tipo DialogResult devuelto por ShowDialog indica si el usuario aceptó la operación (Ok) o la Canceló (Cancel). Cuando el usuario hace clic en el control de Button, el valor asignado a la propiedad de DialogResult de Button se asigna a la propiedad de DialogResult . DialogoResult tiene los siguientes valores:

DialogResult.Abort : El valor devuelto por el cuadro de diálogo es Abort (suele enviarse desde un botón Anular).

DialogResult.Cancel : El valor devuelto por el cuadro de diálogo es Cancel (suele enviarse desde un botón Cancelar).

DialogResult.Ignore : El valor devuelto por el cuadro de diálogo es Ignore (suele enviarse desde un botón Omitir).

DialogResult.No : El valor devuelto por el cuadro de diálogo es No (suele enviarse desde un botón de etiqueta No).


http://msdn.microsoft.com/es-es/library/system.windows.forms.button.aspx

http://msdn.microsoft.com/es-es/library/system.windows.forms.button.dialogresult.aspx

http://msdn.microsoft.com/es-es/library/system.windows.forms.button.aspx

http://msdn.microsoft.com/es-pe/library/system.windows.controls.openfiledialog(v=vs.95).aspx


DialogResult.None : El cuadro de diálogo devuelve Nothing. Esto significa que el cuadro de diálogo modal continúa ejecutándose.

DialogResult.OK : El valor devuelto por el cuadro de diálogo es OK (suele enviarse desde un botón Aceptar).

DialogResult.Retry : El valor devuelto por el cuadro de diálogo es Retry (suele enviarse desde un botón de etiqueta Reintentar).

DialogResult.Yes : El valor devuelto por el cuadro de diálogo es Yes (suele enviarse desde un botón de etiqueta Sí).

Además OpenFileDialog tiene las siguientes propiedades:

OpenFileDialog . InitialDirectory. Obtiene o establece el directorio inicial que muestra el cuadro de diálogo OpenFileDialog . OpenFileDialog.Title. Proporciona le nombre del Cuadro de diálogo.OpenFileDialog.Filename. Obtiene el nombre de un de un archivo seleccionado por OpenFileDialog. FileInfo.Length. Obtiene el tamaño, en bytes, del archivo actual. FileDialog.Filter. Obtiene o establece la cadena de filtro que determina qué tipos de archivo se muestran desde OpenFileDialog o SaveFileDialog. Un objeto String que contiene el filtro. El valor predeterminado es Empty, que indica que no se aplica ningún filtro y que se muestran todos los tipos de archivo. Al menos, una Extension debe describir cada tipo de archivo. Si se usa más de una Extension, se deben separar por punto y coma (";"). Por ejemplo:

"*.doc" "*.xls;" "*.ppt" "*.doc;*.xls;*.ppt" "*.*" Word Documents|*.doc Excel Worksheets|*.xls PowerPoint Presentations|*.ppt Office Files|*.doc;*.xls;*.ppt All Files|*.* Word Documents|*.doc|Excel Worksheets|*.xls|PowerPoint Presentations|*.ppt|Office Files|

*.doc;*.xls;*.ppt|All Files|*.*

OpenFileDialog oOpenFileDialog = new OpenFileDialog();oOpenFileDialog.InitialDirectory="c:\\";oOpenFileDialog.Title="Selecione un archivo de texto ";oOpenFileDialog.Filter="Archivos de datos |*.dat";DialogResult oDialogResult = oOpenFileDialog.ShowDialog();if (oDialogResult==DialogResult.OK) { AlumnoDAO oAlumnoDAO=new AlumnoDAO(); oArregloAlumno=oAlumnoDAO.CargarArchivoDeTexto(oOpenFileDialog, oArregloAlumno);

…}

…

SaveFileDialog.ShowDialogEs idéntico al cuadro de diálogo OpenFileDialog donde SaveFileDialog permite al usuario seleccionar una unidad de disco, abrir una carpeta, visualizar archivos con extensión especificadas y finalmente seleccionar o proporcionar el nombre de un archivo para guardarlo. Ejemplo:

private void buttonGrabarArchivodeTexto_Click(object sender, EventArgs e) { SaveFileDialog oSaveFileDialog = new SaveFileDialog(); oSaveFileDialog.InitialDirectory="c:\\";


http://msdn.microsoft.com/es-es/library/system.string.empty.aspx

http://msdn.microsoft.com/es-es/library/system.string.aspx

http://msdn.microsoft.com/es-es/library/microsoft.win32.savefiledialog.aspx

http://msdn.microsoft.com/es-es/library/microsoft.win32.openfiledialog.aspx


oSaveFileDialog.Filter="Archivos de datos |*.dat"; oSaveFileDialog.Title="Selecione un archivo de texto "; DialogResult oDialogResult = oSaveFileDialog.ShowDialog();

if (oDialogResult==DialogResult.OK) { AlumnoDAO oAlumnoDAO=new AlumnoDAO(); oAlumnoDAO.grabarArchivoDeTexto(oSaveFileDialog, oArregloAlumno); } }

A continuación se presenta un ejemplo de una aplicación que administra un archivo de testo secuencial que tiene las siguientes características:

a) Presenta un formulario para un Ssistema de Mantenimiento ABCM de alumnos.b) La letra ABCM significan Altas, Bajas, Consultas y Modificación respectivamente.c) La estructura de la clase Alumno es la siguiente: int alumno_id

String apellidoNombredouble evaluacionParcial1

double evaluacionParcial2 double promedioDeTrabajo double promedioFinald) La longitud del registro es 52 bytes.e) Utiliza una clase de acceso a datos (DAO) que permite interactuar la aplicación con el archivo de datos de texto almacenado externamentef) Utiliza un clase denominada ABCMAction para almacenar las constantes de las operaciones posibles.g) La Figura 7.1 visualiza el diagrama de clases de clase de la aplicación ejemplo. h) En la Figura 7.2, Figura 7.3, Figura 7.4, Figura 7.5, Figura 7.6, Figura 7.7 y Figura 7.8 se visualizan los formularios de la aplicación ejemplo. i) La Figura 7.9 visualiza la aplicación en el Explorador de Soluciones.j) La Figura 7.10 presenta el código de la aplicación – ABCMAction.k) La Figura 7.11 presenta el código de la aplicación – Programa principal.l) La Figura 7.12 presenta el código de la aplicación – Clase Alumno.m) La Figura 7.13 presenta el código de la aplicación – Clase Alumno DAO.n) La Figura 7.14 presenta Código de la aplicación – Clase FormularioABCM



Figura 7.1: Diagrama de clases

Figura 7.2: Formulario Sistema de Mantenimiento ABCM de alumnos – No action



Figura 7.3: Formulario Sistema de Mantenimiento ABCM de alumnos – Action Insertar-Buscar

Figura 7.4: Formulario Sistema de Mantenimiento ABCM de alumnos – Action Insertar-Guardar



Figura 7.5: Formulario Sistema de Mantenimiento ABCM de alumnos – Action Modificar-Guardar

Figura 7.6: Formulario Sistema de Mantenimiento ABCM de alumnos – Action Modificar-Confirmar



Figura 7.7: Formulario Sistema de Mantenimiento ABCM de alumnos – Consultar

Figura 7.8: Formulario Sistema de Mantenimiento ABCM de alumnos – Eliminar - Confirmar



Figura 7.9: Aplicación en el Explorador de soluciones

Figura 7.10: Código de la aplicación – ABCMAction

using System;namespace ABCMyDAO { public class ABCMAccion

{ public static int NO_ACTION = 1;public static int ACTION_BUSCAR = 2;public static int ACTION_INSERTAR = 3;public static int ACTION_MODIFICAR = 4;public static int ACTION_CANCELAR = 5;public static int ACTION_ELIMINAR = 6;public static int ACTION_CONSULTA = 7;

}


using System;using System.Windows.Forms;namespace ABCMyDAO{ static class Program

{ [STAThread] static void Main()

{ Alumno[] oArregloAlumno = new Alumno[100]; for (int i = 0; i<100; i=i+1) { oArregloAlumno[i]=new Alumno(); }

Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); AlumnoDAO oAlumnoDAO=new AlumnoDAO(); Application.Run(new FormularioSistemaDeMenu(oArregloAlumno)); } } }



Figura 7.12: Código de la aplicación – Clase Alumnousing System;namespace ABCMyDAO

{ public class Alumno { public int alumno_id {get;set;} public String apellidoNombre {get;set;} public double evaluacionParcial1 {get;set;} public double evaluacionParcial2 {get;set;} public double promedioDeTrabajo {get;set;} public double promedioFinal {get;set;}

public Alumno ( ) { this.alumno_id = 0; this.apellidoNombre = null; this.evaluacionParcial1 = 0; this.evaluacionParcial2 = 0; this.promedioDeTrabajo = 0; }

public Alumno ( int alumno_id, String apellidoNombre, double evaluacionParcial1, double evaluacionParcial2, double promedioDeTrabajo, double promedioFinal ) { this.alumno_id = alumno_id; this.apellidoNombre = apellidoNombre; this.evaluacionParcial1 = evaluacionParcial1; this.evaluacionParcial2 = evaluacionParcial2; this .promedioDeTrabajo = promedioDeTrabajo; this .promedioFinal = promedioFinal; }

public void setPromedioFinal ( ) { this.promedioFinal =(this.evaluacionParcial1 + this.evaluacionParcial2 + this .promedioDeTrabajo) / 3; }

public override String ToString ( ) { return apellidoNombre; } } }

Figura 7.13: Código de la aplicación – Clase Alumno DAOusing System;using System.IO;using System.Windows.Forms;namespace ABCMyDAO

{ public class AlumnoDAO { public int insertarRegistro(Alumno[] oArregloAlumno, Alumno oAlumno, int numeroDeAlumno)

{ oArregloAlumno[numeroDeAlumno]=oAlumno;numeroDeAlumno=numeroDeAlumno+1;

return numeroDeAlumno; }



public Alumno consultarRegistro(Alumno[] oArregloAlumno, int numeroDeAlumno,int busqueda){ Alumno oAlumno = new Alumno();

for (int i = 0; i < numeroDeAlumno; i = i + 1) { if (oArregloAlumno[i].alumno_id==busqueda)

{ oAlumno=oArregloAlumno[i]; return oAlumno; } } return null; }

public Boolean modificarRegistro (Alumno[] oArregloAlumno, int numeroDeAlumno,int busqueda, Alumno oAlumno )

{ int indice=buscarRegistro(oArregloAlumno,numeroDeAlumno, busqueda); oArregloAlumno[indice]=oAlumno; return true;

}

public int eliminarRegistro(Alumno[] oArregloAlumno, int numeroDeAlumno, int busqueda) { int indice = buscarRegistro(oArregloAlumno, numeroDeAlumno, busqueda); for (int i = indice; i < numeroDeAlumno-1; i = i + 1) { oArregloAlumno[i]=oArregloAlumno[i+1]; } numeroDeAlumno=numeroDeAlumno-1; return numeroDeAlumno; }

public int buscarRegistro(Alumno[] oArregloAlumno, int numeroDeAlumno,int busqueda) { Alumno oAlumno = new Alumno();

for (int i = 0; i < numeroDeAlumno; i = i + 1) { if (oArregloAlumno[i].alumno_id==busqueda) { oAlumno=oArregloAlumno[i]; return i; } } return -99; }

public Alumno[] obtenerDatosEnList(Alumno[] oArregloAlumno) { return oArregloAlumno;

}

public Alumno[] CargarArchivoDeTexto(OpenFileDialog oOpenFileDialog, Alumno[] oArregloAlumno) { int tamañoDelRegistro=51; int numeroDeRegistros; FileStream oFileStream=new FileStream(oOpenFileDialog.FileName, FileMode.Open, FileAccess.Read); StreamReader oStreamReader = new StreamReader(oFileStream); FileInfo oFileInfo = new FileInfo(oOpenFileDialog.FileName); int tamañoDelArchivo = (int) oFileInfo.Length; numeroDeRegistros=tamañoDelArchivo/tamañoDelRegistro;



try { String linea; int i=0; while (i<numeroDeRegistros) { linea=oStreamReader.ReadLine(); Alumno oAlumno=new Alumno(); oAlumno.alumno_id=Int32.Parse(linea.Substring(0,5).Trim()); oAlumno.apellidoNombre = linea.Substring(5, 25).Trim(); oAlumno.evaluacionParcial1= double.Parse(linea.Substring(30,5).Trim()); oAlumno.evaluacionParcial2= double.Parse(linea.Substring(35,5).Trim()); oAlumno.promedioDeTrabajo = double.Parse(linea.Substring(40,5).Trim()); oAlumno.promedioFinal = double.Parse(linea.Substring(45,5).Trim()); oArregloAlumno[i]=oAlumno; i=i+1; } return oArregloAlumno; } catch (FileNotFoundException ex) { MessageBox.Show("El archivo no existe!"+ex); return null; } catch (IOException ex) { MessageBox.Show("El archivo no se puede leer!"+ex); return null; } } public void grabarArchivoDeTexto(SaveFileDialog oSaveFileDialog, Alumno[] oArregloAlumno) { FileStream oFileStream=new FileStream(oSaveFileDialog.FileName, FileMode.Create,

FileAccess.Write); StreamWriter oStreamWriter = new StreamWriter(oFileStream); try { for (int i = 0; i<FormularioSistemaDeMenu.numeroDeAlumno; i=i+1) { // Se utiliza String.Format para formatear la salida. // se grabará un registro con todos sus campos, los cuales se alinean a la izquierda.

String output = String.Format"{0,-5} {1,-25} {2,-5} {3,-5} {4,-5} {5,-5}", oArregloAlumno[i].alumno_id.ToString(), oArregloAlumno[i].apellidoNombre, oArregloAlumno[i].evaluacionParcial1.ToString(), oArregloAlumno[i].evaluacionParcial2.ToString(), oArregloAlumno[i].promedioDeTrabajo.ToString(), oArregloAlumno[i].promedioFinal.ToString() ); oStreamWriter.WriteLine(output); } oStreamWriter.Close(); oFileStream.Close(); } catch (IOException e) { MessageBox.Show("Error..."+e); } }

}



}Figura 7.14: Código de la aplicación – Clase FormularioABCM

using System;using System.Windows.Forms;using System.Drawing;namespace ABCMyDAO

{ public partial class FormularioABCMyDAO: Form { private int action = ABCMAction.NO_ACTION; Alumno[] oArregloAlumno; public FormularioABCMyDAO(Alumno[] oArregloAlumno) { InitializeComponent(); this.oArregloAlumno=oArregloAlumno;

controladorDeEventosBotonesABCM(); actualizarDataGridViewAlumno();

}

private void formatearDataGridView() { //Para especificar la fuente utilizada por las celdas de DataGridView dataGridViewAlumno.DefaultCellStyle.Font=new Font("Tahoma", 07);

// Para cambiar mediante programación el estilo de borde de todo el control DataGridView dataGridViewAlumno.BorderStyle=BorderStyle.Fixed3D;

// Para cambiar mediante programación el color de la línea de la cuadrícula dataGridViewAlumno.GridColor=Color.Blue;

// Para indicar la forma de selección de las filas dataGridViewAlumno.SelectionMode=DataGridViewSelectionMode.FullRowSelect;

// Para especificar los colores de primer plano y de fondo de celdas seleccionadas dataGridViewAlumno.DefaultCellStyle.SelectionForeColor=Color.Black;

dataGridViewAlumno.DefaultCellStyle.SelectionBackColor=Color.Aqua;

// Para establecer estilos de filas alternas mediante programación dataGridViewAlumno.RowsDefaultCellStyle.BackColor=Color.Pink; dataGridViewAlumno.AlternatingRowsDefaultCellStyle.BackColor=Color.Azure;

// Para especificar la alineación del texto de celdas de DataGridView dataGridViewAlumno.Columns["ColumnAlumno_id"].DefaultCellStyle.Alignment=

DataGridViewContentAlignment.MiddleRight; dataGridViewAlumno.Columns["ColumnApellidoNombre"].DefaultCellStyle.Alignment=

DataGridViewContentAlignment.MiddleLeft; dataGridViewAlumno.Columns["ColumnEvaluacionparcial1"].DefaultCellStyle.Alignment=

DataGridViewContentAlignment.MiddleRight; dataGridViewAlumno.Columns["ColumnEvaluacionparcial2"].DefaultCellStyle.Alignment=

DataGridViewContentAlignment.MiddleRight; dataGridViewAlumno.Columns["ColumnPromedioDetrabajo"].DefaultCellStyle.Alignment=

DataGridViewContentAlignment.MiddleRight; dataGridViewAlumno.Columns["ColumnPromedioFinal"].DefaultCellStyle.Alignment=

DataGridViewContentAlignment.MiddleRight;

// Para especificar los colores de primer plano y de fondo de las celdas de DataGridView dataGridViewAlumno.DefaultCellStyle.ForeColor=Color.Black; dataGridViewAlumno.DefaultCellStyle.BackColor=Color.Beige;



}private Alumno getObjetoAlumno()

{ Alumno oAlumno = new Alumno(); oAlumno.alumno_id=int.Parse(textBoxAlumno_id.Text); oAlumno.apellidoNombre=textBoxApellidoNombre.Text; oAlumno.evaluacionParcial1=double.Parse(textBoxEvaluacionParcial1.Text); oAlumno.evaluacionParcial2=double.Parse(textBoxEvaluacionParcial2.Text); oAlumno.promedioDeTrabajo=double.Parse(textBoxPromedioDeTrabajo.Text); return oAlumno; }

private void setObjetoAlumno(Alumno oAlumno) { textBoxAlumno_id.Text=oAlumno.alumno_id+""; textBoxApellidoNombre.Text=oAlumno.apellidoNombre+""; textBoxEvaluacionParcial1.Text=oAlumno.evaluacionParcial1+""; textBoxEvaluacionParcial2.Text=oAlumno.evaluacionParcial2+""; textBoxPromedioDeTrabajo.Text=oAlumno.promedioDeTrabajo+""; }

private void limpiarDataGridViewAlumno() { dataGridViewAlumno.Rows.Clear(); } private void actualizarDataGridViewAlumno() { limpiarDataGridViewAlumno(); AlumnoDAO oAlumnDAO = new AlumnoDAO(); oArregloAlumno=oAlumnDAO.obtenerDatosEnList(oArregloAlumno); for (int posicion = 0; posicion<FormularioSistemaDeMenu.numeroDeAlumno; posicion=posicion+1) { dataGridViewAlumno.Rows.Add(oArregloAlumno[posicion].alumno_id,

oArregloAlumno[posicion], oArregloAlumno[posicion].evaluacionParcial1,

oArregloAlumno[posicion].evaluacionParcial2, oArregloAlumno[posicion].promedioDeTrabajo, oArregloAlumno[posicion].promedioFinal);

} } private void dataGridViewAlumno_MouseClick(object sender, MouseEventArgs e) { if (e.Clicks==1 && FormularioSistemaDeMenu.numeroDeAlumno>=1) { int filaSeleccionada = dataGridViewAlumno.CurrentRow.Index; if (filaSeleccionada!=-1) { Alumno oAlumnoSeleccionado = (Alumno)

dataGridViewAlumno.Rows[filaSeleccionada].Cells[1].Value; setObjetoAlumno(oAlumnoSeleccionado);

} } }

private void habilitarBotonesABCM(Boolean cBuscar, Boolean cNuevo, Boolean cGuardar, Boolean cEditar, Boolean cEliminar, Boolean cConsultar, Boolean cCancelar, Boolean cSalir)

{ buttonBuscar.Enabled = cBuscar;buttonNuevo.Enabled = cNuevo;buttonGuardar.Enabled = cGuardar;buttonModificar.Enabled = cEditar;buttonEliminar.Enabled = cEliminar;buttonConsultar.Enabled = cConsultar;buttonCancelar.Enabled = cCancelar;



buttonSalir.Enabled = cSalir;}

private void habilitarCajasDeTexto(Boolean editable){ textBoxApellidoNombre.Enabled = editable;

textBoxEvaluacionParcial1.Enabled = editable;textBoxEvaluacionParcial2.Enabled = editable;textBoxPromedioDeTrabajo.Enabled = editable;

}

private void limpiarCajasDeTexto(){ textBoxApellidoNombre.Text = "";

textBoxEvaluacionParcial1.Text = "";textBoxEvaluacionParcial2.Text = "";textBoxPromedioDeTrabajo.Text = "";

}

private void buttonBuscar_Click(object sender, EventArgs e){ if (action == ABCMAction.ACTION_BUSCAR)

{ AlumnoDAO oAlumnoDAO = new AlumnoDAO();int busqueda = Int32.Parse(textBoxAlumno_id.Text);Alumno oAlumno = oAlumnoDAO.consultarRegistro(oArregloAlumno,

FormularioSistemaDeMenu.numeroDeAlumno, busqueda);if (oAlumno != null)

{ MessageBox.Show("Registro existente !!!");action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();

}else

{ action = ABCMAction.ACTION_INSERTAR;textBoxAlumno_id.Enabled = false;habilitarCajasDeTexto(true);controladorDeEventosBotonesABCM();textBoxApellidoNombre.Focus();

}}

else{ if (action == ABCMAction.ACTION_CONSULTA)

{ AlumnoDAO oAlumnoDAO = new AlumnoDAO();int busqueda = Int32.Parse(textBoxAlumno_id.Text);Alumno oAlumno = oAlumnoDAO.consultarRegistro(oArregloAlumno,

FormularioSistemaDeMenu.numeroDeAlumno, busqueda);if (oAlumno != null)

{ action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();setObjetoAlumno(oAlumno);

}else

{ MessageBox.Show("No se encuentra !!!");action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();

}}

}



}

private void buttonNuevo_Click(object sender, EventArgs e){ dataGridViewAlumno.Enabled = false;

textBoxAlumno_id.Text = "";limpiarCajasDeTexto();action = ABCMAction.ACTION_BUSCAR;controladorDeEventosBotonesABCM();textBoxAlumno_id.Enabled = true;textBoxAlumno_id.Focus();

}

private void buttonGuardar_Click(object sender, EventArgs e) { if (action==ABCMAction.ACTION_INSERTAR) { if (MessageBox.Show("¿Desea guardarlo...?", "Confirme el guardado",

MessageBoxButtons.YesNo, MessageBoxIcon.Question)==DialogResult.Yes) { AlumnoDAO oAlumnoDAO = new AlumnoDAO(); FormularioSistemaDeMenu.numeroDeAlumno=

oAlumnoDAO.insertarRegistro(oArregloAlumno, getObjetoAlumno(), FormularioSistemaDeMenu.numeroDeAlumno);

action=ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); actualizarDataGridViewAlumno(); buttonNuevo.Focus(); } else { limpiarCajasDeTexto(); action=ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); } } else { if (action==ABCMAction.ACTION_MODIFICAR)

{ if (MessageBox.Show("Está seguro de guardar las modificaciones?", "Confirme el guardado", MessageBoxButtons.YesNo, MessageBoxIcon.Question)==DialogResult.Yes)

{ AlumnoDAO oAlumnoDAO = new AlumnoDAO(); Alumno oAlumno = new Alumno(); if (oAlumnoDAO.modificarRegistro(oArregloAlumno,

FormularioSistemaDeMenu.numeroDeAlumno, int.Parse(textBoxAlumno_id.Text), getObjetoAlumno()))

{ MessageBox.Show("Operación exitosa ... !!!"); action=ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); actualizarDataGridViewAlumno(); } else { MessageBox.Show("No se pudo guardar el registro ...!!!"); } } } } }



private void buttonModificar_Click(object sender, EventArgs e) { if (FormularioSistemaDeMenu.numeroDeAlumno>=1) { int filaSeleccionada = dataGridViewAlumno.CurrentRow.Index; if (filaSeleccionada!=-1&&(textBoxAlumno_id.Text.Length)>0) { textBoxApellidoNombre.Focus(); action=ABCMAction.ACTION_MODIFICAR; controladorDeEventosBotonesABCM(); } else { MessageBox.Show("No se ha seleccionado un registro ...!!!"); } }

else { MessageBox.Show("No existen registros ...!!!"); } }

private void buttonCancelar_Click(object sender, EventArgs e) { action=ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); buttonNuevo.Focus(); }

private void buttonSalir_Click(object sender, EventArgs e) { DialogResult dialogo = MessageBox.Show("¿Desea cerrar el formulario?", "Cuidado",

MessageBoxButtons.YesNo); if (dialogo==DialogResult.Yes) { Dispose(); } }

private void controladorDeEventosBotonesABCM(){ if (action == ABCMAction.NO_ACTION)

{ textBoxAlumno_id.Text = "";limpiarCajasDeTexto();textBoxAlumno_id.Enabled = false;habilitarCajasDeTexto(false);habilitarBotonesABCM(false, true, false, true, true, true, false, true);dataGridViewAlumno.Enabled = true;buttonNuevo.Focus();

}else

{ if (action == ABCMAction.ACTION_BUSCAR){ habilitarCajasDeTexto(false);

limpiarCajasDeTexto();habilitarBotonesABCM(true, false, false, false, false, false, true, false);

}else

{ if (action == ABCMAction.ACTION_INSERTAR){ limpiarCajasDeTexto();

textBoxAlumno_id.Enabled = true;



habilitarBotonesABCM(false, false, true, false, false, false, true, false);}

else{ if (action == ABCMAction.ACTION_MODIFICAR)

{ habilitarCajasDeTexto(true);habilitarBotonesABCM(false, false, true, false, false, false, true, false);textBoxAlumno_id.Enabled = false;

}else

{ if (action == ABCMAction.ACTION_ELIMINAR){ actualizarDataGridViewAlumno();}


{ habilitarCajasDeTexto(false);habilitarBotonesABCM(true, false, false, false, false, false, true,

false);textBoxAlumno_id.Enabled = true;

}}

}}

}}

}

private void buttonEliminar_Click(object sender, EventArgs e) { if (FormularioSistemaDeMenu.numeroDeAlumno>=1) { int filaSeleccionada = dataGridViewAlumno.CurrentRow.Index; if (filaSeleccionada!=-1&&(textBoxAlumno_id.Text.Length)>0) { if (MessageBox.Show("Está seguro de eliminar los datos?", "Confirme la eliminación",

MessageBoxButtons.YesNo, MessageBoxIcon.Question)==DialogResult.Yes) { AlumnoDAO oAlumnoDAO = new AlumnoDAO(); Alumno oAlumno = new Alumno(); int busqueda = int.Parse(textBoxAlumno_id.Text); oAlumno=oAlumnoDAO.consultarRegistro(oArregloAlumno,

FormularioSistemaDeMenu.numeroDeAlumno, busqueda); if (oAlumno!=null)

{ FormularioSistemaDeMenu.numeroDeAlumno = oAlumnoDAO.eliminarRegistro(oArregloAlumno,FormularioSistemaDeMenu.numeroDeAlumno, busqueda);

MessageBox.Show("Se eliminó el registro ...!!!"); action=ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); actualizarDataGridViewAlumno(); } else

{ MessageBox.Show("No se pudo eliminar el registro ...!!!"); action=ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); } }



else { MessageBox.Show("No se pudo eliminar el registro ...!!!"); action=ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); } } else { MessageBox.Show("Se tiene que seleccionar un registro ...!!!"); } } else { MessageBox.Show("No existen registros ...!!!"); } }

private void FormularioABCMyDAOyBD_FormClosing(object sender, FormClosingEventArgs e) { DialogResult dialogo = MessageBox.Show("¿Desea cerrar el formulario?", "Cuidado",

MessageBoxButtons.YesNo); if (dialogo==DialogResult.No) { e.Cancel=true; } else { if (dialogo==DialogResult.No) { e.Cancel=false; } } }

private void dataGridViewAlumno_KeyDown(object sender, KeyEventArgs e) { if (e.KeyCode==Keys.Down) { int filaSeleccionada = dataGridViewAlumno.CurrentRow.Index+1; if (filaSeleccionada>=dataGridViewAlumno.RowCount) { filaSeleccionada=filaSeleccionada-1; } else { Alumno oAlumnoSeleccionado = (Alumno)

dataGridViewAlumno.Rows[filaSeleccionada].Cells[1].Value; setObjetoAlumno(oAlumnoSeleccionado); } }

if (e.KeyCode==Keys.Up) { int filaSeleccionada = dataGridViewAlumno.CurrentRow.Index-1; if (filaSeleccionada<=-1) { filaSeleccionada=filaSeleccionada+1; } else { Alumno oAlumnoSeleccionado = (Alumno)

dataGridViewAlumno.Rows[filaSeleccionada].Cells[1].Value; setObjetoAlumno(oAlumnoSeleccionado); } }



}

private void buttonCargarArchivoDeTexto_Click(object sender, EventArgs e) { OpenFileDialog oOpenFileDialog = new OpenFileDialog(); oOpenFileDialog.InitialDirectory="c:\\"; oOpenFileDialog.Filter="Archivos de datos |*.dat"; oOpenFileDialog.Title="Selecione un archivo de texto "; DialogResult oDialogResult = oOpenFileDialog.ShowDialog(); if (oDialogResult==DialogResult.OK) { AlumnoDAO oAlumnoDAO=new AlumnoDAO(); oArregloAlumno=oAlumnoDAO.CargarArchivoDeTexto(oOpenFileDialog, oArregloAlumno); FormularioSistemaDeMenu.numeroDeAlumno=0; for (int i=0; i<100; i=i+1) { if (oArregloAlumno[i].alumno_id!=0) { FormularioSistemaDeMenu.numeroDeAlumno=

FormularioSistemaDeMenu.numeroDeAlumno+1; } else { break; } }

for (int i=0; i<FormularioSistemaDeMenu.numeroDeAlumno; i=i+1) { dataGridViewAlumno.Rows.Add( oArregloAlumno[i].alumno_id, oArregloAlumno[i], oArregloAlumno[i].evaluacionParcial1, oArregloAlumno[i].evaluacionParcial2, oArregloAlumno[i].promedioDeTrabajo, oArregloAlumno[i].promedioFinal); } } } private void buttonGrabarArchivodeTexto_Click(object sender, EventArgs e) { SaveFileDialog oSaveFileDialog = new SaveFileDialog(); oSaveFileDialog.InitialDirectory="c:\\"; oSaveFileDialog.Filter="Archivos de datos |*.dat"; oSaveFileDialog.Title="Selecione un archivo de texto "; DialogResult oDialogResult = oSaveFileDialog.ShowDialog(); if (oDialogResult==DialogResult.OK) { AlumnoDAO oAlumnoDAO=new AlumnoDAO(); oAlumnoDAO.grabarArchivoDeTexto(oSaveFileDialog, oArregloAlumno); } }

private void buttonConsultar_Click(object sender, EventArgs e) { dataGridViewAlumno.ClearSelection();

limpiarCajasDeTexto();textBoxAlumno_id.Text = "";textBoxAlumno_id.Enabled = true;textBoxAlumno_id.Focus();action = ABCMAction.ACTION_CONSULTA;controladorDeEventosBotonesABCM();

} } }



El código de la aplicación se presenta en el Cd que acompaña el libro con el nombre de FormularioABCM-Archivo de datos con acceso secuencial.

CAPÍTULO 8

ACCESO A BASE DE DATOS C#



ACCESO A BASE DE DATOS CON C#Una base de datos es una colección de datos clasificados y estructurados que son guardados en una o varias tablas pero referenciados como si fueran una sola entidad (nombre de base de datos). Para crear y manipular la base de datos relacionales, existen varios sistemas de administración de base de datos Microsoft SQL Server, Oracle, DB2, Postgress, MySQL entre otros. Los datos en una base de datos relacional se almacenan en tablas lógicamente relacionadas entre sí utilizando campos claves. La tabla a su vez posee filas (registros) y columnas (campos). El conjunto de todos los registros forman la tabla de base de datos. Los usuarios de un sistema de administración de base de datos pueden realizar determinadas operaciones como insertar, recuperar, modificar o eliminar datos de la tabla de base de datos, así como añadir nuevas tablas o eliminarlas. Estas operaciones se expresan en el lenguaje SQL Transact.

SQL es un lenguaje estándar para interactuar con una base de datos relacional y es soportado por casi todos los administradores de base de datos actuales. En él, las unidades básicas son los campos, los registros, las tablas y relaciones entre tablas. En Anexo Nª01 muestra un resumen de las sentencias de Microsoft SQL Server 2012 R2 trabajando sobre Windows 7. Para el desarrollo del siguiente apartado se crea un script utilizando de Microsoft SQL Server 2012 R2. En la Figura 8.1 se visualiza el script para el ejemplo a realizar.

Figura 8.1: Script para creación de base de datos ejemplo

ADO.NETADO.NET es un conjunto de clases, pertenecientes al espacio de nombres System.Data (librería de clases del .NET Framework), para acceder a los datos de un origen de datos (base de datos y otros) y cualquier tipo de aplicación. Proporciona un grupo de componentes para crear aplicaciones distribuidas de uso compartido de datos. Entre las características más importantes tenemos:

ADO.NET no depende de las conexiones continuamente activas, que se refiere a que la conexión solo se realiza durante el tiempo necesario para extraer (consulta) o actualizar los datos.

Las interacciones para insertar, consultar, eliminar y actualizar registros se realizan con las sentencias SQL insert, select, delete, update respectivamente, mediante órdenes de acceso a los datos, que son objetos que encapsulan las sentencias SQL o los procedimientos almacenados que definen la operación a realizar sobre el origen de datos.



Los datos requeridos, normalmente se almacenan en memoria caché en conjunto de datos, lo que permite trabajar sin conexión sobre una copia temporal de los datos obtenidos. Los conjuntos de datos son independientes de los orígenes de datos. Cuando sea necesario, se puede restablecer la conexión con la base de datos y actualizarlos desde el conjunto de datos.

El formato de transferencia de datos es XML. La representación XML no utiliza información binaria, sino se basa en texto que permite enviarla mediante cualquier protocolo como por ejemplo HTTP.

En el Gráfico 8.2 presenta a ADO.NET y su relación entre las aplicaciones y los orígenes de datos.

Figura 8.2: ADO.Net y su relación entre las aplicaciones y origen de datos

Los componentes de ADO.NET están diseñados para separar el acceso a datos de la manipulación de los mismos y son: DataSet y el proveedor de datos del NET.Framework. El proveedor de datos es un conjunto de componentes entre los que se incluyen los objetos conexión (Connection), de órdenes (Command), el lector de datos (DataReader) y adaptador de datos (DataAdapter). La Figura 8.3 muestra la interacción entre los objetos de ADO.NET

Figura 8.3: Interacción entre los objetos ADO.Net

En la Figura 8.4 se visualiza cómo trabajan los objetos de manera conjunta para que una aplicación pueda interactuar con un origen de datos utilizando la arquitectura de tres capas:



Figura 8.4: ADO.Net y la arquitectura de tres capas

El trabajo de conexión con la base de datos o la ejecución de la sentencia SQL lo realiza el proveedor de datos . La recuperación de los datos (para procesarlos, manipularlos o volcarlo a un determinado control o dispositivo) es una acción ejecutada en la capa superior. El resultado es un conjunto de datos agrupados en tablas.

PROVEEDOR DE DATOSEn .NET Framework sirve como un puente entre una aplicación y un origen de datos. Se utiliza tanto para recuperar datos desde un origen de datos y para actualizarlos. Los componentes principales de un proveedor de datos .NET son los siguientes objetos:

Conexión con el origen de datos (objeto connection), que establece una conexión a un origen de datos determinado.

Orden para manipular (insertar, eliminar, actualizar, consultar) los datos (objeto Command), que ejecuta una orden en lenguaje SQL en un origen de datos ya sea como sentencia Sql incrustada o procedimiento almacenado.

Lector de datos (objeto DataReader) que lee una secuencia de datos de solo avance y solo lectura desde un origen de datos.

Adaptador de datos (objeto DataAdapter), que llena un DataSet (conjunto de datos) y realiza actualizaciones necesarias en la base de datos.

.NET incluye los siguientes proveedores de datos: ODBC, OLE DB, Oracle y SQL Server que se pueden encontrar en el espacio de nombres como System.Data.Odbc, System.Data.OleDb, System.Data.OracleClient y System.Data.SqlClient. Cada uno de estos proveedores proporciona los drivers adecuados para acceder a las distintas bases de datos. Hay proveedores de igual importancia como MySql, AS/400 que proporcionan el conjunto de clases que proveen acceso a sus bases de datos.

OBJETO CONEXIÓNEl objeto conexión establece la conexión a un origen de datos. Por ejemplo para establecer una conexión a Microsoft SQL Server se utiliza el objeto SqlConnection. La función del objeto conexión es presentar atributos y métodos para permitir establecer y modificar las propiedades de la conexión (por ejemplo identificador del usuario, contraseña entre otras). Ejemplo:



using System;using System.Data.SqlClient;namespace ABCMyDAO

{ public class AdministradorDeConexion{ static SqlConnection conexion;

static public SqlConnection getConexion(){ oSqlConnection = new SqlConnection("Data Source=(local);Initial Catalog=dbAlumno;Integrated Security=True");

return oSqlConnection;}

}}

OBJETO ÓRDENPermite ejecutar sentencias SQL (sentencia Sql incrustada o procedimiento almacenado) y devolver resultados desde el origen de datos. Ejemplo:

namespace ABCMyDAO{ public class AlumnoDAO

{ SqlConnection oSqlConnection;public Boolean insertarRegistro(Alumno oAlumno)

{ try{ oSqlConnection = AdministradorDeConexion.getConexion();

oSqlConnection.Open();String sentencia = "INSERT INTO Alumno( alumno_id, apellidoNombre,

evaluacionParcial1, evaluacionParcial2, promedioDeTrabajo, promedioFinal)

VALUES("+ oAlumno.alumno_id+",'"+ oAlumno.apellidoNombre+"',"+

oAlumno.evaluacionParcial1+","+ oAlumno.evaluacionParcial2+","+ oAlumno.promedioDeTrabajo +","+ oAlumno.promedioFinal+")";

SqlCommand oSqlCommand = new SqlCommand(sentencia, oSqlConnection);oSqlCommand.ExecuteNonQuery();oSqlConnection.Close();return true;

}catch (System.Exception e)

{ oSqlConnection.Close();MessageBox.Show("Error ...!!!"+e.Message);

return false; }

} . . . }

OBJETO LECTOR DE DATOSUn objeto lector de datos obtiene los datos del origen de datos y los pasa directamente a la aplicación cuando no se necesite actualizar los datos. Ejemplo



public Alumno consultarRegistro(int busqueda){ try

{ Alumno oAlumno;SqlConnection oSqlConnection = AdministradorDeConexion .getConexion(); oSqlConnection.Open(); String sentencia="SELECT * FROM Alumno WHERE alumno_id =" + busqueda;SqlCommand oSqlCommand = new SqlCommand(sentencia, oSqlConnection);SqlDataReader oSqlDataReader = oSqlCommand.ExecuteReader();

if (oSqlDataReader.Read()){ oAlumno = new Alumno();

oAlumno.alumno_id = (int) oSqlDataReader ["Alumno_id"]; oAlumno.apellidoNombre = (String) oSqlDataReader ["apellidoNombre"]; oAlumno.evaluacionParcial1 = (double) oSqlDataReader ["evaluacionParcial1"]; oAlumno.evaluacionParcial2 = (double) oSqlDataReader ["evaluacionParcial2"]; oAlumno.promedioDeTrabajo = (double) oSqlDataReader ["promedioDeTrabajo"]; oAlumno.promedioFinal = (double) oSqlDataReader ["promedioFinal"];

oSqlDataReader.Close();oSqlConnection.Close();

return oAlumno; }

else{ return null;}

} catch (System.Exception e) { oSqlDataReader.Close();

MessageBox.Show("Error ...!!!"+e.Message); return null; } }Además el lector de datos es utilizado por un adaptador de datos para llenar un conjunto de datos.

ADAPTADOR DE DATOSEs un conjunto de objetos utilizado para intercambiar datos entre un origen de datos y un conjunto de datos (objeto DataSet). Esto significa que una aplicación leerá datos de una base de datos para un conjunto de datos y a continuación manipulará dichos datos en el conjunto de datos, para que luego, en algunas ocasiones vuelva a escribir en la base de datos los datos modificados del conjunto de datos.

Un adaptador de datos contiene propiedades para facilitar la lectura y actualización de los datos en un origen de datos tales como SelectCommand, InsertCommand, DeleteCommand, UpdateCommand y TableMappings. SelectCommand hace referencia a una orden que recupera filas del origen datos, entendiendo por un objeto Command que almacena una instrucción SQL o un nombre de procedimiento, insertCommand hace referencia a una orden para insertar filas en un origen de datos, UpdateCommand hace referencia a una orden para modificar filas en el origen de datos y deleteCommand hace referencia a una orden para eliminar filas en una base de datos.

CONJUNTO DE DATOSUna aplicación accede a los datos de un origen de datos utilizando un adaptador de datos que lee los datos de la base de datos y lo almacena en tablas de un conjunto de datos. Posteriormente para escribir en el origen de datos se utiliza el adaptador de datos que tomará los datos del conjunto de datos y los escribirá en el origen de datos.Un conjunto de datos incluye una o más tablas basadas en un origen de datos, las relaciones entre esas tablas y las restricciones para los datos que puede contener dichas tablas. Las partes de un conjunto de datos se exponen mediante propiedades y colecciones.



En ADO.NET el componente central de la arquitectura sin conexión es la clase DataSet (conjunto de datos). La clase DataSet incluye la colección DataTableCollection de objetos DataTable (tabla de datos) y la colección DataColumnCollection de objetos DataColumn y la colección ConstraintCollection de objetos constraint (relaciones entre tablas). La Clase DataTable incluye la colección DataRowCollection de objetos DataRow (filas de tabla), la colección DataColumnCollection (columna de datos) y la colección ConstaintCollection de objetos Constraint (restricciones).

Asimismo, la clase DataRow incluye la propiedad RowState que permite saber si la fila cambió y de que modo, desde que la tabla de datos se cargó por primera vez. Algunas propiedades son Added, Deleted, Modified y Unchanged.

VISTA DE DATOSEs importante destacar la existencia de la clase DataView por su relación con la clase DataTable. La clase DataView permite representar los datos de la clase DataTable creando múltiples vistas de los mismos, puesto que permite editar, ordenar, filtrar, buscar y navegar por un conjunto de datos.

En la Figura 8.5 se resume los componentes del DataSet.

Figura 8.5: El DataSet

En la Figura 8.6 se visualiza un resumen de ADO.Net respecto al proveedor de datos y el conjunto de datos.

Figura 8.6: Resumen de ADO.Net



A continuación se presenta un ejemplo de una aplicación que administra un tabla de base de datos que tiene las siguientes características:

a) Presenta un formulario para un sistema de mantenimiento ABCM de alumnos la cual se visualiza en la Figura 8.7. El formulario ABCM tiene la misma funcionalidad que la del ejemplo anterior.

b) La letra ABCM significan Altas, Bajas, Consultas y Modificaciónc) La estructura de la clase alumno es la siguiente: int alumno_id

String apellidoNombredouble evaluacionParcial1

double evaluacionParcial2 double promedioDeTrabajo double promedioFinald) Utiliza una clase ABCMAccion para definir las acciones que se puedan realizar, la cual se visualiza en la

Figura 8.8 como código de la Aplicación ABCMAction.e) En la Figura 8.9 se visualiza la aplicación en el Explorador de Aplicaciones.f) En la Figura 8.10 se visualiza el diagrama de clases de la aplicación. g) En la Figura 8.11 se visualiza la Clase AdministradorDeConexion que contiene el método getConexion() el

cual permite la conexión con la base de datos.h) En la Figura 8.12 se visualiza la clase entidad Alumno.i) En la Figura 8.13 se visualiza el código de la aplicación Programa principalj) Utiliza una clase de acceso a datos (DAO) que permite interactuar la aplicación con el arreglo de objetos, la

cual se visualiza en la Figura 8.14.k) En la Figura 8.15 se visualiza el código de la aplicación – Clase FormularioABCMyDAO.l) En la Figura 8.16: Ejecución del formulario FormularioReporteDeAlumnos.m) En las Figuras del 8.17 a la Figura 8.41 se visualiza el procedimiento para generar reporte con Crystal Report

y C# utilizando como origen de datos una base de datos.

Figura 8.7: Formulario del sistema de mantenimiento ABCM de alumnos con base de datos



Figura 8.8: Código de la aplicación - ABCMActionnamespace ABCMyDAO

{ public class ABCMAccion{ public static int NO_ACTION = 1;

public static int ACTION_INSERTAR = 2;public static int ACTION_MODIFICAR = 3;public static int ACTION_CANCELAR = 4;public static int ACTION_ELIMINAR = 5;public static int ACTION_CONSULTA = 6;

}}

Figura 8.9: Aplicación en el explorador de soluciones

Figura 8.10: Diagrama de clases de la aplicación



Figura 8.11: Código de la aplicación – Clase AdministradorDeConexion

using System;using System.Data.SqlClient;namespace ABCMyDAO

{ public class AdministradorDeConexion{ static SqlConnection oSqlConnection;



}}

Figura 8.12: Código de la aplicación – Clase Entidad Alumnousing System;namespace ABCMyDAO

{ public class Alumno { public int alumno_id {get;set;} public String apellidoNombre {get;set;} public double evaluacionParcial1 {get;set;} public double evaluacionParcial2 {get;set;} public double promedioDeTrabajo {get;set;} public double promedioFinal {get;set;}

public Alumno ( ) { this.alumno_id = 0; this.apellidoNombre = null; this.evaluacionParcial1 = 0; this.evaluacionParcial2 = 0; this.promedioDeTrabajo = 0; }

public Alumno ( int alumno_id, String apellidoNombre, double evaluacionParcial1, double evaluacionParcial2, double promedioDeTrabajo, double promedioFinal ) { this.alumno_id = alumno_id; this.apellidoNombre = apellidoNombre; this.evaluacionParcial1 = evaluacionParcial1; this.evaluacionParcial2 = evaluacionParcial2; this .promedioDeTrabajo = promedioDeTrabajo;



this .promedioFinal = promedioFinal; }

public void setPromedioFinal ( ) { this.promedioFinal =(this.evaluacionParcial1 + this.evaluacionParcial2 + this .promedioDeTrabajo) / 3; }

public override String ToString ( ) { return apellidoNombre; } } }


using System;using System .Windows .Forms;namespace ABCMyDAO { static class Program { static void Main ( )

{ Application .EnableVisualStyles(); Application .SetCompatibleTextRenderingDefault(false);

Application .Run(new FormularioABCMyDAOyBD()); } } }

Figura 8.14: Código de la aplicación – Clase AlumnoDAO

using System;using System.Collections.Generic;using System.Data;using System.Data.SqlClient;using System.Windows.Forms;namespace ABCMyDAO

{ public class AlumnoDAO{ SqlConnection oSqlConnection;

public Boolean insertarRegistro(Alumno oAlumno){ try

{ oSqlConnection = AdministradorDeConexion.getConexion(); oSqlConnection.Open();

String sentencia = "INSERT INTO Alumno(alumno_id,apellidoNombre, evaluacionParcial1, evaluacionParcial2, promedioDeTrabajo, promedioFinal) VALUES("+

oAlumno.alumno_id+",'"+ oAlumno.apellidoNombre+"',"+ oAlumno.evaluacionParcial1+","+ oAlumno.evaluacionParcial2+","+

oAlumno.promedioDeTrabajo +","+ oAlumno.promedioFinal+")";

SqlCommand oSqlCommand = new SqlCommand(sentencia, oSqlConnection);oSqlCommand.ExecuteNonQuery();



oSqlConnection.Close(); return true;

}catch (System.Exception e)

{ oSqlConnection.Close(); MessageBox.Show("Error ...!!!"+e.Message);

return false; }

}

public Alumno consultarRegistro(int busqueda){ try

{ Alumno oAlumno; SqlConnection oSqlConnection = AdministradorDeConexion .getConexion();

oSqlConnection.Open(); String sentencia="SELECT * FROM Alumno WHERE alumno_id =" + busqueda;SqlCommand oSqlCommand = new SqlCommand(sentencia, oSqlConnection);SqlDataReader oSqlDataReader = oSqlCommand.ExecuteReader();

if (oSqlDataReader.Read()){ oAlumno = new Alumno();

oAlumno.alumno_id=(int) oSqlDataReader["Alumno_id"]; oAlumno.apellidoNombre = (String) oSqlDataReader["apellidoNombre"]; oAlumno.evaluacionParcial1 = (double) oSqlDataReader["evaluacionParcial1"]; oAlumno.evaluacionParcial2 = (double) oSqlDataReader["evaluacionParcial2"]; oAlumno.promedioDeTrabajo = (double) oSqlDataReader["promedioDeTrabajo"]; oAlumno.promedioFinal = (double) oSqlDataReader["promedioFinal"];

oSqlDataReader.Close(); return oAlumno;

}else

{ return null;}

} catch (System.Exception e)

{ oSqlConnection.Close();MessageBox.Show("Error ...!!!"+e.Message);

return null; } }

public Boolean modificarRegistro ( int busqueda, Alumno oAlumno ){ try

{ SqlConnection oSqlConnection = AdministradorDeConexion .getConexion();oSqlConnection.Open();string sentencia = "UPDATE Alumno

SET apellidoNombre='"+oAlumno.apellidoNombre+"',"+"evaluacionParcial1="+oAlumno.evaluacionParcial1+","+

"evaluacionParcial2="+oAlumno.evaluacionParcial2+","+"promedioDeTrabajo="+oAlumno.promedioDeTrabajo+ ","+"promedioFinal="+oAlumno.promedioFinal+

" WHERE alumno_id =" + busqueda;



SqlCommand oSqlCommand = new SqlCommand(sentencia, oSqlConnection);oSqlCommand.ExecuteNonQuery();oSqlConnection.Close();return true;

}catch ( System .Exception e )

{ oSqlConnection.Close();MessageBox.Show("Error ...!!!"+e.Message);return false;

}}

public Boolean eliminarRegistro(int busqueda){ try

{ SqlConnection oSqlConnection = AdministradorDeConexion.getConexion();oSqlConnection.Open();string sentencia = "DELETE FROM Alumno WHERE alumno_id ="+busqueda;SqlCommand oSqlCommand = new SqlCommand(sentencia, oSqlConnection); oSqlCommand.ExecuteNonQuery();oSqlConnection.Close();

return true; }

catch (System.Exception e) { oSqlConnection.Close();

MessageBox.Show("Error ...!!!"+e.Message); return false; }

}

public int buscarRegistro(int busqueda) { Alumno oAlumno = new Alumno();

try { SqlConnection oSqlConnection = AdministradorDeConexion.getConexion();

oSqlConnection.Open();String sentencia= "SELECT * FROM Alumno WHERE alumno_id=" + busqueda;SqlCommand oSqlCommand = new SqlCommand(sentencia, oSqlConnection);SqlDataReader oSqlDataReader = oSqlCommand.ExecuteReader();

if (oSqlDataReader.Read()){ oAlumno.alumno_id=(int) oSqlDataReader["alumno_id"];

oAlumno.apellidoNombre=(String)oSqlDataReader["apellidoNombre"]; oAlumno.evaluacionParcial1=(double)oSqlDataReader["evaluacionParcial1"];

oAlumno.evaluacionParcial2=(double)oSqlDataReader["evaluacionParcial2"]; oAlumno.promedioDeTrabajo=(double)oSqlDataReader["promedioDeTrabajo"]; oAlumno.promedioFinal=(double)oSqlDataReader["promedioFinal"];

oSqlDataReader.Close();oSqlConnection.Close();

return oAlumno.alumno_id;}

return -99; }

catch (System.Exception e){ oSqlConnection.Close();

MessageBox.Show("Error ...!!!"+e.Message);



return -99;}

}

public List<Alumno> obtenerDatosEnList(){ List<Alumno> oListAlumno=new List<Alumno>();

try{ oSqlConnection = AdministradorDeConexion.getConexion(); oSqlConnection.Open();

String sentencia = "SELECT * FROM Alumno";SqlCommand oSqlCommand = new SqlCommand(sentencia, oSqlConnection);SqlDataReader oSqlDataReader = oSqlCommand .ExecuteReader();

Alumno oAlumno;

while (oSqlDataReader.Read()){ oAlumno=new Alumno();

oAlumno.alumno_id=(int) oSqlDataReader["Alumno_id"]; oAlumno.apellidoNombre=(String)oSqlDataReader["apellidoNombre"];

oAlumno.evaluacionParcial1=(double)oSqlDataReader["evaluacionParcial1"]; oAlumno.evaluacionParcial2=(double)oSqlDataReader["evaluacionParcial2"]; oAlumno.promedioDeTrabajo=(double)oSqlDataReader["promedioDeTrabajo"]; oAlumno.promedioFinal=(double)oSqlDataReader["promedioFinal"]; oListAlumno.Add(oAlumno); }

oSqlDataReader.Close(); oSqlConnection.Close();

return oListAlumno; }

catch (System.Exception e ){ oSqlConnection.Close();

MessageBox.Show("Error ...!!!" + e .Message);return null;

}}

public Boolean calcularPromedioFinalConCommand(){ try

{ oSqlConnection = AdministradorDeConexion .getConexion();oSqlConnection .Open();string sentencia = "UPDATE Alumno

set promedioFinal=(evaluacionParcial1+evaluacionParcial2+promedioDeTrabajo)/3";SqlCommand oSqlCommand = new SqlCommand(sentencia, oSqlConnection);oSqlCommand.ExecuteNonQuery();oSqlConnection.Close();return true;

}catch ( System .Exception e )

{ oSqlConnection .Close();MessageBox .Show("Error ...!!!" + e .Message);return false;

}}



public Boolean calcularPromedioFinalConDataSet(){ SqlConnection oSqlConnection = AdministradorDeConexion.getConexion();

// Crear el adaptador de datosSqlDataAdapter oSqlDataAdapter = new SqlDataAdapter();// Crear objetos órdenes SqlCommand oSqlSelectCommand = new SqlCommand();SqlCommand oSqlInsertCommand = new SqlCommand();SqlCommand oSqlUpdateCommand = new SqlCommand();SqlCommand oSqlDeleteCommand = new SqlCommand();// Asignar la conexión a cada propiedad del adaptador de datos oSqlSelectCommand.Connection = oSqlConnection; oSqlInsertCommand.Connection = oSqlConnection;oSqlUpdateCommand.Connection = oSqlConnection;oSqlDeleteCommand.Connection = oSqlConnection;// Referenciar las órdenes a las propiedades del adaptador de datosoSqlDataAdapter.SelectCommand = oSqlSelectCommand;oSqlDataAdapter.DeleteCommand = sqlDeleteCommand;oSqlDataAdapter.InsertCommand = oSqlInsertCommand;oSqlDataAdapter.UpdateCommand = oSqlUpdateCommand;// Modificar la propiedad Comand.Text del objeto oSqlSelectCommandoSqlSelectCommand.CommandText = "select * from Alumno";// Crear el conjunto de datosDataSet oDataSet = new DataSet(); // Rellenar el DataSet con el contenido obtenido por SELECToSqlDataAdapter.Fill(oDataSet, "Alumno");// Calcular el promedio final utilizando un buble forfor ( int posicion = 0 ; posicion < oDataSet.Tables[0].Rows.Count ; posicion=posicion + 1 )

{ // Recuperar datos del conjunto de datos y crear objetos oAlumnoAlumno oAlumno=new Alumno (

(int ) oDataSet.Tables["Alumno"].Rows[posicion]["alumno_id"], (string) oDataSet.Tables["Alumno"].Rows[posicion]["apellidoNombre"],

(double) oDataSet.Tables["Alumno"].Rows[posicion]["evaluacionParcial1"], (double) oDataSet.Tables["Alumno"].Rows[posicion]["evaluacionParcial2"],

(double) oDataSet.Tables["Alumno"].Rows[posicion]["promedioDeTrabajo"], (double) oDataSet.Tables["Alumno"].Rows[posicion]["promedioFinal"]

); // Calcular el promedio final

oAlumno.setPromedioFinal();// Asignar el promedio final calculado a la columna "promedio final" de la fila actual en el conjunto de datosoDataSet.Tables[0].Rows[posicion]["promedioFinal"]=oAlumno.promedioFinal;

}// Verificar si ha habido cambio en el conjunto de datosif (oDataSet.HasChanges() ) // Implementación de la orden Update

{ // Añadir los parámetros a la orden oSqlUpdateCommand para cada campo de la filaoSqlUpdateCommand.Parameters.Add("@alumno_id", SqlDbType.Int, 0, "alumno_id");oSqlUpdateCommand.Parameters.Add("@promedioFinal",SqlDbType.Float,0,

"promedioFinal");// Modificar la Sentencia Update a ejecutaroSqlUpdateCommand.CommandText = "UPDATE Alumno SET promedioFinal=

@promedioFinal where alumno_id=@alumno_id";// Actualizar la base de datos desde el DataAdapteroSqlDataAdapter.Update(oDataSet, "Alumno");

}MessageBox.Show("Origen de datos actualizado");return true;

}}

}



Figura 8.15: Código de la aplicación – Clase FormularioABCMyDAOusing System;using System.Collections.Generic;using System.Windows.Forms;

namespace ABCMyDAO{ public partial class FormularioABCMyDAOyBD:Form

{ private int action = ABCMAction.NO_ACTION;public FormularioABCMyDAOyBD(){ InitializeComponent();formatearTabla();controladorDeEventosBotonesABCM();

}public void formatearTabla(){ dataGridViewAlumno.SelectionMode = DataGridViewSelectionMode.FullRowSelect;

}

public Alumno getObjetoAlumno(){ Alumno oAlumno = new Alumno();oAlumno.alumno_id = int.Parse(textBoxAlumno_id.Text);oAlumno.apellidoNombre = textBoxApellidoNombre.Text;oAlumno.evaluacionParcial1

=(double.Parse(textBoxEvaluacionParcial1.Text));oAlumno.evaluacionParcial2 =

(double.Parse(textBoxEvaluacionParcial2.Text));oAlumno.promedioDeTrabajo =

(double.Parse(textBoxPromedioDeTrabajo.Text));return oAlumno;

}

public void setObjetoAlumno(Alumno oAlumno){ textBoxAlumno_id.Text = oAlumno.alumno_id + "";textBoxApellidoNombre.Text = oAlumno.apellidoNombre + "";textBoxEvaluacionParcial1.Text = oAlumno.evaluacionParcial1 + "";textBoxEvaluacionParcial2.Text = oAlumno.evaluacionParcial2 + "";textBoxPromedioDeTrabajo.Text = oAlumno.promedioDeTrabajo + "";

}

public void actualizarDataGridViewAlumno(){ limpiarDataGridViewAlumno();AlumnoDAO oAlumnDAO = new AlumnoDAO();List<Alumno> oListAlumno = oAlumnDAO.obtenerDatosEnList();for (int posicion=0; posicion<oListAlumno.Count;

posicion=posicion + 1){ if (oListAlumno[posicion].alumno_id != 0)

{dataGridViewAlumno.Rows.Add(oListAlumno[posicion].alumno_id,

oListAlumno[posicion], oListAlumno[posicion].evaluacionParcial1, oListAlumno[posicion].evaluacionParcial2, oListAlumno[posicion].promedioDeTrabajo,

oListAlumno[posicion].promedioFinal);}

}}



private void habilitarBotonesABCM(Boolean cBuscar, Boolean cNuevo, Boolean cGuardar, Boolean cEditar, Boolean cEliminar, Boolean cConsultar,

Boolean cCancelar, Boolean cSalir){ buttonBuscar.Enabled = cBuscar;buttonNuevo.Enabled = cNuevo;buttonGuardar.Enabled = cGuardar;buttonModificar.Enabled = cEditar;buttonEliminar.Enabled = cEliminar;buttonConsultar.Enabled = cConsultar;buttonCancelar.Enabled = cCancelar;buttonSalir.Enabled = cSalir;

}

private void habilitarCajasDeTexto(Boolean editable){ textBoxApellidoNombre.Enabled = editable;textBoxEvaluacionParcial1.Enabled = editable;textBoxEvaluacionParcial2.Enabled = editable;textBoxPromedioDeTrabajo.Enabled = editable;

}

private void limpiarCajasDeTexto(){ textBoxApellidoNombre.Text = "";textBoxEvaluacionParcial1.Text = "";textBoxEvaluacionParcial2.Text = "";textBoxPromedioDeTrabajo.Text = "";

}


{ AlumnoDAO oAlumnoDAO = new AlumnoDAO();int busqueda = Int.Parse(textBoxAlumno_id.Text);Alumno oAlumno = oAlumnoDAO.consultarRegistro(busqueda);if (oAlumno != null){ MessageBox.Show("Registro existente !!!");action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();

}else{ action = ABCMAction.ACTION_INSERTAR;textBoxAlumno_id.Enabled = false;habilitarCajasDeTexto(true);controladorDeEventosBotonesABCM();textBoxApellidoNombre.Focus();

}}


{ AlumnoDAO oAlumnoDAO = new AlumnoDAO();int busqueda = Int32.Parse(textBoxAlumno_id.Text);Alumno oAlumno = oAlumnoDAO.consultarRegistro(busqueda);if (oAlumno != null){ action = ABCMAction.NO_ACTION;



controladorDeEventosBotonesABCM();setObjetoAlumno(oAlumno);

}

else{ MessageBox.Show("No se encuentra !!!");action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();

}}

}}

private void buttonNuevo_Click(object sender, EventArgs e){ dataGridViewAlumno.Enabled = false;textBoxAlumno_id.Text = "";limpiarCajasDeTexto();action = ABCMAction.ACTION_BUSCAR;controladorDeEventosBotonesABCM();textBoxAlumno_id.Enabled = true;textBoxAlumno_id.Focus();

}

private void buttonGuardar_Click(object sender, EventArgs e){ if (action == ABCMAction.ACTION_INSERTAR)

{ if (MessageBox.Show("¿Desea guardarlo?", "Confirme el guardado", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)

{ AlumnoDAO oAlumnoDAO = new AlumnoDAO();if (oAlumnoDAO.insertarRegistro(getObjetoAlumno())){ MessageBox.Show("Operación exitosa ... !!!");}

else{ MessageBox.Show("No se pudo guardar el

registro ... !!!");}

action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();buttonNuevo.Focus();

}else{ limpiarCajasDeTexto();action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();

}}

else{ if (action == ABCMAction.ACTION_MODIFICAR)

{ if (MessageBox.Show("Está seguro de guardar los datos?", "Confirme el guardado", MessageBoxButtons.YesNo,

MessageBoxIcon.Question) == DialogResult.Yes){ AlumnoDAO oAlumnoDAO = new AlumnoDAO();Alumno oAlumno = new Alumno();

if (oAlumnoDAO.modificarRegistro(int.Parse(textBoxAlumno_id.Text), getObjetoAlumno()))

{ MessageBox.Show("Operación exitosa ... !!!");action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();actualizarDataGridViewAlumno();



}else{ MessageBox.Show("No se pudo guardar el

registro ...!!!");}

}else{ action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();

}}

}}

private void buttonModificar_Click(object sender, EventArgs e){ if (dataGridViewAlumno.RowCount >= 1)

{ int filaSeleccionada = dataGridViewAlumno.CurrentRow.Index;if (filaSeleccionada != -1 && (textBoxAlumno_id.Text.Length) >

0){ textBoxApellidoNombre.Focus();action = ABCMAction.ACTION_MODIFICAR;controladorDeEventosBotonesABCM();

}else{ MessageBox.Show("No se ha seleccionado un

registro ...!!!");}

}else{ MessageBox.Show("No existen registros ...!!!");}

}

private void buttonEliminar_Click(object sender, EventArgs e){ if (dataGridViewAlumno.RowCount >= 1)

{ int filaSeleccionada = dataGridViewAlumno.CurrentRow.Index;if (filaSeleccionada != -1 && (textBoxAlumno_id.Text.Length) >

0){ if (MessageBox.Show("Está seguro de eliminar los datos?",

"Confirme la eliminación", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)

{ AlumnoDAO oAlumnoDAO = new AlumnoDAO();Alumno oAlumno = new Alumno();int busqueda = int.Parse(textBoxAlumno_id.Text);oAlumno = oAlumnoDAO.consultarRegistro(busqueda);if (oAlumno != null){ oAlumno = getObjetoAlumno();oAlumno.alumno_id = 0;if (oAlumnoDAO.eliminarRegistro(busqueda)){ MessageBox.Show("Se eliminó el

registro ...!!!");action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();actualizarDataGridViewAlumno();

}else



{ MessageBox.Show("No se pudo eliminar el registro ...!!!");

action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();

}}

else{ MessageBox.Show("No se pudo eliminar el

registro ...!!!");action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();

}}

else{ action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();

}}

else{ MessageBox.Show("Se tiene que seleccionar un

registro ...!!!");}

}else{ MessageBox.Show("No existen registros ...!!!");}

}

private void buttonCancelar_Click(object sender, EventArgs e){ action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();buttonNuevo.Focus();

}

private void buttonSalir_Click(object sender, EventArgs e){ Dispose();}

private void dataGridViewAlumno_MouseClick(object sender, MouseEventArgs e)

{ if (e.Clicks == 1 && dataGridViewAlumno.RowCount >= 1){ int filaSeleccionada = dataGridViewAlumno.CurrentRow.Index;if (filaSeleccionada != -1){ Alumno oAlumnoSeleccionado = (Alumno) dataGridViewAlumno.Rows[filaSeleccionada].Cells[1].Value;setObjetoAlumno(oAlumnoSeleccionado);

}}

}

private void limpiarDataGridViewAlumno(){ dataGridViewAlumno.Rows.Clear();}


{ actualizarDataGridViewAlumno();textBoxAlumno_id.Text = "";



limpiarCajasDeTexto();textBoxAlumno_id.Enabled = false;habilitarCajasDeTexto(false);habilitarBotonesABCM(false, true, false, true, true, true,

false, true);

dataGridViewAlumno.Enabled = true;buttonNuevo.Focus();

}else{ if (action == ABCMAction.ACTION_BUSCAR)

{ habilitarCajasDeTexto(false);limpiarCajasDeTexto();habilitarBotonesABCM(true, false, false, false, false,

false, true, false);

}else{ if (action == ABCMAction.ACTION_INSERTAR)

{ limpiarCajasDeTexto();textBoxAlumno_id.Enabled = true;habilitarBotonesABCM(true, false, true, false, false,

false, true, false);

}else{ if (action == ABCMAction.ACTION_MODIFICAR)

{ habilitarCajasDeTexto(true);habilitarBotonesABCM(false, false, true, false, false,

false, true, false);textBoxAlumno_id.Enabled = false;

}else{ if (action == ABCMAction.ACTION_ELIMINAR)

{ actualizarDataGridViewAlumno();}

else { if (action == ABCMAction.ACTION_CONSULTA)

{ habilitarCajasDeTexto(false);habilitarBotonesABCM(true, false, false, false,

false, false, true, false);textBoxAlumno_id.Enabled = true;

}}

}}

}}

}

private void buttonCalcularPromedioFinalConDataSet_Click(object sender,

EventArgs e){ AlumnoDAO oAlumnoDAO = new AlumnoDAO();oAlumnoDAO.calcularPromedioFinalConDataSet();actualizarDataGridViewAlumno();

}



private void buttonCalcularPromedioFinalConCommand_Click(object sender,

EventArgs e){ AlumnoDAO oAlumnoDAO = new AlumnoDAO();oAlumnoDAO.calcularPromedioFinalConCommand();actualizarDataGridViewAlumno();

}

private void dataGridViewAlumno_KeyDown(object sender, KeyEventArgs e)

{ if (e.KeyCode == Keys.Down){ int filaSeleccionada = dataGridViewAlumno.CurrentRow.Index +

1;if (filaSeleccionada >= dataGridViewAlumno.RowCount){ filaSeleccionada = filaSeleccionada - 1;}

else{ Alumno oAlumnoSeleccionado = (Alumno) dataGridViewAlumno.Rows[filaSeleccionada].Cells[1].Value;setObjetoAlumno(oAlumnoSeleccionado);

}}

if (e.KeyCode == Keys.Up){ int filaSeleccionada = dataGridViewAlumno.CurrentRow.Index -

1;if (filaSeleccionada <= -1){ filaSeleccionada = filaSeleccionada + 1;}

else{ Alumno oAlumnoSeleccionado = (Alumno) dataGridViewAlumno.Rows[filaSeleccionada].Cells[1].Value;setObjetoAlumno(oAlumnoSeleccionado);

}}

}

private void buttonImprimir_Click(object sender, EventArgs e){ FormularioReporteDeAlumnos oFormularioReporteDeAlumnos=new FormularioReporteDeAlumnos();oFormularioReporteDeAlumnos.ShowDialog();

}

private void buttonConsultar_Click(object sender, EventArgs e){ dataGridViewAlumno.ClearSelection();limpiarCajasDeTexto();textBoxAlumno_id.Text = "";textBoxAlumno_id.Enabled = true;textBoxAlumno_id.Focus();action = ABCMAction.ACTION_CONSULTA;controladorDeEventosBotonesABCM();

}

}}

Figura 8.16: Ejecución del formulario FormularioReporteDeAlumnos



A continuación se presenta el procedimiento para generar un Formulario que presente un reporte creado en Crystal report con origen de datos a una tabla de base de datos. El proceso empieza con la creación de un DataSetAlumno (Conjunto de datos alumno), pala el cual se debe seguir el siguiente procedimiento:



Seleccione Datos – Conjunto de datos. Escriba DataSetAlumno como nombre del Conjunto de datos. En la Figura 8.18 nuestra lo indicado.

Figura 8.18: Selección de datos – Conjunto de datos



Verifique que se muestra el diseñador de DataSet. La Figura 8.19 muestra el diseñador de DataSet. Luego haga doble clic en el vínculo Explorador de Soluciones que se encuentra en el área de diseño del DataSet.

Figura 8.19: Área de diseño del DataSet

En el área de diseño de DataSet haga doble clic derecho y seleccione del menú conceptual Agregar – Tabla de datos. En la Figura 7.19 nuestra lo indicado.

Figura 8.20: Selección Agregar – Tabla de datos



En Agregar conexión en Origen de datos escriba LocalHost (servidor local) y en seleccione o escriba el nombre de una base de datos escriba dbAlumno. En la Figura 8.21 nuestra lo indicado.

Figura 8.21: Selección Agregar – Columna



Verifique que el Explorador de Servidores visualice la conexión dbalumno (conexión a la base de datos dbAlumno). La Figura 8.22 visualiza la conexión a la base de datos dbAlumno.

Figura 8.22: Conexión a la base de datos dbAlumno

Arrastre la tabla Alumno del Explorador de servidores al área de diseño del DataSet. La Figura 8.23 visualiza la tabla Alumno en el DataSet después de arrastrarla desde el servidor de archivos.

Figura 8.23: Tabla alumno después de arrastrarla del Explorador de Servidores



Para crear un reporte utilizando Crystal Report se debe seguir el siguiente procedimiento:

Hacer clic derecho en el proyecto ABCMyDAO y seleccionar Agregar -> NuevoElemento. En la Figura 8.24 nuestra lo indicado.


.

Seleccione Reporting – Crystal Reports. Escriba CrystalReporteAlumno.rpt como nombre del Reporte. En la Figura 8.25 nuestra lo indicado.

Figura 8.25: Selección Reporting – Crystal Reports



Seleccione Usar asistente de informes -> Estándar y haga clic en el botón de comando Aceptar. En la Figura 8.26 nuestra lo indicado.

Figura 8.26: Selección Estándar – Botón de comando Aceptar

Seleccione en datos del proyecto ADO.NET DataSets - ABCMyDAO.DataSetAlumno - DataTable1. Luego haga

clic en el botón de comando . En la Figura 8.27 nuestra lo indicado.

Figura 8.27: Datos del proyecto ADO.NET DataSets - ABCMyDAO.DataSetAlumnoData



Verifique que la ventana del Asistente para la creación de informes estándar se visualice como en la Figura 8.28. Luego haga clic en el botón de comando Siguiente.


Seleccione todos los campos de la table Alumno haciendo clic en el botón de comando . La Figura 8.29 muestra el asistente en la selección de campos a mostrar.

Figura 8.29: Selección de campos a mostrar



Verifique que la ventana del asistente para la creación de informes estándar se visualice como en la Figura 8.30. Luego haga clic en el botón de comando Finalizar.


Verifique que la ventana del reporte se visualice como en la Figura 8.31 después de agregar otros objetos de texto.

Figura 8.31: Ventana de reporte



Para crear un formulario para desplegar el reporte se debe seguir el siguiente procedimiento:



.

Seleccione Windows Forms – Windows Forms. Escriba FormularioReporte como nombre del Formulario. En la Figura 8.33 nuestra lo indicado.

Figura 8.33: Selección Windows Forms- Windows Forms



Del cuadro de herramientas arrastre el control CrystalReportViewer. En la Figura 8.34 nuestra lo indicado.

Figura 8.34: Selección de control CrystalReportViewer al FormularioReporteDeAlumnos

Verifique que el FormularioReporte y el icono señalado por la fecha se visualicen como en la Figura 8.35. Este icono activa el Menú conceptual Tareas del CrystalReportViewer

Figura 8.35: Ventana FormularioReporteDeAlumnos



Del Menú conceptual -> Tareas del CrystalReportViewer seleccione “Elegir un informe en Crystal…” tal como se presenta en la Figura 8.36.

Figura 8.36 Menú conceptual->Tareas de CrystaReportViewer

En Elegir un informe de Crystal – cristalReportViewer1 seleccione Crystalreport1.rpt tal como se presenta en la Figura 8.37.

Figura 8.37: Menú conceptual tareas de CrystalreportViewer con selección de reporte



Verifique que el FormularioReporte.cs se presente como en la Figura 8.38

Figura 8.38: Vista del formulario FormularioReporteDeAlumno.cs

Pulse F7 ingrese el código del FormularioReporte el cual se presenta en la Figura 8.39.

Figura 8.39: Código del FormularioReporte



Haga docle clic en el objeto app.config del Explorador de soluciones. En la Figura 8.40 se visualiza el objeto app.Config.

Figura 8.40: Objeto app.Config en el explorador de soluciones

Agregue el siguiente código en el objeto app.config. En la Figura 8.41. el código a agregarse en el objeto app.Config. Esto se realiza siempre en cuando no corre la aplicación.



Figura 8:41: Código a agregar en el Objeto app.Config

Ejecute el proyecto y verifique que se presente el Sistema de mantenimiento ABCM de Alumnos y se presente el Reporte de Alumno cuando se haga clic en el botón de comando imprimir tal como se visualiza en la Figura 8.42.

Figura 8.42: Ejecución del Formulario ABCM con base de datos y el reporte de alumnos.

El código de la aplicación se presenta en el Cd que acompaña el libro con el nombre de FormularioABCM-Base de Datos con DAO Propiedades.



CAPÍTULO 9

PROCEDIMIENTOS ALMACENADOS



PROCEDIMIENTOS ALMACENADOSUn procedimiento almacenado (stored procedure) es un programa que se almacena físicamente en una base de datos. Su implementación varía de un gestor de bases de datos a otro. La ventaja de un procedimiento almacenado es que se ejecuta en respuesta a una petición de usuario directamente en el motor de bases de datos, el cual usualmente corre en un servidor de datos. Los procedimientos almacenados acceden directamente a los datos y sólo necesita parámetros para pasar datos de la aplicación al procedimiento almacenado y luego de hacer un proceso devuelve resultados a la aplicación que lo llamó. Esto elimina la sobrecarga de comunicar grandes cantidades de datos salientes y entrantes.

Los procedimientos almacenados son ventajosos cuando una base de datos es manipulada desde muchas aplicaciones externas, los cuales pueden ser escritos en diferentes lenguajes. Incluyen la lógica de la aplicación en la base de datos e eliminan la necesidad de incrustar la lógica en todas las aplicaciones que acceden a los datos, lo cual simplifica la creación y particularmente el mantenimiento de las aplicaciones clientes involucrados. Esto reduce la probabilidad de que los datos sean corrompidos por el uso de aplicaciones clientes defectuosos.

Los procedimientos se asemejan a las construcciones de otros lenguajes de programación porque pueden: Aceptar parámetros de entrada (parámetros) y devolver varios valores (resultados) de salida a la

aplicación que lo llamó. Contener instrucciones realizan operaciones en la base de datos y pueden contener llamadas a otros

procedimientos almacenados. Devolver un valor de estado a un programa que realiza una llamada para indicar si la operación se ha

realizado correctamente o se han producido errores, y el motivo de estos.

Los comandos de un procedimiento almacenado se ejecutan en un único lote de código. Esto reduce significativamente el tráfico de red entre el servidor y el cliente, ya que solo se envía la llamada red que va a ejecutar a través de ella.

Los procedimientos almacenados permiten la reutilización del código, ya que el código de cualquier operación de base de datos redundante resulta un candidato perfecto para la encapsulación de procedimientos. De este modo, se elimina la necesidad de escribir de nuevo el mismo código, se reducen las inconsistencias de código y se permite que cualquier usuario o aplicación que cuente con los permisos necesarios pueda acceder al código y ejecutarlo.

Los procedimientos almacenados permiten un mantenimiento más sencillo, ya que las aplicaciones cliente llaman a procedimientos y mantienen las operaciones de base de datos en la capa de datos, solo deben actualizarse los cambios de los procesos en la base de datos. El nivel de aplicación permanece independiente y no tiene que tener conocimiento sobre los cambios realizados en los diseños, las relaciones o los procesos de la base de datos.

Los procedimientos almacenados aseguran un rendimiento mejorado de forma predeterminada ya se compila la primera vez que se ejecuta y crea un plan de ejecución que vuelve a usarse en posteriores ejecuciones. Como el procesador de consultas no tiene que crear un nuevo plan, normalmente necesita menos tiempo para procesar el procedimiento.

Por otro lado dan mayor seguridad, ya que varios usuarios y aplicaciones cliente pueden realizar operaciones en los objetos de base de datos subyacentes a través de un procedimiento, aunque los usuarios y las aplicaciones no tengan permisos directos sobre esos objetos subyacentes. El procedimiento controla que procesos y actividades se llevan a cabo y protege los objetos de base de datos subyacentes. Esto elimina la necesidad de conceder permisos en cada nivel de objetos y simplifica los niveles de seguridad. Al llamar a un procedimiento a través de la red, solo está visible la llamada que va a ejecutar el procedimiento. Por lo tanto, los usuarios malintencionados no pueden ver los nombres de los objetos de base de datos y tabla, incrustados en sus propias instrucciones Transact-SQL, ni buscar datos críticos.


http://es.wikipedia.org/wiki/DBMS



http://es.wikipedia.org/wiki/Programa_(computaci%C3%B3n)


El uso de parámetros ayuda a protegerse contra ataques por inyección de código SQL. Dado que la entrada de parámetros se trata como un valor literal y no como código ejecutable, resulta más difícil para un atacante insertar un comando en la instrucción Transact-SQL del procedimiento y comprometer la seguridad. Los procedimientos pueden cifrarse, lo que ayuda a ofuscar el código fuente. Entre los comandos importantes para usar procedimientos almacenados en C# tenemos:

SqlConnectionObtiene o establece la conexión SqlConnection que utiliza esta instancia de la SqlCommand. Ejemplo:

public class AdministradorDeConexion{ static SqlConnection conexion;

static public SqlConnection getConexion(){ conexion = new SqlConnection("Data Source=(local);Initial Catalog=dbAlumno;Integrated Security=True");

return conexion;}

}

SqlConnection.OpenAbre una conexión a una base de datos. Ejemplo:

oSqlConnection.Open();

SqlConnection.CloseCierra una conexión a una base de datos. Ejemplo:

oSqlConnection.Close();

SqlCommandRepresenta una sentencia Transact-SQL o un procedimiento almacenado para ejecutarse en una base de datos SQL Server. Ejemplo:

SqlCommand oSqlCommand = new SqlCommand(sentencia, oSqlConnection);

SqlCommand (String, SqlConnection)Inicializa una nueva instancia de la clase SqlCommand con un texto que representa una sentencia Sql o el nombre de procedimiento almacenado y un objeto SqlConnection. Ejemplo:

SqlCommand oSqlCommand = new SqlCommand("dbo.InsertarAlumno", oSqlConnection);

CommandTypeObtiene o establece la instrucción de Transact-SQL para ejecutarse en el origen de datos. Cuando la propiedad CommandType se establece en StoredProcedure, la propiedad CommandText se establece con el nombre del procedimiento almacenado. El comando ejecutará este procedimiento almacenado cuando se llame a uno de los métodos Execute. Ejemplo:

oSqlCommand.CommandType = CommandType.StoredProcedure;

SqlCommand.ParameterLos objetos de comando utilizan parámetros para pasar valores a instrucciones SQL o procedimientos almacenados Se puede definir de manera más explícita parámetros de procedimientos almacenados y para acceder a los parámetros de salida y devolver valores. Los parámetros se almacenan a través de una colección que se asocia a un objeto SqlCommand El valor predeterminado es una colección vacía. Cuando se utilizan parámetros con SqlCommand para ejecutar un procedimiento almacenado de SQL Server, los nombres de los parámetros agregados a la colección deben coincidir con los nombres de los marcadores de parámetros en el procedimiento almacenado. Ejemplo:


http://msdn.microsoft.com/en-us/library/system.data.sqlclient.sqlcommand

http://msdn.microsoft.com/en-us/library/system.data.sqlclient.sqlcommand

http://msdn.microsoft.com/en-us/library/877h0y3a


En C#:oSqlCommand.Parameters.Add(new SqlParameter("@alumno_id", oAlumno.getAlumno_id()));oSqlCommand.Parameters.Add(new SqlParameter("@apellidoNombre", oAlumno.getApellidoNombre()));oSqlCommand.Parameters.Add(new SqlParameter("@evaluacionParcial1", oAlumno.getEvaluacionParcial1()));oSqlCommand.Parameters.Add(new SqlParameter("@evaluacionParcial2", oAlumno.getEvaluacionParcial2()));oSqlCommand.Parameters.Add(new SqlParameter("@promedioTrabajo", oAlumno.getPromedioDeTrabajo()));oSqlCommand.Parameters.Add(new SqlParameter("@promedioFinal", oAlumno.getPromedioFinal()));

En Sql server 2008 R2:CREATE/ALTER PROCEDURE [dbo].[InsertarAlumno]

@alumno_id int,@apellidoNombre char(50),@evaluacionParcial1 float,@evaluacionParcial2 float,@promedioTrabajo float,@promedioFinal float

SqlCommand.ExecuteNonQuery();Ejecuta una instrucción de Transact-SQL (update, insert o delete) o un procedimiento almacenado en una conexión y devuelve el número de filas afectadas. Ejemplo:

SqlCommand.ExecuteNonQuery();

SqlDataReaderProporciona una manera de leer una secuencia de sólo avance de filas de una base de datos. La recuperación implica crear una instancia del objeto SqlCommand y de un SqlDataReader, para lo cual se llama a SqlCommand.ExecuteReader a fin de recuperar filas de un origen de datos. Se utiliza el método Read del objeto SqlDataReader para obtener una fila a partir de los resultados de una consulta. Para tener acceso a cada columna de la fila devuelta, puede pasar a DataReader el nombre de la columna. Los datos de los campos leídos tienen que parsearse para ser utilizados en en C#. Ejemplo:

String sentencia="SELECT * FROM Alumno WHERE alumno_id =" + busqueda;SqlCommand oSqlCommand = new SqlCommand(sentencia, oSqlConnection);SqlDataReader oSqlDataReader = oSqlCommand.ExecuteReader();if (oSqlDataReader.Read())

{ oAlumno = new CEAlumno();oAlumno.alumno_id = (int) oSqlDataReader["alumno_id"];oAlumno.apellidoNombre = (String) oSqlDataReader["apellidoNombre"];oAlumno.evaluacionParcial1 = (double) oSqlDataReader["evaluacionParcial1"];

oAlumno.evaluacionParcial2 = (double) oSqlDataReader["evaluacionParcial2"]; oAlumno.promedioDeTrabajo = (double) oSqlDataReader["promedioDeTrabajo"]; oAlumno.setPromedioFinal = (double) oSqlDataReader["promedioFinal"];

oSqlDataReader.Close(); return oAlumno; }

SqlDataReader oSqlDataReader = oSqlCommand.ExecuteReader();

SqlDataReader.CloseCierra un SqlDataReader aperturado. Ejemplo:

oSqlDataReader.Close();



A continuación se presenta un ejemplo de una aplicación que adminsitra una tabla de base de datos donde se utiliza procedimientos almacenados y desarrollo de aplicaciones con la arquitectura Modelo-Vista-Controlado en Formularios Windows el cual tiene las siguientes características:

a) Presenta un formulario para un sistema de mantenimiento ABCM de alumnos el cual se visualiza en la Figura 9.1.

b) Las letras ABCM significan Altas, Bajas, Consultas y Modificación respectivamente.c) La aplicación se ha desarrollado con la arquitectura Modelo-Vista-Controlador la cual se visualiza en la Figura

9.2. d) La estructura de la clase Alumno es la siguiente:

int alumno_idString apellidoNombredouble evaluacionParcial1

double evaluacionParcial2 double promedioDeTrabajo double promedioFinale) Utiliza la clase ABCMAction para definir las acciones que se pueden realizar, la cual se visualiza en la Figura

9.3 como Código de la Aplicación - ABCMActionf) En la Figura 9.4 se visualiza la clase AdministradorDeConexion que contiene el método getConexion(), el cual

permite la conexión de la aplicación con la base de datos.g) En la Figura 9.5 se visualiza el diagrama de clases de la aplicación.h) En la Figura 9.6 se visualiza la clase entidad Alumno.i) En la Figura 9.7 se visualiza la clase AlumnoDAO j) En la Figura 9.8 se visualiza la Clase ControladorAlumno.cs que es el controlador en el Modelo-Vista-

Controlador.k) En la Figura 9.9 se visualiza el Código de la Aplicación - Clase FormularioABCMyMVCyBD (Vista)l) En la Figura 9.10 se visualiza el Código de la Aplicación - Clase FormularioImprimir(Vista)m) En la Figura 9.11 un formulario para visualizar el reporte de alumnos.n) En la Figura 9.12 se visualiza Código de la Aplicación – Programa principal.o) En la Figura 9.13 se visualiza la base de datos en el Administrador del Micrsoft SQL Server 2008.p) En la Figura 9.14 se visualiza el código SQL para crear la base de datos dbAlumno y la tabla Alumno. Para

crear la base de datos y la tabla se tiene que ejecutar el código SQL en el Microsoft SQL 2008.q) En la Figura 9.15 se visualiza el código SQL para crear los procedimientos almacenados en Microsft SQL

Server 2008. Para crear los procedimientos almacenados se tiene que ejecutar el código SQL en el Microsoft SQL 2008.



Figura 9.1: Formulario de la aplicación

Figura 9.2: Arquitectura de la aplicación utilizando Modelo-Vista-Controlador



Figura 9.3: Código de la Aplicación - ABCMAction

namespace ABCMyMVC.Util{ public class ABCMAccion

{ public static int NO_ACTION = 1; public static int ACTION_INSERTAR = 2; public static int ACTION_MODIFICAR = 3;

public static int ACTION_CANCELAR = 4;public static int ACTION_ELIMINAR = 5;public static int ACTION_CONSULTA = 6;

} }

Figura 9.4: Código de la Aplicación – Clase AdministradorDeConexión

using System;using System.Data.SqlClient;namespace ABCMyMVC.Modelo.Datos

{ public class AdministradorDeConexion{ static SqlConnection conexion;



}}

Figura 9.5: Diagrama de clases de la aplicación



9.6. Código de la Aplicación- Clase entidad Alumno

using System;namespace ABCMyMVC.Modelo.Entidad

{ public class Alumno { public int alumno_id { get; set; } public String apellidoNombre { get; set; } public double evaluacionParcial1 { get; set; } public double evaluacionParcial2 { get; set; } public double promedioDeTrabajo { get; set; } public double promedioFinal { get; set; }

public CEAlumno() { this.alumno_id = 0; this.apellidoNombre = null; this.evaluacionParcial1 = 0; this.evaluacionParcial2 = 0; this.promedioDeTrabajo = 0; }

public Alumno(int alumno_id, String apellidoNombre, double evaluacionParcial1, double evaluacionParcial2, double promedioDeTrabajo, double promedioFinal)

{ this.alumno_id = alumno_id; this.apellidoNombre = apellidoNombre; this.evaluacionParcial1 = evaluacionParcial1; this.evaluacionParcial2 = evaluacionParcial2; this.promedioDeTrabajo = promedioDeTrabajo; this.promedioFinal = promedioFinal; }

public void setPromedioFinal() { this.promedioFinal = (this.evaluacionParcial1 + this.evaluacionParcial2 +

this.promedioDeTrabajo) / 3; }

public override String ToString() { return apellidoNombre; } } }



9.7. Código de la Aplicación- Clase AlumnoDAOusing System;using System.Collections.Generic;using System.Data;using System.Data.SqlClient;using System.Windows.Forms;using ABCMyMVC.Modelo.Entidad;namespace ABCMyMVC.Modelo.Datos { public class AlumnoDAO { SqlConnection oSqlConnection; public Boolean insertarRegistro(Alumno oAlumno) { try { oSqlConnection = AdministradorDeConexion.getConexion(); oSqlConnection.Open(); SqlCommand oSqlCommand = new SqlCommand("dbo.InsertarAlumno", oSqlConnection); oSqlCommand.CommandType = CommandType.StoredProcedure; oSqlCommand.Parameters.Add(new SqlParameter("@alumno_id", oAlumno.alumno_id)); oSqlCommand.Parameters.Add(new SqlParameter("@apellidoNombre", oAlumno.apellidoNombre)); oSqlCommand.Parameters.Add(new SqlParameter("@evaluacionParcial1", oAlumno.evaluacionParcial1)); oSqlCommand.Parameters.Add(new SqlParameter("@evaluacionParcial2", oAlumno.evaluacionParcial2)); oSqlCommand.Parameters.Add(new SqlParameter("@promedioTrabajo", oAlumno.promedioDeTrabajo)); oSqlCommand.Parameters.Add(new SqlParameter("@promedioFinal", oAlumno.promedioFinal)); oSqlCommand.ExecuteNonQuery(); oSqlConnection.Close(); return true; } catch(System.Exception e) { oSqlConnection.Close(); MessageBox.Show("Error ...!!!" + e.Message); return false; } } public Alumno consultarRegistro(int busqueda) { try { Alumno oAlumno; SqlConnection oSqlConnection = AdministradorDeConexion.getConexion(); oSqlConnection.Open(); SqlCommand oSqlCommand = new SqlCommand("dbo.consultarAlumno", oSqlConnection); oSqlCommand.CommandType=CommandType.StoredProcedure; oSqlCommand.Parameters.Add(new SqlParameter("@alumno_id", busqueda)); SqlDataReader oSqlDataReader = oSqlCommand.ExecuteReader(); if(oSqlDataReader.Read()) { oAlumno=new Alumno(); oAlumno.alumno_id = (int) oSqlDataReader ["alumno_id"];

oAlumno.apellidoNombre = (String) oSqlDataReader ["apellidoNombre"]; oAlumno.evaluacionParcial1 = (double) oSqlDataReader ["evaluacionParcial1"]; oAlumno.evaluacionParcial2 = (double) oSqlDataReader ["evaluacionParcial2"]; oAlumno.promedioDeTrabajo = (double) oSqlDataReader ["promedioDeTrabajo"]; oAlumno.promedioFinal = (double) oSqlDataReader ["promedioFinal"]; oSqlDataReader.Close(); return oAlumno; } else { return null; } }



catch(System.Exception e) { oSqlConnection.Close(); MessageBox.Show("Error ...!!!" + e.Message); return null; } }

public Boolean modificarRegistro(int busqueda, Alumno oAlumno) { try { oSqlConnection = AdministradorDeConexion.getConexion(); oSqlConnection.Open(); SqlCommand oSqlCommand = new SqlCommand("dbo.ModificarAlumno", oSqlConnection); oSqlCommand.CommandType = CommandType.StoredProcedure; oSqlCommand.Parameters.Add(new SqlParameter("@alumno_id", oAlumno.alumno_id)); oSqlCommand.Parameters.Add(new SqlParameter("@apellidoNombre",

oAlumno.apellidoNombre)); oSqlCommand.Parameters.Add(new SqlParameter("@evaluacionParcial1",

oAlumno.evaluacionParcial1)); oSqlCommand.Parameters.Add(new SqlParameter("@evaluacionParcial2",

oAlumno.evaluacionParcial2)); oSqlCommand.Parameters.Add(new SqlParameter("@promedioTrabajo",

oAlumno.promedioDeTrabajo)); oSqlCommand.Parameters.Add(new SqlParameter("@promedioFinal",

oAlumno.promedioFinal)); oSqlCommand.ExecuteNonQuery(); oSqlConnection.Close(); return true; } catch(System.Exception e) { oSqlConnection.Close(); MessageBox.Show("Error ...!!!" + e.Message); return false; } }

public Boolean eliminarRegistro(int busqueda) { try { oSqlConnection = AdministradorDeConexion.getConexion(); oSqlConnection.Open(); SqlCommand oSqlCommand = new SqlCommand("dbo.EliminarAlumno", oSqlConnection); oSqlCommand.CommandType = CommandType.StoredProcedure; oSqlCommand.Parameters.Add(new SqlParameter("@alumno_id", busqueda)); oSqlCommand.ExecuteNonQuery(); oSqlConnection.Close(); return true; } catch(System.Exception e) { oSqlConnection.Close(); MessageBox.Show("Error ...!!!" + e.Message); return false; } }



public int buscarRegistro(int busqueda) { Alumno oAlumno = new Alumno(); try { SqlConnection oSqlConnection = AdministradorDeConexion.getConexion(); oSqlConnection.Open(); SqlCommand oSqlCommand = new SqlCommand("dbo.ConsultarAlumno", oSqlConnection); oSqlCommand.CommandType = CommandType.StoredProcedure; oSqlCommand.Parameters.Add(new SqlParameter("@alumno_id", oAlumno.alumno_id)); SqlDataReader oSqlDataReader = oSqlCommand.ExecuteReader(); if(oSqlDataReader.Read()) { oAlumno.alumno_id = (int)oSqlDataReader ["alumno_id"]; oAlumno.apellidoNombre = (String)oSqlDataReader ["apellidoNombre"]; oAlumno.evaluacionParcial1 = (double)oSqlDataReader ["evaluacionParcial1"]; oAlumno.evaluacionParcial2 = (double)oSqlDataReader ["evaluacionParcial2"]; oAlumno.promedioDeTrabajo = (double)oSqlDataReader ["promedioDeTrabajo"]; oAlumno.promedioFinal = (double)oSqlDataReader ["promedioFinal"]; oSqlDataReader.Close(); oSqlConnection.Close(); return oAlumno.alumno_id; } return -99; } catch(System.Exception e) { oSqlConnection.Close(); MessageBox.Show("Error ...!!!" + e.Message); return -99; } }

public List<Alumno> obtenerDatosEnList() { List<Alumno> oListAlumno = new List<Alumno>(); try { oSqlConnection = AdministradorDeConexion.getConexion(); oSqlConnection.Open(); SqlCommand oSqlCommand = new SqlCommand("dbo.ListarAlumnos", oSqlConnection); oSqlCommand.CommandType = CommandType.StoredProcedure; SqlDataReader oSqlDataReader = oSqlCommand.ExecuteReader(); Alumno oAlumno; while(oSqlDataReader.Read()) { oAlumno = new Alumno(); oAlumno.alumno_id = (int)oSqlDataReader["alumno_id"]; oAlumno.apellidoNombre = (String)oSqlDataReader["apellidoNombre"]; oAlumno.evaluacionParcial1 = (double)oSqlDataReader["evaluacionParcial1"]; oAlumno.evaluacionParcial2 = (double)oSqlDataReader["evaluacionParcial2"]; oAlumno.promedioDeTrabajo = (double)oSqlDataReader["promedioDeTrabajo"]; oAlumno.promedioFinal = (double)oSqlDataReader["promedioFinal"]; oListAlumno.Add(oAlumno); } oSqlDataReader.Close(); oSqlConnection.Close(); return oListAlumno; }



catch(System.Exception e) { oSqlConnection.Close(); MessageBox.Show("Error ...!!!" + e.Message); return null; } }

public Boolean calcularPromedioFinalConCommand() { try { oSqlConnection = AdministradorDeConexion.getConexion(); oSqlConnection.Open(); SqlCommand oSqlCommand = new SqlCommand("dbo.CalculoPromedioFinal", oSqlConnection); oSqlCommand.CommandType = CommandType.StoredProcedure; oSqlCommand.ExecuteNonQuery(); oSqlConnection.Close(); return true; } catch(System.Exception e) { oSqlConnection.Close(); MessageBox.Show("Error ...!!!" + e.Message); return false; } } } } }

9.8: Código de la Aplicación- Clase Controlador Alumno

using System;using System.Collections.Generic;using ABCMyMVC.Modelo.Entidad;using ABCMyMVC.Modelo.Datos;namespace ABCMyMVC.Controlador { public class ControladorAlumno { public Boolean insertarRegistro(Alumno oAlumno) { AlumnoDAO oAlumnoDAO = new AlumnoDAO(); return oAlumnoDAO.insertarRegistro(oAlumno); }

public Alumno consultarRegistro(int busqueda) { AlumnoDAO oAlumnoDAO = new AlumnoDAO(); return oAlumnoDAO.consultarRegistro(busqueda); }

public Boolean modificarRegistro(int busqueda, Alumno oAlumno) { AlumnoDAO oAlumnoDAO = new AlumnoDAO(); return oAlumnoDAO.modificarRegistro(busqueda, oAlumno); }

public Boolean eliminarRegistro(int busqueda) { AlumnoDAO oAlumnoDAO = new AlumnoDAO(); return oAlumnoDAO.eliminarRegistro(busqueda); }



public int buscarRegistro(int busqueda) { AlumnoDAO oAlumnoDAO = new AlumnoDAO(); return oAlumnoDAO.buscarRegistro(busqueda); }

public List<Alumno> obtenerDatosEnList() { AlumnoDAO oAlumnoDAO = new AlumnoDAO(); return oAlumnoDAO.obtenerDatosEnList(); }

public Boolean calcularPromedioFinalConCommand() { AlumnoDAO oAlumnoDAO = new AlumnoDAO(); return oAlumnoDAO.calcularPromedioFinalConCommand(); } } }

Figura 9.9: Código de la Aplicación - Clase FormularioABCMyMVCyBD (Vista)

using System;using System.Collections.Generic;using System.Windows.Forms;using ABCMyMVC.Util;using ABCMyMVC.Modelo.Entidad;using ABCMyMVC.Controlador;namespace Vista

{ public partial class FormularioABCMyMVCyBD: Form{ private int action = ABCMAction.NO_ACTION;

public FormularioABCMyMVCyBD(){ InitializeComponent();

controladorDeEventosBotonesABCM(); actualizarDataGridViewAlumno(); }

public Alumno getObjetoAlumno(){ Alumno oAlumno = new Alumno();

oAlumno.alumno_id = int.Parse(textBoxAlumno_id.Text); oAlumno.apellidoNombre = textBoxApellidoNombre.Text; oAlumno.evaluacionParcial1 = double.Parse(textBoxEvaluacionParcial1.Text); oAlumno.evaluacionParcial2 = double.Parse(textBoxEvaluacionParcial2.Text); oAlumno.promedioDeTrabajo = double.Parse(textBoxPromedioDeTrabajo.Text); return oAlumno; }

public void setObjetoAlumno(Alumno oAlumno){ textBoxAlumno_id.Text = oAlumno.alumno_id + "";

textBoxApellidoNombre.Text = oAlumno.apellidoNombre + ""; textBoxEvaluacionParcial1.Text = oAlumno.evaluacionParcial1 + ""; textBoxEvaluacionParcial2.Text = oAlumno.evaluacionParcial2 + ""; textBoxPromedioDeTrabajo.Text = oAlumno.promedioDeTrabajo + ""; }



public void actualizarDataGridViewAlumno(){ limpiarDataGridViewAlumno();

ControladorAlumno oControladorAlumno = new ControladorAlumno(); List<Alumno> oListAlumno = oControladorAlumno.obtenerDatosEnList(); for(int posicion = 0; posicion < oListAlumno.Count; posicion = posicion + 1)

{ if(oListAlumno[posicion].alumno_id != 0) { dataGridViewAlumno.Rows.Add(oListAlumno[posicion].alumno_id,

oListAlumno[posicion], oListAlumno[posicion].evaluacionParcial1,

oListAlumno[posicion].evaluacionParcial2, oListAlumno[posicion].promedioDeTrabajo,

oListAlumno[posicion].promedioFinal);

} }

}

private void habilitarBotonesABCM(Boolean cBuscar, Boolean cNuevo, Boolean cGuardar, Boolean cEditar, Boolean cEliminar, Boolean cConsultar, Boolean cCancelar, Boolean cSalir)

{ buttonBuscar.Enabled = cBuscar;buttonNuevo.Enabled = cNuevo;buttonGuardar.Enabled = cGuardar;buttonModificar.Enabled = cEditar;buttonEliminar.Enabled = cEliminar;buttonConsultar.Enabled = cConsultar;buttonCancelar.Enabled = cCancelar;buttonSalir.Enabled = cSalir;

}

private void limpiarCajasDeTexto(){ textBoxApellidoNombre.Text = "";

textBoxEvaluacionParcial1.Text = ""; textBoxEvaluacionParcial2.Text = ""; textBoxPromedioDeTrabajo.Text = ""; }

private void habilitarCajasDeTexto(Boolean editable){ textBoxApellidoNombre.Enabled = editable;

textBoxEvaluacionParcial1.Enabled = editable; textBoxEvaluacionParcial2.Enabled = editable; textBoxPromedioDeTrabajo.Enabled = editable;

}


{ Alumno oAlumno = new Alumno(); ControladorAlumno oControladorAlumno = new ControladorAlumno(); int busqueda = int.Parse(textBoxAlumno_id.Text); oAlumno = oControladorAlumno.consultarRegistro(busqueda);

if (oAlumno != null){ MessageBox.Show("Registro existente !!!");

action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();



}

else{ action = ABCMAction.ACTION_INSERTAR;

textBoxAlumno_id.Enabled = false;habilitarCajasDeTexto(true);controladorDeEventosBotonesABCM();textBoxApellidoNombre.Focus();

}}


{ ControladorAlumno oControladorAlumno = new ControladorAlumno();int busqueda = Int32.Parse(textBoxAlumno_id.Text);Alumno oAlumno = oControladorAlumno.consultarRegistro(busqueda);if (oAlumno != null)

{ action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();setObjetoAlumno(oAlumno);

}else

{ MessageBox.Show("No se encuentra !!!");action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();

}}

}}

private void buttonNuevo_Click(object sender, EventArgs e)

{ dataGridViewAlumno.ClearSelection(); dataGridViewAlumno.Enabled = false;

textBoxAlumno_id.Text = "";limpiarCajasDeTexto();action = ABCMAction.ACTION_BUSCAR;controladorDeEventosBotonesABCM();textBoxAlumno_id.Enabled = true;textBoxAlumno_id.Focus();

}

private void buttonGuardar_Click(object sender, EventArgs e){ if(action == ABCMAction.ACTION_INSERTAR)

{ if(MessageBox.Show("¿Desea guardarlo?", "Confirme el guardado", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)

{ ControladorAlumno oControladorAlumno = new ControladorAlumno(); if(oControladorAlumno.insertarRegistro(getObjetoAlumno()))

{ action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM();

actualizarDataGridViewAlumno(); buttonNuevo.Focus(); }

else{ MessageBox.Show("No se pudo guardar el registro ... !!!");

}



}else

{ limpiarCajasDeTexto(); action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); }

} else

{ if(action == ABCMAction.ACTION_MODIFICAR){ if(MessageBox.Show("Está seguro de guardar los datos?", "Confirme el guardado",

MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes){ ControladorAlumno oControladorAlumno = new ControladorAlumno();

Alumno oAlumno = new Alumno(); if(oControladorAlumno.modificarRegistro(int.Parse(textBoxAlumno_id.Text),

getObjetoAlumno())){ MessageBox.Show("Operación exitosa ... !!!");

action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); actualizarDataGridViewAlumno(); } else

{ MessageBox.Show("No se pudo guardar el registro ...!!!"); }

} } }

}

private void buttonModificar_Click(object sender, EventArgs e){ if(dataGridViewAlumno.RowCount >= 1)

{ int filaSeleccionada = dataGridViewAlumno.CurrentRow.Index;if(filaSeleccionada != -1 && (textBoxAlumno_id.Text.Length) > 0)

{ textBoxApellidoNombre.Focus();action = ABCMAction.ACTION_MODIFICAR;controladorDeEventosBotonesABCM();

} else { MessageBox.Show("No se ha seleccionado un registro ...!!!"); } }

else{ MessageBox.Show("No existen registros ...!!!");

} }

private void buttonEliminar_Click(object sender, EventArgs e){ if(dataGridViewAlumno.RowCount >= 1)

{ int filaSeleccionada = dataGridViewAlumno.CurrentRow.Index;if(filaSeleccionada != -1 && (textBoxAlumno_id.Text.Length) > 0){ if(MessageBox.Show("Está seguro de eliminar los datos?", "Confirme la eliminación",

MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes){ ControladorAlumno oControladorAlumno = new ControladorAlumno();

Alumno oAlumno = new Alumno(); int busqueda = int.Parse(textBoxAlumno_id.Text);



oAlumno = oControladorAlumno.consultarRegistro(busqueda);if(oAlumno != null)

{ oAlumno = getObjetoAlumno(); if(oControladorAlumno.eliminarRegistro(busqueda))

{ MessageBox.Show("Se eliminó el registro ...!!!"); action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); actualizarDataGridViewAlumno(); } else

{ MessageBox.Show("No se pudo eliminar el registro ...!!!"); action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); }

} else { MessageBox.Show("No se pudo eliminar el registro ...!!!"); action = ABCMAction.NO_ACTION; controladorDeEventosBotonesABCM(); }

}else

{ action = ABCMAction.NO_ACTION;controladorDeEventosBotonesABCM();

}}

else{ MessageBox.Show("Se tiene que seleccionar un registro ...!!!");}

}else

{ MessageBox.Show("No existen registros ...!!!");}

}

private void buttonCancelar_Click(object sender, EventArgs e){ action = ABCMAction.NO_ACTION;

controladorDeEventosBotonesABCM(); buttonNuevo.Focus(); }

private void buttonSalir_Click(object sender, EventArgs e){ Dispose();

}

private void dataGridViewAlumno_MouseClick(object sender, MouseEventArgs e){ if(e.Clicks == 1 && dataGridViewAlumno.RowCount >= 1)

{ int filaSeleccionada = dataGridViewAlumno.CurrentRow.Index;if(filaSeleccionada != -1)

{ Alumno oAlumnoSeleccionado = (Alumno)dataGridViewAlumno.Rows[filaSeleccionada].Cells[1].Value;

setObjetoAlumno(oAlumnoSeleccionado); } }



} private void limpiarDataGridViewAlumno()

{ dataGridViewAlumno.Rows.Clear(); }


{ actualizarDataGridViewAlumno();textBoxAlumno_id.Text = "";limpiarCajasDeTexto();textBoxAlumno_id.Enabled = false;habilitarCajasDeTexto(false);habilitarBotonesABCM(false, true, false, true, true, true, false, true);dataGridViewAlumno.Enabled = true;buttonNuevo.Focus();

}else

{ if (action == ABCMAction.ACTION_BUSCAR){ habilitarCajasDeTexto(false);

limpiarCajasDeTexto();habilitarBotonesABCM(true, false, false, false, false, false, true, false);

}else

{ if (action == ABCMAction.ACTION_INSERTAR){ limpiarCajasDeTexto();

textBoxAlumno_id.Enabled = true;habilitarBotonesABCM(true, false, true, false, false, false, true, false);

}else

{ if (action == ABCMAction.ACTION_MODIFICAR){ habilitarCajasDeTexto(true);

habilitarBotonesABCM(false, false, true, false, false, false, true, false);textBoxAlumno_id.Enabled = false;

}else

{ if (action == ABCMAction.ACTION_ELIMINAR){ actualizarDataGridViewAlumno();}

else { if (action == ABCMAction.ACTION_CONSULTA)

{ habilitarCajasDeTexto(false);habilitarBotonesABCM(true, false, false, false, false, false, true, false);textBoxAlumno_id.Enabled = true;

}}

}}

}}

}

private void buttonCalcularPromedioFinalConCommand_Click(object sender, EventArgs e){ ControladorAlumno oControladorAlumno = new ControladorAlumno();

oControladorAlumno.calcularPromedioFinalConCommand(); actualizarDataGridViewAlumno();



} private void dataGridViewAlumno_KeyDown(object sender, KeyEventArgs e) { if(e.KeyCode == Keys.Down) { int filaSeleccionada = dataGridViewAlumno.CurrentRow.Index + 1; if(filaSeleccionada >= dataGridViewAlumno.RowCount) { filaSeleccionada = filaSeleccionada - 1; } else { Alumno oAlumnoSeleccionado =

(Alumno)dataGridViewAlumno.Rows[filaSeleccionada].Cells[1].Value; setObjetoAlumno(oAlumnoSeleccionado); } }

if(e.KeyCode == Keys.Up) { int filaSeleccionada = dataGridViewAlumno.CurrentRow.Index - 1; if(filaSeleccionada <= -1) { filaSeleccionada = filaSeleccionada + 1; } else

{ Alumno oAlumnoSeleccionado = (Alumno)dataGridViewAlumno.Rows[filaSeleccionada].Cells[1].Value;

setObjetoAlumno(oAlumnoSeleccionado); } } }

private void buttonImprimir_Click(object sender, EventArgs e){ FormularioImprimir oFormularioImprimir=new FormularioImprimir();

oFormularioImprimir.Show(); }

private void buttonConsultar_Click(object sender, EventArgs e){ dataGridViewAlumno.ClearSelection();

limpiarCajasDeTexto();textBoxAlumno_id.Text = "";textBoxAlumno_id.Enabled = true;textBoxAlumno_id.Focus();action = ABCMAction.ACTION_CONSULTA;controladorDeEventosBotonesABCM();

} } }



Figura 9.10: Código de la Aplicación – Clase FormularioImprimir(Vista)

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;using System.Data.SqlClient;using ABCMyMVC.Modelo.Datos;using ABCMyMVC.Vista;namespace Vista { public partial class FormularioImprimir: Form { public FormularioImprimir() { InitializeComponent(); } private void FormularioImprimir_Load(object sender, EventArgs e) { poblarReporte(); } private void poblarReporte() { //Definimos las sentencias las cuales seleccionan los datos string sentencia = "select * from Alumno"; // Se crea un conjunto de datos del tipo DataSetAlumno DataSetAlumno oDataSetProducto = new DataSetAlumno(); try { // Se solicita y abre una conexión a base de datos SqlConnection oSqlConnection = AdministradorDeConexion.getConexion(); oSqlConnection.Open(); //creamos el adaptador de datos SqlDataAdapter oSqlDataAdapter = new SqlDataAdapter(sentencia, oSqlConnection);

// Se pobla las tablas del conjunto de datos tipeado oSqlDataAdapter.Fill(oDataSetProducto, "Alumno");

//Ahora poblamos el informe y lo mostramos CrystalReportAlumno oCrystalReportAlumno = new CrystalReportAlumno(); oCrystalReportAlumno.SetDataSource(oDataSetProducto); crystalReportViewerAlumno.ReportSource = oCrystalReportAlumno; oSqlConnection.Close(); } catch(Exception e) { MessageBox.Show(e.Message); } } } }



Figura 9.11: Formulario de la aplicación (Reporte de alumnos)

Figura 9.12: Código de la Aplicación – Programa principalusing System;using System.Windows.Forms;using vista;namespace ABCMyMVC

{ static class Program { static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new FormularioABCMyMVCyBD()); } } }

Figura 9.13: Código SQL para creación de base de datos dbAlumno y tablas Alumno



Figura 9.14: Base de datos en el Administrador del Micrsoft SQL Server 2008.



Figura 9.15: Código SQL para la base de datos dbAlumno, tabla Alumno y los procedimientos almacenados

USE MASTERIF EXISTS ( SELECT name FROM sysdatabases WHERE name = 'dbAlumno' )

DROP DATABASE dbAlumnoGO

CREATE DATABASE dbalumnoGOUSE dbAlumnoGOCREATE TABLE Alumno ( alumno_id int not null,

apellidoNombre char(31), evaluacionParcial1 float,

evaluacionParcial2 float, promedioDeTrabajo float, promedioFinal float

) GO ALTER TABLE Alumno ADD CONSTRAINT PK_Alumno_id PRIMARY KEY CLUSTERED (alumno_id) GO

CREATE PROCEDURE InsertarAlumno@alumno_id int,@apellidoNombre char(31),@evaluacionParcial1 float,@evaluacionParcial2 float,@promedioTrabajo float,@promedioFinal float

ASBEGIN

INSERT INTO [dbAlumno].[dbo].[Alumno] ([alumno_id], [apellidoNombre], [evaluacionParcial1], [evaluacionParcial2], [promedioDeTrabajo], [promedioFinal]) VALUES ( @alumno_id, @apellidoNombre, @evaluacionParcial1, @evaluacionParcial2, @promedioTrabajo, @promedioFinal);ENDGO

CREATE PROCEDURE ConsultarAlumno@alumno_id int

ASBEGIN

SELECT [alumno_id],[apellidoNombre],[evaluacionParcial1],[evaluacionParcial2],[promedioDeTrabajo],[promedioFinal]

FROM Alumno

WHERE



Alumno.alumno_id=@alumno_id;ENDGO

CREATE PROCEDURE ModificarAlumno@alumno_id int,@apellidoNombre char(31),@evaluacionParcial1 float,@evaluacionParcial2 float,@promedioTrabajo float,@promedioFinal float

ASBEGIN

UPDATE [dbAlumno].[dbo].[Alumno]SET

[apellidoNombre] = @apellidoNombre,[evaluacionParcial1] = @evaluacionParcial1,[evaluacionParcial2] = @evaluacionParcial2,[promedioDeTrabajo] = @promedioTrabajo,[promedioFinal] = @promedioFinal

WHERE [alumno_id] = @alumno_idEND

GOCREATE PROCEDURE ListarAlumnosASBEGINSELECT [alumno_id], [apellidoNombre], [evaluacionParcial1], [evaluacionParcial2], [promedioDeTrabajo], [promedioFinal] FROM Alumno;ENDGO

CREATE PROCEDURE EliminarAlumno@alumno_id int

ASBEGIN

DELETE FROM Alumno WHERE Alumno.alumno_id=@alumno_id;

ENDGO

CREATE PROCEDURE CalculoPromedioFinalASBEGIN

UPDATE [dbo].[Alumno]SET promedioFinal=(evaluacionParcial1+evaluacionParcial2+promedioDeTrabajo)/3;

ENDGO

El código de la aplicación se presenta en el Cd que acompaña el libro con el nombre de FormularioABCM-MVC y Procedimientos Almacenados.



BIBLIOGRAFÍA

Enciclopedia de Microsoft Visual C#. Fco Javier Ceballos. Alfaomega. Tercera Edición. 2012. Mexico

Como programar en Java. Deitel, Harvey M.; Deitel, Paul J. Pearson Education. 5ta Edición. 2004. México.

Desarrollo de aplicaciones en Java. Castañeda León, Juan José. Ritisa Graff. 1ra Edición. 2007. Lima. 536 páginas.

Estructura de datos en Java: Compatible con Java 2. Allen Weiss, Mark. Pearson Education. 1ra Edición. 2000.

Madrid.

Java 2: Curso de programación. Ceballos Sierra, Francisco Javier. Alfaomega Grupo Editor. 2da Edición. 2003.

México.

Piensa en Java. Eckel, Bruce. Pearson Education. 2da Edición. 2002. Madrid.

Problemas resueltos de programación en Java. Pérez Menor, José María; Carretero Pérez, Jesús; García

Carballeira, Félix. Thomson Learning. 1ra Edición. 2003. España.

Programación en Java 2: Algoritmos, estructuras de datos y programación orientada a objetos. Joyanes Aguilar,

Luis; Zahonero Martínez, Ignacio. McGraw-Hill Interamericana. 1ra Edición. 2002. España.



ANEXO Nº01

A continuación se presentan los comandos básicos de base de datos del Microsoft SQL Server 12 .

CREATE DATABASESCrea una base de datos. Ejemplo:

create database dbalumno

USEIndica al Microsoft SQL que use una base de datos especificada. Ejemplo:

use dbalumno

CREATE TABLECrea una tabla de base de datos. Ejemplo:

create table alumno ( alumno_id int not null,

apellidoNombre char(31), evaluacionParcial1 float,

evaluacionParcial2 float, promedioDeTrabajo float, promedioFinal float

)

INSERTInserta registros en la tabla de base de datos. Ejemplo;

insert into alumno ( alumno_id, apellidoNombre, evaluacionParcial1, evaluacionParcial2, promedioDeTrabajo, promedioFinal ) values ( 1, ‘Arias, Alex’, 11, 11, 11,11 ) insert into alumno ( alumno_id, apellidoNombre, evaluacionParcial1, evaluacionParcial2, promedioDeTrabajo, promedioFinal ) values ( 2, ‘Barreto, Byron’, 12, 12, 12,12 )

SELECT Visualiza los registros de una tabla. Ejemplo:

select * from alumno ----> Para visualizar todos los registros con todos sus camposselect alumno_id, apellidoNombre from alumno ----> Para visualizar los campos alumno_id y apellidoNombre de la tabla alumno óselect count (*) from alumno ----> Para visualizar el número de registros almacenados en la tabla alumno.select from alumno order by alumno_id ----> Para visualizar los datos ordenados por el campo alumno_id

UPDATEActualiza datos de registros en una tabla de base de datos. Ejemplo.

update alumno set evaluacionParcial = 10 where alumno_id = 1

La cláusula where permite condicionar la actualización de un conjunto de registros específicos. Si no se especifica un registro determinado, se actualizan todos los registros.



DELETEElimina registros

delete from alumno where alumno_id = 1

ALTER TABLE . . . DROP COLUMN . . .Elimina una columna de la tabla. Ejemplo:

alter table tAlumno drop column promedioDeTrabajo

ALTER TABLE . . . ADD COLUMN . . .Agrega una columna de la tabla. Ejemplo:

alter table talumno add promedioDeTrabajo int

ALTER TABLE . . . MODIFY COLUMN . . .Modifica el tipo de dato de una columna. Ejemplo:

alter table talumno alter column promedioDeTrabajo float

ALTER TABLE . . . CHANGE COLUMN . . .Modifica el nombre de una columna. Ejemplo:

EXEC sp_rename 'tAlumno.apellidoNombre', 'ap'EXEC sp_rename 'tAlumno.ap', 'apellidoNombre'

ALTER TABLE . . . ALTER COLUMN . . .Modifica una columna de NULL a not NULL

ALTER TABLE tAlumno ALTER COLUMN alumno_id int not NULL

ALTER TABLE . . . ADD CONSTRAINT . . .Crea un índice de búsqueda en la tabla utilizando un campo clave. Ejemplo:

alter table talumno add constraint pk_alumno primary key (alumno_id)

SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLESPermite ver las tablas de una base de datos. Ejemplo

USE DbAlumnoSelect table_name from information_schema.tablesSelect table_name, column_name from information_schema.columns

DROP TABLE Permite borrar una tabla de base de datosdrop table talumno

DROP DATABASE Borra una base de datos. Ejemplo:

drop database dbalumno


http://www.lawebdelprogramador.com/foros/SQL_Server/574660-Cambiar_una_columna_de_NOT_NULL_a_NULL.html