windows forms

Pag. 1 de 127

Desarrollo de Aplicaciones para Windows - Utilizando Visual Basic.Net

TEMA 1.............................................................................................................................................................2

¿Qué es la Plataforma .NET?........................................................................................................................3

¿Qué es el .NET Framework?........................................................................................................................3

Visual Basic .NET...........................................................................................................................................4

Crear un Proyecto.........................................................................................................................................4

¿Qué es un Formulario?...............................................................................................................................5

Ventana de Código.......................................................................................................................................5

Barra de Herramientas.................................................................................................................................6

Propiedades..................................................................................................................................................6

Métodos.......................................................................................................................................................8

Controles....................................................................................................................................................10

Ejercicio Practico Nº1.................................................................................................................................12

Resolver:.....................................................................................................................................................13

TEMA 2...........................................................................................................................................................15

Tipo de Datos..............................................................................................................................................16

Variables.....................................................................................................................................................17

Ámbito de una Variable..............................................................................................................................18

Ejercicio Práctico Nº1:................................................................................................................................20

Variables Estáticas......................................................................................................................................20

Variables vs. Constantes.............................................................................................................................21

Convertir Tipos de Datos............................................................................................................................22

Ejercicios.....................................................................................................................................................23

TEMA 3...........................................................................................................................................................27

FUNCIONES TIPO CADENA..........................................................................................................................28

Format........................................................................................................................................................30

TEMA 4...........................................................................................................................................................37

Cómo Utilizar Operadores Aritméticos.......................................................................................................38

Cómo Utilizar Operadores de Comparación...............................................................................................39

Cómo Utilizar los Operadores Lógicos........................................................................................................39

Uso de Estructuras de Decisión..................................................................................................................40

TEMA 5...........................................................................................................................................................47

Control ListBox y ComboBox.......................................................................................................................48

Ejercicio Practico Nº1.................................................................................................................................49

INDICE

Pag. 2 de 127


TEMA 6...........................................................................................................................................................54

Bucles.........................................................................................................................................................55

TEMA 7...........................................................................................................................................................61

Arreglos......................................................................................................................................................62

Los Arrays Multidimensionales...................................................................................................................64

Estructuras..................................................................................................................................................67

Ejercicios de Arrays.....................................................................................................................................70

TEMA 8...........................................................................................................................................................74

Sentencia RND ().........................................................................................................................................75

Procedimientos Sub....................................................................................................................................77

Procedmientos Function.............................................................................................................................77

El Control Timer..........................................................................................................................................78

TEMA 9...........................................................................................................................................................81

RadioButton y CheckBox.............................................................................................................................82

Try...Catch..................................................................................................................................................88

TEMA 10.........................................................................................................................................................91

Control OpenFileDialog..............................................................................................................................92

Control SaveFileDialog................................................................................................................................92

Control FontDialog.....................................................................................................................................93

Control ColorDialog....................................................................................................................................93

ProgressBar................................................................................................................................................96

TEMA 11.........................................................................................................................................................98

El Control DateTimePicker..........................................................................................................................99

MonthCalendar..........................................................................................................................................99

ToolTip........................................................................................................................................................99

NotifyIcon...................................................................................................................................................99

Ejercicio Práctico Nº1...............................................................................................................................100

TEMA 12.......................................................................................................................................................103

Formulario MDI Padre..............................................................................................................................104

El Editor de Menú.....................................................................................................................................104

Creación de un Menú Contextual.............................................................................................................105

Control ToolBar........................................................................................................................................105


ToolStrip...................................................................................................................................................108

StatusStrip................................................................................................................................................108

Pag. 3 de 127



TEMA 13.......................................................................................................................................................114

Creación de Controles en Visual Basic.Net 2005......................................................................................115

Explorador Web........................................................................................................................................123

Reproductor de Música y Video...............................................................................................................124

Pag. 4 de 127


TEMA 1

¿Qué es la plataforma Microsoft .NET?

¿Qué es el .NET Framework?

Conceptos básicos de .NET

Explorar el entorno de desarrollo

Crear un proyecto Visual Basic .NET

Pag. 5 de 127


IntroducciónIntroducción¿Qué es la Plataforma .NET?

La plataforma .NET proporciona la base de la siguiente generación de software que permite conectar sistemas, información, dispositivos y usuarios distintos de un modo más unificado y personalizado. Incorpora servicios Web XML como el medio para permitir la interoperabilidad entre tecnologías diferentes.

Visual Basic .NET usa una jerarquía de clases que están incluidas en el .NET Framework, por tanto conocer el .NET Framework nos ayudará a conocer al propio Visual Basic .NET.

¿Qué es el .NET Framework?

"El .NET Framework es un entorno multi-lenguaje para la construcción, distribución y ejecución de Servicios Webs y aplicaciones."

El .NET Framework es el corazón de .NET, cualquier cosa que queramos hacer en cualquier lenguaje .NET debe pasar por el filtro cualquiera de las partes integrantes del .NET Framework.

El .NET Framework tiene dos componentes principales: el Common Lenguaje Runtime y la biblioteca de clases.

Biblioteca de Clases: La biblioteca de clases es una colección completa orientada a objetos de clases reutilizables y organizadas en espacios de nombres jerárquicos en base a su funcionalidad. Podemos utilizar la biblioteca de clases para desarrollar aplicaciones que abarcan desde las aplicaciones clientes tradicionales hasta las aplicaciones basadas en las últimas innovaciones proporcionadas por ASP.NET y los servicios Web XML.

Common Language Runtime: El Common Language Runtime es la base del .NET Framework. En el entorno .NET, los programadores desarrollan aplicaciones en el lenguaje compatible con .NET que elijan; el código se compila en MSIL, y el entorno de ejecución gestiona y ejecuta el código compilado.

Pag. 6 de 127


Visual Basic .NET

Crear un Proyecto Como ustedes ya saben hay dos formas de crear un nuevo proyecto, lo único que veremos, lo que tenemos que escoger, al crear un proyecto esta vez seleccionaremos Aplicación para Windows, le pondremos un nombre y luego daremos clic en aceptar.

Ventana de Diseño

Al crear una nueva solución de Aplicación para Windows, siempre nos aparecerá la siguiente ventana.

Como se darán cuenta acá el archivo siempre tendrá un nombre de Form1, que es el primer formulario del proyecto.

¿Qué es un Formulario? Es la ventana principal, porque sirve de fondo para los controles que se dibujan. en una aplicación, como cajas de textos, etiquetas, botones, etc. Se podría decir que es un contenedor de controles y objetos.

Ventana de Código Esta ventana contendrá todo el código que realizara los diferentes eventos, procedimientos, instrucciones del formulario. Mayormente para activar esta ventana y añadir cualquier código, siempre se tendrá que hacer doble clic en el control deseado, o si no oprimir la tecla F7.

Pag. 7 de 127


Caja de Herramientas

Contiene los controles que se dibujan en el formulario, en tiempo de diseño y no en tiempo de ejecución. Estos controles están divididos por clases, los controles más usados son los de Common Controls, mas adelante ya veremos con más detalle cada control.

Explorador de Soluciones

En esta ventana se encuentra el formulario, también vas a poder encontrar todos los Ítem que agregas de aquí en adelante, ya sean formularios, módulos, clases, etc.

Barra de Herramientas Esta barra contendrá diversos botones que suelen facilitar al programador en el uso del programa.

Pag. 8 de 127


Propiedades

Pag. 9 de 127


Pag. 10 de 127


Métodos Vamos a tocar los métodos más utilizados, ya que existen un sin fin de métodos.

Eventos

Vamos a tocar los eventos más utilizados, ya que existen una cierta cantidad considerables de eventos.

Pag. 11 de 127


Controles Con el .NET Framework 2.0 tenemos una diversidad de control y objetos que podemos usar en nuestras aplicaciones, ahora veremos algunos controles que mas vamos a usar divididos en categorías.

Pag. 12 de 127


Pag. 13 de 127


Ejercicio Practico Nº1.1. Diseñar el siguiente Formulario:

2. En el evento click del boton BtnMensaje codificamos lo siguiente:

Private Sub btnMensaje_Click MsgBox("Bienvenido a Visual Basic .Net " & Me.txtnombre.Text) End Sub

Ejercicio Practico Nº2.

1. Diseñar el siguiente Formulario:

2.- Luego codificamos lo siguiente en el evento click de los botones:

Private Sub BtnColorTexto_Click Me.TxtTexto.ForeColor = Color.Blue End Sub

Private Sub BtnColorFondo_Click Me.BackColor = Color.Red End Sub

Ejercicio Practico Nº3.

1. Diseñar el siguiente Formulario:

BtnMensaj

LblNombre TxtNombre

btnColorFondo

btnColorTexto

TxtTexto

BtnDividi

BtnRest

BtnSum

BtnPotenci

BtnNuev

TxtR

BtnMultiplic

Txt

Txt

Pag. 14 de 127


2.- Luego codificamos lo siguiente en el evento click de los botones:

Private Sub btnsuma_Click Me.txtres.Text = Val(Me.txt1.Text) + Val(Me.txt2.Text) End Sub

Private Sub btnresta_Click Me.txtres.Text = Val(Me.txt1.Text) - Val(Me.txt2.Text) End Sub

Private Sub btnmulti_Click Me.txtres.Text = Val(Me.txt1.Text) * Val(Me.txt2.Text) End Sub

Private Sub btndividir_Click Me.txtres.Text = Val(Me.txt1.Text) / Val(Me.txt2.Text) End Sub

Private Sub btnpotencia_Click Me.txtres.Text = Val(Me.txt1.Text) ^ Val(Me.txt2.Text) End Sub

Private Sub btnnuevo_Click Me.txt1.Clear() Me.txt2.Clear() Me.txtres.Clear() Me.txt1.Focus() End Sub

Resolver:1.- Crear una aplicación en la cual me permita realizar la siguiente ecuacion:

y= 5x2+2x+2

10

2.- Crear una aplicación en la cual me permita realizar la siguiente ecuacion:

y=4x2+√x+5

2√x

Pag. 15 de 127


Pag. 16 de 127


TEMA 2

Pag. 17 de 127


Tipo de Datos

El tipo de datos de un elemento de programación hace referencia a la clase de datos que puede contener y a cómo se almacenan los datos.

La ilustración anterior lista algunos de los tipos más utilizados en Visual Basic .NET. El término con signo significa que los números pueden ser positivos o negativos, como en +48 o -48.

¿Como Escoger un Tipo de Dato?

Introducción a los Tipos de Datos

¿Qué son las Variables?

Ámbito de las Variables

Convertir Tipos de Datos

Pag. 18 de 127


Visual Basic no requiere que seleccione explícitamente un tipo de datos cuando declara una variable. Sin embargo, es una buena idea hacerlo, ya que de esta forma sus aplicaciones serán más fiables y requerirán menos memoria. El tipo de datos determina los valores permitidos para una variable, que, a su vez, determinan las operaciones que pueden realizarse sobre esa variable.

Puede seguir las directrices generales que se muestran en la ilustración anterior para seleccionar el tipo de datos adecuado para una variable.

Si usted declara variables sin tipo de datos, se les otorga de forma predeterminada el tipo de datos Object. Esto facilita la escritura rápida de programas, pero puede hacer que éstos se ejecuten más lentamente.

Variables

¿Qué son las Variables?

Utilizamos variables para almacenar valores que pueden cambiar cuando una aplicación se está ejecutando. Una variable tiene los siguientes elementos:

Ámbito: El conjunto de todo el código que puede acceder y utilizar la variable.

Nombre: La palabra que utilizamos para hacer referencia a la variable en código.

Tipo de Datos: El tipo y tamaño inicial de datos que la variable puede almacenar.

Antes de poder utilizar variables en su aplicación, debe asignarles un valor. Puede asignar un valor a una variable después de declararla o mientras la declara.

Cómo Declarar Variables

Declaramos una variable para especificar su nombre y características. La instrucción de declaración tanto para variables de tipo valor como de tipo referencia es la instrucción Dim. La ubicación y el contenido de la declaración determinan las características de la variable.

Sintaxis para Declarar una Variable

Para declarar una variable, utilice la siguiente sintaxis:

Dim nombreVariable As Type

Utilizamos la instrucción Dim para declarar y asignar espacio de almacenamiento para variables en bloques, procedimientos, módulos, estructuras y clases. Utilizamos la cláusula As en la instrucción Dim para especificar el tipo de datos de la variable.

Nota: La palabra clave Dim es una abreviatura de la palabra dimensión.

Pag. 19 de 127


Cómo Asignar Valores a Las Variables

Antes de poder utilizar variables en su aplicación, debe asignarles un valor.

Puede asignar un valor a una variable después de declararla o mientras la declara.

Sintaxis

Para asignar un valor a una variable, utilice el operador de asignación (=), como se muestra en la siguiente expresión:

NombreVariable = Valor

El valor del lado derecho de la expresión se asigna a la variable del lado izquierdo de la expresión.

Asignar un Valor después de Declararla

Puede asignar valores a variables después de declararlas, como se muestra en el siguiente ejemplo:

Dim cumpleaños As DateCumpleaños = #3/9/1974#

Cuando creamos una variable con la instrucción Dim, Visual Basic inicializa automáticamente las variables numéricas a 0, las cadenas de texto a vacías ("") y las variables de fecha a 1 de enero de 0001.

Asignar Valores mientras la Declaras

También puede asignar un valor a una variable mientras la declara, como se muestra en los siguientes ejemplos:

Dim cumpleaños As Date = #3/9/1974#

Dim goodNews As String = "Su cheque está en el correo."

Dim testCondition As Boolean = True

Nota: Los valores de fecha (Date) deben estar encerrados entre almohadillas (##), y los valores de cadena (String) deben estar encerrados entre comillas ("").

Ámbito de una VariableCuando utilizamos variables, debemos asegurarnos de que son accesibles desde todas las áreas de código que hacen referencia a ellas. Por otra parte, es posible que necesite restringir el acceso a determinadas variables. Todo el conjunto de código que puede hacer referencia a una variable por su nombre se denomina ámbito (scope) de la variable.

Pag. 20 de 127


Pag. 21 de 127


Ejercicio Práctico Nº1:1.- Diseñar el siguiente formulario

2.- Luego codificamos lo siguiente

Imports System.Drawing.Image

Public Class Form3 Dim ruta As String = "Aqui pondremos la ruta donde se encuentran las imágenes unido con un \" Private Sub btnimagen1_Click Me.PictureBox1.Image = FromFile(ruta & "nombre de la imagen con su extension") End SubEnd Class

3.- El codigo del evento click del boton BtnImagen1; es el mismo para los otros botones pero con imágenes diferentes.

Variables Estáticas

La vida de una variable local empieza cuando un procedimiento la invoca y acaba cuando el procedimiento finaliza. Cuando acaba la vida de una variable local, la instancia de la variable se destruye y su valor se pierde. En ocasiones, es posible que deseemos que la vida de una variable local sea más larga que la vida del procedimiento. Por ejemplo, podemos desear que un procedimiento realice una acción específica la primera vez que sea invocado y que no haga nada en las siguientes llamadas. Podemos declarar una variable estática para conseguir esta funcionalidad.

Definición: Una variable estática perdurará mientras la aplicación siga ejecutándose. Las variables estáticas siguen existiendo y conservan sus últimos valores entre invocaciones al procedimiento en el que se han declarado. Sin embargo, el código de otros procedimientos no puede acceder a ellas.

Sintaxis: Para declarar una variable estática local, utilizaremos la siguiente sintaxis:

Static variableName As Type

BtnImagen4

BtnImagen3

BtnImagen2

BtnImagen1

PictureBox1

Pag. 22 de 127


Ejercicio Práctico Nº2:

1.- Diseñar el siguiente formulario

2.- Luego codificaremos lo siguiente dentro del botón btnincrementa (Evento Click)

Dim a As IntegerStatic b As Integera = a + 1b = b + 1lbla.Text = alblb.Text = b

Variables vs. Constantes

Las constantes almacenan valores que, como su nombre indica, permanecen constantes durante la ejecución de una aplicación. Algunas ventajas de utilizar constantes son:

Hacen que el código sea más fácil de leer.

Pag. 23 de 127


Utilizan menos memoria que las variables.

Hacen que los cambios a nivel de aplicación sean más fáciles de implementar.

Ejercicio Práctico Nº3:

1. Diseñar el siguiente formulario

2. Luego codificaremos lo siguiente, declaramos para todo el formulario las siguientes variables.

Dim circunferencia, radio as DoubleConst Pi as Double = 3.1415

3. Luego codificar el siguiente código dentro del evento clic del botón btncalcular.

Radio=txtradio.text

Circunferencia= 2 * Pi * radio

Txtcircun.text=circunferencia

Convertir Tipos de Datos

El proceso de convertir el valor de un tipo de datos en otro se denomina conversión o casting. Podemos convertir explícitamente valores de un tipo en otro antes de que sean utilizados, evitando así errores en nuestro código y haciendo que éste se ejecute más rápidamente. Visual Basic .NET también puede realizar algunas conversiones de tipos de datos automática o implícitamente, como convertir algunas cadenas a enteros. Sin embargo, las conversiones implícitas pueden producir resultados imprevistos.

Pag. 24 de 127


Ejercicios


btnReporteEnabled=False

TxtFin

TxtParTxtN1

TxtCur

TxtNiv

TxtAñ

TxtNom

TxtGra

Pag. 25 de 127


2.- Luego agregaremos un Modulo.

3.- Iremos al Menú Proyecto /Agregar Modulo.

4.- Después de Agregarlo codificaremos lo siguiente en el modulo:

Module Module1

Public fecha As Integer Public nom, niv, grad, cur As String Public n1, par, fin, prom, edad As Short

End Module

5.- Luego codificaremos lo siguiente en el Form1:

Private Sub btnreporte_Click

nom = Me.txtnom.Text fecha = Me.txtaño.Text niv = Me.txtniv.Text grad = Me.txtgrad.Text cur = Me.txtcur.Text n1 = CInt(Me.txtn1.Text) par = CInt(Me.txtpar.Text) fin = CInt(Me.txtfin.Text) edad = 2008 - fecha

prom = (n1 + par + fin) / 3

frmreporte.Show() Me.Hide()

End Sub

Private Sub Form1_Load

Me.txtaño.Clear() Me.txtcur.Clear() Me.txtfin.Clear() Me.txtgrad.Clear()

Pag. 26 de 127


Me.txtn1.Clear() Me.txtniv.Clear() Me.txtnom.Clear() Me.txtpar.Clear() Me.txtnom.Focus()

End Sub Private Sub txtfin_TextChanged

If Me.txtfin.Text <> "" Then Me.btnreporte.Enabled = True Else Me.btnreporte.Enabled = False End If

End Sub

6.- Agregamos otro formulario llamado FrmReporte y diseñaremos de la siguiente manera:

7.- En el formulario FrmReporte codificaremos lo siguiente

Private Sub btnmostrar_Click

Me.lblmensaje.Text = "El Alumno:" & nom.ToString & vbCrLf _ & "Con Edad:" & edad.ToString & vbCrLf _ & "Nivel:" & niv.ToString & vbCrLf _ & "Grado:" & grad.ToString & vbCrLf _ & "En el Curso de " & cur.ToString & " tiene un promedio de " & prom.ToString

End Sub

Private Sub btnvolver_Click

BtnMostrar BtnVolver

LblMensaje

Pag. 27 de 127


Form1.Show() Me.Hide()

End Sub

8.- Por ultimo probaremos la aplicación y quedara de la siguiente manera

Ejercicios PropuestosEjercicio Nº1

1.- Calcular el interés, su primera cuota de pago y el monto total a pagar de un préstamo. Utilizando variables y constante.

Ejercicio Nº2

1.- Realizar una pequeña aplicación de pagos de trabajadores. Utilizando variables.

Pag. 28 de 127


Pag. 29 de 127


Funciones Left, Rigth, Len, Trim, etc

Uso de FormatDateTime.

TEMA 3

Pag. 30 de 127


FUNCIONES TIPO CADENA

Una cadena es un dato de tipo String (Carácter); es decir se refiere a letras o letras y números, ahora veremos las funciones de cadenas más utilizadas y posteriormente realizaremos una aplicación para que les quede más claro, sobre las funciones de cadena.

Right: Obtiene de una cadena, una cantidad de caracteres empezando por la derecha: Sintaxis; Microsoft.VisulBasic.Right(Cadena,N).

Left: Obtiene de una cadena, una cantidad de caracteres empezando por la izquierda: Sintaxis; Microsoft.VisulBasic.Left(Cadena,N).

Mid: Obtiene de una cadena, una cantidad de caracteres a partir de una posición determinada: Sintaxis; Microsoft.VisulBasic.Mid(Cadena,N).

Len: Obtiene la longitud de una cadena, es decir la cantidad de caracteres que contiene incluyendo los espacios en blanco: Sintaxis; Len(Cadena).

Trim: Quita los espacios en blanco al final de una cadena: Sintaxis; Trim(Cadena). RTrim: Quita los espacios en blanco al final de una cadena: Sintaxis; RTrim(Cadena). LTrim: Quita los espacios en blanco al inicio de una cadena: Sintaxis; LTrim(Cadena). UCase: Convierte una cadena en mayúsculas: Sintaxis; UCase(Cadena). LCase: Convierte una cadena en minúsculas: Sintaxis; LCase(Cadena). StrConv: Convierte una cadena en 3 formas diferentes, en mayúsculas = 1, minúsculas = 2, la

primera letra de cada palabra en mayúsculas = 3 : Sintaxis; StrConv(Cadena,Valor). InStr: Obtiene un número que indica la posición de una subcadena dentro de una cadena:

Sintaxis; InStr(Cadena,SubCadena).

Ejercicio Práctico Nº1


Pag. 31 de 127


2. Luego codificaremos lo siguiente dentro del botón btnMuestra (Evento Click) .

Me.lblLongitud.Text = Len(Trim(Me.txtFrase.Text))

Me.lblPrimero.Text = Microsoft.VisulBasic.Left(Trim(Me.txtFrase.Text), 1)

Me.lblUltimo.Text = Microsoft.VisulBasic.Right(Trim(Me.txtFrase.Text), 1)

Me.lblSegSex.Text = Microsoft.VisulBasic.Mid(Trim(Me.txtFrase.Text), 2, 5)

Me.lblPosA.Text = InStr(Me.txtFrase.Text, "a")

Me.lblMinusculas.Text = LCase(Me.txtFrase.Text)

Me.lblMayusculas.Text = UCase(Me.txtFrase.Text)

Me.lblSoloPrim.Text = StrConv(Me.txtFrase.Text, 3)

3. Luego codificaremos lo siguiente dentro del botón btnNuevo_Click (Evento Click) .

Me.txtFrase.Text = ""

Me.lblLongitud.Text = ""

Me.lblMayusculas.Text = ""

Me.lblMinusculas.Text = ""

Me.lblPosA.Text = ""

Me.lblPrimero.Text = ""

Me.lblSegSex.Text = ""

Me.lblSoloPrim.Text = ""

Me.lblUltimo.Text = ""

Me.txtFrase.Focus()

4. Luego codificaremos lo siguiente dentro del botón btnSalir (Evento Click)

Me.Close()

Pag. 32 de 127


Format

Esta función Format nos permite darle un formato a un dato, ya sea una fecha, número, hora, etc. Sus formatos más utilizados son:

Su sintaxis sería la siguiente:

Format(Variable,.Formato.)

Ejemplo:

Dim Numero As Double

Numero = 100000/3

Me.Label1.Text = Format(Numero, "###,##0.00")

Y lo que nos mostraría el Label en la pantalla seria lo siguiente

Rpta.- 33,333.33

Pag. 33 de 127




2.- Luego codificaremos lo siguiente

Private Sub btnfecactual_Click

Me.txtfecha.Text = Format(Now(), "dd/MM/yy")

End Sub

Private Sub btnhora_Click

Me.txthora.Text = Format(Now(), "hh:mm:ss tt")

BtnMostra TxtFH

TxtFC

TxtFL

TxtHora

TxtFecha

BtnHor

BtnFecActual

Pag. 34 de 127


End Sub

Private Sub btnmostrar_Click

Dim FecLar, FecCor As Date FecLar = CDate(Me.txtfecha.Text) FecCor = CDate(Me.txtfecha.Text)

Me.txtfl.Text = FormatDateTime(FecLar, DateFormat.LongDate).ToString Me.txtfc.Text = FormatDateTime(FecCor, DateFormat.ShortDate).ToString Me.txtfhc.Text = FormatDateTime(Me.txthora.Text, DateFormat.ShortTime).ToString

End Sub

Ejercicios

Ejercicio 1

1. En esta aplicación se debe de ingresar el nombre del un producto, su precio unitario y la cantidad comprada de dicho producto, luego se debe calcular y visualizar el sub Total, el descuento en porcentaje, el descuento en soles y el total a pagar. El descuento en porcentaje se depende del sub total, de acuerdo a la siguiente tabla.

Pag. 35 de 127


2. Digitar el siguiente código dentro del botón btnCalcular (Evento Click)

Dim Desc As Integer

lblSubTotal.Text = CStr(Val(txtPrecUnit.Text) * Val(txtCantComp.Text))

Select Case Val(lblSubTotal.Text)

Case 100, 101 : Desc = 2

Case 101.1 To 200 : Desc = 4

Case 200.1 To 500 : Desc = 6

Case Is > 500 : Desc = 10

Case Else : Desc = 0

End Select

lblDescP.Text = CStr(Desc)

lblDescS.Text = Val(lblSubTotal.Text) * Desc / 100

lblTotal.Text =Val(lblSubTotal.Text) - Val(lblDescS.Text)

lblSubTotal.Text = Val(lblSubTotal.Text)

3. Digitar el siguiente código dentro del botón btnNuevo (Evento Click)

txtCantComp.Text = ""

txtPrecUnit.Text = ""

txtProducto.Text = ""

lblDescP.Text = ""

lblDescS.Text = ""

lblSubTotal.Text = ""

lblTotal.Text = ""

txtProducto.Focus()

btnSalir (Evento Click)

Me.Close()

Ejercicio 2

1. En este programa se debe de ingresar el nombre del alumno, su nota número 1 y su nota número 2, al hacer clic en el botón obtener promedio se debe de visualizar: el

Pag. 36 de 127


promedio del alumno, una observación que indica si el alumno esta aprobado o desaprobado, la cantidad de puntos que le faltan para aprobar, si esta desaprobado o los puntos para llegar a veinte en caso que este aprobado.

2. También se debe visualizar la nota cualitativa del alumno de acuerdo al promedio. Se debe de controlar que solo se ingresen notas entre 0 y 20.

3. Este es el diseño del formulario.

4. Digitar el siguiente código dentro del botón btnObtener (Evento Click)

lblPromedio.Text = CStr((Val(txtN1.Text) + Val(txtN2.Text)) / 2)

If Val(lblPromedio.Text) >= 10.5 Then

lblObservación.Text = "Aprobado(a)"

lblPuntos.Text = "Le faltan " + CStr(20 - Val(lblPromedio.Text)) + " puntos para tener 20"

Else

lblObservación.Text = "Desaprobado(a)"

lblPuntos.Text = "Le faltan " + CStr(11 - Val(lblPromedio.Text)) + " puntos para aprobar"

End If

Select Case Val(lblPromedio.Text)

Pag. 37 de 127


Case 0 To 5 : lblCualidad.Text = "Pésimo"

Case 5.1 To 10.4 : lblCualidad.Text = "Malo"

Case 10.5 To 14.4 : lblCualidad.Text = "Regular"

Case 14.5 To 17.4 : lblCualidad.Text = "Bueno"

Case 17.5 To 20 : lblCualidad.Text = "Excelente"

End Select

5. Digitar el siguiente código dentro del botón btnOtro (Evento Click)

txtAlumno.Text = ""

txtCurso.Text = ""

txtN1.Text = ""

txtN2.Text = ""

lblCualidad.Text = ""

lblObservación.Text = ""

lblPromedio.Text = ""

lblPuntos.Text = ""

txtAlumno.Focus()

6. Digitar el siguiente código dentro del botón btnSalir (Evento Click)

Me.Close()

Ejercicio Propuesto.

En esta aplicación se debe de ingresar el nombre y el año de nacimiento de una persona y se tiene que visualizar: su edad, una observación que indica si es mayor o menor de edad, Si es menor de edad se debe mostrar cuantos años le faltan para se

Pag. 38 de 127


mayor de edad y si es mayor de edad se debe mostrar hace cuantos años es mayor de edad. También se debe mostrar la etapa de la persona teniendo en cuenta lo siguiente.

Pag. 39 de 127


¿Qué son las expresiones condicionales?

Cómo utilizar operadores aritméticos

Cómo utilizar operadores de comparación

Cómo utilizar operadores lógicos

Cómo utilizar instrucciones If…Then

Cómo utilizar instrucciones If…Then…Else

Cómo utilizar instrucciones If…Then…ElseIf

Cómo utilizar instrucciones Select Case

TEMA 4

Pag. 40 de 127


¿Qué son las Expresiones Condicionales? Las expresiones condicionales permiten desarrollar la aplicación para realizar tareas de forma selectiva, en función de valores generados por la aplicación o de valores introducidos por el usuario. Las expresiones condicionales tienen numerosos usos en programación, pero generalmente se encuentran en instrucciones que controlan la ejecución de programas.

Las expresiones condicionales deben devolver True o False.

Cómo Utilizar Operadores Aritméticos

Los operadores aritméticos se utilizan para realizar muchas de las operaciones aritméticas familiares que implican el cálculo de valores numéricos representados por literales, variables, otras expresiones, llamadas de funciones y propiedades, y constantes.

La siguiente tabla presenta una lista de los operadores aritméticos que utilizaremos con mayor frecuencia en Visual Basic .NET.

Pag. 41 de 127


Cómo Utilizar Operadores de Comparación

Un operador de comparación realiza una operación sobre dos valores y devuelve un resultado Boolean. Visual Basic .NET soporta seis operadores de comparación.

Los seis operadores de comparación que podemos utilizar en Visual Basic .NET son los siguientes:

Cómo Utilizar los Operadores Lógicos

Utilizamos operadores lógicos para evaluar una o más expresiones condicionales y devolver un único valor Boolean True o False. En Visual Basic .NET, podemos utilizar seis operadores lógicos.

La siguiente tabla muestra los seis operadores lógicos utilizados en Visual Basic .NET. Observe que todos los operadores excepto Not trabajan con dos expresiones, que también se denominan operandos.

Pag. 42 de 127


Uso de Estructuras de Decisión

En nuestro programa, podemos desear que algunas secciones de su código se ejecuten únicamente cuando se cumpla una determinada condición. Esto se consigue utilizando una estructura de decisión. Esta lección explica cómo utilizar las estructuras de decisión If…Then y Select Case. Estudiaremos cómo incorporar expresiones condicionales en estas estructuras.

Cómo Utilizar Instrucciones If...ThenEn general, la instrucción If…Then se utiliza cuando el programa debe evaluar si una instrucción es verdadera o falsa.

Las instrucciones If…Then evalúan si una condición es verdadera o falsa y dirigen el flujo del programa en consecuencia.

Podemos utilizar la siguiente sintaxis en una línea:

If condition Then clause

También podemos utilizar la siguiente sintaxis en forma de bloque:

If condition ThenStatementsEnd If

Pag. 43 de 127


Cómo Utilizar Instrucciones If…Then...ElseLas instrucciones If…Then…Else son una extensión del concepto If…Then.Utilizando un bloque If…Then…Else, podemos definir dos bloques de código y que nuestro programa ejecute uno u otro dependiendo del resultado de una condición. Si es verdadera más de una de las condiciones de una estructura condicional, únicamente se ejecutarán las instrucciones de código incluidas en la primera condición verdadera.

Una instrucción If…Then…Else incluye los siguientes componentes:

Una condición que evalúa si es True o False Una o más instrucciones que se ejecutan dependiendo del resultado de la prueba de la condición Una instrucción End If en el caso de un bloque

Para utilizar una instrucción If…Then…Else, utilizar la siguiente sintaxis:

If condition ThenstatementsElsestatementsEnd If

Pag. 44 de 127


Cómo Utilizar Instrucciones If…Then...ElseifLas instrucciones If…Then…ElseIf son como las instrucciones If…Then…Else, excepto en que permiten que nuestro programa elija entre más de dos alternativas.Para utilizar una instrucción If…Then…ElseIf, utilizar la siguiente sintaxis:

If condition ThenstatementsElseIf condition2 ThenstatementsElsestatementsEnd If

Como Utilizar Instrucciones Select CaseLa instrucción Select Case permite a nuestra aplicación ejecutar uno o varios bloques de código dependiendo del valor de una expresión de prueba. La instrucción Select Case funciona como una compleja estructura If…Then…Else anidada, pero su mantenimiento es más sencillo.La sintaxis para la instrucción Select Case es como sigue:

Select Case testexpression[Case expressionlist-n][statements-n1] . . .[Case Else][elsestatement]

Pag. 45 de 127


End Select



2. Declarar para todo el formulario las siguientes variables.

Dim usu, contra As String Dim num As Integer

3. Digitar el siguiente codigo dentro del control txtpas evento (TextChanged).

usu = Me.txtusu.Text contra = Me.txtpas.Text If usu = "Carlos" And contra = "123" Then Me.btningresar.Enabled = True Me.btningresar.Focus() num = 1 ElseIf usu = "Sunheri" And contra = "456" Then

Btningresar BtnSali

TxtPas

TxtUsu

Pag. 46 de 127


Me.btningresar.Enabled = True Me.btningresar.Focus() num = 2 ElseIf usu = "Cecilia" And contra = "789" Then Me.btningresar.Enabled = True Me.btningresar.Focus() num = 3 End If

4. Digitar el siguiente código dentro del control btningresar evento(Click).

Select Case num Case 1 : MsgBox("Bienvenido Usuario Carlos", MsgBoxStyle.Information, "Sistema") Case 2 : MsgBox("Bienvenido Usuario Sunheri", MsgBoxStyle.Information, "Sistema") Case 3 : MsgBox("Bienvenido Usuario Cecilia", MsgBoxStyle.Information, "Sistema") End Select Me.txtusu.Clear() Me.txtpas.Clear() Me.txtusu.Focus()

5. Digitar el siguiente código dentro del control btnsalir evento(Click).

Me.Close()



2. Digitar el siguiente código dentro del evento Load del formulario.

BtnSali

BtnOk

Lblfecac

Lblfecin

lbldiase

lblañoin

lblmesinLbldiain

TxtFecNac

TxtNombre

Pag. 47 de 127


lblfecact.Text = "Hoy es " + (Now()).ToString

3. Digitar el siguiente código dentro del control btnsalir evento(Click).

If MsgBox("¿Desea salir del programa?", MsgBoxStyle.Question.YesNo,"Funciones Tipo fecha") = MsgBoxResult.Yes Then Me.Close()

4. Digitar el siguiente código dentro del control btnOk evento(Click).

Dim fecha As DateDim nmes, diasemana As StringDim dia, mes, año, ndia As IntegerIf IsDate(txtfecnac.Text) = False ThenMsgBox("Debe de ingresar un fecha válida, como se muestra en el ejemplo",MsgBoxStyle.Information, "Funciones Tipo Fecha")txtfecnac.Text = ""txtfecnac.Focus()Exit SubEnd Iffecha = CDate(txtfecnac.Text)dia = Microsoft.VisualBasic.Day(fecha)mes = Microsoft.VisualBasic.Month(fecha)año = Year(fecha)ndia = Weekday(fecha)lbldiaing.Text = dia.ToStringlblmesing.Text = mes.ToStringlblanioing.Text = año.ToStringSelect Case ndiaCase 1 : diasemana = "Domingo"Case 2 : diasemana = "Lunes"

Case 3 : diasemana = "Martes"Case 4 : diasemana = "Miercoles"Case 5 : diasemana = "Jueves"Case 6 : diasemana = "Viernes"Case 7 : diasemana = "Sábado"End Selectlbldiasem.Text = diasemanaSelect Case mesCase 1 : nmes = "Enero"Case 2 : nmes = "Febrero"Case 3 : nmes = "Marzo"Case 4 : nmes = "Abril"Case 5 : nmes = "Mayo"Case 6 : nmes = "Junio"Case 7 : nmes = "Julio"Case 8 : nmes = "Agosto"Case 9 : nmes = "Septiembre"Case 10 : nmes = "Octubre"Case 11 : nmes = "Noviembre"Case 12 : nmes = "Diciembre"End Selectlblfecing.Text = diasemana + ", " + dia.ToString + " de " + nmes + " de " +año.ToString

Pag. 48 de 127


Pag. 49 de 127


Como Utilizar el ListBox y ComboBox

Propiedades más utilizadas

Ejemplos prácticos

TEMA 5

Pag. 50 de 127


Control ListBox y ComboBoxEl control ListBox es un buen ejemplo de la categoría de opciones. El control ListBox de Windows Forms muestra una lista de elementos de los cuales el usuario puede seleccionar uno o más. Si el número total de elementos supera el número que puede mostrarse, automáticamente se agrega una barra de desplazamiento al control ListBox.

La siguiente tabla muestra una lista de las propiedades importantes del control ListBox:

Estos dos controles (ListBox y ComboBox) se parecen mucho, tanto en sus propiedades como en eventos, ya sea añadiendo elementos, eliminándolos, obteniendo el elementos seleccionado, etc. Hay dos formas de ingresar los elementos en estos controles, ya sea mediante un editor (en modo de diseño), o mediante código (en tiempo de ejecución). Instrucciones más utilizadas para los dos controles.

Para añadir un elemento

ListBox1.Items.Add(Cadena de Texto) ComboBox1.Items.Add(Cadena de Texto) Para eliminar un elemento

ListBox1.Items.Remove(Numero del Elemento a Eliminar) ComboBox1.Items.Remove(Numero del Elemento a Eliminar)

Pag. 51 de 127


Para saber que elemento se ha seleccionado ListBox1.SelectedIndex() ComboBox1.SelectedIndex()

Para Saber el Numero de los Elementos de la Lista ListBox1.Items.Count() ComboBox1.Items.Count() Para seleccionar un Elemento ListBox1.SelectedIndex = Numero del Elemento a seleccionar ComboBox1.SelectedIndex = Numero del Elemento a seleccionar

Elimina todos los elementos de la lista.ListBox1.Items.Clear()ComboBox1.Items.Clear()

Ordena los elementos de la lista usar solo al tiempo de diseño. ListBox1.Sorted=TrueComboBox1.Soter=True

Regresa True o False si el dato se encuentra o no se encuentra en la lista.ListBox1.Items.Contains(dato)ComboBox1.Items.Contains(dato)

Elimina el dato que esta en la posición indicada.ListBox1.Items.RemoveAt(indice)ComboBox1.Items.RemoveAt(indice)

Ejercicio Practico Nº1


LblTotal

BtnBuscar

TxtBuscar

LstNombres

TxtNom

BtnLimpiar

BtnEliminar2

BtnEliminar1

BtnAgregar

Pag. 52 de 127


2. Digitar el siguiente código dentro del control btnAgregar evento(Click).

If Me.txtnom.Text.Trim <> "" Then Me.lstnombres.Items.Add(Me.txtnom.Text.Trim.ToUpper) Me.txtnom.Clear() Me.txtnom.Focus() Me.lbltotal.Text = Me.lstnombres.Items.Count Else MsgBox("Ingrese un Nombre", MsgBoxStyle.Information, "ListBox y ComboBox") Me.txtnom.Clear() Me.txtnom.Focus() End If

3. Digitar el siguiente código dentro del control btnEliminar1 evento(Click).

Me.lstnombres.Items.Remove(Me.lstnombres.SelectedItem) Me.lbltotal.Text = Me.lstnombres.Items.Count

4. Digitar el siguiente código dentro del control btnEliminar2 evento(Click).

If Me.lstnombres.SelectedIndex <> -1 Then Me.lstnombres.Items.RemoveAt(Me.lstnombres.SelectedIndex) Me.lbltotal.Text = Me.lstnombres.Items.Count Else MsgBox("Seleccione un Nombre", MsgBoxStyle.Information, "ListBox y ComboBox") End If

5. Digitar el siguiente código dentro del control lstnombres evento(KeyDown).

'El evento Keydowm se dispara cuando estoy presionando una tecla If e.KeyCode = Keys.Delete Then Me.lstnombres.Items.Remove(Me.lstnombres.SelectedItem) Me.lbltotal.Text = Me.lstnombres.Items.Count End If

6. Digitar el siguiente código dentro del control btnLimpiar evento(Click).

Me.lstnombres.Items.Clear() Me.lbltotal.Text = Me.lstnombres.Items.Count

7. Digitar el siguiente código dentro del evento Load del formulario.

Me.lbltotal.Text = Me.lstnombres.Items.Count

8. Digitar el siguiente código dentro del control btnBuscar evento(Click).

Pag. 53 de 127


If Me.lstnombres.Items.Contains(Me.txtbuscar.Text.ToUpper.Trim) = True Then MsgBox("El nombre si se encuentra", MsgBoxStyle.Information, "ListBox y ComboBox") Else MsgBox("El nombre no se encuentra", MsgBoxStyle.Information, "ListBox y ComboBox") End If



2. Digitar el siguiente código dentro del control btnAñadir evento(Click).

lstcurso.Items.Add(txtcurso.Text) txtcurso.Text = "" txtcurso.Focus()

3. Digitar el siguiente código dentro del control btnAgregar1 evento(Click). If lstcurso.SelectedIndex <> -1 Then lstcurso2.Items.Add(lstcurso.Text) lstcurso.Items.RemoveAt(lstcurso.SelectedIndex) End If

4. Digitar el siguiente código dentro del control btnAgregar2 evento(Click).

Btnsalir

Lstcurso2

lstcurso

txtcurso

Btnagregar4

Btnagregar3

Btnagregar2

Btnagregar1

btnañadi

Pag. 54 de 127


Dim i As Integer For i = 0 To lstcurso.Items.Count - 1 lstcurso2.Items.Add(lstcurso.Items(i)) Next lstcurso.Items.Clear()


If lstcurso2.SelectedIndex <> -1 Then lstcurso.Items.Add(lstcurso2.Text) lstcurso2.Items.RemoveAt(lstcurso2.SelectedIndex) End If


Dim i As Integer For i = 0 To lstcurso2.Items.Count - 1 lstcurso.Items.Add(lstcurso2.Items(i)) Next lstcurso2.Items.Clear()

7. Digitar el siguiente código dentro del control btnSalir evento(Click).

End

Pag. 55 de 127


Pag. 56 de 127


Cómo utilizar instrucciones For…Next

Cómo utilizar instrucciones For Each…Next

Cómo utilizar instrucciones Do…Loop

Cómo utilizar instrucciones Exit

TEMA 6

Pag. 57 de 127


BuclesEs probable que necesite frecuentemente repetir la ejecución de un bloque de código hasta que se cumpla una determinada condición en los programas que desarrolle. Para repetir la ejecución de un bloque de código en Visual Basic .NET, es conveniente utilizar estructuras de bucle condicionales. Esta lección describe cómo utilizar bucles condicionales para decidir si ejecutar o no código y cuándo hacerlo. Esta lección también describe cómo decidir el uso de una instrucción Exit para salir de un bucle.

Cómo Utilizar Instrucciones For…Next

Podemos utilizar un bucle For…Next cuando conocemos el número de veces que es necesario que se ejecute un bucle. Una instrucción For…Next repite un conjunto de instrucciones un número específico de veces.

Un bucle For…Next se ejecuta un determinado número de veces fijado por un contador de bucles. El valor del contador de un bucle For…Next puede incrementarse o disminuir dependiendo de si step es positivo o negativo.

La sintaxis de una instrucción For…Next es la siguiente:

For counter = start To end [Step step]

[statements]

[Exit For]

Next [counter]

En el siguiente ejemplo, se utiliza una instrucción For…Next para recorrer el contenido de una pequeña matriz. Se utiliza un cuadro de mensaje para mostrar cada nombre en pantalla. Los nombres se muestran otra vez, pero en orden inverso.

Dim NamePos as Integer

Dim Names(4) As String

Names(0) = "Bob"

Names(1) = "Tina"

Names(2) = "Robert"

Names(3) = "George"

Names(4) = "Greg"

For NamePos = 0 to 4

MessageBox.Show(Names(NamePos))

Next

Pag. 58 de 127


' En reversa

For NamePos = 4 to 0 Step -1

MessageBox.Show(Names(NamePos))

Next

Cómo Utilizar Instrucciones For Each…Next

Una instrucción For Each…Next ejecuta un bloque de instrucciones para cada elemento de una colección o una matriz.

Una colección es un conjunto de objetos agrupados conjuntamente y a los que se hace referencia como una unidad.

La sintaxis para la instrucción For Each…Next es la siguiente:

For Each elementvariable In collection

' Statement block to be executed for each value

' of elementvariable

Next [elementvariable]



2. Digitar el siguiente código dentro del control btnCalcular evento(Click).

Dim n, s, r As Integer n = Val(Me.txtnum.Text) For s = 1 To 12 Me.ListBox2.Items.Add(s & " =")

ListBox

ListBox

ListBox

BtnLimpiar

BtnCalcular

TxtNum

Pag. 59 de 127


Next For r = 1 To 12 Me.ListBox3.Items.Add(n * r) Next


Me.ListBox2.Items.Clear() Me.ListBox3.Items.Clear() Me.txtnum.Clear() Me.txtnum.Focus()




Dim con As Control For Each con In Me.Controls If TypeOf con Is TextBox Then con.Text = "" If TypeOf con Is GroupBox Then Dim con2 As Control For Each con2 In con.Controls If TypeOf con2 Is TextBox Then con2.Text = "" Next End If Next End Sub

Como Utilizar Instrucción Do …Loop

Puede utilizar instrucciones Do…Loop para ejecutar un bloque de instrucciones un número de veces indefinido dependiendo del valor de tipo bolean de una condición.

Las instrucciones pueden repetirse mientras el valor de la condición sea True o hasta que sea True. Generalmente, la condición es el resultado de comparar dos valores, pero también puede ser cualquier expresión que da como resultado un valor de tipo Bolean (True o False).

El bucle DO...LOOP es muy versatil. Con el se pueden crear gran variedad de bucles distintos, bucles que comprueben una condición antes de ejecutar el bucle una vez, después de la primera ejecución y con conbinaciones con mientras (WHILE) que se cumple una condición o hasta (UNTIL) que esa condicion se cumpla. la sintaxis de esta estructura es la siguiente:

btnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpiabtnLimpia

Pag. 60 de 127


DO [WHILE | UNTIL (condicion)] Sentencias .....LOOP [WHILE | UNTIL (condición)]

Vamos a tratar de explicar esta sentencia de manera pausada para que sea más fácil de entender. Lo que siempre tendremos en estos bucles es el DO y el LOOP, entre estos dos colocaremos las sentencias que queremos ejecutar en cada iteración del bucle. Los bucles tienen que evaluar entre cada iteración si se siguen ejecutando o no, para ello evalúa una condición. Lo versátil de este bucle es que la condición se puede expresar de muchas maneras distintas.

Condición expresada al lado del DO: en este caso la condición se evalúa antes de empezar a ejecutarse el bucle.

Condición expresada al lado del LOOP: en este caso la condición se evalúa después de ejecutarse el bucle. Tiene como diferencia principal frente al otro método que en este caso el bucle se ejecutará por lo menos una vez.

Además de poder expresar la condición en estos dos sitios también se puede construir la condición con un enunciado mientras (WHILE) o un enunciado hasta (UNTIL). Las diferencias semánticas de estas dos posibilidades se trasladan también a su manera de funcionar.

Vamos a ver un par de ejemplos de este bucle para comprender su funcionamiento. El ejemplo pide constantemente el nombre del autor de la página y no para hasta que el nombre sea "Castilla". También tiene el usuario la posibilidad de escribir "out", en ese caso, comprobado con un enunciado IF, se sale del bucle rompiéndolo con la sentencia EXIT DO, utilizada para romper bucles.



2. Digitar el siguiente código dentro del control btnWhile evento (Click).

Dim entrada as Stringentrada = ""DO WHILE (entrada <> "diego") entrada = inputbox ("Dime el nombre del autor","seguridad","diego",2,3) if (entrada = "out") then msgbox ("salgo por la puerta de atras") exit do end ifLOOP

El siguiente ejemplo realiza una cuenta y entre cuenta y cuenta se muestra el valor de la cuenta actual en una ventanita donde sale un botón de Reintentar y otro de Cancelar. Si se pulsa reintentar se sigue ejecutando el bucle y si se pulsa Cancelar se sale por la puerta de atrás, de manera similar a como se salía en el ejemplo anterior, con EXIT DO.

BtnUntil

BtnWhil

Pag. 61 de 127


3. Digitar el siguiente código dentro del control btnUntil evento(Click).

Dim cont Dim respuesta cont = 0 Do cont = cont + 1 respuesta = MsgBox(cont, 69, "Variable del bucle, con valor 6 se sale") If (respuesta = 2) Then MsgBox("Cuenta Cancelada", 16, "Cancelaste!") Exit Do End If Loop Until (cont = 6)

Propuesto:

1.- Realizar una aplicación, con un listbox y un button.

El el listbox deberá haber un listado de nombres, y cuando le de clic sobre el button, los nombres deberán aparecer mediante un mensaje uno por uno.

2.- Crear una Estructura con Tres Campos: Codigo, Nombre, Nota.

Luego almacenar 3 valores a cada campos y que se me muestre en un mensaje al dar clic en el botón Recorrer la Estructura.

Pag. 62 de 127


Pag. 63 de 127


¿Qué es una matriz?

Cómo declarar una matriz unidimensional

Cómo utilizar matrices multidimensionales

Cómo cambiar el tamaño de las matrices

¿Qué son las estructuras?

Cómo declarar estructuras

Cómo utilizar estructuras

TEMA 7

Pag. 64 de 127


ArreglosArrays

Una de las formas en las que podemos agrupar varios datos es mediante los arrays (o matrices).Usando un array, podemos acceder a cualquiera de los valores que tenemos almacenado mediante un índice numérico. Por ejemplo, si tenemos la variable discografía y queremos acceder al tercer disco, podríamos hacerlo de la siguiente forma: discografía (3).Sabiendo esto, podemos comprobar que sería fácil recorrer el contenido de los arrays mediante un bucle For.

¿Qué tipos de datos se pueden usar para crear arrays?

Los tipos de datos de las variables usadas como array, pueden ser de cualquier tipo, dependiendo de lo que queramos guardar. Por ejemplo, si queremos guardar los nombres de los discos que tenemos, podemos usar un array del tipo String

Declarar Variables Como Arrays

Para poder indicarle al VB que nuestra intención es crear un array podemos hacerlo de dos formas distintas, para este ejemplo crearemos un array de tipo Integer:

1- La clásica (la usada en versiones anteriores)Dim a() As Integer

2- La nueva forma introducida en .NET: Dim a As Integer()

Reservar Memoria Para Un Array

Para poder hacerlo tenemos que usar la instrucción ReDim:ReDim a(5)

Al ejecutarse este código, tendremos un array con capacidad para 6 elementos.Y son seis y no cinco, (como por lógica habría que esperar), porque en .NET Framework el índice menor de un array siempre es cero y en Visual Basic, el índice superior es el indicado entre paréntesis. Por tanto el array a tendrá reservada memoria para 6 valores de tipo Integer, los índices serían desde 0 hasta 5 ambos inclusive.

Además de usar ReDim, que realmente sirve para "redimensionar" el contenido de un array, es decir, para volver a dimensionarlo o cambiarlo por un nuevo valor. Si sabemos con antelación el tamaño que contendrá el array, podemos hacerlo de esta forma:

Dim a(5) As Integer

Pag. 65 de 127


Con este código estaríamos declarando la variable a como un array de 6 elementos (de 0 a 5) del tipo Integer.

Cuando indicamos la cantidad de elementos que contendrá el array no podemos usar la segunda forma de declaración que te mostré anteriormente: Dim a As Integer(5) ya que esto produciría un error sintáctico.

Asignar Valores A Un Array

Para asignar un valor a un elemento de un array, se hace de la misma forma que con las variables normales, pero indicando el índice (o posición) en el que guardará el valor.Por ejemplo, para almacenar el valor 15 en la posición 3 del array a, haríamos lo siguiente: a(3) = 15

Acceder A Un Elemento De Un Array

De igual forma, si queremos utilizar ese elemento que está en la posición 3 para una operación, podemos hacerlo como con el resto de las variables, pero siempre usando el paréntesis y el número de elemento al que queremos acceder:

i = b * a(3)

Los Límites De Los Índices De Un Array

Como ya he comentado antes, el índice inferior de un array, siempre es cero, esto es invariable, todos los arrays de .NET Framework empiezan a contar por cero.Pero el índice superior puede ser el que nosotros queramos, aunque sin pasarnos, que la memoria disponible se puede agotar si pretendemos usar un valor exageradamente alto. Realmente el índice superior de un array es 2^64 -1 (el valor máximo de un tipo Long)

Inicializar Un Array Al Declararla

Al igual que las variables normales se pueden declarar y al mismo tiempo asignarle un valor inicial, con los arrays también podemos hacerlo, pero de una forma diferente, ya que no es lo mismo asignar un valor que varios.

Aunque hay que tener presente que si inicializamos un array al declararla, no podemos indicar el número de elementos que tendrá, ya que el número de elementos estará supeditado a los valores asignados.Para inicializar un array debemos declarar ese array sin indicar el número de elementos que contendrá, seguida de un signo igual y a continuación los valores encerrados en llaves. Veamos un ejemplo:

Dim a() As Integer = {1, 42, 15, 90, 2}

Pag. 66 de 127


También podemos hacerlo de esta otra forma:

Dim a As Integer() = {1, 42, 15, 90, 2}

Usando cualquiera de estas dos formas mostradas, el número de elementos será 5, por tanto los índices irán desde 0 hasta 4.

Los Arrays Pueden Ser De Cualquier Tipo

En todos estos ejemplos estamos usando valores de tipo Integer, pero podríamos hacer lo mismo si fuesen de tipo String o cualquier otro.En el caso de que sean datos de tipo String, los valores a asignar deberán estar entre comillas dobles o ser variables de tipo String. Por ejemplo:

Dim s As String() = {"Hola", "Mundo, ", "te", "saludo"}

Cambiar El Tamaño De Un Array Y Mantener Los Elementos Que Tuviera.

Para poder conseguirlo, debemos usar ReDim seguida de la palabra clave Preserve, por tanto si tenemos la siguiente declaración:

Dim a() As Integer = {1, 2, 3, 4, 5}

Y queremos que en lugar de 5 elementos (de 0 a 4) tenga, por ejemplo 10 y no perder los otros valores, usaremos la siguiente instrucción:

ReDim Preserve a(10)

A partir de ese momento, el array tendrá 11 elementos (de 0 a 10), los 5 primeros con los valores que antes tenía y los nuevos elementos tendrán un valor cero, que es el valor por defecto de los valores numéricos.Si sólo usamos ReDim a(10), también tendremos once elementos en el array, pero todos tendrán un valor cero, es decir, si no se usa Preserve, se pierden los valores contenidos en el array.

Eliminar Un Array De La Memoria.

Si en algún momento del programa queremos eliminar el contenido de un array, por ejemplo para que no siga ocupando memoria, ya que es posible que no siga ocupando memoria, podemos usar Erase seguida del array que queremos "limpiar", por ejemplo:

Erase a Esto eliminará el contenido del array a.Si después de eliminar el contenido de un array queremos volver a usarlo, tendremos que ReDimensionarlo con el mismo número de dimensiones que tenía, ya que Erase sólo borra el contenido, no la definición del array.

Pag. 67 de 127


Los Arrays Multidimensionales

La diferencia entre los arrays unidimensionales y los arrays multidimensionales es precisamente eso, que los arrays unidimensionales, (o normales, por llamarlos de alguna forma), sólo tienen una dimensión: los elementos se referencian por medio de un solo índice. Por otro lado, los arrays multidimensionales tienen más de una dimensión. Para acceder a uno de los valores que contengan habrá que usar más de un índice. La forma de acceder, por ejemplo en el caso de que sea de dos dimensiones, sería algo como esto: multiDimensional(x, y).

Es decir, usaremos una coma para separar cada una de las dimensiones que tenga. El número máximo de dimensiones que podemos tener es de 32, aunque no es recomendable usar tantas, (según la documentación de Visual Studio .NET no deberían usarse más de tres o al menos no debería ser el caso habitual), en caso de que pensemos que debe ser así, (que tengamos que usar más de tres), deberíamos plantearnos usar otro tipo de datos en lugar de una matriz. Entre otras cosas, porque el Visual Basic reservará espacio de memoria para cada uno de los elementos que reservemos al dimensionar un array, con lo cual, algo que puede parecernos pequeño no lo será tanto.

Declarar Arrays Multidimensionales

Para declarar un array multidimensional, lo podemos hacer, (al igual que con las unidimensionales), de varias formas, dependiendo de que simplemente declaremos el array, que le indiquemos (o reservemos) el número de elementos que tendrá o de que le asignemos los valores al mismo tiempo que la declaramos, veamos ejemplos de estos tres casos:

Dim a1() As Integer

Dim a2(,) As Integer

Dim a3(,,) As Integer

Dim b1(2) As Integer

Dim b2(1, 6) As Integer

Dim b3(3, 1, 5, 2) As Integer

Dim c1() As Integer = {1, 2, 3, 4}

Dim c2(,) As Integer = {{1, 2, 3}, {4, 5, 6}}

' este array se declararía como c3(3, 2, 1)

Dim c3(,,) As Integer = { _

{{1, 2}, {3, 4}, {5, 6}}, _

{{7, 8}, {9, 10}, {11, 12}}, _

{{13, 14}, {15, 16}, {17, 18}}, _

{{19, 20}, {21, 22}, {23, 24}} _

}

Pag. 68 de 127


En estos ejemplos he usado arrays con una, dos y tres dimensiones.En el último caso, he usado el continuador de líneas para que sea más fácil "deducir" el contenido de cada una de las dimensiones... imagínate que en lugar de tres dimensiones hubiese usado más... sería prácticamente imposible saber cuántos elementos tiene cada una de las dimensiones. Recuerda que cuando declaramos con a (1) realmente tenemos dos elementos el cero y el uno.


1. Diseñar el siguiente formulario.

2. Declarar la siguiente variable para todo el formulario. Dim nombres(0) As String


If Me.txtnombre.Text.Trim <> "" Then

nombres(UBound(nombres)) = Me.txtnombre.Text

ReDim Preserve nombres(UBound(nombres) + 1)

MsgBox("Guardado ...!", MsgBoxStyle.Information, "Arreglos")

Me.txtnombre.Clear()

Me.txtnombre.Focus()

Else

MsgBox("Por Favor Ingrese un Nombre", MsgBoxStyle.Information, "Arreglos")

Me.txtnombre.Clear()

LstNombresBtnLimpiar

BtnMostrar

BtnAgregar

TxtNombres

Pag. 69 de 127


Me.txtnombre.Focus()

End If

4. Digitar el siguiente código dentro del control btnMostrar evento(Click).

Dim x As Integer For x = 0 To UBound(nombres) - 1 Me.lstnombres.Items.Add(nombres(x)) Next ReDim nombres(0)

5. Digitar el siguiente código dentro del control btnLimpiar evento(Click). Me.lstnombres.Items.Clear()

EstructurasPodemos combinar elementos de datos de distintos tipos para crear una combinación de tipos de datos única denominada estructura. Las estructuras resultan útiles cuando deseamos que una única variable guarde varias piezas de información relacionadas. Después de declarar una estructura, podemos declarar variables de ese tipo.Definición.-Una estructura es una combinación de tipos de datos que se crea combinando otros tipos de datos. Las estructuras son de tipo valor (es decir, una variable de tipo estructura contiene los datos de la estructura, en lugar de una referencia a los datos como hace el tipo referencia). Las estructuras pueden tener datos, propiedades, métodos y procedimientos y pueden invocar y manipular eventos.EjemploEl uso más simple y habitual de las estructuras es encapsular variables relacionadas, creando un tipo de datos definido por el usuario. Por ejemplo, es posible que deseemos guardar juntos el nombre, fecha de contratación, cargo y salario de un empleado. Podríamos utilizar varias variables para esta información, o podemos definir una estructura y utilizarla como la variable de un único empleado. La ventaja de la estructura se hace patente cuando tiene muchos empleados y, por tanto, muchas instancias de la variable. El siguiente ejemplo muestra una estructura Employee simple:

Public Structure EmployeePublic FirstName As StringPublic LastName As StringPublic HireDate As DatePublic JobTitle As StringPrivate Salary As Decimal

End StructureCómo Declarar Estructuras

Pag. 70 de 127


Cómo Utilizar Las Estructuras


1. Agregar un Modulo a la aplicación y escribir el siguiente código.

Module Module1 'Declaramos la estructura Public Structure DatosAlumnos Public codigo As Integer Public nombre As String Public curso As String Public promedio As Integer End Structure 'Declaramos un arrays que me almacenen los valores Public alumnos(0) As DatosAlumnosEnd Module

txtcurso

txtnombre

Pag. 71 de 127


2. Luego diseñar el siguiente formulario


'Declarar una variable para manipular la estructura Dim mialumno As DatosAlumnos 'Asignar valores a la estructura With mialumno .codigo = UBound(alumnos) + 1 .nombre = txtnombre.Text .curso = txtcurso.Text .promedio = txtpromedio.Text End With 'Agregar valores al arrays de la estructura alumnos(UBound(alumnos)) = mialumno 'Redimensionar la matriz manteniendo la los valores ReDim Preserve alumnos(UBound(alumnos) + 1) 'Mostrar mensaje de Datos Agregados

MsgBox("Datos Agregados...", MsgBoxStyle.Information, "Alumnos") 'Limpiamos las cajas de textos txtnombre.Text = "" txtcurso.Text = "" txtpromedio.Text = "" txtnombre.Focus()

4. Digitar el siguiente código dentro del control btnConsultar evento(Click).

Frmconsulta.Show()

5. Luego diseñaremos el siguiente formualrio.

btninscribitxtpromedi

txtcurs

txtnombr

txtcodig

txtconsult

Pag. 72 de 127


6. Luego en el evento load del formulario frmconsulta.

Frminscribir.Hide()

7. Digitar el siguiente código dentro del control btnConsultar evento(Click).

Dim mialumno As DatosAlumnos Dim x As String = txtconsulta.Text mialumno = alumnos(x - 1) txtcodigo.Text = mialumno.codigo txtnombre.Text = mialumno.nombre txtcurso.Text = mialumno.curso txtpromedio.Text = mialumno.promedio txtconsulta.Text = "" txtconsulta.Focus()

8. Digitar el siguiente código dentro del control btnInscribir evento(Click).

Frminscribir.Show() Me.Close()

Ejercicios de ArraysEjercicio 1

1. Esta aplicación nos permite ingresar un número del 1 al 7 y visualizar el nombre del día de la semana.

2. Para esta aplicación los nombres de los controles son los siguientes:

Pag. 73 de 127


El TextBox1 se llamara txtNumero

El Label2 se llamara lblNombDia

El Button1 se llamara btnOk

El Button2 se llamara btnSalir

3. Declaramos variables a Nivel del Formulario.

Dim Dias (6) As String

4. Luego en el evento load del formulario. Dias(0) = "Lunes"

Dias(1) = "Martes"

Dias(2) = "Miércoles"

Dias(3) = "Jueves"

Dias(4) = "Viernes"

Dias(5) = "Sábado"

Dias(6) = "Domingo"

5. Digitar el siguiente código dentro del control btnOK evento(Click).

Dim N As Integer

N = Val(txtNumero.Text) If N >= 1 And N <= 7 Then lblNombDia.Text = "El número ingresado representa el día " + CStr(Dias(N -1)) Else MsgBox("Solo números del 1 al 7", MsgBoxStyle.Information, "Por Favor") txtNumero.Text = "" txtNumero.Focus()

End If

6. Digitar el siguiente código dentro del control btnSalir evento(Click). Me.Close()

Ejercicio 2

1. Desarrollar una aplicación que permita realizar consultas de una serie de cursos que aparecerán en un control ListBox. El usuario debe seleccionar un curso y se debe de presentar los horarios del laboratorio y de teoría asi como los syllabus de los cursos.

Lbl1

txtte

txtla

lstcursos

Pag. 74 de 127


2. Declaramos variables a Nivel del Formulario.

‘Declaramos los arrays a nivel formulario

Dim hlab(4) As String

Dim hteo(4) As String

Dim syll(4) As String

3. Luego en el evento load del formulario. 'Asiganmos las Horas de Laboratorio

hlab(0) = "Lun 08-10"

hlab(1) = "Mar 08-10"

hlab(2) = "Mier 18-20"

hlab(3) = "Jue 08-10"

hlab(4) = "Vie 18-20"

'Asignamos las horas de teoria

hteo(0) = "Dom 09-12"

hteo(1) = "Sab 09-12"

hteo(2) = "Dom 13-17"

hteo(3) = "Dom 09-12"

hteo(4) = "Sab 13-17"

'Asignamos el valor a cada variable

syll(0) = "Introduccion" & vbCrLf & "Uso de Controles" & vbCrLf & "El Uso del Lenguaje"

syll(1) = "Introduccion" & vbCrLf & "El Control Data" & vbCrLf & "SQL y Access"

syll(2) = "Introduccion" & vbCrLf & "Creación de Base de Datos" & vbCrLf & "Creación de Reportes"

syll(3) = "Introduccion" & vbCrLf & "El Formulario" & vbCrLf & "Creacion de Programas"

syll(4) = "Introduccion" & vbCrLf & "El Objeto Aplicación" & vbCrLf & "Acceso a Base de Datos"

4. Digitar el siguiente código dentro del control LstCursos evento(Click).

lbl1.Enabled = True

lbl1.Text = lstCursos.Text

txtlab.Text = hlab(lstCursos.SelectedIndex)

txtteo.Text = hteo(lstCursos.SelectedIndex)

Pag. 75 de 127


txtsyllabus.Text = syll(lstCursos.SelectedIndex)

5. Digitar el siguiente código dentro del control btnSalir evento(Click).

Me.Close()

ResolverDesarrollar una aplicación en la que seleccione un producto en un ListBox, y me salga el precio, stock, categoría y Fecha de vencimiento como información del producto, pero esa información se visualice en un mensaje.

Pag. 76 de 127


Cómo utilizar Sentencia Rnd()

Cómo utilizar Procedimiento Sub y Function

Uso del Control Timer

TEMA 8

Pag. 77 de 127


Sentencia RND ()Visual Basic.Net nos provee la Sentencia Rnd() la cual nos genera un valor aleatoriamente (random) entre 0.0 y 1.0

Private Sub BtnAleatorio_Click

Me.txtale.Text = Rnd()

End Sub

Note que cada vez que da clic al botón se genera un número aleatorio(random) y se muestra en la caja de texto, pero cierre el programa y ejecútelo de nuevo, notará que siempre da la misma secuencia de números, es por ello que a estos números se les llama pseudo-aleatorios.

Si requiere obtener un número entero a partir del número generado, en vez de la fracción, entonces multiplíquelo por 10 y después redondéelo utilizando la función de redondeo de la clase Math.



Me.txtale.Text = Math.Round(Me.txtale.Text * 100)

End Sub

RandomizeLa función Rnd crea siempre la misma secuencia de números aleatorios, para crear un auténtico número aleatorio utilice el método Randomize la cual utiliza el reloj de la PC para crear un punto de inicio aleatorio el cual será utilizado después por la función Rnd().

BtnAleatorio

TxtAl

BtnAleatorio

TxtAl

BtnAleatorio

TxtAl

Pag. 78 de 127



VBMath.Randomize()


End Sub

El método Randomize pertenece a la clase Microsoft.VisualBasic.VBMath

RangoSi deseamos que nuestro valor circule dentro de un rango de números determinados podemos hacer lo siguiente:

Dim num As Double

Private Sub btnaleatorio_Click

Randomize()

num = Rnd()

num = Math.Round(num * 100)

If num >= CInt(Me.txtini.Text) And num <= CInt(Me.txtlim.Text) Then

Me.txtale.Text = num

End If

End Sub

TxtLi

TxtAl

BtnAleatori

TxtIni

Pag. 79 de 127


Procedimientos Sub

Un procedimiento Sub ejecuta acciones, pero no devuelve ningún valor. Puede tomar argumentos, como constantes, variables o expresiones, que le pasa el código de llamda.La sintaxis para declarar un procedimiento Sub es la siguiente:Declarción:

[ Public | Private | Friend ] Sub <Nombre Subrutina> ([Lista de Parámetros])<Sentencias>[Exit Sub]End Sub

Procedmientos Function

Un procedimiento Function consiste en una serie de instrucciones de Visual Basic delimitadas por las instrucciones Function y End Function. Cada vez que se llama a un procedimiento de este tipo, se ejecutan las instrucciones de éste, desde la primera instrucción ejecutable.La sintaxis para declarar un procedimiento Function es la siguiente:

[ Public | Private | Friend ] Function <Nombre Función> ([Lista de Parámetros])As <Tipo de Dato><Sentencias>[Exit Function]End Function


1.- Agregar una clase la cual se llamara CLSOPERACIONES

Public Class clsoperaciones Public Function promedio(ByVal nota1 As Short, ByVal nota2 As Short, ByVal nota3 As Short) As Short promedio = (nota1 + nota2 + nota3) / 3 End Function Public Function parimpar(ByVal numero As Integer) As String If numero Mod 2 = 0 Then parimpar = "Es par"

Pag. 80 de 127


Else parimpar = "Impar" End If End Function Public Sub limpiar(ByVal frm As Form) Dim con As Control For Each con In frm.Controls If TypeOf con Is TextBox Then con.Text = "" If TypeOf con Is GroupBox Or TypeOf con Is Panel Then Dim con2 As Control For Each con2 In con.Controls If TypeOf con2 Is TextBox Then con2.Text = "" If TypeOf con2 Is GroupBox Or TypeOf con2 Is Panel Then Dim con3 As Control For Each con3 In con2.Controls If TypeOf con3 Is TextBox Then con3.Text = "" Next End If Next End If Next End SubEnd Class

El Control Timer El control Timer es un temporizador que nos permite ejecutar instrucciones de código, rutinas, funciones etc..., cada cierto intervalo de tiempo, es decir el tiempo que nosotros le establezcamos.

El control Timer es un control que es invisible en tiempo de ejecución, esto quiere decir que no tiene interfaz gráfica, solo es visible cuando lo agregamos a un formulario y estamos en modo de diseño , pero en modo de ejecución este funcionará como tal pero no estará visible en el formulario.

La propiedad mas importante de este control es la propiedad Interval

Esta propiedad es la que determina el intervalo en el que ejecutará las instrucciones que estén en el evento llamado Timer

El Evento Timer es el único evento que posee este control

Antes de hacer un ejemplo, hay que aclarar que la propiedad Interval está expresada en milisegundos, esto quiere decir que por ejemplo si quiero ejecutar una instrucción cada 3 segundos por decir un ejemplo, la propiedad Interval debe estar en 3000, si quisiera ejecutarla cada 10 segundos en 10000 etc...

Pag. 81 de 127


Propiedades

Enabled: Obtiene o establece si el temporizador esta funcionando.

Interval: Obtiene o establece el tiempo, en milisegundos, entre los pasos de temporizador.

Métodos:

Start: Inicia el temporizador

Stop: Detiene el temporizador

Eventos:

Tick: Se produce cuando ha transcurrido el intervalo de tiempo especificado y está activado el temporizador.


Agregar también un Control Timer de su cuadro de herramientas.

Y en su propiedad Interval=1000

Y Enabled=False

Private Sub Timer1_Tick

Static sw As Integer

If sw = 0 Then

pc1.Visible = True

pc2.Visible = False

pc3.Visible = False

sw = 1

Else

If sw = 1 Then

pc1.Visible = False

pc2.Visible = True

pc3.Visible = False

sw = 2

Else

If sw = 2 Then

pc1.Visible = False

pc2.Visible = False

pc3.Visible = True

sw = 0

End If

Label

Pc1

Pc3

Pc2

Pag. 82 de 127


End If

End If

End Sub


Timer1.Enabled = True

End Sub

Pag. 83 de 127


Cómo utilizar RadioButton

Cómo utilizar CheckBox

Uso de la Propiedad Checked

Uso del Try...Catch

TEMA 9

Pag. 84 de 127


RadioButton y CheckBox

CheckBox

Un control CheckBox muestra una Check cuando esta activado, el checked desaparece

cuando esta desactivado. Utilice este control para ofrecer al usuario una opción de tipo

Verdadero o Falso o Sí o No. Puede utilizar controles CheckBox en grupos para mostrar

múltiples opciones entre las cuales el usuario puede seleccionar una o más.

Propiedades

Name: Generalmente usaremos el prefijo Chk.

Appearance: Controla la apariencia del control, puede ser: Normal(como casilla) o

Button(como botón de comando)

AutoCheck: Cambia de estado cada vez que se da clic al botón.

Checked: Indica si el checkbox ha sido seleccionado o no.

CheckAlign : Controla la alineación del checkbox. Hay 9 opciones.

CheckState: Devuelve el estado del checkbox, puede ser: Unchecked(sin marcar),

Checked(marcado), o Indeterminate(gris).

ThreeState: Habilita o deshabilita el estado in determinado del checkbox cada vez

que se da el tercer clic.

RadioButton

Un control OptionButtton muestra una opción que se puede activar o desactivar

El control OptionButton se utiliza en un grupo de opciones para mostrar opciones entre las

cuales el usuario sólo puede seleccionar una.

Propiedades

Name: Generalmente usaremos el prefijo Rbn.

Appearance: Controla la apariencia del control, puede ser: Normal(como botón de

opción) o Button(como botón de comando).

AutoCheck: Cambia de estado cada vez que se da clic al botón.

CheckAlign: Controla la alineación del botón. Hay 9 opciones.

Pag. 85 de 127


Checked: Indica si el botón ha sido seleccionado o no.

Crear el siguiente Procedimiento:

Public Sub Fuente()

If chknegrita.Checked = True AndAlso chksubrayado.Checked = True AndAlso

chkcursiva.Checked = True Then

lblTexto.Font = New Font(lblTexto.Font, FontStyle.Bold + FontStyle.Italic +

FontStyle.Underline)

ElseIf chknegrita.Checked = True AndAlso chksubrayado.Checked = True Then

lblTexto.Font = New Font(lblTexto.Font, FontStyle.Bold + FontStyle.Underline)

ElseIf chknegrita.Checked = True AndAlso chkcursiva.Checked = True Then

lblTexto.Font = New Font(lblTexto.Font, FontStyle.Bold + FontStyle.Italic)

ElseIf chknegrita.Checked = False AndAlso chksubrayado.Checked = True AndAlso

chkcursiva.Checked = True Then

lblTexto.Font = New Font(lblTexto.Font, FontStyle.Underline + FontStyle.Italic)

Pag. 86 de 127


ElseIf chknegrita.Checked = False AndAlso chksubrayado.Checked = True Then

lblTexto.Font = New Font(lblTexto.Font, FontStyle.Underline)

ElseIf chknegrita.Checked = False AndAlso chkcursiva.Checked = True Then

lblTexto.Font = New Font(lblTexto.Font, FontStyle.Italic)

ElseIf chknegrita.Checked = True Then

lblTexto.Font = New Font(lblTexto.Font, FontStyle.Bold)

Else

lblTexto.Font = New Font(lblTexto.Font, FontStyle.Regular)

End If

End Sub

Private Sub chknegrita_CheckedChanged

Fuente()

End Sub

Private Sub chksubrayado_CheckedChanged

Fuente()

End Sub

Private Sub chkcursiva_CheckedChanged

Fuente()

End Sub


cbocolor.Items.Add("Negro")

cbocolor.Items.Add("Rojo")

cbocolor.Items.Add("Azul")

cbocolor.Items.Add("Verde")

cbocolor.Items.Add("Rosado")

cbocolor.Items.Add("Blanco")

cbocolor.Items.Add("Amarillo")

cbocolor.Items.Add("Anaranjado")

Pag. 87 de 127


cbocolor.SelectedIndex = 0

End Sub

Private Sub cbocolor_SelectedIndexChanged

Dim Index As Integer

Index = cbocolor.SelectedIndex

Select Case Index

Case 0 : lblTexto.ForeColor = System.Drawing.Color.Black

Case 1 : lblTexto.ForeColor = System.Drawing.Color.Red

Case 2 : lblTexto.ForeColor = System.Drawing.Color.Blue

Case 3 : lblTexto.ForeColor = System.Drawing.Color.Green

Case 4 : lblTexto.ForeColor = System.Drawing.Color.Pink

Case 5 : lblTexto.ForeColor = System.Drawing.Color.White

Case 6 : lblTexto.ForeColor = System.Drawing.Color.Yellow

Case 7 : lblTexto.ForeColor = System.Drawing.Color.Orange

End Select

End Sub

Agregar otro formulario

LstTurno

LstCasado

LstEdad

LstNombre

RbNocheRbMañana

RbTarde

ChkCasadoUpEdad

TxtNombre

Pag. 88 de 127


Public Class Form2

Dim casado, turno, nombre As String

Dim edad As Byte

Private Sub btnagregar_Click

edad = Me.UpEdad.Value

nombre = Me.TxtNombre.Text.ToUpper

If Me.ChkCasado.Checked = True Then

casado = "Si"

Else

casado = "No"

End If

If Me.RbMañana.Checked = True Then

turno = "Mañana"

ElseIf Me.RbTarde.Checked = True Then

turno = "Tarde"

ElseIf Me.RbNoche.Checked = True Then

turno = "Noche"

End If

Me.LstNombre.Items.Add(nombre)

Me.LstEdad.Items.Add(edad.ToString)

Me.LstTurno.Items.Add(turno)

Me.LstCasado.Items.Add(casado)

Pag. 89 de 127


End Sub

End Class

Agregar otro formulario

Private Sub btnconvertir_Click

If Me.RbCe.Checked = False And Me.RbFa.Checked = False Then

MsgBox("Seleccione el Tipo de Conversion", MsgBoxStyle.DefaultButton1)

End If

Dim grados, r As Double

grados = CInt(Me.txtgrados.Text)

If Me.RbCe.Checked = True Then

r = (grados * 9 / 5) + 32

Else

r = (grados - 32) * 5 / 9

End If

Me.lblresul.Text = r.ToString

End Sub

BtnConvertir

TxtGrados

LblRes

LblALblDe

RbCe RbFa

Pag. 90 de 127


Private Sub RbCe_CheckedChanged

Me.lblDE.Text = "Grados ºC:"

Me.lblA.Text = "Grados ºF:"

Me.txtgrados.Clear()

Me.lblresul.Text = ""

End Sub

Private Sub RbFa_CheckedChanged

Me.lblDE.Text = "Grados ºF:"

Me.lblA.Text = "Grados ºC:"

End Sub

Private Sub txtgrados_TextChanged

Me.btnconvertir.Enabled = Len(Trim(Me.txtgrados.Text)) > 0

End Sub

Try...CatchCuando durante la ejecución de un programa se produce un error que impide su

continuación, Visual Basic lanza una excepción que hace que se visualice un mensaje acerca

de lo ocurrido y se detenga la ejecución. Cuando esto ocurra, si no deseamos que la

ejecución del programa se detenga, habrá que utilizar Try para poner en alerta al programa

acerca del codigo que puede lanzar una excepción y utilizar Catch para capturar y manejar

cada excepción que se lance. Por ejemplo, el código que se muestra a continuación:

Dentro de un Button escribimos

Private Sub Button1_Click

Dim dato1, dato2, dato3 As Integer

dato1 = dato1 + 1

dato3 = dato1 / dato2

dato2 = dato2 + 1

End Sub

La información dad por el mensaje anterior, además del tipo de excepción, especifica que ha

Pag. 91 de 127


ocurrido una división por cero en la línea n

Modifiquemos este código con la intención de capturar la excepción lanzada.

El resultado puede ser el siguiente:

Private Sub Button1_Click

Dim dato1, dato2, dato3 As Integer

Try

dato1 = dato1 + 1

dato3 = dato1 / dato2 ‘Provoca División por cero

dato2 = dato2 + 1

Catch ex As Exception

MessageBox.Show(ex.Message) ’Mensaje para el Usuario

Finally

MsgBox("Fin de la Instrucción Try", MsgBoxStyle.Information, "Mensaje")

End Try

End Sub

Pag. 92 de 127


Pag. 93 de 127


Cómo utilizar OpenFileDialog

Cómo utilizar SaveDialog

Cómo utilizar ColorDialog

Cómo utilizar FontDialog

Como usar la Barra de Progreso (ProgressBar)

TEMA 10

Pag. 94 de 127


Control OpenFileDialog

Este uno de los nuevos controles que se encuentra en esta nueva versión y no te preocupes, que son fáciles de usar, primero familiarícese con la imagen del control, que es el siguiente.

Este control nos permite abrir múltiples tipos de archivos, ya sean de imágenes, sonido, texto, etc. para abrir cada tipo de archivo necesitará utilizar un *.ocx o un *.dll que pueda soportar esa extensión, ahora veremos su sintaxis de utilización: Sintaxis

NombreDelControl.Filter() = .Tipo de Archivo (*.ExtensiónDelArchivo)|*. ExtensiónDelArchivo.

Por ejemplo, para abrir archivos de solo texto. OpenFileDialog1.Filter () = "Archivos de Texto (*.txt)|*.txt"

Control SaveFileDialogEste nuevo control nos permite guardar múltiples archivos, ya sean de imágenes, textos, etc. Este es el siguiente icono del archivo.

Sintaxis NombreDelControl.Filter() = .Tipo de Archivo (*.ExtensiónDelArchivo)|*. ExtensiónDelArchivo.

Ejemplo, para guardar un archivo de imagen: SaveFileDialog1.Filter () = "Imágenes JPG (*.jpg)|*.jpg " SaveFileDialog1.Title = "Guarda la imagen como..." 'En Una Sola Línea este código PictureBox1.Image.Save (SaveFileDialog1.FileName, System.Drawing.Imaging.ImageFormat.Jpeg)

Y listo esta imagen mostrada en un Picture Box se guardar en el lugar que le indiquemos, que fácil no?. Como se han dado cuenta para el filtro se utiliza igual la sintaxis del control anterior, la propiedad FileName del control SaveFileDialog1, tiene el nombre y la ruta del archivo a guardar y para decirle a la PC como que lo vamos a guardar, mejor dicho mediante que extensión lo guardamos, utilizamos el ImageFormat.Jpeg, que es la extensión de una

Pag. 95 de 127


imagen comprimida, si queremos BMP, seleccionaremos BMP en ImageFormat, así de sencillo.

Control FontDialog Este nuevo control nos permite visualizar y cambiar el tipo de fuente de letra, tamaño, estilo, su utilización es más fácil que ponerse unas medias, su sintaxis es la siguiente:

Sintaxis NombreDelControl.ShowDialog()

Por ejemplo para cambiar la fuente a un TextBox en tiempo de ejecución. FontDialog1.ShowDialog () TextBox1.Font = FontDialog1.Font

Control ColorDialogEste nuevo control nos permite visualizar y cambiar el color a varios controles, también es muy fácil de usar, su sintaxis es la siguiente: Sintaxis

NombreDelControl.ShowDialog() Por ejemplo para cambiar el color de la letra de un control TextBox en tiempo de ejecución. ColorDialog1.ShowDialog () TextBox1.ForeColor = ColorDialog1.Color

Ejercicio Práctico 1

btnGuardar

btnAbrirPictureBox1

Pag. 96 de 127


Private Sub btnabrir_Click Me.OpenFileDialog1.Filter = "Archivo de Imagenes(*.jpg;*.bmp)|*.jpg;*.bmp" If Me.OpenFileDialog1.ShowDialog = Windows.Forms.DialogResult.OK Then Me.PictureBox1.Image = New Bitmap(Me.OpenFileDialog1.OpenFile) Me.PictureBox1.SizeMode = PictureBoxSizeMode.StretchImage End If End SubPrivate Sub btnguardar_Click Dim nombreimagen As String If Not Me.PictureBox1.Image Is Nothing Then Me.SaveFileDialog1.Filter = "Imagenes(*.jpg)|*.jpg|Mapa de Bits(*.bmp)|*.bmp" Me.SaveFileDialog1.Title = "Guardar Imagen Como..." If Me.SaveFileDialog1.ShowDialog = Windows.Forms.DialogResult.OK Then nombreimagen = Me.SaveFileDialog1.FileName If (nombreimagen.EndsWith("jpg")) Then Me.PictureBox1.Image.Save(nombreimagen, System.Drawing.Imaging.ImageFormat.Jpeg) If (nombreimagen.EndsWith("bmp")) Then Me.PictureBox1.Image.Save(nombreimagen, System.Drawing.Imaging.ImageFormat.Bmp) End If End If End If End If End SubEjercicio Práctico Nº2

btnColor

btnFuente

btnGuardar

btnAbrir RichTextBox1

Pag. 97 de 127


Private Sub BtnAbrir_Click Me.OpenFileDialog1.Filter = "Documento de texto (*.txt)|*.txt" If Me.OpenFileDialog1.ShowDialog = Windows.Forms.DialogResult.OK Then Me.RichTextBox1.LoadFile(Me.OpenFileDialog1.OpenFile, RichTextBoxStreamType.PlainText) Else Exit Sub End If End Sub

Private Sub BtnGuardar_Click Dim nombretexto As String If Not Me.RichTextBox1.Text = "" Then Me.SaveFileDialog1.Filter = "Documento de Texto(*.txt)|*.txt" Me.SaveFileDialog1.Title = "Guardar Documento Como..." If Me.SaveFileDialog1.ShowDialog = Windows.Forms.DialogResult.OK Then nombretexto = Me.SaveFileDialog1.FileName If (nombretexto.EndsWith("txt")) Then Me.RichTextBox1.SaveFile(nombretexto, RichTextBoxStreamType.PlainText) End If End If End If End Sub

Private Sub BtnFuente_Click If Me.FontDialog1.ShowDialog = Windows.Forms.DialogResult.OK Then Me.RichTextBox1.Font = Me.FontDialog1.Font End If End Sub

Private Sub BtnColor_Click If Me.ColorDialog1.ShowDialog = Windows.Forms.DialogResult.OK Then Me.RichTextBox1.ForeColor = Me.ColorDialog1.Color End IfEnd Sub

Pag. 98 de 127


ProgressBarUn objeto ProgressBar es una barra de progreso; esto es, un rectángulo de una longitud arbitraria, del cual, en un instante determinado, estará coloreado un tanto por ciento en función de la cantidad ya finalizada de un proceso por el que estamos esperando. Es una forma de indicar al usuario que una aplicación no esta bloqueada, sino que esta realizando una tarea larga.La propiedades Maximum y Minimum definen el intervalo de valores que representarían el progreso de una tarea. Normalmente la propiedad Minimum se pone a valor cero y Maximun al valor que indica que la tarea ha terminado. La propiedad value representa el progreso que la aplicación realiza para terminar la operación. Esta propiedad se puede modificar directamente, o se puede utilizar la propiedad Step para especificar el valor con que se incrementara y, después, llamar el método PerformStep para incrementar ese valor, o se puede utilizar el método increment. El método Increment permite incrementar el valor de la propiedad Value una cantidad específica; este método es similar a utilizar la propiedad Step con el método PerformStep.


Private Sub Timer1_Tick Me.pb1.Value = Me.pb1.Value + 1 Me.lblprogreso.Text = Me.pb1.Value & " %" If Me.pb1.Value = 100 Then Me.Timer1.Stop() End If

BtnSumar

lblTotal

lblprogrtkbavanc

Pb1

btnComenzlblprogres

Pag. 99 de 127


End Sub

Private Sub btncomenzar_Click Me.Timer1.Enabled = True End Sub

Private Sub tkbavance_Scroll Me.lblprogre.Text = Me.tkbavance.Value End Sub

Private Sub btnsumar_Click Me.lblTotal.Text = Me.NumericUpDown1.Value + Me.NumericUpDown2.Value End Sub

Pag. 100 de 127


Cómo utilizar MonthCalendar

Cómo utilizar DateTimePicker

Diferencia entre MonthCalendar y DateTimePicker

Función del ToolTip

Cómo utilizar el NotifyIcon

TEMA 11

Pag. 101 de 127


El Control DateTimePicker El control DateTimePicker permite seleccionar una fecha de manera conveniente. Cuando se accede a este objeto, muestra la fecha actual y, mediante flechas de desplazamiento que pertenecen al control, muestra calendarios que pueden recorrerse mes a mes y año a año.Efectuando un clic sobre un número de día, el control se cierra, pudiéndose extraer este dato a través de la Propiedad Text o la Propiedad Value, para que se pueda utilizar a posteriori. Asimismo, la Propiedad Value puede extenderse para extraer solo partes del dato obtenido, es decir, solo el número del día, el número del mes o el número del año, entre muchas otras funcionalidades.

MonthCalendar El control MonthCalendar de formularios Windows Forms muestra una intuitiva interfaz gráfica de usuario para que los usuarios vean y establezcan información relativa a fechas. El control muestra una cuadrícula que contiene los días numerados del mes actual, organizados en columnas bajo los días de la semana. Para seleccionar un mes diferente, puede hacer clic en los botones de fecha a los lados del título del mes. A diferencia del control DateTimePicker, de apariencia similar, con este control es posible seleccionar un intervalo de fechas; sin embargo, el control DateTimePicker le permite establecer horas y fechas.

ToolTip El componente ToolTip de los formularios Windows Forms muestra texto cuando el usuario apunta a otros controles. Un ToolTip puede asociarse a cualquier otro control. Por ejemplo, este control se puede utilizar para ahorrar espacio en un formulario, puede mostrar un pequeño icono en un botón y utilizar un control ToolTip para explicar la función del botón.

NotifyIcon El componente NotifyIcon de formularios Windows Forms muestra iconos en el área de notificación de estado de la barra de tareas para procesos que se ejecutan en segundo plano y que, de otro modo, no tendrían interfaz de usuario. Un ejemplo sería un programa de protección antivirus al que se puede tener acceso si se hace clic en un icono situado en el área de notificación de estado de la barra de tareas.

PropiedadesIcon: Obtiene o establece el icono actual.

http://msdn2.microsoft.com/es-es/library/system.windows.forms.tooltip.aspx

http://msdn2.microsoft.com/es-es/library/system.windows.forms.datetimepicker.aspx

Pag. 102 de 127


Text: Obtiene o establece el texto de la información sobre herramientas que se muestra cuando el mouse pasa sobre un icono del área de estado.Visible: Obtiene o establece un valor que indica si el icono es visible en la bandeja del sistema de Windows.

EventosClick: Se produce cuando el usuario hace clic en el icono del área de estado.DoubleClick: Se produce cuando el usuario hace doble clic en el icono del área de notificación de estado de la barra de tarea.MouseDown: Se produce cuando el usuario presiona el botón del mouse mientras el puntero esta sobre el icono del área de notificación de estado de la barra de tareas.MouseMove: Se produce cuando el usuario mueve el mouse mientras el puntero esta sobre el icono del área de notificación de estado de la barra de tareas.MouseUp: Se produce cuando el usuario suelta el botón del mouse mientras el puntero esta sobre el icono del área de notificación de estado de la barra de tareas.


Private Sub Dtpfecha_ValueChanged_1 txtfecha.Text = Format(dtpfecha.Value, "Short Date") txtaño.Text = dtpfecha.Value.Year txtdia.Text = dtpfecha.Value.Day txtmes.Text = dtpfecha.Value.Month

btnsuma

txtsuma

Txt1

txtmes

txtdia

txtaño

txtfecha

DtpFecha

Pag. 103 de 127


End SubPrivate Sub btnsuma_Click

txtsuma.Text = Format(DateAdd(DateInterval.Day, CType(txt1.Text, Integer), dtpfecha.Value), "Short Date")

End SubEjercicio Práctico Nº2

Agregar un control ToolTip y NotifyIcon de su cuadro de herramientas.

1. Para mostrar mas de 2 meses a mas tenemos que modificar la propiedad CalendarDimensions del control MonthCalendar; el cual nos pide dos valores (a;b) el cual a vendría a ser el número de columnas a mostrar y b el número de filas a mostrar

Private Sub MonthCalendar1_DateChanged txtfecha1.Text = MonthCalendar1.SelectionRange.Start txtfecha2.Text = MonthCalendar1.SelectionRange.EndEnd Sub

Private Sub btntooltip_MouseMove ToolTip1.SetToolTip(btntooltip, "Save changes")End Sub

btnnotifybtntooltip

Txtfecha2

Txtfecha1

MounthCalendar

Pag. 104 de 127


Private Sub btnnotify_Click NotifyIcon1.Visible = True NotifyIcon1.Text = "Antivirus program"End Sub

Pag. 105 de 127


Cómo crear un Formulario MDI

Cómo agregar Menús

Cómo agregar un Menú Contextual

Cómo agregar un Barra de Estado

Cómo agregar una Barra de Herramientas

TEMA 12

Pag. 106 de 127


Formulario MDI PadrePara crear un formulario MDI padre solo hay que configurar la propiedad IsMDIContainer del formulario a True.Formulario MDI HijoPara crear un formulario MDI hijo hay que configurar la propiedad Parent(disponible solo en tiempo de ejecución) del formulario hijo apuntando al formulario padre y luego usar el método Show para mostrarlo.Organizando Formularios MDI HijoSi es que se desea organizar los formularios MDI hijos se debe usar el método LayoutMDI del formulario MDI padre, junto con una constante de tipo MDILayaout, que tiene 4 valores: ArrangeIcons, Cascade, TitleHorizontal y TitleVertical.

El Editor de MenúEl Menú o Barra de Menú es la segunda línea de cualquier ventana Windows, donde pueden verse distintos nombres. La Barra de Menú es un componente de un formulario.Para crear un menú debe usarse el Editor de Menú, que se encuentra en la Barra de Herramientas.Para colocar el cursor de escritura en una u otra casilla, puede hacerse bien con las flechas. Para pasar a la siguiente línea de edición (crear una nueva palabra), basta con pulsar Enter.

En la versión anterior de visual Basic, se llamaba Menú, pero ahora se llama MenuStrip, viene a hacer el mismo control pero con otro nombre, a diferencia del control anterior en VB 6.0, este no utiliza un editor de menús, solo nos basta escribir en el menú y darle entrar cada vez que ya queremos que grabe ese menú, como en la figura que esta a continuación.

Pag. 107 de 127


Ahora, si deseas agregar una tecla de acceso rápido, debes escribir el símbolo y delante de la letra a la que deseas acceder. Y seleccionar en la propiedad ShortcutKeys, la tecla con la que deseas acceder.Si te sitúas sobre una línea ya editada, y haciendo clic sobre el botón con flecha hacia la izquierda, puedes agregar submenús.

Creación de un Menú ContextualUn menú contextual es un menú emergente (flotante) que se muestra sobre un formulario, independientemente de la barra de menús. Para mostrar un menú contextual el usuario debe pulsar el botón derecho del ratón sobre el formulario.Para crear un menú contextual, realiza lo siguiente:

1. Selecciona el control ContextMenuStrip de la caja de herramientas y colócala en el formulario.

2. Se mostrará el modelo de diseño para tu menú contextual.

3. En la propiedad ContextMenu del formulario, seleccionaremos que control de menú contextual queramos que nos muestre.

Control ToolBar Este control también no ha cambiado mucho en su utilización, necesita un control ImageList para almacenar las imágenes que se van a mostrar en los botones, lo único que cambia es un poco en su codificación pero eso ya lo veremos, como ya les dije este, también es un control de colección así que también tendrá un editor de colecciones, veamos la ventana de propiedades de este control para que me entiendan.

Pag. 108 de 127


ImageList.- En esta propiedad seleccionaremos de qué contenedor (Control de colección) utilizaremos las imágenes para los botones. Buttons.- En esta propiedad empezaremos a insertar los botones que queramos que se muestre en nuestro Toolbar.

Una vez de dar clic en la propiedad Buttons del control Toolbar nos aparecerá el editor de menú, que es la siguiente figura.

Las propiedades mas utilizadas en el editor de los botones son:

Name.- Si queremos ponerle un nombre especial o identificativo al botón. ImageIndex.- Aquí seleccionaremos el índice o la imagen que queramos que se muestre en el botón, estas imágenes son las que están en el control ImageList. ToolTipText.- Aquí escribiremos el texto que se va a mostrar cuando ubicaremos el Mouse por el botón.

Pag. 109 de 127



Diseñar los siguientes Menús

Agregar un Control ImageList y agregarle a este control 6 imágenes.

Private Sub ToolBar1_ButtonClick Dim x As Integer x = Me.ToolBar1.Buttons.IndexOf(e.Button) Select Case x Case 0 : MsgBox("Nuevo Documento", MsgBoxStyle.Information, "ToolBar") Case 1 : MsgBox("Abre un Documento", MsgBoxStyle.Information, "ToolBar") Case 2 : MsgBox("Graba un Nuevo Documento", MsgBoxStyle.Information, "ToolBar") Case 3 : MsgBox("Imprime un Nuevo Documento", MsgBoxStyle.Information, "ToolBar") Case 4 : MsgBox("Elimina un Nuevo Documento", MsgBoxStyle.Information, "ToolBar") Case 5 : MsgBox("Ventana de Ayuda", MsgBoxStyle.Information, "ToolBar")

MenúSt ToolBar

Pag. 110 de 127


Case 6 : MsgBox("Salir del Sistema", MsgBoxStyle.Information, "ToolBar") End Select

End Sub

ToolStrip(Barra de Herramientas)Desde el punto de vista de la jerarquía de clases de biblioteca .Net, una barra de herramientas es un objeto ToolStrip que actúa como contenedor para los objetos de las clases ToolStripButton, ToolStripLabel, etc.

StatusStrip(Barra de Estado)Desde el punto de vista de la jerarquía de clases de la biblioteca .Net, una barra de estado es un objeto StatusStrip que actúa como contenedor para los objetos de las clases ToolStripStatusLabel, ToolStripProgressBar, ToolStripDropDownButton y ToolStripSplitButton.Para añadir la barra de estado, arrastre desde la caja de herramientas de Visual Studio .Net un control StatusStrip sobre el formulario.


Private Sub Form1_Load Me.stblabel1.Text = Format(Now, "dd - MMM - yyyy") Me.Timer1.Enabled = True End Sub Private Sub Timer1_Tick Me.stblabel3.Text = Format(Now, "hh:mm:ss tt")

stbLabel1 stbLabel3

Pag. 111 de 127


End Sub


Agregamos los siguientes controles

Agregamos los siguientes SubMenús

Pag. 112 de 127


Agregar los siguientes menús para el ContexMenuStrip

1.- Código para los SubMenús del Menú Archivo.

Private Sub EjercicioPracticoNº1ToolStripMenuItem_Click EjercicioPracticoNº1ToolStripMenuItem.Click Form1.MdiParent = Me Form1.Show() End Sub




Private Sub SalirDelSistemaToolStripMenuItem1_Click SalirDelSistemaToolStripMenuItem1.Click Dim x As String

Pag. 113 de 127


x = MsgBox("Desea Salir del Sistema", MsgBoxStyle.YesNo + MsgBoxStyle.Information, "Sistema") If x = vbYes Then Me.Close() End If

End Sub2.- Código para los SubMenús del Menú Ordenar Private Sub VerticalToolStripMenuItem_Click Me.LayoutMdi(MdiLayout.TileVertical) End Sub Private Sub HorizontalToolStripMenuItem_Click Me.LayoutMdi(MdiLayout.TileHorizontal) End Sub

Private Sub CascadaToolStripMenuItem_Click Me.LayoutMdi(MdiLayout.Cascade) End Sub

3.- Código para los SubMenús del Menú Utilitarios.

Private Sub CalculadoraToolStripMenuItem_Click Shell("C:\WINDOWS\system32\calc.exe", AppWinStyle.MaximizedFocus) End Sub

Private Sub PaintToolStripMenuItem_Click Shell("C:\WINDOWS\system32\mspaint.exe", AppWinStyle.MaximizedFocus) End Sub

Private Sub BlocDeNotasToolStripMenuItem_Click BlocDeNotasToolStripMenuItem.Click Shell("C:\WINDOWS\system32\notepad.exe", AppWinStyle.MaximizedFocus) End Sub

Private Sub SalirDelSistemaToolStripMenuItem_Click SalirDelSistemaToolStripMenuItem.Click Dim x As String x = MsgBox("Desea Salir del Sistema", MsgBoxStyle.YesNo + MsgBoxStyle.Information, "Sistema") If x = vbYes Then Me.Close() End If End Sub

Pag. 114 de 127


4.- Código para la Hora del StatusStrip

Private Sub Timer1_Tick Me.ToolStripStatusLabel3.Text = Format(Now, "hh:mm:ss tt") End Sub

Private Sub frmprincipal_Load Me.Timer1.Enabled = True Me.MostrarHoraToolStripMenuItem.Enabled = False Me.MostrarFechaToolStripMenuItem.Enabled = True End Sub

5.- Código para los Menús del ContextMenúStrip

Private Sub MostrarFechaToolStripMenuItem_Click MostrarFechaToolStripMenuItem.Click Me.Timer1.Enabled = False Me.ToolStripStatusLabel3.Text = Format(Now, "dddd, MMM d yyyy") Me.MostrarFechaToolStripMenuItem.Enabled = False Me.MostrarHoraToolStripMenuItem.Enabled = True End Sub

Private Sub MostrarHoraToolStripMenuItem_Click Me.Timer1.Enabled = True Me.ToolStripStatusLabel3.Text = Format(Now, "hh:mm:ss tt") Me.MostrarHoraToolStripMenuItem.Enabled = False Me.MostrarFechaToolStripMenuItem.Enabled = True End Sub

6.- Código para los Botones del ToolStrip

Private Sub ToolStripButton1_Click Form1.MdiParent = Me Form1.Show() End Sub Private Sub ToolStripButton2_Click Form3.MdiParent = Me Form3.Show() End Sub

Private Sub ToolStripButton3_Click Form5.MdiParent = Me

Pag. 115 de 127


Form5.Show() End SubPrivate Sub ToolStripButton4_Click Dim x As String x = MsgBox("Desea Salir del Sistema", MsgBoxStyle.YesNo + MsgBoxStyle.Information, "Sistema") If x = vbYes Then Me.Close() End If End Sub

Pag. 116 de 127


Uso de Agentes

Explorador Web

Reproductor de Windows Media Player

TEMA 13

Pag. 117 de 127


Creación de Controles en Visual Basic.Net 2005

Introducción

Ya conocemos los controles TextBox y Label. Para utilizarlos, puede dibujarlos en un formulario y determinar y comportamiento a través de la propiedades y eventos. Cuando cree su propio control Windows, estará creando un objeto similar, con la ventaja de que Ud. Será quien determine sus propiedades, métodos y eventos o mejorar los controles ya existentes agregando mas funcionalidades como veremos en la separata, su uso de un control de usuario creado o mejorado será igual que un control TextBox u otro control ya existente.

Creando el control de Usuario

1.- Crear un Proyecto de tipo Biblioteca de Controles de Windows de nombre “Creando controles”: como se muestra en la siguiente pantalla.

2.- Cuando crea un proyecto de este tipo por defecto se crea un Control de Usuario de nombre “UserControl1”

3.- Agregaremos un Label y un TextBox.

4.- El TextBox ingresado en su propiedad Name=TxtNombre

5.- Luego clic derecho sobre el UserControl1 y escoger Ver Código.

6.- Dentro de la Clase UserControl1 escribiremos el siguiente código.

Pag. 118 de 127


Public Class UserControl1

Public Property control() As String

Get

Return txtnombre.Text

End Get

Set(ByVal value As String)

txtnombre.Text = value

End Set

End Property

End Class

7.- Ahora debemos generar nuestra DLL de tipo control, para eso haga clik derecho sobre el Proyecto “Creando Controles” y seleccione Generar.

8.- Cuando generamos un Proyecto de tipo Biblioteca de Controles lo que se genera es un archivo DLL reutilizable, para poder ver vaya a la carpeta del Proyecto donde visualizar una carpeta Bin / Release, el archivo se verá como sigue:

Nota: recuerde la ubicación de su archivo para poder usar más adelante.

¿Cómo usar el control de Usuario?

Una vez que hemos creado nuestro Control de Usuario, tenemos que probar en una aplicación real de Windows, entonces empecemos

1.- Crear un nuevo proyecto de Aplicación Windows de nombre “Probando Control”.

2.- Desde el Cuadro de Herramientas Clic derecho seleccione Elegir elementos…

Pag. 119 de 127


3.- Le mostrara la siguiente pantalla: haga clic en el botón Examinar y seleccione su DLL del Control de Usuario (Creando Controles.dll).

4.- Luego haga click en botón aceptar. En el cuadro de herramientas aparecerá el control de usuario creado de esta forma.

5.- Al Form1 que tiene en le proyecto agregar el control creado, y al final debe quedar de la siguiente manera.

Creando un Textbox Que Solo Acepte Letras

Pag. 120 de 127


1.- Agregar un Control de Usuario a su proyecto “Creando Controles”.

2.- Menú proyecto Agregar > Control de Usuario.

3.- Le pondremos de Nombre SoloLetras.

4.- Agregamos un TextBox y en su propiedad Name= TxtLetra

5.- Dentro de la Clase SoloLetras escribiremos el siguiente código.

Public Property letra() As String

Get

Return txtletra.Text

End Get

Set(ByVal value As String)

txtletra.Text = value

End Set

End Property

6.- Luego en el evento KeyPress del TextBox TxtLetra codificaremos:

Private Sub txtletra_KeyPress

If Asc(e.KeyChar) >= 48 And Asc(e.KeyChar) <= 57 Then

Pag. 121 de 127


MsgBox("Debe Ingresar Solo Letras", MsgBoxStyle.Information, "Mensaje")

e.KeyChar = ChrW(0)

End If

End Sub

7.- Luego menú Generar / Generar Solución.

8.- Luego en nuestro proyecto Probando Controles agregaremos otro formulario, y agregaremos la DLL que contiene los controles en este caso (Creando Controles.dll)

9.- En el formulario agregaremos un Label y el control SoloLetras. Y deberá quedar de la siguiente manera.

10.- Ejecutamos y probaremos ingresando números en el control SoloLetras, nos debe mostrar de la siguiente manera.

Resolver:

Crear un control que solo me acepte Números.

Código ASCII para los ControlesPequeña Tabla De Código Ascii

De A a la Z = del 65 al 90 De a a la z = del 97 al 122 á = 255, é = 233, í = 237, ó = 243, ú = 250, ñ = 241, Ñ = 209 De 0 al 9 = del 48 al 57 ENTER = 13

Pag. 122 de 127


BACKSPACE = 8 ESC = 27 Barra Espaciadora = 32

Consumo de Bibliotecas COMEn este laboratorio usaremos la librería COM [Microsoft Agent Object] para el uso de los “Agentes de Microsoft”, los mismos que utiliza el Microsoft Office para mostrar ayuda al usuario. Los agentes son pequeños objetos que pueden interactuar con el usuario a base de movimientos, gestos, leyendas e incluso por voz.

1. Diseñe el siguiente formulario:

2. Agregue la librería COM Microsoft Agent Control 2.0, para ello ir al Menú Proyecto / Agregar Referencia así como se muestra en la figura:

3. Luego en la etiqueta COM de la ventana emergente escogeremos Microsoft Agent Control 2.0, así como se muestra en la figura.

ListBox1

TxtMensajeBtnMensaje

BtnMovimiento

BtnOcultar

BtnMostrar

Pag. 123 de 127


4. Luego escribiremos el siguiente código.

A nivel Formulario:

Public Class Form1 'Declarar los Objetos Dim Agente As New AgentObjects.Agent Dim Muñeco As AgentObjects.IAgentCtlCharacterEx

En el evento Load del Formulario

Private Sub Form1_Load 'Cargar un Character; es decir el muñeco que va a aparecer Agente.Connected = True Agente.Characters.Load("Merlin", "merlin.acs") Muñeco = Agente.Characters("Merlin")

'Bucle para Cargar Todos los Movimientos Dim Mov As Object For Each Mov In Muñeco.AnimationNames Me.ListBox1.Items.Add(Mov) NextEnd Sub

En el evento clic de cada uno de los Botones:

Private Sub btnmostrar_Click 'Muestra el Agente Muñeco.Show() 'Desplaza de Posicion al Agente Muñeco.MoveTo(450, 350) End Sub Private Sub btnocultar_Click 'Oculta al Agente Muñeco.Hide() End Sub Private Sub btnmovimiento_Click 'Ejecuta el Movimiento

Pag. 124 de 127


Muñeco.Play(Me.ListBox1.SelectedItem) End Sub Private Sub btnmensaje_Click 'Muestra el Mensaje Muñeco.Speak(Me.txtmensaje.Text) End Sub

5. Al final ejecutamos la aplicación y se debe de mostrar de la siguiente manera:

Para que el agente Merlin pueda tener voz, es necesario instalar 2 archivos los cuales son:

Microsoft SAPI 4.0 Para que Hablen en español

Un archivo es para el sistema operativo Windows y el otro es para el idioma.Para que puedan trabajar con estos archivos es necesario que su instructor les provea de la carpeta Ayudantes para Microsoft.

Componentes ActiveXVisual Basic.Net permite usar componentes ya definidos en nuestros formularios, dichos componentes no son más que clases que trabajan de una forma concreta que han sido creados para realizar funciones especificas, dichos componentes, cuentan con eventos y propiedades, dado que son usados como objetos.

Estos componentes forman parte de una lista de controles que Visual Basic.Net nos ofrece, así mismo podremos agregar más componentes según nuestro propio requerimientos.

Pag. 125 de 127


Explorador WebPara poder comprender mejor el uso de componentes COM realizaremos un programa que nos

permita crear un explorador de páginas web.

1.- Crear un formulario.

2.- Luego como nuestro componente Web no se encuentra en la lista, procederemos a sacarlo de la

lista de elementos.

Pulsamos clic derecho en el menú de Componentes.

Elegimos la opción Elegir Elementos.

3.- Seleccionaremos el componente Explorador del Web de Microsoft y luego en Aceptar.4.- Luego nos mostrara el componente en nuestra lista de Elementos.5.- Después insertamos ese componente usándolo como control a nuestro formulario, también insertaremos un control TextBox y Button.

TxtDi

AxWebBrow

BtnIr

Pag. 126 de 127


6.- Luego en el evento clic del botón BtnIr codificamos lo siguiente.

Me.AxWebBrowser1.Navigate(Me.txtdir.Text.Trim)

Reproductor de Música y Video

Crearemos un reproductor de música y Video usando componentes COM, dicho programa es muy simple y sencillo el cual te permitirá tener un enfoque claro de los componentes ActiveX.

1. Utilizaremos el componente AxWindowsMediaPlayer, si no lo encontramos en nuestra lista lo agregaremos de nuestra lista de Elegir Elementos.

2. Luego insertamos el control Windows Media Player en nuestro formulario junto con 2 botones uno para el audio y el otro para el video. El formulario deberá quedar de la siguiente manera.

3. Luego en el evento clic de cada botón codificaremos lo siguiente.

Private Sub btnaudio_Click

BtnAudi BtnVideo

AxWindowsMediaPlaye

Pag. 127 de 127


Me.AxWindowsMediaPlayer1.URL = "D:\Rocky.mp3"

End Sub

Private Sub btnvideo_Click

Me.AxWindowsMediaPlayer1.URL = "D:\madonna.mpg"

End Sub

windows forms

Documents