Formularios MDI, Controles, y Empezando con ADO.NET

1 Formularios MDI y Nuevos Controles.
1.1 Creación de Formularios MDI

Para crear un formulario tipo MDI, este debe tener asignado en la propiedad IsMdiContainer como verdadero, este transforma a un formulario como un contenedor de formularios.

Para involucrar un nuevo formulario como involucrado dentro de un MDI, este se debe establecer en la propiedad MdiParent del formulario.

Dim xfrm As New frmAlumnos
xfrm.MdiParent = Me
xfrm.Show()

1.2 Uso del control MenuStrip
En VS2005 uno de los controles nuevo e interesantes son los asociados al manejo de menús, ahora estos controles entregan nuevas funcionalidades que hacen sus usos mas fáciles y potentes a la vez. El control MenuStrip es nuevo en esta versión, con este control se pueden incluso crear menús de acceso rápido estándar como los que aparecen en todos los programas de Office.

Este control se usa para formulario tipo MDI para la creación de menús, permite teclas de acceso rápido, tecla de método abreviado, marcas de verificación, imágenes por opción, barras separadoras, y otros controles de la familia System.Windows.Forms.Control es decir TextBox, Labels, etc.

Aunque el control MenuStrip reemplaza al anterior, éste conserva a efectos de compatibilidad con versiones anteriores y uso futuro, según sea el caso.

El control MenuStrip se encuentra agrupado por los controles “Menus & Toolbars”.

Agregando elementos predefinidos

Elementos de un MenuStrip
MenuItem
ComboBox
Separator
TextBox

Cuadro de Opciones para Mantenimiento de un MenuStrip
Para la edición manual de los elementos se debe seleccionar el MenuStrip Click derecho y seleccionamos “Edición de Ítems” o desde el cuadro de propiedades en “Ítems” y tendremos el siguiente cuadro para ver el “El cuadro de edición”.

Miembros importantes del control MenuStrip
ToolStripMenuItem

Representa una opción seleccionable mostrada en un MenuStrip. A nivel clases inicializa una nueva instancia de la clase ToolStripMenuItem con el nombre especificado que muestra la imagen y el texto especificados, y realiza la acción especificada cuando se hace clic en ToolStripMenuItem, entre otras instancias principales.

'Creamos los menús

Dim tCabecera As New ToolStripMenuItem
Dim tOpcion As New ToolStripMenuItem
'Colocamos los nombres respectivos
tCabecera.Text = "Archivo"
tOpcion.Text = "Abrir Archivo"
'Agregamos a "Archivo" el item "Abrir Archivo"
tCabecera.DropDownItems.Add(tOpcion)
'Agregamos los menús al MenuStrip
Me.MenuStrip1.Items.Add(tCabecera)

Solo para las cabeceras se agregaran elementos con el método Items.Add, para los demas será con el método DropDownItems, para este ejemplo:

ToolStripControlHost
Aloja controles personalizados o controles de formularios Windows Forms.

'Creamos otro menú:
Dim tControl As New ToolStripMenuItem
tControl.Text = "Alojando Controles"

'Creando el control para ser alojado
Dim oCalendario As New MonthCalendar
Dim tControlHost As New ToolStripControlHost(oCalendario)

'Agregamos los menús
tControl.DropDownItems.Add(tControlHost)
Me.MenuStrip1.Items.Add(tControl)

Para este ejemplo tenemos lo siguiente:

1.3 Uso del control ToolStrip
El ToolStrip es un control de acceso rápido, se comporta como un contenedor de controles para formar la barra de herramientas, ofrece también vistas para Windows XP tipo Office o Internet Explorer. Al igual que el control MenuStrip ofrece la incorporación de elementos estándar.

Con este control incluye la activación y edición en contexto, permite realizar un diseño personalizado, posición del control tanto horizontal como vertical, todo esto dentro del control ToolStripContainer especificado

Agregando elementos predefinidos

Elementos de un ToolStrip

El ToolStrip, es un control de contenedores de los siguientes objetos:

ToolStripButton,
ToolStripComboBox,
ToolStripSplitButton,
ToolStripLabel,
ToolStripSeparator,
ToolStripDropDownButton,
ToolStripProgressBar
ToolStripTextBox.

Ejemplo: Realicemos el siguiente Diseño para un ToolStrip:

Agregando Elementos a un ToolStrip.

'Agregando un Boton a un ToolStrip:
Dim tBoton As New ToolStripButton
tBoton.Text = "Mi Nuevo Boton"
Me.ToolStrip1.Items.Add(tBoton)

Al usar uno de los botones del ToolStrip de diseño anterior, en el botón ir podríamos colocar lo siguiente (previamente colocar el control WebBrowser)

El control WebBrowser, nos permite crear exploradores dentro de nuestros proyectos, en este pequeño ejemplo dentro del control ToolStripTextBox se ingresara la ruta que queremos explorar y al accionar en el control ToolStripButton activaremos la página en el control WebBrowser.

'Obtenemos la dirección ingresada:
Dim sUrl As String
sUrl = Me.ToolStripTextBox2.Text

'Mostramos la pagina:

Me.WebBrowser1.Navigate(sUrl)

1.4 Uso del Control StatusStrip
El control StatusStrip representa un control que sirve para representar información de la aplicación, como el nombre del equipo, el usuario, el aplicativo, la opción del sistema, la fecha actual. Como se ve este control se usa mayormente para mostrar información sobre la aplicación, este control para la muestra de información utiliza los objetos:

ToolStripStatusLabel

ToolStripProgressBar

ToolStripDropDownButton

ToolStripSplitButton

Este control reemplaza y amplía las funciones del control StatusBar de versiones anteriores, para el control efectos de compatibilidad con versiones anteriores.

2 Nuevos Controles, Acceso a Datos con ADO.NET
2.1 Introducción
La versión de ADO.NET 2.0 incorpora nuevas clases e interfaces que no existiera en la versión anterior, además de nuevos controles y mejoramiento para el uso de clases que ya existían, para esto a la hora de usar una clase o método antiguo, nos dará un mensaje de que este esta obsoleto y la recomendación por el cual fue cambiado.

ADDO.NET 2.0 mejora el tratamiento de los datos, modificación de datos para bloques de información de gran cantidad.

ADO.NET 2.0 incorpora varios proveedores de datos, entre ellos dos principales que permiten conectarse con SQL Server y Oracle (siempre y cuando se haya instalado su manejador de BD), así como otros que facilitan el uso de controladores ODBC y OLE DB para acceder a aquellos provenientes de Excel, Access, MySQL, y otras bases más.

2.2 Modelo Practico de cómo Interactúan los Objetos de ADO.NET

2.3 Crear una Conexión a una Base de Datos
Para crear una conexión a un servidor de base de datos, se debe usar el “Explorador de Servidores”, que creara una nueva conexión, como se muestra en la pantalla:

2.4 Configurar la Conexión.
Al seleccionar una nueva configuración la pantalla a mostrarse será la siguiente, donde tendremos que indicar lo siguiente:

Nombre del Servidor de la Base de Datos.
Modo de Autenticación.
Base de Datos a conectarse.

Al terminar de configurar la conexión, en el explorador de soluciones se observara lo siguiente, las tablas y demás objetos de la base de datos seleccionada.

2.5 Como crear una fuente de datos en nuestro Proyecto
Para crear una fuente de datos en nuestro proyecto se de seleccionar desde el menú Data y ejecutamos “Add New Data Source”, para que aparezca el asistente de creación de fuentes de datos.

El tratamiento de los distintos orígenes de datos con los que puede trabajar .NET. son basados de una fuente de datos que puede interactuar con un servicio Web, una colección de objetos persistentes o un servidor de bases de datos.

Si elegimos una base de datos, lo siguiente es indicar la conexión creada anteriormente o en todo caso crear una nueva para generar la cadena de conexión.

Al indicarle el servidor con el que nos vamos a conectar, debemos elegir los objetos de la base de datos que vamos a incluir en la fuente de datos. Para este ejemplo elegiremos una sola tabla: Employees.

Una vez seleccionado los datos a conectarse en la ventana de “Data Sources” veremos el objeto seleccionado. como se puede observar estamos dando exactamente los mismos pasos que si fuésemos a definir un conjunto de datos con tipos o un adaptador de datos en la versión anterior de Visual Studio 2003, asimismo en el explorador de soluciones se abra creado un nuevo objeto con el nombre NorthwindDataSet.xsd.

Desde el archivo creado en el explorador de soluciones buscamos el archivo creado con la extensión .xsd le damos doble Click, para observar dentro del DataSet la tabla creada.

2.6 El Adaptador de Datos
El Adaptador de datos representa una clase que te permite realizar un conjunto de comandos desde la base de datos hacia el cliente, es decir permite establecer una conexión a la base de datos para realizar llenados de datos hacia un DataSet y actualizar el origen de datos de las modificaciones realizadas.

Al realizar una conexión y establecer la consulta a traer crea una tabla en el DataSet, y esto significa crear además una clase adicional a la tabla correspondiente. Las clases generadas por este adaptador a diferencia de lo que ocurre con los conjuntos de datos con tipos, no tienen ningún tipo de ancestro común.

El adaptador nos permite configurar métodos para adicionar consultas personalizadas, ejecución de procedimientos almacenados, entre otros sobre la tabla agregada al conjunto de datos.

Una vez seleccionado la adición de una nueva consulta, la pantalla siguiente será esta:

Dentro del siguiente cuadro de dialogo seleccionaremos que nos devuelva una simple consulta de todas las opciones mostrada.

Luego dentro de ella se puede configurar la consulta generada por el ayudante.

Luego se crearan los métodos que implementan el llenado de la data configurada.

Al visualizar nuevamente en el DataSet esta tabla quedaría configurada con los siguientes eventos creados:

A diferencia de Visual Studio, la muestra de datos es automática la generación de código par mostrar la tabla o consulta, tan solo desde la ventana Data Source seleccionamos la tabla y la arrastramos al formulario y se creara lo siguiente.

El cual generara el código siguiente:

Private Sub EmployeesBindingNavigatorSaveItem_Click(ByVal sender As...
Me.Validate()
Me.EmployeesBindingSource.EndEdit()
Me.EmployeesTableAdapter.Update(Me.NorthwindDataSet.Employees)
End Sub

Private Sub frmAdo_Load(ByVal sender As System.Object, ByVal e ...
'TODO: This line of code loads data into the 'NorthwindDataSet.Employees' table.
'You can move, or remove it, as needed.
Me.EmployeesTableAdapter.Fill(Me.NorthwindDataSet.Employees)
End Sub

Solo a modo de indicar que efectúa cada uno, el método EmployeesBindingNavigatorSaveItem realiza la modificación de los registros hacia la base de datos, mientras que el método frmAdo_Load realiza la muestra de información de la tabla Employees; para esto utiliza el adaptador de datos que contiene el método para rellenar la tabla empleados EmployeesTableAdapter y se le indica el DataTable Employees que se encuentra en el DataSet NorthwindDataSet.

2.7 Nuevo Control BindingSource
Para facilitar el enlace a datos de los controles, se ha añadido un nuevo componente de .NET 2.0: llamado BindingSource que para este caso solo lo usaremos a nivel diseño. Este nuevo componente permite aislar a los controles visuales de muestra de datos del origen de datos con el que deben trabajar. Tanto el control como la barra de navegación harán referencia a estos componentes para realizar sincronización de avance o desplazamiento de registros, en vez de usar directamente el conjunto de datos, que es lo que ocurría en las versiones anteriores el cual era directo.

Aunque esta forma solo es recomendada al usar para vista de un DataGriView combinando con controles de acceso a datos como los TextBox, al ejecutar el formulario se tendrá lo siguiente:

2.8 Del DataGrid al DataGridView
El control DataGridView a diferencia del DataGrid una forma mas eficaz y flexible para la muestra de datos de un DataTable, a nivel diseño se mejoro el tratamiento sobre el mismo DataGridView y ya no sobre una clase aparte como se hacia con el DataGrid. Con este nuevo control podemos mostrar vistas de solo lectura o mostrar vistas modificables con el conjunto de datos asociados.

El control DataGridView nos permite adicionarle comportamientos personalizados para un determinado conjunto de datos, para la ordenación, selección, edición, eliminación u otras acciones sobre el DataGridView. Permite personalizar la apariencia o diseño con las propiedades que proporciona como filas normales, filas alternantes, filas seleccionadas, etc.

Permite adicionar columnas con tipos de datos definidos o definir los tipos de datos de las columnas existentes relacionada con el origen de datos asociadas.

2.9 Formas de presentación de datos en el control DataGridView.
En el control DataGridView se puede mostrar los datos en tres modos distintos: con enlace, sin enlazar y en forma virtual.

Sin enlazar
El modo sin enlace sirve para mostrar cantidades de datos relativamente pequeñas que se puedan manejar a nivel de programación para validaciones simples en forma temporal mediante matrices o estructuras de datos.

1.- Ejemplo de mostrar datos sin enlazar:
Primero crearemos un formulario en el crearemos un DataGridView con el nombre dgSinLace.

2.- Indicarle el número de columnas:
Me.dgSinEnlace.ColumnCount = 3

3.- Darle Formato al DataGridView:

With Me.dgSinEnlace.ColumnHeadersDefaultCellStyle
.BackColor = Color.Blue
.ForeColor = Color.Beige
.Font = New Font(Me.dgSinEnlace.Font, FontStyle.Bold)
End With

4.- Agregando Columnas con Estilo Definido:

With Me.dgSinEnlace
.Name = "Listado de Empleados SysCOM"
.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.DisplayedCellsExceptHeaders
.ColumnHeadersBorderStyle = DataGridViewHeaderBorderStyle.Single
.CellBorderStyle = DataGridViewCellBorderStyle.Single
.GridColor = Color.Black

.Columns(0).Name = "Nombres"
.Columns(1).Name = "Apellidos"
.Columns(2).Name = "Areas"

.SelectionMode = DataGridViewSelectionMode.FullRowSelect
End With

5.- Agregando filas:

Dim fila1 As String() = {"Carlos Alberto", "Salas Ruiz", "Venta"}
Dim fila2 As String() = {"Raul la Torre ", "Rojas Arpe", "Operaciones"}
Dim fila3 As String() = {"Ana Sonia", "Segura Panduro", "Contabilidad"}

With Me.dgSinEnlace.Rows
.Add(fila1)
.Add(fila2)
.Add(fila3)
End With

6.- Muestra del Formulario:



Enlazado
Este modo realiza un enlace determinado a un origen de datos mediante un DataSet, realizado anteriormente con un Adaptador de datos.

Virtual
El modo virtual se usa para la muestra de grandes volúmenes de datos en formato de una tabla, para esto se debe establecer la propiedad VirtualMode en true y así poder administrar la información en la cache y poder trabajar sobre ella, se puede controlar las columnas que se quieren enlazar con el origen de datos.

Laboratorio 05:
I.- Crear un formulario con el nombre frmMDI, con las siguientes propiedades:
IsMdiContainer = True

WindowState = Maximized
Text = Sistema de Aplicaciones System – Com.Net

II.- Dentro de él agregar un MenuStrip con los siguientes elementos para el menú:

&Persona Ver &Reporte &Ayuda
Agregar &Clientes Reporte de Clientes Acerca de..
Agregar &Empleados Reporte de Empleados

Luego agregar un ToolStrip y un StatusStrip, con los elementos mostrados en la imagen.

III.- Crear 2 formularios uno con el nombre frmEmpleado y frmReportes.

IV.- Del capitulo anterior, en el formulario frmLogin debemos cambiar para cuando el usuario se autentifique se abra el formulario frmMDI.

V.- En el evento Load del formulario escribimos lo siguiente, para mostrar información de la aplicación:

Me.ToolStripSplitButton1.Text = "Usuario: Administrador"
Me.ToolStripSplitButton2.Text = "Base de Datos: NorthWind"
Me.ToolStripSplitButton3.Text = "Equipo: VBX-251"

VI.- En el Data Source, modificar el DataSet para que se muestren las tablas Customers y Employees.

Al realizar esto se crearan los controles tanto el DataSet como los Adaptadores de Datos a nivel diseño en el cuadro de controles:

VI.- En el formulario frmReportes, a nivel diseño seleccionar estos controles y lo ubicamos sobre el formulario, tanto para mostrar las tablas Customers y Employees, luego modificar el diseño como se muestra en el siguiente diseño:

Para esto el DataGridView se llamara dgReportes, para los botones btnEmpleados y btnClientes.

VII.- El BindingSource creado en diseño cambiar su propiedad Name a BindingSource, luego dentro del formulario crear los siguientes métodos:

Sub getEmpleados()
Me.Text = "Reporte de Empleados"
Me.EmployeesTableAdapter1.Fill(NorthwindDataSet1.Employees)
Me.dgReportes.DataSource = NorthwindDataSet1.Employees
End Sub

Sub getClientes()
Me.Text = "Reporte de Clientes"
Me.CustomersTableAdapter1.Fill(NorthwindDataSet1.Customers)
Me.dgReportes.DataSource = NorthwindDataSet1.Customers
End Sub

VIII.- Ahora en el formulario frmMDI se debe de llamar a estos métodos, que deben ser colocados dentro de los botones correspondientes del ToolStrip y MenuStrip para las opciones “Ver Empleados” y “Ver Clientes”.

Para Abrir el listado de Empleados:

'Mostramos los Empleados
frmReportes.MdiParent = Me
frmReportes.Show()
frmReportes.getEmpleados()
Me.ToolStripSplitButton1.Text = frmReportes.Text

Para Abrir el listado de Clientes:

'Mostramos los Clientes
frmReportes.MdiParent = Me
frmReportes.Show()
frmReportes.getClientes()
Me.ToolStripSplitButton1.Text = frmReportes.Text

X.- Todo estos eventos configurarlos, tanto en el control ToolStrip y MenuStrip

XI.- Al Salir del frmMDI, se debe cerrar la aplicación.

Obs.: La realización del formulario frmEmpleados será configurado en el capítulo siguiente, el formulario frmClientes corresponde al capitulo anterior.

Realizar lo siguiente:
I.- Configurar los botones btnEmpleados y btnClientes para la muestra de las respectivas tablas.

Modulo I - Declaración por Referencia e Instancia

1 Declaración por Referencia e Instancia.

1.1 Creación de un Objeto Por Referencia e Instancia.

Se referencia al objeto hacia una variable:

Dim Variable as [Objeto]

Creando el objeto o Instanciandolo:

Variable = New [Objeto]

1.2 Creación de un Objeto Por Referencia e Instancia a la vez.
Se referencia e instancia a la vez:

Dim Variable as New [Objeto]

Una vez creado el objeto se puede hacer uso de sus métodos y propiedades.

Ejemplo:Acá se muestra que el objeto solo es referenciado por lo tanto se producirá una excepción que el objeto no fue instanciado.

Figura 1

Si ahora instanciamos el objeto veremos que no produce ninguna excepción.

Figura 2

1.3 Uso de Clases en .NET
Como vimos en los laboratorios anteriores, los tipos de datos se dividen en dos grupos: tipos por valor y tipos por referencia. Los tipos por referencia realmente son clases, de la cuales debemos crear una instancia para poder usarlas, cuando instanciamos una clase esta se crea en la parte lejana de la memoria llamada heap, y las variables que la contienen solo hacen una referencia a la dirección de su ubicación en la que la CLR ha almacenado el objeto recién creado.

En el .NET Framework la mayor parte a usar será una clase, la creación de formularios, la creación de módulos, y las clases mismas etc., toda estas se grabaran con la extensión vb si usamos como lenguaje predeterminado Visual Basic, para C# la extensión sera .cs.

Figura 3

2 Creación de Clases en .NET

1.4 Object: La clase base de todas las clases de .NET
Las clases existentes en la biblioteca de clases del .NET Framework, derivan de una clase principal llamada object, es decir así lo indiquemos o no cualquier clase que definamos o usemos tendrá el comportamiento.
Todas las clases de .NET se derivan de la clase Object, es decir, lo indiquemos o no, cualquier clase que definamos tendrá el comportamiento heredado de esa clase. El uso de la clase Object como base del resto de las clases de .NET es la única excepción a la herencia simple soportada por .NET, ya que de forma implícita, todas las clases de .NET se derivan de la clase Object independientemente de que estén derivadas de cualquier otra.

De los miembros que tiene la clase Object debemos resaltar el método ToString, este método está pensado para devolver una representación en formato cadena de un objeto.

Figura 4

1.5 Definir una clase

En Visual Basic 2005, todo el código que queramos escribir, lo tendremos que hacer en un fichero con la extensión .vb, dentro de ese fichero es donde escribiremos nuestro código, el cual, tal como dijimos anteriormente siempre estará incluido dentro de una clase, aunque un fichero de código de VB puede contener una o más clases, es decir, no está limitado a una clase por fichero. En Visual Basic 2005 las clases se definen usando la palabra clave Class seguida del nombre de la clase, esa definición acaba indicándolo con End Class.

Figura 5

1.6 Los miembros de una clase
Una clase puede contener cualquiera de estos elementos (miembros):

• Enumeraciones

• Campos

• Métodos (funciones o procedimientos)

• Propiedades

• Eventos

Aquí una breve descripción:
Los campos: Son variables usadas para mantener los datos que la clase manipulará.

Los métodos: Son las acciones que la clase puede realizar, normalmente esas acciones serán sobre los datos que

contiene. Dependiendo de que el método devuelva o no un valor, podemos usar métodos de tipo Function o de tipo Sub respectivamente.

Las propiedades: Son las "características" de las clases y la forma de acceder "públicamente" a los datos que contiene. Por ejemplo, podemos considerar que el nombre y los apellidos de un cliente son dos características del cliente.

Los eventos: Son mensajes que la clase puede enviar para informar que algo está ocurriendo en la clase.

Esquema de una Clase:

Public Class Empleados

Dim Codigo As Integer

Public bEstado As Boolean

Private sCta As String

Public Property Cuenta()

Get

Return sCta

End Get

Set(ByVal value)

sCta = value

End Set

End Property

Public Function BuscaEMpleado(ByVal _codigo As Integer) As String

Return "Felipe Castañeda"

End Function

End Class

Uso de la clase:

Figura 6

1.7 Creación de Procedimientos Sobre Cargados
La sobrecarga de funciones (tanto para funciones como para procedimientos Sub), es una característica que nos permite tener una misma función con diferentes tipos de parámetros, ya sea en número o en tipo.

Supongamos que queremos tener dos funciones (o más) que nos permitan hacer operaciones con diferentes tipos de datos, y que, según el tipo de datos usado, el valor que devuelva sea de ese mismo tipo.

Ejemplo de procedimientos sobre cargados:

Sub VerificarDatos()

'Codigo a ejecutar

'.....

'.......................

End Sub

Sub VerificarDatos(ByVal xVar1 As String)

'Codigo a ejecutar

'.....

'.......................

End Sub

Function VerificarDatos(ByVal xVar1 As String, ByVal xVar2 As Integer) As Boolean

'Codigo a ejecutar

'.....

'.......................

End Function

Sub VerificarDatos(ByVal ParamArray xVar1() As String)

'Codigo a ejecutar

'.....

'.......................

End Sub

Llamada a un Procedimiento Sobre Cargado:

Figura 7

2 Inicio de una Aplicación, Control de Excepciones.

2.1 Ejecución de una Aplicación
Para iniciar y cerrar una aplicación, la biblioteca de clases del .NET Framework proporciona la clase Application, esta clase contiene dos métodos principales aparte de métodos para gestionar una aplicación

A nivel Aplicación.
Run: Invoca el método Application.Run para iniciar la aplicación.

Figura 8

Exit: Para cerrar una aplicación, invocamos al método Application.Exit

Figura 9

A nivel Formulario.

Show: Llama al formulario indicado para ser mostrado:

Close: Destruye el formulario al que hace referencia.

2.2 Manejo de excepciones
Las excepciones en Visual Basic 2005 las podemos controlar usando las instrucciones Try / Catch / Finally., estas instrucciones realmente son bloques de instrucciones, al estilo de If / Else.

Cuando queramos controlar una parte del código que puede producir un error lo incluimos dentro del bloque Try, si se produce un error, éste lo podemos detectar en el bloque Catch, por último, independientemente de que se produzca o no una excepción, podemos ejecutar el código que incluyamos en el bloque Finally, para indicar el final del bloque de control de excepciones lo haremos con End Try.Cuando creamos una estructura de control de excepciones no estamos obligados a usar los tres bloques, aunque el primero: Try si es necesario, ya que es el que le indica al compilador que tenemos intención de controlar los errores que se produzcan. Por tanto podemos crear un "manejador" de excepciones usando los tres bloques, usando Try y Catch o usando Try y Finally.

Try

En este bloque incluiremos el código en el que queremos comprobar los errores, el código a usar será un código normal, es decir, no tenemos que hacer nada en especial, ya que en el momento que se produzca el error se usará (si hay) el código del bloque Catch.

Catch

Si se produce una excepción, ésta la capturamos en un bloque Catch. En el bloque Catch podemos indicar que tipo de excepción queremos capturar, para ello usaremos una variable de tipo Exception, la cual pude ser del tipo de error específico que queremos controlar o de un tipo genérico.

Finally

En este bloque podemos indicar las instrucciones que queremos que se ejecuten, se produzca o no una excepción. De esta forma nos aseguramos de que siempre se ejecutará un código, por ejemplo para liberar recursos, se haya producido un error o no.

Ejemplo

Dim x, y, r As Integer

Try

x = 5

y = 6

r = x / 6

Console.WriteLine("El resultado es {0}", r)

Catch ex As ArithmeticException When y = 0

Console.WriteLine("Sucedio un error Aritmetico")

Catch ex As Exception

Console.WriteLine(ex.Message)

End Try

Laboratorio 04:
Empecemos a crear una aplicación para demostrar el uso de las funciones estudiadas:
I.- Crear el siguiente formulario con el nombre frmLogin, con el siguiente diseño:

Figura 10

Las propiedades para este formulario, son las siguientes:

MaximizeBox= False

MinimizeBox= False

StartPosition = CenterScreen

ShowIcon = False

Opacity = 85%

Y las propiedades para los objetos textbox son las siguientes:

TxtUsuario:

MaxLength = 5

CharacterCasing= Upper

TxtClave:

MaxLength = 5

PasswordChar = *

II.- Una vez realizado esto, dentro del modulo modGeneral, crear un método con el nombre “Sub Main”.

Sub Main()

''''''''''''''''''''''

'Ejecución de procesos.

'...

'.......

''''''''''''''''''''''

frmLogin.Show()

Application.Run()

End Sub

Para indicarle a nuestro proyecto que al iniciarse se ejecute nuestro método “Sub Main”, en propiedades del proyecto debemos indicarle desactivando la opción “Enable application framework”:

Figura 11

II.- Crear el siguiente formulario con el nombre frmClientes y con el siguiente diseño.

Figura 12

III.- Aprendiendo a configurar la tabulación de nuestros controles, desde el menú Ver seleccionamos Orden de Tabulación.

Figura 13

Luego la visualización del formulario quedara como sigue, dándole un Click comenzaremos a configurarlo el orden de tabulación.

Figura 14

IV.- Ahora crearemos un modulo con el nombre modGeneral, dentro de él tendremos que crear al as siguientes variables:

Private _Usuario As String = "admin"

Private _Clave As String = "admin"

Después un Enum para la definición de los tipos de clientes:

Enum TipoCliente

Mayorista

Nuevo

Moroso

End Enum

Public Tipo As TipoCliente

Luego agregaremos la siguiente función llamada Logeo, dentro de este modulo:

Function Login(ByVal Usuario As String, ByVal Clave As String) As Boolean

Dim bEstado As Boolean = False
If Usuario = _Usuario And Clave = _Clave Then

bEstado = True

Else

bEstado = False

End If

Return bEstado
End Function

V.- Ahora en el formulario frmLogin debemos escribir lo siguiente dentro del botón Aceptar.

If Login(Me.txtUsuario.Text, Me.txtClave.Text) Then

frmClientes.Show()

Me.Close()

Else

MessageBox.Show("Usuario incorrecto", "Sistemas",

_ MessageBoxButtons.OK, MessageBoxIcon.Exclamation)

End If

VI.- En el formulario frmLogin, frmClientes buscamos el evento FormClosed y escribimos lo siguiente, asimismo en el botón cancelar del formulario frmLogin:

Application.Exit()

VII.- Crear una clase al proyecto con el nombre Clientes, y dentro de el definir las siguientes variables, como se muestra en el siguiente grafico:

Public Class Clientes
Public Codigo As String = ""

Public Nombre As String = ""

Public Apellido As String = ""

Public Ciudad As String = ""

Public Telefono As String = ""

Public FecNacimiento As String = ""
End Class

VIII.- En la misma clase tenemos que agregar el siguiente método:

Public Sub AgregaClientes(ByVal xList As ListBox)

Dim sDato As String = ""

Codigo += Space(5 - Len(Codigo))

Nombre += Space(20 - Len(Nombre))

Apellido += Space(20 - Len(Apellido))

Ciudad += Space(13 - Len(Ciudad))

Telefono += Space(8 - Len(Telefono))

sDato = Codigo + Space(3) + Nombre + Space(3) + Apellido

Select Case Tipo

Case TipoCliente.Mayorista

sDato += Ciudad

Case TipoCliente.Nuevo

sDato += Ciudad + Space(3)

sDato += Telefono

Case TipoCliente.Moroso

End Select

xList.Items.Add(sDato)

End Sub

IX.- Finalmente en la clase agregamos un último procedimiento sobrecargado con en el mismo nombre del procedimiento anterior en el punto VIII:

Public Function AgregaClientes() As String

Dim sDato As String = ""

sDato = Codigo + " " + Nombre + " " + Apellido + " " + Ciudad

Return sDato

End Function

X.- Volviendo al formulario frmClientes, agregar lo siguiente en el botón Agregar y probar el formulario.

If Me.radMayorista.Checked = True Then Tipo = TipoCliente.Mayorista

If Me.radMoroso.Checked = True Then Tipo = TipoCliente.Mayorista

If Me.radNuevo.Checked = True Then Tipo = TipoCliente.Mayorista

Dim _Clientes As New Clientes

With _Clientes

.Codigo = Me.txtCodigo.Text

.Nombre = Me.txtNombres.Text

.Apellido = Me.txtApellidos.Text

.Ciudad = Me.txtCiudad.Text

.Telefono = Me.txtTelefono.Text

.FecNacimiento = Me.dtpFecha.Value

End With

_Clientes.AgregaClientes(Me.lstClientes)

Realizar lo siguiente:

I.- Cuando se seleccione la opción “Otros” de “Tipo de clientes” se debe de usar el procedimiento sobrecargado del punto IX:

II.- Implementar la eliminación del listado de clientes.