1 - Conceptos básicos de programación

Este tutorial está pensado para ser seguido por una persona que no conoce nada de programación y se
utilice como primer lenguaje de programación el Visual Basic .Net de Microsoft.
El objetivo fundamental de este curso es permitir que el estudiante pueda resolver problemas de distinta
índole (matemáticos, administrativos, gráficos, contables etc.) empleando como herramienta la
computadora.
Hay que tener en cuenta que para llegar a ser programador se debe recorrer un largo camino donde cada
tema es fundamental para conceptos futuros. Es importante no dejar temas sin entender y relacionar.
La programación a diferencia de otras materias como podría ser la historia requiere un estudio metódico y
ordenado (en historia se puede estudiar la edad media sin tener grandes conocimientos de la edad
antigua)
La programación es una actividad nueva para el estudiante, no hay en los estudios primarios y secundarios
una materia parecida.
Es bueno tenerse paciencia cuando los problemas no se resuelven por completo, pero es de fundamental
importancia dedicar tiempo al análisis individual de los problemas.
¿Qué es un programa?
Programa: Conjunto de instrucciones que entiende un ordenador o computadora para realizar una
actividad. Todo programa tiene un objetivo bien definido: un procesador de texto es un programa que
permite cargar, modificar e imprimir textos, un programa de ajedrez permite jugar al ajedrez contra el
ordenador u otro contrincante humano. La actividad fundamental del programador es resolver problemas
empleando el ordenador como herramienta fundamental.
Para la resolución de un problema hay que plantear un algoritmo.
Algoritmo: Son los pasos a seguir para resolver un problema.
Diagrama de flujo
Un diagrama de flujo es la representación gráfica de un
ALGORITMO.
Los símbolos gráficos a utilizar para el planteo de diagramas de
flujo son:
Estos son los elementos esenciales que intervienen en el desarrollo
de un diagrama de flujo.
Planteo de un problema utilizando diagramas de flujo.
Para plantear un diagrama de flujo debemos tener muy en claro el
problema a resolver. Ejemplo : Calcular el sueldo mensual de un
operario conociendo la cantidad de horas trabajadas y el pago por
hora.
Podemos identificar:
Datos conocidos:
Horas trabajadas en el mes.
Pago por hora.
Proceso:
Cálculo del sueldo multiplicando la cantidad de horas por el pago por hora.
Información resultante:
Sueldo mensual.
Si hacemos un análisis todo problema está constituido por:
- Datos conocidos: Datos con los que se cuenta al plantear el problema.
- Proceso: Operaciones a realizar con los datos conocidos.
- Información resultante: Es la información que resuelve el problema.
Esta forma de expresar un problema identificando sus datos conocidos, procesos e información resultante
puede llegar a ser engorrosa para problemas complejos donde hay muchos datos conocidos y procesos. Es
por eso que resulta mucho más efectivo representar los pasos para la resolución del problema mediante
un diagrama de flujo.

Página 1 de 190
Resulta mucho más fácil entender un gráfico que un texto.
El diagrama de flujo nos identifica claramente los datos de entrada, operaciones y datos de salida.
En el ejemplo tenemos dos datos de entrada: horasTrabajadas y costoHora, a las entradas las
representamos con un paralelogramo y hacemos un paralelogramo por cada dato de entrada.
La operación se representa con un rectángulo, debemos hacer un rectángulo por cada operación. A la
salida la representamos con la hoja rota.
El diagrama de flujo nos da una idea del orden de ejecución de las actividades en el tiempo. Primero
cargamos los datos de entrada, luego hacemos las operaciones necesarias y por último mostramos los
resultados.
Codificación del problema con el lenguaje Visual Basic .Net
No debemos perder de vista que el fin último es realizar un programa de computación que permita
automatizar una actividad para que muchos procesos sean desarrollados por la computadora.
El diagrama de flujo es un paso intermedio para poder ser interpretado por la computadora.
El paso siguiente es la codificación del diagrama de flujo en un lenguaje de computación, en nuestro caso
emplearemos el lenguaje Visual Basic
Lenguaje de computación: Conjunto de instrucciones que son interpretadas por una computadora para
realizar operaciones, mostrar datos por pantalla, sacar listados por impresora, entrar datos por teclado,
etc.
Conceptos básicos para codificar un programa.
Variable: Es un depósito donde hay un valor. Consta de un nombre y pertenece a un tipo.
Para el ejemplo planteado la variable HorasTrabajadas almacena la cantidad de horas trabajadas por el
operario. La variable ValorHora almacena el precio de una hora de trabajo. La variable Sueldo almacena el
sueldo a abonar al operario.
En el ejemplo tenemos tres variables.
Tipos de variable:
Una variable puede almacenar:
- Valores Enteros (100, 260, etc.)
- Valores Reales (1.24, 2.90, 5.00, etc.)
- Cadenas de caracteres ("Juan", "Compras", "Listado", etc.)
Elección del nombre de una variable:
Debemos elegir nombres de variables representativas. En el ejemplo el nombre HorasTrabajadas es lo
suficientemente claro para darnos una idea acabada sobre su contenido. Podemos darle otros buenos
nombres. Otros no son tan representativos, por ejemplo HTr. Posiblemente cuando estemos resolviendo
un problema dicho nombre nos recuerde que almacenamos las horas trabajadas por el operario pero
cuando pase el tiempo y leamos el diagrama probablemente no recordemos ni entendamos qué significa
HTr.
Consideraciones a tener en cuenta en cada proyecto.
Hay que tener en cuenta que el entorno de programación "Microsoft Visual Studio" no ha sido desarrollado
pensando en un principiante de la programación y cuenta con un conjunto de herramientas que en un
principio no utilizaremos. Cuenta con un gran conjunto de opciones que puede atemorizarnos, pero a
medida que avancemos con el curso comenzaremos a entenderlas.
Veremos los pasos para la creación de un proyecto en Visual Basic .Net

Página 2 de 190
Pasos.
1 - Ingresemos al "Microsoft Visual Studio".

2 - Creación del proyecto. Para esto seleccionamos desde el menú la opción "Archivo" -> "Nuevo" ->
"proyecto..."

Aparece un diálogo donde debemos indicar del lado izquierdo que utilizaremos el lenguaje Visual Basic-
>Windows->Escritorio clásica, del lado de la derecha seleccionamos "Aplicación de consola" y en la parte
inferior definimos el "nombre", "ubicación" y "nombre de la solución" (podemos usar el mismo texto para
el "nombre de la solución" y "nombre"):

Podemos ver que el entorno nos generó automáticamente el esqueleto de nuestro programa:

3 - Si vamos al Explorador de archivos de windows podemos ver que tenemos creada la carpeta con
nuestro programa:

Página 3 de 190
4 - Una vez que finalizamos de trabajar con el proyecto lo cerramos desde el menú de opciones Archivo ->
Cerrar solución:

3 - Codificación del diagrama de flujo con Visual Basic .Net

Ahora debemos codificar el diagrama de flujo utilizando las instrucciones

del lenguaje Visual Basic. Como hemos visto el entorno de programación del Visual Basic nos creó un esqueleto
básico sobre el cual continuaremos el programa.
Abrimos el proyecto que creamos en el concepto anterior desde el menú de opciones Archivo->Abrir->Proyecto o
Solución, y en el diálogo que aparece seleccionamos el archivo con extensión *.sln:

El archivo Module1.vb tiene el siguiente código:

Module Module1
Sub Main()
End Sub
End Module
A medida que avancemos en el curso veremos que significa la palabra clave Module y el nombre por defecto
definido como "Module1", por el momento nos centraremos donde codificaremos nuestros diagramas de flujo.
La codificación del diagrama de flujo la haremos dentro del bloque Sub Main (El procedimiento Sub Main es lo
primero que se ejecuta al iniciarse un programa)
El programa completo para el calculo del sueldo de un operario conociendo la cantidad de horas trabajadas y el
costo por hora es:
Module Module1
Sub Main()
Dim horasTrabajadas As Integer
Dim costoHora As Single
Dim sueldo As Single

Console.Write("Ingrese Horas trabajadas por el operario:")

Página 4 de 190
 horasTrabajadas = Console.ReadLine()
Console.Write("Ingrese el pago por hora:")
costoHora = Console.ReadLine()
sueldo = horasTrabajadas * costoHora
Console.Write("El sueldo total del operario es:")
Console.Write(sueldo)
Console.ReadKey()
End Sub

End Module
Para probar el funcionamiento del programa debemos presionar el ícono con un triángulo verde (o la tecla especial
F5 o desde el menú elegir la opción "Depurar" -> "Iniciar depuración"):

La ejecución del programa permite ingresar la cantidad de horas trabajadas por un operario y su pago por hora,
mostrando seguidamente el sueldo que se debe pagar, un ejemplo de la ejecución de este programa es :

Si el texto de la ventana donde se ejecuta el programa es muy pequeña podemos modificar su tamaño de fuente
desde el menú que tiene a la izquierda:

Y seleccionar un tamaño mayor:7

Página 5 de 190
Conceptos que deben quedar claros:
Por el momento haremos todo el algoritmo en el procedimiento Main. Es decir el resto siempre lo crea el entorno
del Visual Studio y lo veremos más adelante.
Si observamos el diagrama de flujos vemos que debemos definir tres variables: (horasTrabajadas, costoHora,
sueldo), aquí es donde debemos definir que tipos de datos se almacenarán en las mismas. La cantidad de horas
normalmente será un valor entero (Integer) (ej. 100 - 150 - 230 etc.), pero el costo de la hora es muy común que sea
un valor real (Single) (ej. 5,35 - 7,50 etc.) y como el sueldo resulta de multiplicar las horas trabajadas por el costo por
hora el mismo deberá ser real (con parte decimal)
La definición de las variables la hacemos dentro del procedimiento Sub Main:
Dim horasTrabajadas As Integer
Dim costoHora As Single
Dim sueldo As Single
Utilizamos la palabra clave Dim para definir variables. Luego de la palabra Dim indicamos el nombre de la variable,
seguimos con la palabra clave As y finalmente indicamos el tipo de variable que se trata: Integer (entero), Single
(valor real con coma)
Debemos buscar siempre nombres de variables que nos indiquen que almacenan (no es conveniente llamar a
nombres de variables con letras individuales salvo en casos puntuales que veremos más adelante)
Para mostrar mensajes en la pantalla utilizamos el objeto "Console":
Console.Write("Ingrese Horas trabajadas por el operario:")
Con esta sintaxis todo lo que se encuentra contenido entre comillas aparecerá exactamente en la ventana de la
"Console".
Si disponemos una variable:
Console.Write(sueldo)
Aparecerá el contenido de la variable. Es decir el valor almacenado en la variable sueldo y no el mensaje "sueldo".
Para hacer la entrada de datos por teclado en Visual Basic .Net llamamos al método ReadLine del objeto Console:
horasTrabajadas = Console.ReadLine()
Las operaciones que indicamos en el diagrama de flujo mediante la figura rectángulo la codificamos tal cual:
sueldo = horasTrabajadas * costoHora
Podemos ver una relación entre las instrucciones que debemos utilizar para cada símbolo del diagrama de flujo:

Página 6 de 190
En el diagrama de flujo no indicamos la definición de variables:
Dim horasTrabajadas As Integer
Dim costoHora As Single
Dim sueldo As Single
No representamos con símbolos los mensajes a mostrar previo a la carga de datos por teclado:
Console.Write("Ingrese Horas trabajadas por el operario:")
Para que la ventana del programa no se cierre automáticamente debemos llamar al método ReadKey del objeto
Console antes de finalizar el programa:
Console.ReadKey()
Como hemos visto hasta ahora hay algunas partes de nuestro código que no entendemos pero son indispensables
para la implementación de nuestros programas, a medida que avancemos con el curso muchos de estos conceptos
se irán aclarando.
Recordar que cuando terminamos con un programa debemos cerrarlo antes de crear uno nuevo mediante Archivo ->
Cerrar solución:

4 - Errores sintácticos y lógicos

Confeccionaremos un problema y agregaremos adrede una serie de errores tipográficos. Este tipo de errores
siempre son detectados por el COMPILADOR, antes de ejecutar el programa.
A los errores tipográficos, como por ejemplo nombres de variables incorrectas, falta de paréntesis, palabras claves
mal escritas, etc. los llamamos errores SINTACTICOS.
Un programa no se puede ejecutar sin corregir absolutamente todos los errores sintácticos.
Existe otro tipo de errores llamados ERRORES LOGICOS. Este tipo de errores en programas grandes (miles de líneas)
son más difíciles de localizar. Por ejemplo un programa que permite hacer la facturación pero la salida de datos por
impresora es incorrecta.
Problema :
Hallar la superficie de un cuadrado conociendo el valor de un lado.
Diagrama de flujo:

Proyecto:
Creemos un proyecto llamado SuperficieCuadrado.
Recordemos que si tenemos un proyecto abierto actualmente debemos cerrarlo desde Archivo -> Cerrar solución:

Página 7 de 190
Codificamos el algoritmo en Visual Basic .Net e introducimos dos errores sintáctico:
1 - Disponemos el nombre del objeto Console sin la e final.
2 - Tratamos de imprimir el nombre de la variable superficie sin la primer letra.

Como podemos observar aparece subrayado la línea donde disponemos Consol sin la letra e, como en la línea que
imprimimos la variable superficie sin la letra s. Si modificamos y corregimos los dos errores sintácticos podremos
ejecutar nuestro programa.
Programa correctamente codificado:
Module Module1

Sub Main()
Dim lado As Integer
Dim superficie As Integer
Console.Write("Ingrese el valor del lado del cuadrado:")
lado = Console.ReadLine()
superficie = lado * lado
Console.Write("La superficie del cuadrado es:")
Console.Write(superficie)
Console.ReadKey()
End Sub

End Module
Programa con un error lógico:
Module Module1

Sub Main()
Dim lado As Integer
Dim superficie As Integer
Console.Write("Ingrese el valor del lado del cuadrado:")
lado = Console.ReadLine()
superficie = lado * lado * lado
Console.Write("La superficie del cuadrado es:")
Console.Write(superficie)
Console.ReadKey()
End Sub

End Module

Página 8 de 190
Como podemos observar si ejecutamos el programa no presenta ningún error de compilación. Pero luego de ingresar
el valor del lado del cuadrado (por ejemplo el valor 10) obtenemos como resultado un valor incorrecto (imprime el
1000), esto debido que definimos incorrectamente la fórmula para calcular la superficie del cuadrado:
superficie = lado * lado * lado
5 - Estructura de programación secuencial

Cuando en un problema sólo participan operaciones, entradas y salidas se la denomina una estructura secuencial.
Los problemas diagramados y codificados previamente emplean solo estructuras secuenciales.
La programación requiere una práctica ininterrumpida de diagramación y codificación de problemas.
Problema :
Realizar la carga de dos números enteros por teclado e imprimir su suma y su producto.
Diagrama de flujo:

Tenemos dos entradas num1 y num2, dos operaciones: realizar la suma y el producto de los valores ingresados y dos
salidas, que son los resultados de la suma y el producto de los valores ingresados. En el símbolo de impresión
podemos indicar una o más salidas, eso queda a criterio del programador, lo mismo para indicar las entradas por
teclado.
Programa:
Module Module1

Sub Main()
Dim num1, num2, suma, producto As Integer
Console.Write("Ingrese primer valor:")
num1 = Console.ReadLine()
Console.Write("Ingrese segundo valor:")
num2 = Console.ReadLine()
suma = num1 + num2
producto = num1 * num2
Console.Write("La suma de los dos valores es:")
Console.WriteLine(suma)
Console.Write("El producto de los dos valores es:")
Console.WriteLine(producto)
Console.ReadKey()
End Sub

End Module
Recordemos que tenemos que seguir todos los pasos vistos para la creación de un proyecto.
Algunas cosas nuevas que podemos notar:
Podemos definir varias variables en la misma línea:
Dim num1, num2, suma, producto As Integer
Si llamamos a la función WriteLine en lugar de Write, la impresión siguiente se efectuará en la próxima línea:
Console.WriteLine(suma)

Página 9 de 190
Problemas propuestos
Realizar la carga del lado de un cuadrado, mostrar por pantalla el perímetro del mismo (El perímetro de un cuadrado
se calcula multiplicando el valor del lado por cuatro)
Escribir un programa en el cual se ingresen cuatro números, calcular e informar la suma de los dos primeros y el
producto del tercero y el cuarto.
Realizar un programa que lea cuatro valores numéricos e informar su suma y promedio.
Se debe desarrollar un programa que pida el ingreso del precio de un artículo y la cantidad que lleva el cliente.
Mostrar lo que debe abonar el comprador.
Solución
Module Module1

Sub Main()
Dim lado, perimetro As Integer
Console.Write("Ingrese el lado del cuadrado:")
lado = Console.ReadLine()
perimetro = lado * 4
Console.Write("El perímetro del cuadrado es:")
Console.Write(perimetro)
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim num1, num2, num3, num4, suma, producto As Integer
Console.Write("Ingrese primer valor:")
num1 = Console.ReadLine()
Console.Write("Ingrese segundo valor:")
num2 = Console.ReadLine()
Console.Write("Ingrese tercer valor:")
num3 = Console.ReadLine()
Console.Write("Ingrese cuarto valor:")
num4 = Console.ReadLine()
suma = num1 + num2
producto = num3 * num4
Console.Write("La suma de los dos primero valores es:")
Console.WriteLine(suma)
Console.Write("El producto del tercer y cuarto valor es:")
Console.Write(producto)
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim num1, num2, num3, num4, suma, promedio As Integer
Console.Write("Ingrese primer valor:")
num1 = Console.ReadLine()
Console.Write("Ingrese segundo valor:")
num2 = Console.ReadLine()
Console.Write("Ingrese tercer valor:")

Página 10 de 190
 num3 = Console.ReadLine()
Console.Write("Ingrese cuarto valor:")
num4 = Console.ReadLine()
suma = num1 + num2 + num3 + num4
promedio = suma / 4
Console.Write("La suma de los cuatro valores es:")
Console.WriteLine(suma)
Console.Write("El promedio es:")
Console.Write(promedio)
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim cantidad As Integer
Dim precio, importe As Single
Console.Write("Ingrese la cantidad de artículos a llevar:")
cantidad = Console.ReadLine()
Console.Write("Ingrese el valor unitario del producto:")
precio = Console.ReadLine()
importe = precio * cantidad
Console.Write("El importe total a pagar es:")
Console.Write(importe)
Console.ReadKey()
End Sub

End Module

6 - Estructuras condicionales simples y compuestas

No todos los problemas pueden resolverse empleando estructuras secuenciales. Cuando hay que tomar una decisión
aparecen las estructuras condicionales.
En nuestra vida diaria se nos presentan situaciones donde debemos decidir.
¿Elijo la carrera A o la carrera B?
¿Me pongo este pantalón?
Para ir al trabajo, ¿Elijo el camino A o el camino B?
Al cursar una carrera, ¿Elijo el turno mañana, tarde o noche?
Por supuesto que en un problema se combinan estructuras secuenciales y condicionales.
Estructura condicional simple.
Cuando se presenta la elección tenemos la opción de realizar una actividad o no realizar ninguna Representación
gráfica:

Podemos observar: El rombo representa la condición. Hay dos opciones que se pueden tomar. Si la condición da
verdadera se sigue el camino del verdadero, o sea el de la derecha, si la condición da falsa se sigue el camino de la
izquierda donde no hay ninguna actividad.
Se trata de una estructura CONDICIONAL SIMPLE porque por el camino del verdadero hay actividades y por el

Página 11 de 190
camino del falso no hay actividades.
Por el camino del verdadero pueden existir varias operaciones, entradas y salidas, inclusive ya veremos que puede
haber otras estructuras condicionales.
Problema :
Ingresar el sueldo de una persona, si supera los 3000 pesos mostrar un mensaje en pantalla indicando que debe
abonar impuestos.
Diagrama de flujo:

Podemos observar lo siguiente: Siempre se hace la carga del sueldo, pero si el sueldo que ingresamos supera 3000
pesos se mostrará por pantalla el mensaje "Esta persona debe abonar impuestos", en caso que la persona cobre
3000 o menos no aparece nada por pantalla.
Programa:
Module Module1

Sub Main()
Dim sueldo As Single
Console.Write("Ingrese el sueldo:")
sueldo = Console.ReadLine()
If sueldo > 3000 Then
Console.Write("Esta persona debe abonar impuestos")
End If
Console.ReadKey()
End Sub

End Module
La palabra clave "If" indica que estamos en presencia de una estructura condicional; seguidamente disponemos la
condición. La actividad dentro del If finaliza con la palabra clave End If.
Es común que el contenido del If se indente (corrido hacia la derecha) para una fácil lectura del programa.
Ejecutando el programa e ingresamos un sueldo superior a 3000 pesos. Podemos observar como aparece en pantalla
el mensaje "Esta persona debe abonar impuestos", ya que la condición del If es verdadera.

Página 12 de 190
Volvamos a ejecutar el programa y carguemos un sueldo menor o igual a 3000 pesos. No debe aparecer mensaje en
pantalla.
Estructura condicional compuesta.
Cuando se presenta la elección tenemos la opción de realizar una actividad u otra. Es decir tenemos actividades por
el verdadero y por el falso de la condición. Lo más importante que hay que tener en cuenta que se realizan las
actividades de la rama del verdadero o las del falso, NUNCA se realizan las actividades de las dos ramas.
Representación gráfica:

En una estructura condicional compuesta tenemos entradas, salidas, operaciones, tanto por la rama del verdadero
como por la rama del falso.
Problema :
Realizar un programa que solicite ingresar dos números distintos y muestre por pantalla el mayor de ellos.
Diagrama de flujo:

Se hace la entrada de num1 y num2 por teclado. Para saber cual variable tiene un valor mayor preguntamos si el
contenido de num1 es mayor (>) que el contenido de num2, si la respuesta es verdadera vamos por la rama de la
derecha e imprimimos num1, en caso que la condición sea falsa vamos por la rama de la izquierda (Falsa) e
imprimimos num2.
Como podemos observar nunca se imprimen num1 y num2 simultáneamente.
Estamos en presencia de una ESTRUCTURA CONDICIONAL COMPUESTA ya que tenemos actividades por la rama del
verdadero y del falso.
Programa:
Module Module1

Sub Main()
Dim num1, num2 As Integer
Console.Write("Ingrese primer valor:")
num1 = Console.ReadLine()
Console.Write("Ingrese segundo valor:")
num2 = Console.ReadLine()

Página 13 de 190
 If num1 > num2 Then
Console.Write(num1)
Else
Console.Write(num2)
End If
Console.ReadKey()
End Sub

End Module
Cotejemos el diagrama de flujo y la codificación y observemos que el primer bloque después del If representa la
rama del verdadero y el segundo bloque después de la palabra clave Else representa la rama del falso.
Compilemos el programa, si hubo errores sintácticos corrijamos y carguemos dos valores, como por ejemplo:
Ingrese el primer valor: 10
Ingrese el segundo valor: 4
10
Si ingresamos los valores 10 y 4 la condición del If retorna verdadero y ejecuta el primer bloque.
Un programa se controla y corrige probando todos sus posibles resultados.
Ejecutemos nuevamente el programa e ingresemos:
Ingrese el primer valor: 10
Ingrese el segundo valor: 54
54
Cuando a un programa le corregimos todos los errores sintácticos y lógicos ha terminado nuestra tarea y podemos
entregar el mismo al USUARIO que nos lo solicitó.
Operadores
En una condición deben disponerse únicamente variables, valores constantes y operadores relacionales.
Operadores Relacionales:
> (mayor)
< (menor)
>= (mayor o igual)
<= (menor o igual)
= (igual)
<> (distinto)
Operadores Matemáticos
+ (más)
- (menos)
* (producto)
/ (división)
mod (resto de una división) Ej.: x=13 mod 5 {se guarda 3}
Hay que tener en cuenta que al disponer una condición debemos seleccionar que operador relacional se adapta a la
pregunta.
Ejemplos:
Se ingresa un número multiplicarlo por 10 si es distinto a 0. (<>)
Se ingresan dos números mostrar una advertencia si son iguales. (=)
Los problemas que se pueden presentar son infinitos y la correcta elección del operador sólo se alcanza con la
práctica intensiva en la resolución de problemas.
Problemas propuestos
Realizar un programa que lea por teclado dos números, si el primero es mayor al segundo informar su suma y
diferencia, en caso contrario informar el producto y la división del primero respecto al segundo.
Se ingresan tres notas de un alumno, si el promedio es mayor o igual a siete mostrar un mensaje "Promocionado".
Se ingresa por teclado un número positivo de uno o dos dígitos (1..99) mostrar un mensaje indicando si el número
tiene uno o dos dígitos.
(Tener en cuenta que condición debe cumplirse para tener dos dígitos, un número entero)
Solución
Module Module1

Página 14 de 190
 Sub Main()
Dim num1, num2 As Integer
Console.Write("Ingrese primer valor:")
num1 = Console.ReadLine()
Console.Write("Ingrese segundo valor:")
num2 = Console.ReadLine()
If num1 > num2 Then
Dim suma, diferencia As Integer
suma = num1 + num2
diferencia = num1 - num2
Console.Write("La suma de los dos valores es:")
Console.WriteLine(suma)
Console.Write("La diferencia de los dos valores es:")
Console.WriteLine(diferencia)
Else
Dim producto, division As Integer
producto = num1 * num2
division = num1 / num2
Console.Write("El producto de los dos valores es:")
Console.WriteLine(producto)
Console.Write("La división de los dos valores es:")
Console.WriteLine(division)
End If
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim nota1, nota2, nota3 As Integer
Console.Write("Ingrese primer nota:")
nota1 = Console.ReadLine()
Console.Write("Ingrese segunda nota:")
nota2 = Console.ReadLine()
Console.Write("Ingrese tercer nota:")
nota3 = Console.ReadLine()
Dim promedio As Integer
promedio = (nota1 + nota2 + nota3) / 3
If promedio >= 7 Then
Console.Write("Promocionado")
End If
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim num As Integer
Console.Write("Ingrese un valor entero de 1 o 2 dígitos:")
num = Console.ReadLine()
If num < 10 Then
Console.Write("Tiene un dígito")

Página 15 de 190
 Else
Console.Write("Tiene dos dígitos")
End If
Console.ReadKey()
End Sub

End Module
7 - Estructuras condicionales anidadas

Decimos que una estructura condicional es anidada cuando por la rama del verdadero o del falso de una estructura
condicional hay otra estructura condicional.

El diagrama de flujo que se presenta contiene dos estructuras condicionales. La principal se trata de una estructura
condicional compuesta y la segunda es una estructura condicional simple y está contenida por la rama del falso de la
primer estructura.
Es común que se presenten estructuras condicionales anidadas aún más complejas.
Problema :
Confeccionar un programa que pida por teclado tres notas de un alumno, calcule el promedio e imprima alguno de
estos mensajes:
Si el promedio es >=7 mostrar "Promocionado".
Si el promedio es >=4 y <7 mostrar "Regular".
Si el promedio es <4 mostrar "Reprobado".
Diagrama de flujo:

Analicemos el siguiente diagrama. Se ingresan tres valores por teclado que representan las notas de un alumno, se
obtiene el promedio sumando los tres valores y dividiendo por 3 dicho resultado (Tener en cuenta que si el resultado

Página 16 de 190
es un valor real solo se almacena la parte entera).
Primeramente preguntamos si el promedio es superior o igual a 7, en caso afirmativo va por la rama del verdadero
de la estructura condicional mostramos un mensaje que indica "Promocionado" (con comillas indicamos un texto
que debe imprimirse en pantalla).
En caso que la condición nos de falso, por la rama del falso aparece otra estructura condicional, porque todavía
debemos averiguar si el promedio del alumno es superior o igual a cuatro o inferior a cuatro.
Estamos en presencia de dos estructuras condicionales compuestas.
Programa:
Module Module1

Sub Main()
Dim nota1, nota2, nota3, promedio As Integer
Console.Write("Ingrese primer nota:")
nota1 = Console.ReadLine()
Console.Write("Ingrese segunda nota:")
nota2 = Console.ReadLine()
Console.Write("Ingrese tercer nota:")
nota3 = Console.ReadLine()
promedio = (nota1 + nota2 + nota3) / 3
If promedio >= 7 Then
Console.Write("Promocionado")
Else
If promedio >= 4 Then
Console.Write("Regular")
Else
Console.Write("Reprobado")
End If
End If
Console.ReadKey()
End Sub

End Module
Codifiquemos y ejecutemos este programa. Al correr el programa deberá solicitar por teclado la carga de tres notas y
mostrarnos un mensaje según el promedio de las mismas.
Podemos definir un conjunto de variables del mismo tipo en una misma línea:
Dim nota1, nota2, nota3, promedio As Integer
Esto no es obligatorio pero a veces, por estar relacionadas, conviene.
A la codificación del If anidado podemos observarla por el else del primer If.
Problemas propuestos
Se cargan por teclado tres números distintos. Mostrar por pantalla el mayor de ellos.
Se ingresa por teclado un valor entero, mostrar una leyenda que indique si el número es positivo, nulo o negativo.
Confeccionar un programa que permita cargar un número entero positivo de hasta tres cifras y muestre un mensaje
indicando si tiene 1, 2, o 3 cifras. Mostrar un mensaje de error si el número de cifras es mayor.
Un postulante a un empleo, realiza un test de capacitación, se obtuvo la siguiente información: cantidad total de
preguntas que se le realizaron y la cantidad de preguntas que contestó correctamente. Se pide confeccionar un
programa que ingrese los dos datos por teclado e informe el nivel del mismo según el porcentaje de respuestas
correctas que ha obtenido, y sabiendo que:
Nivel máximo:Porcentaje>=90%.
Nivel medio: Porcentaje>=75% y <90%.
Nivel regular: Porcentaje>=50% y <75%.
Fuera de nivel: Porcentaje<50%.
Solucion
Module Module1

Sub Main()
Dim num1, num2, num3 As Integer

Página 17 de 190
 Console.Write("Ingrese primer valor:")
num1 = Console.ReadLine()
Console.Write("Ingrese segunda valor:")
num2 = Console.ReadLine()
Console.Write("Ingrese tercer valor:")
num3 = Console.ReadLine()
If num1 > num2 Then
If num1 > num3 Then
Console.Write(num1)
Else
Console.Write(num3)
End If
Else
If num2 > num3 Then
Console.Write(num2)
Else
Console.Write(num3)
End If
End If
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim num As Integer
Console.Write("Ingrese un valor:")
num = Console.ReadLine()
If num = 0 Then
Console.Write("Se ingresó el cero")
Else
If num > 0 Then
Console.Write("Se ingresó un valor positivo")
Else
Console.Write("Se ingresó un valor negativo")
End If
End If
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim num As Integer
Console.Write("Ingrese un valor de hasta tres dígitos
positivo:")
num = Console.ReadLine()
If num < 10 Then
Console.Write("Tiene un dígito")
Else
If num < 100 Then
Console.Write("Tiene dos dígitos")

Página 18 de 190
 Else
If num < 1000 Then
Console.Write("Tiene tres dígitos")
Else
Console.Write("Error en la entrada de datos.")
End If
End If
End If
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim totalPreguntas, totalCorrectas As Integer

Console.Write("Ingrese la cantidad total de preguntas del

examen:")
totalPreguntas = Console.ReadLine()
Console.Write("Ingrese la cantidad total de preguntas
contestadas correctamente:")
totalCorrectas = Console.ReadLine()
Dim porcentaje As Integer
porcentaje = totalCorrectas * 100 / totalPreguntas
If porcentaje >= 90 Then
Console.Write("Nivel máximo")
Else
If porcentaje >= 75 Then
Console.Write("Nivel medio")
Else
If porcentaje >= 50 Then
Console.Write("Nivel regular")
Else
Console.Write("Fuera de nivel")
End If
End If
End If
Console.ReadKey()
End Sub

End Module
8 - Estructuras condicionales con condiciones compuestas y operadores lógicos

Hasta ahora hemos visto los operadores:

relacionales (>, <, >=, <= , =, <>)
matemáticos (+, -, *, /, Mod)
pero nos están faltando otros operadores imprescindibles:
lógicos (And, Or).
Estos dos operadores se emplean fundamentalmente en las estructuras condicionales para agrupar varias
condiciones simples.
Operador And

Página 19 de 190
Traducido se lo lee como ?Y?. Si la Condición 1 es verdadera Y la condición 2 es verdadera luego ejecutar la rama del
verdadero.
Cuando vinculamos dos o más condiciones con el operador "And", las dos condiciones deben ser verdaderas para
que el resultado de la condición compuesta de Verdadero y continúe por la rama del verdadero de la estructura
condicional.
La utilización de operadores lógicos permiten en muchos casos plantear algoritmos más cortos y comprensibles.
Problema :
Confeccionar un programa que lea por teclado tres números distintos y nos muestre el mayor.
Diagrama de flujo:

Este ejercicio está resuelto sin emplear operadores lógicos en un concepto anterior del tutorial. La primera
estructura condicional es una ESTRUCTURA CONDICIONAL COMPUESTA con una CONDICION COMPUESTA.
Podemos leerla de la siguiente forma:
Si el contenido de la variable num1 es mayor al contenido de la variable num2 Y si el contenido de la variable num1
es mayor al contenido de la variable num3 entonces la CONDICION COMPUESTA resulta Verdadera.
Si una de las condiciones simples da falso la CONDICION COMPUESTA da Falso y continua por la rama del falso.
Es decir que se mostrará el contenido de num1 si y sólo si num1>num2 y num1>num3.
En caso de ser Falsa la condición, analizamos el contenido de num2 y num3 para ver cual tiene un valor mayor.
En esta segunda estructura condicional no se requieren operadores lógicos al haber una condición simple.
Programa:
Module Module1
Sub Main()
Dim num1, num2, num3 As Integer
Console.Write("Ingrese primer valor:")
num1 = Console.ReadLine()
Console.Write("Ingrese segundo valor:")

Página 20 de 190
 num2 = Console.ReadLine()
Console.Write("Ingrese tercer valor:")
num3 = Console.ReadLine()
If num1 > num2 And num1 > num3 Then
Console.Write(num1)
Else
If num2 > num3 Then
Console.Write(num2)
Else
Console.Write(num3)
End If
End If
Console.ReadKey()
End Sub

End Module
Operador Or

Traducido se lo lee como "O". Si la condición primera es Verdadera o la condición segunda es Verdadera, luego
ejecutar la rama del Verdadero.
Cuando vinculamos dos o más condiciones con el operador "Or", con que una de las dos condiciones sea Verdadera
alcanza para que el resultado de la condición compuesta sea Verdadero.
Problema :
Se carga una fecha (día, mes y año) por teclado. Mostrar un mensaje si corresponde al primer trimestre del año
(enero, febrero o marzo) Cargar por teclado el valor numérico del día, mes y año.
Ejemplo: dia:10 mes:1 año:2016.
Diagrama de flujo:

La carga de una fecha se hace por partes, ingresamos las variables dia, mes y año.
Mostramos el mensaje "Corresponde al primer trimestre" en caso que el mes ingresado por teclado sea igual a 1, 2 ó
3.
En la condición no participan las variables dia y año.
Programa:
Module Module1

Sub Main()
Dim dia, mes, año As Integer

Página 21 de 190
 Console.Write("Ingrese nro de día:")
dia = Console.ReadLine()
Console.Write("Ingrese nro de mes:")
mes = Console.ReadLine()
Console.Write("Ingrese nro de año:")
año = Console.ReadLine()
If mes = 1 Or mes = 2 Or mes = 3 Then
Console.Write("Corresponde al primer trimestre")
End If
Console.ReadLine()
End Sub

End Module
Problemas propuestos
Realizar un programa que pida cargar una fecha cualquiera, luego verificar si dicha fecha corresponde a Navidad.
Se ingresan tres valores por teclado, si todos son iguales se imprime la suma del primero con el segundo y a este
resultado se lo multiplica por el tercero.
Se ingresan por teclado tres números, si todos los valores ingresados son menores a 10, imprimir en pantalla la
leyenda "Todos los números son menores a diez".
Se ingresan por teclado tres números, si al menos uno de los valores ingresados es menor a 10, imprimir en pantalla
la leyenda "Alguno de los números es menor a diez".
Escribir un programa que pida ingresar la coordenada de un punto en el plano, es decir dos valores enteros x e y
(distintos a cero).
Posteriormente imprimir en pantalla en que cuadrante se ubica dicho punto. (1º Cuadrante si x > 0 Y y > 0 , 2º
Cuadrante: x < 0 Y y > 0, etc.)
De un operario se conoce su sueldo y los años de antigüedad. Se pide confeccionar un programa que lea los datos de
entrada e informe:
a) Si el sueldo es inferior a 500 y su antigüedad es igual o superior a 10 años, otorgarle un aumento del 20 %, mostrar
el sueldo a pagar.
b)Si el sueldo es inferior a 500 pero su antigüedad es menor a 10 años, otorgarle un aumento de 5 %.
c) Si el sueldo es mayor o igual a 500 mostrar el sueldo en pantalla sin cambios.
Escribir un programa en el cual: dada una lista de tres valores numéricos distintos se calcule e informe su rango de
variación (debe mostrar el mayor y el menor de ellos)
Solución
Module Module1

Sub Main()
Dim dia, mes, año As Integer
Console.Write("Ingrese nro de día:")
dia = Console.ReadLine()
Console.Write("Ingrese nro de mes:")
mes = Console.ReadLine()
Console.Write("Ingrese nro de año:")
año = Console.ReadLine()
If mes = 12 And dia = 25 Then
Console.Write("La fecha ingresada corresponde a navidad.")
End If
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()

Página 22 de 190
 Dim num1, num2, num3 As Integer
Console.Write("Ingrese primer valor:")
num1 = Console.ReadLine()
Console.Write("Ingrese segundo valor:")
num2 = Console.ReadLine()
Console.Write("Ingrese tercer valor:")
num3 = Console.ReadLine()
If num1 = num2 And num1 = num3 Then

Dim suma, producto As Integer

suma = num1 + num2
Console.Write("La suma del primero y segundo:")
Console.WriteLine(suma)
producto = suma * num3
Console.Write("La suma del primero y segundo multiplicado
por el tercero:")
Console.Write(producto)
End If
Console.ReadKey()
End Sub

End Module
Module Module1

Sub Main()
Dim num1, num2, num3 As Integer
Console.Write("Ingrese primer valor:")
num1 = Console.ReadLine()
Console.Write("Ingrese segundo valor:")
num2 = Console.ReadLine()
Console.Write("Ingrese tercer valor:")
num3 = Console.ReadLine()
If num1 < 10 And num2 < 10 And num3 < 10 Then
Console.Write("Todos los números son menores a diez")
End If
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim num1, num2, num3 As Integer
Console.Write("Ingrese primer valor:")
num1 = Console.ReadLine()
Console.Write("Ingrese segundo valor:")
num2 = Console.ReadLine()
Console.Write("Ingrese tercer valor:")
num3 = Console.ReadLine()
If num1 < 10 Or num2 < 10 Or num3 < 10 Then
Console.Write("Alguno de los números es menor a diez")
End If
Console.ReadKey()
End Sub

Página 23 de 190
End Module

Module Module1

Sub Main()
Dim x, y As Integer
Console.Write("Ingrese coordenada x:")
x = Console.ReadLine()
Console.Write("Ingrese coordenada y:")
y = Console.ReadLine()
If x > 0 And y > 0 Then
Console.Write("Se encuentra en el primer cuadrante")
Else
If x < 0 And y > 0 Then
Console.Write("Se encuentra en el segundo cuadrante")
Else
If x < 0 And y < 0 Then
Console.Write("Se encuentra en el tercer cuadrante")
Else
Console.Write("Se encuentra en el cuarto cuadrante")
End If
End If
End If
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim sueldo As Single
Dim antiguedad As Integer
Console.Write("Ingrese sueldo del empleado:")
sueldo = Console.ReadLine()
Console.Write("Ingrese su antiguedad en años:")
antiguedad = Console.ReadLine()
If sueldo < 500 And antiguedad > 10 Then
Dim aumento As Single
aumento = sueldo * 0.2
Dim sueldoTotal As Single
sueldoTotal = sueldo + aumento
Console.Write("Sueldo a pagar:")
Console.Write(sueldoTotal)
Else
If sueldo < 500 Then
Dim aumento As Single
aumento = sueldo * 0.05
Dim sueldoTotal As Single
sueldoTotal = sueldo + aumento
Console.Write("Sueldo a pagar:")
Console.Write(sueldoTotal)
Else
Console.Write("Sueldo a pagar:")
Console.Write(sueldo)
End If

Página 24 de 190
 End If
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim num1, num2, num3 As Integer
Console.Write("Ingrese primer valor:")
num1 = Console.ReadLine()
Console.Write("Ingrese segundo valor:")
num2 = Console.ReadLine()
Console.Write("Ingrese tercer valor:")
num3 = Console.ReadLine()
Console.Write("Rango de valores:")
If num1 < num2 And num1 < num3 Then
Console.Write(num1)
Else
If num2 < num3 Then
Console.Write(num2)
Else
Console.Write(num3)
End If
End If
Console.Write("-")
If num1 > num2 And num1 > num3 Then
Console.Write(num1)
Else
If num2 > num3 Then
Console.Write(num2)
Else
Console.Write(num3)
End If
End If
Console.ReadKey()
End Sub

End Module
9 - Estructura repetitiva Do While (condición) ... Loop

Hasta ahora hemos empleado estructuras SECUENCIALES y CONDICIONALES. Existe otro tipo de estructuras tan
importantes como las anteriores que son las estructuras REPETITIVAS.
Una estructura repetitiva permite ejecutar una instrucción o un conjunto de instrucciones varias veces.
Una ejecución repetitiva de sentencias se caracteriza por:
- Las sentencias que se repiten.
- El test o prueba de condición antes de cada repetición, que motivará que se repitan o no las sentencias.
Estructura repetitiva Do While (condición) ... Loop.
Representación gráfica de la estructura Do While (condición) ... Loop:

Página 25 de 190
No debemos confundir la representación gráfica de la estructura repetitiva Do While ... Loop (Mientras) con la
estructura condicional If (Si)
Funcionamiento: En primer lugar se verifica la condición, si la misma resulta verdadera se ejecutan las operaciones
que indicamos por la rama del Verdadero.
A la rama del verdadero la graficamos en la parte inferior de la condición. Una línea al final del bloque de repetición
la conecta con la parte superior de la estructura repetitiva.
En caso que la condición sea Falsa continúa por la rama del Falso y sale de la estructura repetitiva para continuar con
la ejecución del algoritmo.
El bloque se repite MIENTRAS la condición sea Verdadera.
Importante: Si la condición siempre retorna verdadero estamos en presencia de un ciclo repetitivo infinito. Dicha
situación es un error de programación, nunca finalizará el programa.
Problema 1:
Realizar un programa que imprima en pantalla los números del 1 al 100.
Si no conocemos las estructuras repetitivas podemos resolver el problema empleando una estructura secuencial.
Inicializamos una variable con el valor 1, luego imprimimos la variable, incrementamos nuevamente la variable y así
sucesivamente.
Diagrama de flujo:

Si continuamos con el diagrama no nos alcanzarían las próximas 5 páginas para finalizarlo.
Emplear una estructura secuencial para resolver este problema produce un diagrama de flujo y un programa en
Visual Basic muy largo.
Ahora veamos la solución empleando una estructura repetitiva Do While(condición) ... Loop:

Página 26 de 190
Es muy importante analizar este diagrama:
La primera operación inicializa la variable x en 1, seguidamente comienza la estructura repetitiva while y disponemos
la siguiente condición ( x <= 100), se lee MIENTRAS la variable x sea menor o igual a 100.
Al ejecutarse la condición retorna VERDADERO porque el contenido de x (1) es menor o igual a 100. Al ser la
condición verdadera se ejecuta el bloque de instrucciones que contiene la estructura while que finaliza en la palabra
clave Loop. El bloque de instrucciones contiene una salida y una operación.
Se imprime el contenido de x, y seguidamente se incrementa la variable x en uno.
La operación x = x + 1 se lee como "en la variable x se guarda el contenido de x más 1". Es decir, si x contiene 1 luego
de ejecutarse esta operación se almacenará en x un 2.
Al finalizar el bloque de instrucciones que contiene la estructura repetitiva se verifica nuevamente la condición de la
estructura repetitiva y se repite el proceso explicado anteriormente.
Mientras la condición retorne verdadero se ejecuta el bloque de instrucciones; al retornar falso la verificación de la
condición se sale de la estructura repetitiva y continua el algoritmo, en este caso finaliza el programa.
Lo más difícil es la definición de la condición de la estructura while y qué bloque de instrucciones se van a repetir.
Observar que si, por ejemplo, disponemos la condición x >=100 ( si x es mayor o igual a 100) no provoca ningún error
sintáctico pero estamos en presencia de un error lógico porque al evaluarse por primera vez la condición retorna
falso y no se ejecuta el bloque de instrucciones que queríamos repetir 100 veces.
No existe una RECETA para definir una condición de una estructura repetitiva, sino que se logra con una práctica
continua solucionando problemas.
Una vez planteado el diagrama debemos verificar si el mismo es una solución válida al problema (en este caso se
debe imprimir los números del 1 al 100 en pantalla), para ello podemos hacer un seguimiento del flujo del diagrama
y los valores que toman las variables a lo largo de la ejecución:
x
1
2
3
4
.
.
100
101 Cuando x vale 101 la condición de la estructura repetitiva retorna falso,
en este caso finaliza el diagrama.
Importante: Podemos observar que el bloque repetitivo puede no ejecutarse ninguna vez si la condición retorna
falso la primera vez.
La variable x debe estar inicializada con algún valor antes que se ejecute la operación x = x + 1 en caso de no estar
inicializada aparece un error de compilación.
Programa:
Module Module1

Sub Main()
Dim x As Integer

Página 27 de 190
 x = 1
Do While x <= 100
Console.Write(x)
Console.Write(" - ")
x = x + 1
Loop
Console.ReadKey()
End Sub

End Module
Recordemos que un problema no estará 100% solucionado si no hacemos el programa en Visual Basic .Net que
muestre los resultados buscados.
Probemos algunas modificaciones de este programa y veamos que cambios se deberían hacer para:
1 - Imprimir los números del 1 al 500.
2 - Imprimir los números del 50 al 100.
3 - Imprimir los números del -50 al 0.
4 - Imprimir los números del 2 al 100 pero de 2 en 2 (2,4,6,8 ....100).
Respuestas:
1 - Debemos cambiar la condición del Do While con x<=500.
2 - Debemos inicializar x con el valor 50.
3 - Inicializar x con el valor -50 y fijar la condición x<=0.
4 - Inicializar a x con el valor 2 y dentro del bloque repetitivo incrementar a x en 2
x=x+2
Problema 2:
Escribir un programa que solicite la carga de un valor positivo y nos muestre desde 1 hasta el valor ingresado de uno
en uno.
Ejemplo: Si ingresamos 30 se debe mostrar en pantalla los números del 1 al 30.
Es de FUNDAMENTAL importancia analizar los diagramas de flujo y la posterior codificación en Visual Basic .Net de
los siguientes problemas, en varios problemas se presentan otras situaciones no vistas en el ejercicio anterior.
Diagrama de flujo:

Podemos observar que se ingresa por teclado la variable n. El operador puede cargar cualquier valor.
Si el operador carga 10 el bloque repetitivo se ejecutará 10 veces, ya que la condición es "Mientras x<=n ", es decir
"mientras x sea menor o igual a 10"; pues x comienza en uno y se incrementa en uno cada vez que se ejecuta el
bloque repetitivo.
A la prueba del diagrama la podemos realizar dándole valores a las variables; por ejemplo, si ingresamos 5 el
seguimiento es el siguiente:
n x
5 1 (Se imprime el contenido de x)
2 " "

Página 28 de 190
 3 " "
4 " "
5 " "
6 (Sale del while porque 6 no es menor o igual a 5)
Programa:
Module Module1

Sub Main()
Dim n, x As Integer
Console.Write("Ingrese el valor final:")
n = Console.ReadLine()
x = 1
Do While x <= n
Console.Write(x)
Console.Write(" - ")
x = x + 1
Loop
Console.ReadKey()
End Sub

End Module
Los nombres de las variables n y x pueden ser palabras o letras (como en este caso)
La variable x recibe el nombre de CONTADOR. Un contador es un tipo especial de variable que se incrementa o
decrementa con valores constantes durante la ejecución del programa.
El contador x nos indica en cada momento la cantidad de valores impresos en pantalla.
Problema 3:
Desarrollar un programa que permita la carga de 10 valores por teclado y nos muestre posteriormente la suma de
los valores ingresados y su promedio.
Diagrama de flujo:

En este problema, a semejanza de los anteriores, llevamos un CONTADOR llamado x que nos sirve para contar las

Página 29 de 190
vueltas que debe repetir el while.
También aparece el concepto de ACUMULADOR (un acumulador es un tipo especial de variable que se incrementa o
decrementa con valores variables durante la ejecución del programa)
Hemos dado el nombre de suma a nuestro acumulador. Cada ciclo que se repita la estructura repetitiva, la variable
suma se incrementa con el contenido ingresado en la variable valor.
La prueba del diagrama se realiza dándole valores a las variables:
valor suma x promedio
0 0
(Antes de entrar a la estructura repetitiva estos son los valores).
5 5 1
16 21 2
7 28 3
10 38 4
2 40 5
20 60 6
5 65 7
5 70 8
10 80 9
2 82 10
8 90 11
9

Este es un seguimiento del diagrama planteado. Los números que toma la variable valor dependerá de qué cifras
cargue el operador durante la ejecución del programa.
El promedio se calcula al salir de la estructura repetitiva (es decir primero sumamos los 10 valores ingresados y luego
los dividimos por 10)
Hay que tener en cuenta que cuando en la variable valor se carga el primer número (en este ejemplo 5) al cargarse el
segundo valor (16) el valor anterior 5 se pierde, por ello la necesidad de ir almacenando en la variable "suma" los
valores ingresados.
Programa:
Module Module1

Sub Main()
Dim x, suma, valor, promedio As Integer
x = 1
suma = 0
Do While x <= 10
Console.Write("Ingrese un valor:")
valor = Console.ReadLine()
suma = suma + valor
x = x + 1
Loop
promedio = suma / 10
Console.Write("La suma de los 10 valores es:")
Console.WriteLine(suma)
Console.Write("El promedio es:")
Console.Write(promedio)
Console.ReadKey()
End Sub

End Module
Problema 4:
Una planta que fabrica perfiles de hierro posee un lote de n piezas.
Confeccionar un programa que pida ingresar por teclado la cantidad de piezas a procesar y luego ingrese la longitud

Página 30 de 190
de cada perfil; sabiendo que la pieza cuya longitud esté comprendida en el rango de 1,20 y 1,30 son aptas. Imprimir
por pantalla la cantidad de piezas aptas que hay en el lote.
Diagrama de flujo:

Podemos observar que dentro de una estructura repetitiva puede haber estructuras condicionales (inclusive puede
haber otras estructuras repetitivas que veremos más adelante)
En este problema hay que cargar inicialmente la cantidad de piezas a ingresar ( n ), seguidamente se cargan n valores
de largos de piezas.
Cada vez que ingresamos un largo de pieza (largo) verificamos si es una medida correcta (debe estar entre 1,20 y
1,30 el largo para que sea correcta), en caso de ser correcta la CONTAMOS (incrementamos la variable cantidad en
1)
Al contador cantidad lo inicializamos en cero porque inicialmente no se ha cargado ningún largo de pieza.
Cuando salimos de la estructura repetitiva porque se han cargado n largos de piezas mostramos por pantalla el
contador cantidad (que representa la cantidad de piezas aptas)
En este problema tenemos dos CONTADORES:
x (Cuenta la cantidad de piezas cargadas hasta el momento)
cantidad (Cuenta los perfiles de hierro aptos)
Programa:
Module Module1

Sub Main()
Dim x, cantidad, n As Integer
Dim largo As Single
x = 1
cantidad = 0
Console.Write("Cuantas piezar procesará:")
n = Console.ReadLine()
Do While x <= n
Console.Write("Ingrese la medida de la pieza:")
largo = Console.ReadLine()

Página 31 de 190
 If largo >= 1.2 And largo <= 1.3 Then
cantidad = cantidad + 1
End If
x = x + 1
Loop
Console.Write("La cantidad de piezas aptas son:")
Console.Write(cantidad)
Console.ReadKey()
End Sub

End Module
Problemas propuestos
Ha llegado la parte fundamental, que es el momento donde uno desarrolla individualmente un algoritmo para la
resolución de problemas.
El tiempo a dedicar a esta sección EJERCICIOS PROPUESTOS debe ser mucho mayor que el empleado a la sección de
EJERCICIOS RESUELTOS.
La experiencia dice que debemos dedicar el 80% del tiempo a la resolución individual de problemas y el otro 20% al
análisis y codificación de problemas ya resueltos por otras personas.
Es de vital importancia para llegar a ser un buen PROGRAMADOR poder resolver problemas en forma individual.
Escribir un programa que solicite ingresar 10 notas de alumnos y nos informe cuántos tienen notas mayores o
iguales a 7 y cuántos menores.
Se ingresan un conjunto de n alturas de personas por teclado. Mostrar la altura promedio de las personas.
En una empresa trabajan n empleados cuyos sueldos oscilan entre $100 y $500, realizar un programa que lea los
sueldos que cobra cada empleado e informe cuántos empleados cobran entre $100 y $300 y cuántos cobran más de
$300. Además el programa deberá informar el importe que gasta la empresa en sueldos al personal.
Realizar un programa que imprima 25 términos de la serie 11 - 22 - 33 - 44, etc. (No se ingresan valores por teclado)
Mostrar los múltiplos de 8 hasta el valor 500. Debe aparecer en pantalla 8 - 16 - 24, etc.
Realizar un programa que permita cargar dos listas de 15 valores cada una. Informar con un mensaje cual de las dos
listas tiene un valor acumulado mayor (mensajes "Lista 1 mayor", "Lista 2 mayor", "Listas iguales")
Tener en cuenta que puede haber dos o más estructuras repetitivas en un algoritmo.
Desarrollar un programa que permita cargar n números enteros y luego nos informe cuántos valores fueron pares y
cuántos impares.
Emplear el operador ?%? en la condición de la estructura condicional:
If valor Mod 2=0 Then //Si el if da verdadero luego es par.
Solución
Module Module1

Sub Main()
Dim x, nota, conta1, conta2 As Integer
x = 1
conta1 = 0
conta2 = 0
Do While x <= 10
Console.Write("Ingrese nota:")
nota = Console.ReadLine()
If nota >= 7 Then
conta1 = conta1 + 1
Else
conta2 = conta2 + 1
End If
x = x + 1
Loop
Console.Write("Cantidad de alumnos con notas mayores o iguales a
7:")
Console.WriteLine(conta1)
Console.Write("Cantidad de alumons con notas menores a 7:")

Página 32 de 190
 Console.Write(conta2)
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim n, x As Integer
Dim altura, suma, promedio As Single
Console.Write("Cuantas personas hay:")
n = Console.ReadLine()
x = 1
suma = 0
Do While x <= n
Console.Write("Ingrese la altura:")
altura = Console.ReadLine()
suma = suma + altura
x = x + 1
Loop
promedio = suma / n
Console.Write("Altura promedio:")
Console.Write(promedio)
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim n, x, conta1, conta2 As Integer
Dim sueldo, gastos As Single
Console.Write("Cuantos empleados tiene la empresa:")
n = Console.ReadLine()
x = 1
conta1 = 0
conta2 = 0
gastos = 0
Do While x <= n
Console.Write("Ingrese el sueldo del empleado:")
sueldo = Console.ReadLine()
If sueldo <= 300 Then
conta1 = conta1 + 1
Else
conta2 = conta2 + 1
End If
gastos = gastos + sueldo
x = x + 1
Loop
Console.Write("Cantidad de empleados con sueldos entre 100 y
300:")
Console.WriteLine(conta1)
Console.Write("Cantidad de empleados con sueldos mayor a 300:")
Console.WriteLine(conta2)

Página 33 de 190
 Console.Write("Gastos total de la empresa en sueldos:")
Console.WriteLine(gastos)
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim x, termino As Integer
x = 1
termino = 11
Do While x <= 25
Console.Write(termino)
Console.Write(" - ")
x = x + 1
termino = termino + 11
Loop
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim mult8 As Integer
mult8 = 8
Do While mult8 <= 500
Console.Write(mult8)
Console.Write(" - ")
mult8 = mult8 + 8
Loop
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim valor, x, suma1, suma2 As Integer
x = 1
suma1 = 0
suma2 = 0
Console.WriteLine("Primer lista")
Do While x <= 15
Console.Write("Ingrese valor:")
valor = Console.ReadLine()
suma1 = suma1 + valor
x = x + 1
Loop
Console.WriteLine("Segunda lista")
x = 1
Do While x <= 15

Página 34 de 190
 Console.Write("Ingrese valor:")
valor = Console.ReadLine()
suma2 = suma2 + valor
x = x + 1
Loop
If suma1 > suma2 Then
Console.Write("Lista 1 mayor.")
Else
If suma2 > suma1 Then
Console.Write("Lista2 mayor.")
Else
Console.Write("Listas iguales.")
End If
End If
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim n, x, valor, pares, impares As Integer
x = 1
pares = 0
impares = 0
Console.Write("Cuantos números ingresará:")
n = Console.ReadLine()
Do While x <= n
Console.Write("Ingrese el valor:")
valor = Console.ReadLine()
If valor Mod 2 = 0 Then
pares = pares + 1
Else
impares = impares + 1
End If
x = x + 1
Loop
Console.Write("Cantadad de pares:")
Console.WriteLine(pares)
Console.Write("Cantidad de impares:")
Console.Write(impares)
Console.ReadKey()
End Sub

End Module
10 - Estructura repetitiva Do ... Loop While (condición)

La estructura Do ... Loop While (condición) permite ejecutar al menos una vez su bloque repetitivo, a diferencia del
Do While (condición) ... Loop que puede no ejecutar el bloque.
Esta estructura repetitiva se utiliza cuando conocemos de antemano que por lo menos una vez se ejecutará el
bloque repetitivo.
La condición de la estructura está abajo del bloque a repetir, a diferencia del Do While (condición) ... Loop que está
en la parte superior.
Representación gráfica:

Página 35 de 190
El bloque de operaciones se repite MIENTRAS que la condición sea Verdadera.
Si la condición retorna Falso el ciclo se detiene.
Es importante analizar y ver que las operaciones se ejecutan como mínimo una vez.
Problema 1:
Escribir un programa que solicite la carga de un número entre 0 y 999, y nos muestre un mensaje de cuántos dígitos
tiene el mismo. Finalizar el programa cuando se cargue el valor 0.
Diagrama de flujo:

No hay que confundir los rombos de las estructuras condicionales con los de las estructuras repetitivas.
En este problema por lo menos se carga un valor. Si se carga un valor mayor o igual a 100 se trata de un número de
tres cifras, si es mayor o igual a 10 se trata de un valor de dos dígitos, en caso contrario se trata de un valor de un
dígito. Este bloque se repite mientras se ingresa en la variable valor un número distinto a cero. Cuando se ingresa el
cero la condición del ciclo repetitivo se evalúa falsa y por lo tanto sale del bloque repetitivo.
Programa:
Module Module1

Sub Main()
Dim valor As Integer
Do
Console.Write("Ingrese un valor entre 0 y 999 (0
finaliza):")
valor = Console.ReadLine()
If valor >= 100 Then
Console.WriteLine("Tiene 3 dígitos.")

Página 36 de 190
 Else
If valor >= 10 Then
Console.WriteLine("Tiene 2 dígitos.")
Else
Console.WriteLine("Tiene 1 dígito.")
End If
End If
Loop While (valor <> 0)
End Sub

End Module
Problema 2:
Escribir un programa que solicite la carga de números por teclado, obtener su promedio. Finalizar la carga de valores
cuando se cargue el valor 0.
Cuando la finalización depende de algún valor ingresado por el operador conviene el empleo de la estructura Do ...
Loop While (condición), por lo menos se cargará un valor (en el caso más extremo se carga 0, que indica la
finalización de la carga de valores)
Diagrama de flujo:

Es importante analizar este diagrama de flujo.

Definimos un contador cant que cuenta la cantidad de valores ingresados por el operador (no lo incrementa si
ingresamos 0)
El valor 0 no es parte de la serie de valores que se deben sumar.
Definimos el acumulador suma que almacena todos los valores ingresados por teclado.
La estructura repetitiva Do ... Loop While (condición) se repite mientras se ingrese un valor distinto a 0. Con el valor
cero la condición del ciclo retorna falso y continúa con el flujo del diagrama.
Disponemos por último una estructura condicional para el caso que el operador cargue únicamente un 0 y por lo
tanto no podemos calcular el promedio ya que no existe la división por 0.
En caso que el contador cant tenga un valor distinto a 0 el promedio se obtiene dividiendo el acumulador suma por
el contador cant que tiene la cantidad de valores ingresados antes de introducir el 0.

Página 37 de 190
Programa:
Module Module1

Sub Main()
Dim suma, cant, valor, promedio As Integer
suma = 0
cant = 0
Do
Console.Write("Ingrese un valor (0 para finalizar):")
valor = Console.ReadLine()
If valor <> 0 Then
suma = suma + valor
cant = cant + 1
End If
Loop While valor <> 0
If cant <> 0 Then
promedio = suma / cant
Console.Write("El promedio de los valores ingresados es:")
Console.Write(promedio)
Else
Console.Write("No se ingresaron valores.")
End If
Console.ReadKey()
End Sub

End Module
El contador cant DEBE inicializarse antes del ciclo, lo mismo que el acumulador suma. El promedio se calcula siempre
y cuando el contador cant sea distinto a 0.
Problema 3:
Realizar un programa que permita ingresar el peso (en kilogramos) de piezas. El proceso termina cuando ingresamos
el valor 0. Se debe informar:
a) Cuántas piezas tienen un peso entre 9,8 Kg. y 10,2 Kg.?, cuántas con más de 10,2 Kg.? y cuántas con menos de 9,8
Kg.?
b) La cantidad total de piezas procesadas.
Diagrama de flujo:

Página 38 de 190
Los tres contadores cont1, cont2, y cont3 se inicializan en 0 antes de entrar a la estructura repetitiva.
A la variable suma no se la inicializa en 0 porque no es un acumulador, sino que guarda la suma del contenido de las
variables cont1, cont2 y cont3.
La estructura se repite mientrasno se ingrese el valor 0 en la variable peso. Este valor no se lo considera un peso
menor a 9,8 Kg., sino que indica que ha finalizado la carga de valores por teclado.
Programa:
Module Module1

Sub Main()
Dim cant1, cant2, cant3, suma As Integer
Dim peso As Single
cant1 = 0
cant2 = 0
cant3 = 0
Do
Console.Write("Ingrese el peso de la pieza (0 pera
finalizar):")
peso = Console.ReadLine()
If peso > 10.2 Then
cant1 = cant1 + 1
Else
If peso >= 9.8 Then
cant2 = cant2 + 1
Else
If peso > 0 Then
cant3 = cant3 + 1
End If
End If
End If
Loop While peso <> 0
suma = cant1 + cant2 + cant3
Console.Write("Piezas aptas:")
Console.WriteLine(cant2)
Console.Write("Piezas con un peso superior a 10,2:")
Console.WriteLine(cant1)
Console.Write("Piezas con un peso inferior a 9,8:")
Console.WriteLine(cant3)
Console.ReadKey()
End Sub

End Module
Problemas propuestos
Realizar un programa que acumule (sume) valores ingresados por teclado hasta ingresar el 9999 (no sumar dicho
valor, indica que ha finalizado la carga). Imprimir el valor acumulado e informar si dicho valor es cero, mayor a cero o
menor a cero.
En un banco se procesan datos de las cuentas corrientes de sus clientes. De cada cuenta corriente se conoce:
número de cuenta y saldo actual. El ingreso de datos debe finalizar al ingresar un valor negativo en el número de
cuenta.
Se pide confeccionar un programa que lea los datos de las cuentas corrientes e informe:
a)De cada cuenta: número de cuenta y estado de la cuenta según su saldo, sabiendo que:
Estado de la cuenta 'Acreedor' si el saldo es >0.
'Deudor' si el saldo es <0.
'Nulo' si el saldo es =0.
b) La suma total de los saldos acreedores.
Solución
Module Module1

Página 39 de 190
 Sub Main()
Dim suma, valor As Integer
suma = 0
Do
Console.Write("Ingrese un valor:")
valor = Console.ReadLine()
If valor <> 9999 Then
suma = suma + valor
End If
Loop While (valor <> 9999)
Console.Write("El valor acumulado es ")
Console.WriteLine(suma)
If suma = 0 Then
Console.WriteLine("El valor acumulado es cero.")
Else
If suma > 0 Then
Console.WriteLine("El valor acumulado es positivo.")
Else
Console.WriteLine("El valor acumulado es negativo")
End If
End If
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim cuenta As Integer
Dim saldo, suma As Single
suma = 0
Do
Console.Write("Ingrese número de cuenta:")
cuenta = Console.ReadLine()
If cuenta >= 0 Then
Console.Write("Ingrese saldo:")
saldo = Console.ReadLine()
If saldo > 0 Then
Console.WriteLine("Saldo Acreedor.")
suma = suma + saldo
Else
If saldo < 0 Then
Console.WriteLine("Saldo Deudor.")
Else
Console.WriteLine("Saldo Nulo.")
End If
End If
End If
Loop While cuenta >= 0
Console.Write("Total de saldos Acreedores:")
Console.Write(suma)
Console.ReadKey()
End Sub

Página 40 de 190
End Module
11 - Estructura repetitiva For... Next

Cualquier problema que requiera una estructura repetitiva se puede resolver empleando la estructura Do While
(condición) ... Loop. Pero hay otra estructura repetitiva cuyo planteo es más sencillo en ciertas situaciones.
En general, la estructura For... Next se usa en aquellas situaciones en las cuales CONOCEMOS la cantidad de veces
que queremos que se ejecute el bloque de instrucciones. Ejemplo: cargar 10 números, ingresar 5 notas de alumnos,
etc. Conocemos de antemano la cantidad de veces que queremos que el bloque se repita.
Representación gráfica:

En su forma más típica y básica, esta estructura requiere una variable que cumple la función de un CONTADOR de
vueltas. El primer valor que indicamos es el valor inicial que toma el contador. Cada vez que se ejecuta el bloque a
repetir el contador se incrementa en uno y si no supera el valor final especificado en el For vuelve a ejecutar el
bloque.
Si conocemos la cantidad de veces que se repite el bloque es muy sencillo emplear un For, por ejemplo si queremos
que se repita 50 veces el bloque de instrucciones puede hacerse así:

La variable del For puede tener cualquier nombre. En este ejemplo se la ha definido con el nombre f.
Analicemos el ejemplo:
- La variable f toma inicialmente el valor 1.
- Se ejecutan la/s operación/es.
- Al finalizar de ejecutarlas automáticamente se incrementa en 1 el contador f.
- Si el contador f no supera a 50 vuelve a ejecutar el bloque.
- El proceso se repetirá hasta que la variable f llegue al valor 51.
En este momento finaliza el ciclo repetitivo.
La variable f no conviene modificarla dentro del For.
La variable f puede ser inicializada en cualquier valor y finalizar en cualquier valor.
Problema 1:
Realizar un programa que imprima en pantalla los números del 1 al 100.
Diagrama de flujo:

Inicialmente f vale 1 y como no es superior a 100 se ejecuta el bloque, imprimimos el contenido de f, al finalizar el
bloque repetitivo se incrementa la variable f en 1, como 2 no es superior a 100 se repite el bloque de instrucciones.
Cuando la variable del For llega a 101 sale de la estructura repetitiva y continúa la ejecución del algoritmo que se
indica después del círculo.
La variable f (o como sea que se decida llamarla) debe estar definida como una variable más.

Página 41 de 190
Programa:
Module Module1

Sub Main()
Dim f As Integer
For f = 1 To 100
Console.Write(f)
Console.Write("-")
Next
Console.ReadKey()
End Sub

End Module
El comienzo del bloque For es:
For f = 1 To 100
f previamente está definida como variable entera.
El ciclo repetitivo For finaliza con la palabra clave:
Next
La ejecución del programa da como resultado la siguiente pantalla:

Problema 2:
: Desarrollar un programa que permita la carga de 10 valores por teclado y nos muestre posteriormente la suma de
los valores ingresados y su promedio. Este problema ya lo desarrollamos, lo resolveremos empleando la estructura
for.
Diagrama de flujo:

En este caso, a la variable del for (f) sólo se la requiere para que se repita el bloque de instrucciones 10 veces.

Página 42 de 190
Programa:
Module Module1

Sub Main()
Dim suma, f, valor, promedio As Integer
suma = 0
For f = 1 To 10
Console.Write("Ingrese valor:")
valor = Console.ReadLine()
suma = suma + valor
Next
Console.Write("La suma es:")
Console.WriteLine(suma)
promedio = suma / 10
Console.Write("El promedio es:")
Console.Write(promedio)
Console.ReadKey()
End Sub

End Module
El problema requiere que se carguen 10 valores y se sumen los mismos.
El promedio se calcula fuera del For luego de haber cargado los 10 valores.
Problema 3:
Escribir un programa que solicite por teclado 10 notas de alumnos y nos informe cuántos tienen notas mayores o
iguales a 7 y cuántos menores.
Para resolver este problema se requieren tres contadores:
aprobados (Cuenta la cantidad de alumnos aprobados)
reprobados (Cuenta la cantidad de reprobados)
f (es el contador del For)
Dentro de la estructura repetitiva debemos hacer la carga de la variable nota y verificar con una estructura
condicional si el contenido de la variable nota es mayor o igual a 7 para incrementar el contador aprobados, en caso
de que la condición retorne falso debemos incrementar la variable reprobados.
Diagrama de flujo:

Página 43 de 190
Los contadores aprobados y reprobados deben imprimirse FUERA de la estructura repetitiva.
Es fundamental inicializar los contadores aprobados y reprobados en cero antes de entrar a la estructura For.
Importante: Un error común es inicializar los contadores dentro de la estructura repetitiva. En caso de hacer esto
los contadores se fijan en cero en cada ciclo del For, por lo que al finalizar el For como máximo el contador puede
tener el valor 1.
Programa:
Module Module1

Sub Main()
Dim aprobados, reprobados, f, nota As Integer
aprobados = 0
reprobados = 0
For f = 1 To 10
Console.Write("Ingrese la nota:")
nota = Console.ReadLine()
If nota >= 7 Then
aprobados = aprobados + 1
Else
reprobados = reprobados + 1
End If
Next
Console.Write("Cantidad de aprobados:")
Console.WriteLine(aprobados)
Console.Write("Cantidad de reprobados:")
Console.Write(reprobados)
Console.ReadKey()
End Sub

End Module
Definimos todas las variables de tipo entera:
Dim aprobados, reprobados, f, nota As Integer
Iniciamos los dos contadores en cero previo al for:
aprobados = 0
reprobados = 0
El contador del For se inicia con el valor 1:
For f = 1 To 10
Dentro del ciclo For cargamos la nota y según el valor ingresado incrementamos uno de los dos contadores:
Console.Write("Ingrese la nota:")
nota = Console.ReadLine()
If nota >= 7 Then
aprobados = aprobados + 1
Else
reprobados = reprobados + 1
End If
Fuera del ciclo For procedemos a mostrar la cantidad de aprobados y reprobados:
Console.Write("Cantidad de aprobados:")
Console.WriteLine(aprobados)
Console.Write("Cantidad de reprobados:")
Console.Write(reprobados)
Problema 4:
Escribir un programa que lea 10 números enteros y luego muestre cuántos valores ingresados fueron múltiplos de 3
y cuántos de 5. Debemos tener en cuenta que hay números que son múltiplos de 3 y de 5 a la vez.
Diagrama de flujo:

Página 44 de 190
Tengamos en cuenta que el operador matemático Mod retorna el resto de dividir un valor por otro, en este caso:
valor Mod 3 retorna el resto de dividir el valor que ingresamos por teclado, por tres.
Veamos: si ingresamos 6 el resto de dividirlo por 3 es 0, si ingresamos 12 el resto de dividirlo por 3 es 0.
Generalizando: cuando el resto de dividir por 3 al valor que ingresamos por teclado es cero, se trata de un múltiplo
de dicho valor.
Ahora bien ¿por qué no hemos dispuesto una estructura If anidada? Porque hay valores que son múltiplos de 3 y de
5 a la vez. Por lo tanto con If anidados no podríamos analizar los dos casos.
Es importante darse cuenta cuando conviene emplear If anidados y cuando no debe emplearse.
Programa:
Module Module1

Sub Main()
Dim mul3, mul5, valor, f As Integer
mul3 = 0
mul5 = 0
For f = 1 To 10
Console.Write("Ingrese un valor:")
valor = Console.ReadLine()
If valor Mod 3 = 0 Then
mul3 = mul3 + 1
End If
If valor Mod 5 = 0 Then
mul5 = mul5 + 1
End If
Next
Console.Write("Cantidad de valores ingresados múltiplos de 3:")
Console.WriteLine(mul3)
Console.Write("Cantidad de valores ingresados múltiplos de 5:")

Página 45 de 190
 Console.Write(mul5)
Console.ReadKey()
End Sub

End Module
El If para verificar si el valor cargado es múltiplo de 3 (el contador mul3 lo iniciamos en cero antes del For):
If valor Mod 3 = 0 Then
mul3 = mul3 + 1
End If
Problema 5:
Escribir un programa que lea n números enteros y calcule la cantidad de valores mayores o iguales a 1000.
Este tipo de problemas también se puede resolver empleando la estructura repetitiva for. Lo primero que se hace es
cargar una variable que indique la cantidad de valores a ingresar. Dicha variable se carga antes de entrar a la
estructura repetitiva For.
La estructura For permite que el valor inicial o final dependa de una variable cargada previamente por teclado.
Diagrama de flujo:

Tenemos un contador llamado cantidad y f que es el contador del For.

La variable entera n se carga previo al inicio del For, por lo que podemos fijar el valor final del for con la variable n, es
decir previo a que inicie el For ya sabemos la cantidad de veces que debe repetirse.
Por ejemplo si el operador carga 5 en n la estructura repetitiva For se ejecutará 5 veces.
La variable valor se ingresa dentro de la estructura repetitiva, y se verifica si el valor de la misma es mayor o igual a
1000, en dicho caso se incrementa en uno el contador cantidad.
Fuera de la estructura repetitiva imprimimos el contador cantidad que tiene almacenado la cantidad de valores
ingresados mayores o iguales a 1000.
Programa:
Module Module1

Sub Main()
Dim cantidad, n, f, valor As Integer
cantidad = 0
Console.Write("Cuantos valores ingresará:")
n = Console.ReadLine()
For f = 1 To n
Console.Write("Ingrese el valor:")
valor = Console.ReadLine()
If valor >= 1000 Then
cantidad = cantidad + 1
End If

Página 46 de 190
 Next
Console.Write("La cantidad de valores ingresados mayores o
iguales a 1000 son:")
Console.Write(cantidad)
Console.ReadKey()
End Sub

End Module
Otra variante de la estructura repetitiva For...Next
Podemos en ciertos casos hacer que el contador del for se incremente en un valor distinto a uno.
Veamos como sería el programa para imprimir los números de 1 al 3 pero incrementando en 0,25 cada paso:
Module Module1

Sub Main()
Dim f As Single
For f = 1 To 3 Step 0.25
Console.Write(f)
Console.Write(" - ")
Next
Console.ReadKey()
End Sub

End Module

El contador del For es una variable de tipo Single (es decir podemos guardar valores con decimal)
Aparece la nueva palabra clave Step dentro del For que le indica cuanto debe modificarse el contador en cada vuelta
(cuando no indicamos Step luego el incremento por defecto es 1):
For f = 1 To 3 Step 0.25
Problemas propuestos
Ha llegado nuevamente la parte fundamental, que es el momento donde uno desarrolla individualmente un
algoritmo para la resolución de un problema.
Confeccionar un programa que lea n pares de datos, cada par de datos corresponde a la medida de la base y la altura
de un triángulo. El programa deberá informar:
a) De cada triángulo la medida de su base, su altura y su superficie.
b) La cantidad de triángulos cuya superficie es mayor a 12.
Desarrollar un programa que solicite la carga de 10 números e imprima la suma de los últimos 5 valores ingresados.
Desarrollar un programa que muestre la tabla de multiplicar del 5 (del 5 al 50)
Confeccionar un programa que permita ingresar un valor del 1 al 10 y nos muestre la tabla de multiplicar del mismo
(los primeros 12 términos)
Ejemplo: Si ingreso 3 deberá aparecer en pantalla los valores 3, 6, 9, hasta el 36.
Realizar un programa que lea los lados de n triángulos, e informar:
a) De cada uno de ellos, qué tipo de triángulo es: equilátero (tres lados iguales), isósceles (dos lados iguales), o
escaleno (ningún lado igual)
b) Cantidad de triángulos de cada tipo.
Escribir un programa que pida ingresar coordenadas (x,y) que representan puntos en el plano.
Informar cuántos puntos se han ingresado en el primer, segundo, tercer y cuarto cuadrante. Al comenzar el
programa se pide que se ingrese la cantidad de puntos a procesar.
Se realiza la carga de 10 valores enteros por teclado. Se desea conocer:
a) La cantidad de valores ingresados negativos.
b) La cantidad de valores ingresados positivos.

Página 47 de 190
c) La cantidad de múltiplos de 15.
d) El valor acumulado de los números ingresados que son pares.
Se cuenta con la siguiente información:
Las edades de 50 estudiantes del turno mañana.
Las edades de 60 estudiantes del turno tarde.
Las edades de 110 estudiantes del turno noche.
Las edades de cada estudiante deben ingresarse por teclado.
a) Obtener el promedio de las edades de cada turno (tres promedios)
b) Imprimir dichos promedios (promedio de cada turno)
c) Mostrar por pantalla un mensaje que indique cual de los tres turnos tiene un promedio de edades mayor.
Solución
Module Module1

Sub Main()
Dim basetri, altura, superficie, cantidad, f, n As Integer
cantidad = 0
Console.Write("Cuantos triángulos procesará:")
n = Console.ReadLine()
For f = 1 To n
Console.Write("Ingrese el valor de la base:")
basetri = Console.ReadLine()
Console.Write("Ingrese el valor de la altura:")
altura = Console.ReadLine()
superficie = basetri * altura / 2
Console.Write("La superficie es:")
Console.WriteLine(superficie)
If superficie > 12 Then
cantidad = cantidad + 1
End If
Next
Console.Write("La cantidad de triángulos con superficie superior
a 12 son:")
Console.Write(cantidad)
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim f, valor, suma As Integer
suma = 0
For f = 1 To 10
Console.Write("Ingrese un valor:")
valor = Console.ReadLine()
If f > 5 Then
suma = suma + valor
End If
Next
Console.Write("La suma de los últimos 5 valores es:")
Console.Write(suma)
Console.ReadKey()
End Sub

End Module

Página 48 de 190
Module Module1

Sub Main()
Dim f, tabla As Integer
For f = 1 To 10
tabla = f * 5
Console.Write(tabla)
Console.Write("-")
Next
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim f, valor, tabla As Integer
Console.Write("Ingrese un valor entre 1 y 10:")
valor = Console.ReadLine()
For f = 1 To 12
tabla = valor * f
Console.Write(tabla)
Console.Write("-")
Next
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim f, lado1, lado2, lado3, cant1, cant2, cant3, n As Integer
cant1 = 0
cant2 = 0
cant3 = 0
Console.Write("Ingrese la cantidad de triángulos:")
n = Console.ReadLine()
For f = 1 To n
Console.Write("Ingrese lado 1:")
lado1 = Console.ReadLine()
Console.Write("Ingrese lado 2:")
lado2 = Console.ReadLine()
Console.Write("Ingrese lado 3:")
lado3 = Console.ReadLine()
If lado1 = lado2 And lado1 = lado3 Then
Console.WriteLine("Es un triángulo equilatero.")
cant1 = cant1 + 1
Else
If lado1 = lado2 Or lado1 = lado3 Or lado2 = lado3 Then
Console.WriteLine("Es un triángulo isósceles.")
cant2 = cant2 + 1
Else
cant3 = cant3 + 1
Console.WriteLine("Es un triángulo escaleno.")

Página 49 de 190
 End If
End If
Next
Console.Write("Cantidad de triángulos equilateros:")
Console.WriteLine(cant1)
Console.Write("Cantidad de triángulos isósceles:")
Console.WriteLine(cant2)
Console.Write("Cantidad de triángulos escalenos:")
Console.WriteLine(cant3)
Console.ReadKey()
End Sub
End Module

Module Module1

Sub Main()
Dim n, f, x, y, cant1, cant2, cant3, cant4 As Integer
cant1 = 0
cant2 = 0
cant3 = 0
cant4 = 0
Console.Write("Cantidad de puntos:")
n = Console.ReadLine()
For f = 1 To n
Console.Write("Ingrese coordenada x:")
x = Console.ReadLine()
Console.Write("Ingrese coordenada y:")
y = Console.ReadLine()
If x > 0 And y > 0 Then
cant1 = cant1 + 1
Else
If x < 0 And y > 0 Then
cant2 = cant2 + 1
Else
If x < 0 And y < 0 Then
cant3 = cant3 + 1
Else
If x > 0 And y < 0 Then
cant4 = cant4 + 1
End If
End If
End If
End If
Next
Console.Write("Cantidad de puntos en el primer cuadrante:")
Console.WriteLine(cant1)
Console.Write("Cantidad de puntos en el segundo cuadrante:")
Console.WriteLine(cant2)
Console.Write("Cantidad de puntos en el tercer cuadrante:")
Console.WriteLine(cant3)
Console.Write("Cantidad de puntos en el cuarto cuadrante:")
Console.WriteLine(cant4)
Console.ReadKey()
End Sub

End Module

Página 50 de 190
Module Module1

Sub Main()
Dim f, valor, negativos, positivos, mult15, sumapares As Integer
negativos = 0
positivos = 0
mult15 = 0
sumapares = 0
For f = 1 To 10
Console.Write("Ingrese valor:")
valor = Console.ReadLine()
If valor < 0 Then
negativos = negativos + 1
Else
If valor > 0 Then
positivos = positivos + 1
End If
End If
If valor Mod 15 = 0 Then
mult15 = mult15 + 1
End If
If valor Mod 2 = 0 Then
sumapares = sumapares + valor
End If
Next
Console.Write("Cantidad de valores negativos:")
Console.WriteLine(negativos)
Console.Write("Cantidad de valores positivos:")
Console.WriteLine(positivos)
Console.Write("Cantidad de valores múltiplos de 15:")
Console.WriteLine(mult15)
Console.Write("Suma de los valores pares:")
Console.WriteLine(sumapares)
Console.ReadKey()
End Sub

End Module

Module Module1

Sub Main()
Dim f, edad, suma1, suma2, suma3, pro1, pro2, pro3 As Integer
suma1 = 0
suma2 = 0
suma3 = 0
For f = 1 To 50
Console.Write("Ingrese edad:")
edad = Console.ReadLine()
suma1 = suma1 + edad
Next
pro1 = suma1 / 50
Console.Write("Promedio de edades del turno mañana:")
Console.WriteLine(pro1)
For f = 1 To 60
Console.Write("Ingrese edad:")

Página 51 de 190
 edad = Console.ReadLine()
suma2 = suma2 + edad
Next
pro2 = suma2 / 60
Console.Write("Promedio de edades del turno tarde:")
Console.WriteLine(pro2)
For f = 1 To 110
Console.Write("Ingrese edad:")
edad = Console.ReadLine()
suma3 = suma3 + edad
Next
pro3 = suma3 / 110
Console.Write("Promedio de edades del turno noche:")
Console.WriteLine(pro3)
If pro1 < pro2 And pro1 < pro3 Then
Console.Write("El turno mañana tiene un promedio menor de
edades.")
Else
If pro2 < pro3 Then
Console.Write("El turno tarde tiene un promedio menor de
edades.")
Else
Console.Write("El turno noche tiene un promedio menor de
edades.")
End If
End If
Console.ReadKey()
End Sub

End Module
12 - Cadenas de caracteres

En Visual Basic .Net hemos visto que cuando queremos almacenar un valor entero definimos una variable
de tipo Ingeger, si queremos almacenar un valor con decimales definimos una variable de tipo Single.
Ahora si queremos almacenar una cadena de caracteres (por ejemplo un nombre de una persona)
debemos definir una variable de tipo String.
Más adelante veremos en profundidad y detenimiento los conceptos del manejo de String, por ahora solo
nos interesa la mecánica para trabajar con cadenas de caracteres.
Problema 1:
Solicitar el ingreso del nombre y edad de dos personas. Mostrar el nombre de la persona con mayor edad.
Programa:
Module Module1

Sub Main()
Dim nombre1, nombre2 As String
Dim edad1, edad2 As Integer
Console.Write("Ingrese el nombre:")
nombre1 = Console.ReadLine()
Console.Write("Ingrese edad:")
edad1 = Console.ReadLine()
Console.Write("Ingrese el nombre:")
nombre2 = Console.ReadLine()
Console.Write("Ingrese edad:")
edad2 = Console.ReadLine()
Console.Write("La persona de mayor edad es:")

Página 52 de 190
 If edad1 = edad2 Then
Console.Write("Tienen la misma edad")
Else
If (edad1 > edad2) Then
Console.Write(nombre1)
Else
Console.Write(nombre2)
End If
End If
Console.ReadKey()
End Sub

End Module

Para almacenar un nombre debemos definir una variable de tipo String y su ingreso por teclado se hace
llamando al método ReadLine del objeto Console:
nombre1 = Console.ReadLine()
Problema 2:
Solicitar el ingreso de dos nombres de personas. Mostrar un mensaje si son iguales o distintos.
Programa:
Module Module1

Sub Main()
Dim nombre1, nombre2 As String
Console.Write("Ingrese primer nombre:")
nombre1 = Console.ReadLine()
Console.Write("Ingrese segundo segundo:")
nombre2 = Console.ReadLine()
If nombre1 = nombre2 Then
Console.Write("Los nombres son iguales")
Else
Console.Write("Los nombres son distintos")
End If
Console.ReadKey()
End Sub

End Module
Para comparar si el contenido de dos String son iguales se utiliza el operador = como si se estuvieran comparando
dos enteros.
La condición se verifica verdadero si los contenidos de los dos String son exactamente iguales, es decir si cargamos
"Martinez" en nombre1 y "martinez" en nombre2 luego retorna falso ya que no es lo mismo la "M" mayúscula y la
"m" minúscula.
En el caso que necesitemos considerar igual caracteres mayúsculas y minúsculas veremos más adelante como
resolverlo
También funcionan los otros operadores relacionales con el manejo de cadenas de caracteres:
> (mayor) (el primer String es mayor alfabéticamente que el segundo)
< (menor)
>= (mayor o igual)
<= (menor o igual)
= (igual)
<> (distinto)
13 - Declaración de una clase y definición de un objeto de dicha clase

La programación orientada a objetos se basa en la programación de clases.

Una clase es un molde del que luego se pueden crear múltiples objetos, con similares características.

Página 53 de 190
Una clase es una plantilla (molde), que define atributos (variables) y métodos (son los procedimientos)
La clase define los atributos y métodos comunes a los objetos de ese tipo, pero luego, cada objeto tendrá sus
propios valores y compartirán las mismas funciones.
Debemos crear una clase antes de poder crear objetos (instancias) de esa clase. Al crear un objeto de una clase, se
dice que se crea una instancia de la clase o un objeto propiamente dicho.
La estructura de una clase es:
Public Class [nombre de la clase]
[atributos o variables de la clase]
[métodos o procedimientos de la clase]
End Class

Cuando un algoritmo comienza a ser más complejo no podemos codificar todo en el procedimiento Main:
Sub Main()
....
End Sub
Vamos a ver como dividir dicho algoritmo en distintos procedimientos y luego llamarlos desde la Main.
Iremos haciendo una serie de problemas para introducir los conceptos de programación orientada a objetos y ver
como organizar el algoritmo dentro de una clase.
Problema 1:
Confeccionar una clase que permita cargar el nombre y la edad de una persona. Mostrar los datos cargados.
Imprimir un mensaje si es mayor de edad (edad>=18)
Si bien este algoritmo es muy pequeño y lo podemos resolver todo en el procedimiento Main como veníamos
trabajando lo que vamos a hacer es plantear una clase que resuelva este problema.
En un principio veremos que parece mucho más complejo pero más adelante veremos que esta forma de organizar
un algoritmo mediante clases nos facilita el planteo sobre todo si el problema es más complejo.
Programa:
Module Module1

Public Class Persona

Private nombre As String
Private edad As Integer

Public Sub Inicializar()

Console.Write("Ingrese el nombre:")
nombre = Console.ReadLine()
Console.Write("Ingrese la edad:")
edad = Console.ReadLine()
End Sub

Public Sub Imprimir()

Console.Write("Nombre:")
Console.WriteLine(nombre)
Console.Write("Edad:")
Console.WriteLine(edad)
End Sub

Public Sub EsMayorEdad()

If edad >= 18 Then
Console.Write("Es mayor de edad")
Else
Console.Write("No es mayor de edad")
End If
Console.ReadKey()
End Sub
End Class

Página 54 de 190
 Sub Main()
Dim per1 As Persona
per1 = New Persona()
per1.Inicializar()
per1.Imprimir()
per1.EsMayorEdad()
End Sub

End Module
El nombre de la clase debe hacer referencia al concepto (en este caso la hemos llamado Persona):
Public Class Persona
Los atributos(variables) los definimos dentro de la clase (no usamos la palabra clave Dim):
Private nombre As String
Private edad As Integer
Veremos más adelante que un atributo es normalmente definido con la cláusula Private (con esto no permitimos el
acceso al atributo desde otras clases)
A los atributos se tiene acceso desde cualquier método de la clase. En nuestro problema definimos tres métodos
dentro de la clase Persona: Inicializar, Imprimir y EsMayorEdad.
Luego de definir los atributos de la clase debemos declarar los métodos o funciones de la clase. La sintaxis es
parecida al procedimineto Main (con la cláusula Public):
Public Sub Inicializar()
Console.Write("Ingrese el nombre:")
nombre = Console.ReadLine()
Console.Write("Ingrese la edad:")
edad = Console.ReadLine()
End Sub
En el método inicializar (que será el primero que deberemos llamar desde la Main) cargamos por teclado los
atributos nombre y edad. Como podemos ver el método inicializar puede hacer acceso a los atributos de la clase
Persona.
El segundo método tiene por objetivo imprimir el contenido de los atributos nombre y edad (los datos de los
atributos se cargaron al ejecutarse previamente el método inicializar:
Public Sub Imprimir()
Console.Write("Nombre:")
Console.WriteLine(nombre)
Console.Write("Edad:")
Console.WriteLine(edad)
End Sub
El tercer método tiene por objetivo mostrar un mensaje si la persona es mayor o no de edad:
Public Sub EsMayorEdad()
If edad >= 18 Then
Console.Write("Es mayor de edad")
Else
Console.Write("No es mayor de edad")
End If
Console.ReadKey()
End Sub
Por último en la Main declaramos un objeto de la clase Persona y llamamos a los métodos en un orden adecuado:
Sub Main()
Dim per1 As Persona
per1 = New Persona()
per1.Inicializar()
per1.Imprimir()
per1.EsMayorEdad()
End Sub

Página 55 de 190
El procedimiento Sub Main() se encuentra fuera de la clase Persona. Este procedimiento Main es el que primero que
se ejecuta al iniciar todo programa en Visual Basic.
Para definir y crear un objeto de la clase persona debemos utilizar la palabra clave Dim y el operador New para
crearlo:
Dim per1 As Persona
per1 = New Persona()
Luego de creado el objeto per1 de la clase Persona podemos llamar a sus métodos en un orden lógico:
per1.Inicializar()
per1.Imprimir()
per1.EsMayorEdad()
Problema 2:
Desarrollar un programa que cargue los lados de un triángulo e implemente los siguientes métodos: inicializar los
atributos, imprimir el valor del lado mayor y otro método que muestre si es equilátero o no.
Programa:
Module Module1
Public Class Triangulo

Private lado1 As Integer

Private lado2 As Integer
Private lado3 As Integer

Public Sub Inicializar()

Console.Write("Medida lado 1:")
lado1 = Console.ReadLine()
Console.Write("Medida lado 2:")
lado2 = Console.ReadLine()
Console.Write("Medida lado 3:")
lado3 = Console.ReadLine()
End Sub

Public Sub LadoMayor()

Console.Write("Lado mayor:")
If lado1 > lado2 And lado1 > lado3 Then
Console.WriteLine(lado1)
Else
If lado2 > lado3 Then
Console.WriteLine(lado2)
Else
Console.WriteLine(lado3)
End If
End If
End Sub

Public Sub EsEquilatero()

If lado1 = lado2 And lado1 = lado3 Then
Console.Write("Es un triángulo equilátero")
Else
Console.Write("No es un triángulo equilátero")
End If
End Sub
End Class

Sub Main()
Dim triangulo1 As New Triangulo
triangulo1.Inicializar()
triangulo1.LadoMayor()

Página 56 de 190
 triangulo1.EsEquilatero()
Console.ReadKey()
End Sub

End Module
Declaramos una clase llamada Triangulo:
Public Class Triangulo
...
End Class
Este problema requiere definir tres atributos de tipo entero donde almacenamos los valores de los lados
del triángulo:
Private lado1 As Integer
Private lado2 As Integer
Private lado3 As Integer
El primer método que deberá llamarse desde la Main es el Inicializar donde cargamos los tres atributos por
teclado:
Public Sub Inicializar()
Console.Write("Medida lado 1:")
lado1 = Console.ReadLine()
Console.Write("Medida lado 2:")
lado2 = Console.ReadLine()
Console.Write("Medida lado 3:")
lado3 = Console.ReadLine()
End Sub
El método LadoMayor muestra el valor mayor de los tres enteros ingresados:
Public Sub LadoMayor()
Console.Write("Lado mayor:")
If lado1 > lado2 And lado1 > lado3 Then
Console.WriteLine(lado1)
Else
If lado2 > lado3 Then
Console.WriteLine(lado2)
Else
Console.WriteLine(lado3)
End If
End If
End Sub
Como podemos observar cuando un problema se vuelve más complejo es más fácil y ordenado separar los
distintos algoritmos en varios métodos y no codificar todo en la Main.
El último método de esta clase verifica si los tres enteros ingresados son iguales:
Public Sub EsEquilatero()
If lado1 = lado2 And lado1 = lado3 Then
Console.Write("Es un triángulo equilátero")
Else
Console.Write("No es un triángulo equilátero")
End If
End Sub
En la main definimos y creamos un objeto de la clase Triangulo y llamamos los métodos respectivos:
Sub Main()
Dim triangulo1 As New Triangulo
triangulo1.Inicializar()
triangulo1.LadoMayor()

Página 57 de 190
 triangulo1.EsEquilatero()
Console.ReadKey()
End Sub
Lo más común es declarar y crear el objeto de la clase Triangulo en una única línea:
Dim triangulo1 As New Triangulo
La otra forma que vimos en el ejemplo 1 sería con la sintaxis:
Dim triangulo1 As Triangulo
triangulo1=New Triangulo()
Problema 3:
Desarrollar una clase que represente un punto en el plano y tenga los siguientes métodos: cargar los valores de x e y,
imprimir en que cuadrante se encuentra dicho punto (concepto matemático, primer cuadrante si x e y son positivas,
si x<0 e y>0 segundo cuadrante, etc.)
Programa:
Module Module1
Public Class Punto

Private x As Integer
Private y As Integer

Public Sub Inicializar()

Console.Write("Ingrese coordenada x :")
x = Console.ReadLine()
Console.Write("Ingrese coordenada y :")
y = Console.ReadLine()
End Sub

Public Sub ImprimirCuadrante()

If x > 0 And y > 0 Then
Console.Write("Se encuentra en el primer cuadrante.")
Else
If x < 0 And y > 0 Then
Console.Write("Se encuentra en el segundo
cuadrante.")
Else
If x < 0 And y < 0 Then
Console.Write("Se encuentra en el tercer
cuadrante.")
Else
If x > 0 And y < 0 Then
Console.Write("Se encuentra en el cuarto
cuadrante.")
Else
Console.Write("El punto no está en un
cuadrante.")
End If
End If
End If
End If
End Sub

End Class

Sub Main()
Dim punto1 = New Punto()
punto1.Inicializar()
Página 58 de 190
 punto1.ImprimirCuadrante()
Console.ReadKey()
End Sub

End Module
Declaramos la clase Punto:
Public Class Punto
End Class
Definimos dos atributos enteros dentro de la clase Punto (estas valores pueden ser accedidos luego en los métodos
que definamos en la clase):
Public Class Punto

Private x As Integer
Private y As Integer

End Class
El método Inicializar pide cargar las coordenadas x e y:
Public Sub Inicializar()
Console.Write("Ingrese coordenada x :")
x = Console.ReadLine()
Console.Write("Ingrese coordenada y :")
y = Console.ReadLine()
End Sub
El segundo método mediante un conjunto de if verificamos en que cuadrante se encuentra el punto ingresado:
Public Sub ImprimirCuadrante()
If x > 0 And y > 0 Then
Console.Write("Se encuentra en el primer cuadrante.")
Else
If x < 0 And y > 0 Then
Console.Write("Se encuentra en el segundo cuadrante.")
Else
If x < 0 And y < 0 Then
Console.Write("Se encuentra en el tercer cuadrante.")
Else
If x > 0 And y < 0 Then
Console.Write("Se encuentra en el cuarto cuadrante.")
Else
Console.Write("El punto no está en un cuadrante.")
End If
End If
End If
End If
End Sub
La Main no tiene grandes diferencias con los problemas realizados anteriormente, declaramos un objeto llamado
punto1 de la clase Punto, creamos el objeto mediante el operador New y seguidamente llamamos a los métodos
Inicializar e ImprimirCuadrante en ese orden:
Sub Main()
Dim punto1 = New Punto()
punto1.Inicializar()
punto1.ImprimirCuadrante()
Console.ReadKey()
End Sub
Problema 4:

Página 59 de 190
Desarrollar una clase que represente un Cuadrado y tenga los siguientes métodos: cargar el valor de su lado,
imprimir su perímetro y su superficie.
Programa:
Module Module1
Public Class Cuadrado

Private lado As Integer

Public Sub Inicializar()

Console.Write("Ingrese el valor del lado:")
lado = Console.ReadLine()
End Sub

Public Sub ImprimirPerimetro()

Dim perimetro As Integer
perimetro = lado * 4
Console.Write("El perímetro es:")
Console.WriteLine(perimetro)
End Sub

Public Sub ImprimirSuperficie()

Dim superficie As Integer
superficie = lado * lado
Console.Write("La superficie es:")
Console.Write(superficie)
End Sub

End Class

Sub Main()
Dim cuadrado1 As New Cuadrado()
cuadrado1.Inicializar()
cuadrado1.ImprimirPerimetro()
cuadrado1.ImprimirSuperficie()
Console.ReadKey()
End Sub

End Module
En este problema es interesante ver como no definimos dos atributos donde se almacenan la superficie y el
perímetro del cuadrado, esto debido a que solo estos datos se los requiere en el método donde se imprimen (se
definen variables locales a dichos métodos):
Public Sub ImprimirPerimetro()
Dim perimetro As Integer
perimetro = lado * 4
Console.Write("El perímetro es:")
Console.WriteLine(perimetro)
End Sub
Esto significa que la variable perimetro es una variable local al método ImprimirPerimetro. Esta variable es local a
dicho método y solo se la puede acceder dentro del método. La diferencia fundamental entre una variable local y un
atributo de la clase es que al atributo se lo puede acceder desde cualquier método de la clase y la variable local solo
existe mientras se está ejecutando el método.
Problemas propuestos
Confeccionar una clase que represente un empleado. Definir como atributos su nombre y su sueldo. Confeccionar
los métodos para la carga, otro para imprimir sus datos y por último uno que imprima un mensaje si debe pagar
impuestos (si el sueldo supera a 3000)

Página 60 de 190
Implementar la clase Operacion. Se deben cargar dos valores enteros, calcular su suma, resta, multiplicación y
división, cada una en un método, imprimir dichos resultados.
Solución
Module Module1
Public Class Empleado

Private nombre As String

Private sueldo As Single

Public Sub Inicializar()

Console.Write("Ingrese el nombre del empleado:")
nombre = Console.ReadLine()
Console.Write("Ingrese su sueldo:")
sueldo = Console.ReadLine()
End Sub

Public Sub PagaImpuestos()

If sueldo > 3000 Then
Console.WriteLine("Debe abonar impuestos")
Else
Console.WriteLine("No paga impuestos")
End If
End Sub
End Class

Sub Main()
Dim empleado1 As New Empleado()
empleado1.Inicializar()
empleado1.PagaImpuestos()
Console.ReadKey()
End Sub

End Module

Module Module1
Public Class Operaciones

Private valor1 As Integer

Private valor2 As Integer

Public Sub Inicializar()

Console.Write("Ingrese primer valor:")
valor1 = Console.ReadLine()
Console.Write("Ingrese segundo valor:")
valor2 = Console.ReadLine()
End Sub

Public Sub Sumar()

Dim suma As Integer
suma = valor1 + valor2
Console.Write("La suma es:")
Console.WriteLine(suma)
End Sub

Public Sub Restar()

Dim resta As Integer

Página 61 de 190
 resta = valor1 - valor2
Console.Write("La resta es:")
Console.WriteLine(resta)
End Sub

Public Sub Multiplicar()

Dim multiplicacion As Integer
multiplicacion = valor1 * valor2
Console.Write("La multiplicación es:")
Console.WriteLine(multiplicacion)
End Sub

Public Sub dividir()

Dim division As Integer
division = valor1 / valor2
Console.Write("La división es:")
Console.WriteLine(division)
End Sub

End Class

Sub Main()
Dim operacion1 = New Operaciones()
operacion1.Inicializar()
operacion1.Sumar()
operacion1.Restar()
operacion1.Multiplicar()
operacion1.dividir()
Console.ReadKey()
End Sub

End Module
14 - Declaración de métodos con parámetros y/o retorno de datos

Cuando uno plantea una clase en lugar de especificar todo el algoritmo en un único método (lo que hicimos en los
primeros pasos de este tutorial) es dividir todas las responsabilidades de las clase en un conjunto de métodos.
Un método hemos visto que tiene la siguiente sintaxis:
Public Sub [nombre del método]()
[algoritmo]
End Sub
Veremos que hay varios tipos de métodos:
Métodos con parámetros.
Un método puede tener parámetros:
Public Sub [nombre del método]([parámetros])
[algoritmo]
End Sub
Los parámetros los podemos imaginar como variables locales al método, pero su valor se inicializa con datos que
llegan cuando lo llamamos.
Problema 1:
Confeccionar una clase que permita ingresar valores enteros por teclado y nos muestre la tabla de multiplicar de
dicho valor. Finalizar el programa al ingresar el -1.
Programa:
Module Module1

Public Class TablaMultiplicar

Public Sub CargarValor()

Página 62 de 190
 Dim valor As Integer
Do
Console.Write("Ingrese un valor (-1 para finalizar):")
valor = Console.ReadLine()
If valor <> -1 Then
Calcular(valor)
End If
Loop While valor <> -1
End Sub

Public Sub Calcular(ByVal v As Integer)

Dim f, tabla As Integer
For f = 1 To 10
tabla = f * v
Console.Write(tabla)
Console.Write("-")
Next
Console.WriteLine()
End Sub
End Class

Sub Main()
Dim tablamultiplicar As New TablaMultiplicar()
tablamultiplicar.CargarValor()
End Sub

End Module
En esta clase no hemos definido ningún atributo, no se requieren.
El método Calcular recibe un parámetro llamado "v" de tipo entero, luego lo utilizamos dentro del método para
mostrar la tabla de multiplicar de dicho valor:
Public Sub Calcular(ByVal v As Integer)
Dim f, tabla As Integer
For f = 1 To 10
tabla = f * v
Console.Write(tabla)
Console.Write("-")
Next
Console.WriteLine()
End Sub
Como vemos los parámetros se indican entre paréntesis luego del nombre del método. Se le antecede la palabra
clave ByVal al nombre del parámetro)
Un método puede no tener parámetros como hemos visto en problemas anteriores o puede tener uno o más
parámetros (en caso de tener más de un parámetro los mismos se separan por coma)
El método CargarValores no tiene parámetros y tiene por objetivo cargar un valor entero por teclado y llamar al
método Calcular para que muestre la tabla de multiplicar del valor que le pasamos por teclado:
Public Sub CargarValor()
Dim valor As Integer
Do
Console.Write("Ingrese un valor (-1 para finalizar):")
valor = Console.ReadLine()
If valor <> -1 Then
Calcular(valor)
End If
Loop While valor <> -1
End Sub

Página 63 de 190
Como vemos al método Calcular lo llamamos por su nombre y entre paréntesis le pasamos el dato a enviar (debe ser
un valor o variable entera)
En este problema en la Main solo llamamos al método CargarValor, ya que el método Calcular luego es llamado por
el método CargarValor:
Sub Main()
Dim tablamultiplicar As New TablaMultiplicar()
tablamultiplicar.CargarValor()
End Sub
Métodos que retornan un dato.
Un método puede retornar un dato:
Public Function [nombre del método]([parámetros]) As [Tipo de dato]
[algoritmo]
return [dato]
End Function
Cuando queremos que un método retorne un dato debemos definir una Function en lugar de un procedimiento Sub.
Cuando un método retorna un dato al final de la declaración de la función indicamos el tipo de dato que devuelve.
Luego dentro del algoritmo en el momento que queremos que finalice el mismo y retorne el dato empleamos la
palabra clave Return con el valor respectivo.
Problema 2:
Confeccionar una clase que permita ingresar tres valores por teclado. Luego mostrar el mayor y el menor.
Programa:
Module Module1

Public Class MayorMenor

Public Sub cargarValores()

Dim valor1, valor2, valor3, mayor, menor As Integer
Console.Write("Ingrese primer valor:")
valor1 = Console.ReadLine()
Console.Write("Ingrese segundo valor:")
valor2 = Console.ReadLine()
Console.Write("Ingrese tercer valor:")
valor3 = Console.ReadLine()
mayor = CalcularMayor(valor1, valor2, valor3)
menor = CalcularMenor(valor1, valor2, valor3)
Console.WriteLine("El valor mayor de los tres es:" & mayor)
Console.WriteLine("El valor menor de los tres es:" & menor)
End Sub

Public Function CalcularMayor(ByVal v1 As Integer, ByVal v2 As

Integer, ByVal v3 As Integer) As Integer
Dim m As Integer
If v1 > v2 And v1 > v3 Then
m = v1
Else
If v2 > v3 Then
m = v2
Else
m = v3
End If
End If
Return m
End Function

Public Function CalcularMenor(ByVal v1 As Integer, ByVal v2 As

Integer, ByVal v3 As Integer) As Integer

Página 64 de 190
 Dim m As Integer
If v1 < v2 And v1 < v3 Then
m = v1
Else
If v2 < v3 Then
m = v2
Else
m = v3
End If
End If
Return m
End Function
End Class

Sub Main()
Dim mm As New MayorMenor()
mm.cargarValores()
Console.ReadKey()
End Sub

End Module
Si vemos la sintaxis que calcula el mayor de tres valores enteros es similar al algoritmo visto en conceptos anteriores:
Public Function CalcularMayor(ByVal v1 As Integer, ByVal v2 As Integer, ByVal v3 As Integer) As Integer
Dim m As Integer
If v1 > v2 And v1 > v3 Then
m = v1
Else
If v2 > v3 Then
m = v2
Else
m = v3
End If
End If
Return m
End Function
Lo primero que podemos observar que el método retorna un entero y recibe tres parámetros, como retorna un dato
utilizamos la palabra clave Function:
Public Function CalcularMayor(ByVal v1 As Integer, ByVal v2 As Integer, ByVal v3 As Integer) As Integer
Dentro del método verificamos cual de los tres parámetros almacena un valor mayor, a este valor lo almacenamos
en una variable local llamada "m", al valor almacenado en esta variable lo retornamos al final con un Return.
La llamada al método calcularMayor lo hacemos desde dentro del método CargarCalores:
mayor = CalcularMayor(valor1, valor2, valor3)
Debemos asignar a una variable el valor devuelto por el método CalcularMayor. Luego el contenido de la variable
mayor lo mostramos:
Console.WriteLine("El valor mayor de los tres es:" & mayor)
Para mostrar un String y un Integer en el método WriteLine podemos utilizar el operador & para concatenar los dos
datos. Esta línea la veníamos escribiendo:
Console.Write("El valor mayor de los tres es:")
Console.WriteLine(mayor)
La lógica es similar para el cálculo del menor.
15 - Estructura de datos tipo vector

Hemos empleado variables de distinto tipo para el almacenamiento de datos (variables Integer, Single, String) En
esta sección veremos otros tipos de variables que permiten almacenar un conjunto de datos en una única variable.

Página 65 de 190
Un vector es una estructura de datos que permite almacenar un CONJUNTO de datos del MISMO tipo.
Con un único nombre se define un vector y por medio de un subíndice hacemos referencia a cada elemento del
mismo (componente)
Problema 1:
Se desea guardar los sueldos de 5 operarios.
Según lo conocido deberíamos definir 5 variables si queremos tener en un cierto momento los 5 sueldos
almacenados en memoria.
Empleando un vector solo se requiere definir un único nombre y accedemos a cada elemento por medio del
subíndice.

Para definir una propiedad de una clase de tipo vector utilizamos la siguiente sintaxis:
Private sueldos(4) As Integer
Estamos definiendo un vector llamado sueldos que puede almacenar 5 componentes (esto debido a que las
componentes comienzan a numerarse en cero).
Los elementos o componentes del vector sueldos solo pueden almacenar valores enteros. No podemos tener
componentes de distinto tipo.
Programa:
Module Module1
Public Class PruebaVector1

Private sueldos(4) As Integer

Public Sub Cargar()

Dim f As Integer
For f = 0 To 4
Console.Write("Ingrese importe del sueldo:")
sueldos(f) = Console.ReadLine()
Next
End Sub

Public Sub Imprimir()

Dim f As Integer
For f = 0 To 4
Console.WriteLine(sueldos(f))
Next
Console.ReadKey()
End Sub

End Class

Sub Main()
Dim pv As New PruebaVector1()
pv.Cargar()
pv.Imprimir()
End Sub

End Module

Como atributo de la clase declaramos el vector:

Private sueldos(4) As Integer
Lo definimos como atributo de la clase ya que lo utilizaremos en los dos métodos.

Página 66 de 190
Para cargar cada componente debemos indicar entre paréntesis que elemento del vector estamos accediendo, es
común utilizar un ciclo For para indicar el índice de la componente:
Public Sub Cargar()
Dim f As Integer
For f = 0 To 4
Console.Write("Ingrese importe del sueldo:")
sueldos(f) = Console.ReadLine()
Next
End Sub
Cuando f vale cero estamos accediendo a la primer componente del vector (en nuestro caso sería):
sueldos(f) = Console.ReadLine()
Lo mas común es utilizar una estructura repetitiva For para recorrer cada componente del vector.
Utilizar el For nos reduce la cantidad de código, si no utilizo un For debería en forma secuencial implementar el
siguiente código:
Console.Write("Ingrese importe del sueldo:")
sueldos(0) = Console.ReadLine()
Console.Write("Ingrese importe del sueldo:")
sueldos(1) = Console.ReadLine()
Console.Write("Ingrese importe del sueldo:")
sueldos(2) = Console.ReadLine()
Console.Write("Ingrese importe del sueldo:")
sueldos(3) = Console.ReadLine()
Console.Write("Ingrese importe del sueldo:")
sueldos(4) = Console.ReadLine()
La impresión de las componentes del vector lo hacemos en el otro método y también utilizamos un For para reducir
el código a programar:
Public Sub Imprimir()
Dim f As Integer
For f = 0 To 4
Console.WriteLine(sueldos(f))
Next
Console.ReadKey()
End Sub
Siempre que queremos acceder a una componente del vector debemos indicar entre paréntesis la componente,
dicho valor comienza a numerarse en cero y continua hasta el valor que indicamos al definir el vector, en nuestro
caso creamos el vector indicando un 4, es decir tiene 5 elementos:
Private sueldos(4) As Integer
Por último en este programa creamos un objeto en la Main y llamamos a lo métodos de Cargar e Imprimir el vector:
Sub Main()
Dim pv As New PruebaVector1()
pv.Cargar()
pv.Imprimir()
End Sub
Problema 2:
Definir un vector de 5 componentes de tipo Single que representen las alturas de 5 personas.
Obtener el promedio de las mismas. Contar cuántas personas son más altas que el promedio y cuántas más bajas.
Programa:
Module Module1

Public Class PruebaVector2

Private alturas(4) As Single
Private promedio As Single

Public Sub Cargar()

Página 67 de 190
 Dim f As Integer
For f = 0 To 4
Console.Write("Ingrese la altura de la persona:")
alturas(f) = Console.ReadLine()
Next
End Sub

Public Sub CalcularPromedio()

Dim suma As Single
suma = 0
Dim f As Integer
For f = 0 To 4
suma = suma + alturas(f)
Next
promedio = suma / 5
Console.WriteLine("Promedio de alturas:" & promedio)
End Sub

Public Sub MayoresMenores()

Dim may, men As Integer
may = 0
men = 0
Dim f As Integer
For f = 0 To 4
If alturas(f) > promedio Then
may = may + 1
Else
If alturas(f) < promedio Then
men = men + 1
End If
End If
Next
Console.WriteLine("Cantidad de personas mayores al
promedio:" & may)
Console.WriteLine("Cantidad de personas menores al
promedio:" & men)
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim pv2 As New PruebaVector2()
pv2.Cargar()
pv2.CalcularPromedio()
pv2.MayoresMenores()
End Sub

End Module
Definimos como atributo un vector donde almacenaremos las alturas. También definimos un atributo "promedio" ya
que se lo calculará en un método y lo consultará en otro:
Private alturas(4) As Single
Private promedio As Single
Procedemos seguidamente a cargar todos sus elementos en el método Cargar:
Public Sub Cargar()
Dim f As Integer
For f = 0 To 4

Página 68 de 190
 Console.Write("Ingrese la altura de la persona:")
alturas(f) = Console.ReadLine()
Next
End Sub
En otro método procedemos a sumar todas sus componentes y obtener el promedio. El promedio lo almacenamos
en un atributo de la clase ya que lo necesitamos en otro método:
Public Sub CalcularPromedio()
Dim suma As Single
suma = 0
Dim f As Integer
For f = 0 To 4
suma = suma + alturas(f)
Next
promedio = suma / 5
Console.WriteLine("Promedio de alturas:" & promedio)
End Sub
Por último en un tercer método comparamos cada componente del vector con el atributo promedio, si el valor
almacenado supera al promedio incrementamos un contador en caso que sea menor al promedio incrementamos
otro contador:
Public Sub MayoresMenores()
Dim may, men As Integer
may = 0
men = 0
Dim f As Integer
For f = 0 To 4
If alturas(f) > promedio Then
may = may + 1
Else
If alturas(f) < promedio Then
men = men + 1
End If
End If
Next
Console.WriteLine("Cantidad de personas mayores al promedio:" & may)
Console.WriteLine("Cantidad de personas menores al promedio:" & men)
Console.ReadKey()
End Sub
Importante:
En este problema podemos observar una ventaja de tener almacenadas todas las alturas de las personas. Si no
conociéramos los vectores tenemos que cargar otra vez las alturas por teclado para compararlas con el promedio.
Mientras el programa está en ejecución tenemos el vector alturas a nuestra disposición. Es importante tener en
cuenta que cuando finaliza la ejecución del programa se pierde el contenido de todas las variables (simples y
vectores)
Problema 3:
Una empresa tiene dos turnos (mañana y tarde) en los que trabajan 8 empleados (4 por la mañana y 4 por la tarde)
Confeccionar un programa que permita almacenar los sueldos de los empleados agrupados por turno.
Imprimir los gastos en sueldos de cada turno.
Programa:
Module Module1
Public Class PruebaVector3

Private turnoMan(3) As Single

Private turnoTar(3) As Single

Página 69 de 190
 Public Sub Cargar()
Console.WriteLine("Sueldos de empleados del turno de la
mañana.")
Dim f As Integer
For f = 0 To 3
Console.Write("Ingrese sueldo:")
turnoMan(f) = Console.ReadLine()
Next
Console.WriteLine("Sueldos de empleados del turno de la
tarde.")
For f = 0 To 3
Console.Write("Ingrese sueldo:")
turnoTar(f) = Console.ReadLine()
Next
End Sub

Public Sub CalcularGastos()

Dim man As Single = 0
Dim tar As Single = 0
Dim f As Integer
For f = 0 To 3
man = man + turnoMan(f)
tar = tar + turnoTar(f)
Next
Console.WriteLine("Total de gastos del turno de la mañana:"
& man)
Console.WriteLine("Total de gastos del turno de la tarde:" &
tar)
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim pv3 As New PruebaVector3()
pv3.Cargar()
pv3.CalcularGastos()
End Sub

End Module
Definimos dos atributos de tipo vector donde almacenaremos los sueldos de los empleados de cada turno:
Private turnoMan(3) As Single
Private turnoTar(3) As Single
Mediante dos estructuras repetitivas procedemos a cargar cada vector:
Public Sub Cargar()
Console.WriteLine("Sueldos de empleados del turno de la mañana.")
Dim f As Integer
For f = 0 To 3
Console.Write("Ingrese sueldo:")
turnoMan(f) = Console.ReadLine()
Next
Console.WriteLine("Sueldos de empleados del turno de la tarde.")
For f = 0 To 3
Console.Write("Ingrese sueldo:")
turnoTar(f) = Console.ReadLine()

Página 70 de 190
 Next
End Sub
En otro método procedemos a sumar las componentes de cada vector y mostrar dichos acumuladores:
Public Sub CalcularGastos()
Dim man As Single = 0
Dim tar As Single = 0
Dim f As Integer
For f = 0 To 3
man = man + turnoMan(f)
tar = tar + turnoTar(f)
Next
Console.WriteLine("Total de gastos del turno de la mañana:" & man)
Console.WriteLine("Total de gastos del turno de la tarde:" & tar)
Console.ReadKey()
End Sub
En la Main creamos un objeto de la clase PruebaVector3 y llamamos a sus dos métodos:
Sub Main()
Dim pv3 As New PruebaVector3()
pv3.Cargar()
pv3.CalcularGastos()
End Sub
Problemas propuestos
Desarrollar un programa que permita ingresar un vector de 8 elementos, e informe:
El valor acumulado de todos los elementos del vector.
El valor acumulado de los elementos del vector que sean mayores a 36.
Cantidad de valores mayores a 50.
Realizar un programa que pida la carga de dos vectores numéricos enteros de 4 elementos. Obtener la suma de los
dos vectores, dicho resultado guardarlo en un tercer vector del mismo tamaño. Sumar componente a componente.
Se tienen las notas del primer parcial de los alumnos de dos cursos, el curso A y el curso B, cada curso cuenta con 5
alumnos.
Realizar un programa que muestre el curso que obtuvo el mayor promedio general.
Cargar un vector de 10 elementos y verificar posteriormente si el mismo está ordenado de menor a mayor.
Solución
Module Module1

Public Class PruebaVector4

Private vec(7) As Integer

Public Sub Cargar()

Dim f As Integer
For f = 0 To 7
Console.Write("Ingrese elemento:")
vec(f) = Console.ReadLine()
Next
End Sub

Public Sub AcumularElementos()

Dim suma As Integer = 0
Dim f As Integer
For f = 0 To 7
suma = suma + vec(f)
Next
Console.WriteLine("La suma de los 8 elementos es:" & suma)
End Sub

Página 71 de 190
 Public Sub AcumularMayores36()
Dim suma As Integer = 0
Dim f As Integer
For f = 0 To 7
If vec(f) > 36 Then
suma = suma + vec(f)
End If
Next
Console.WriteLine("La suma de los elementos mayores a 36
es:" & suma)
End Sub

Public Sub CantidadMayores50()

Dim cant As Integer = 0
Dim f As Integer
For f = 0 To 7
If vec(f) > 50 Then
cant = cant + 1
End If
Next
Console.WriteLine("La cantidad de valores mayores a 50 es:"
& cant)
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim pv4 As New PruebaVector4()
pv4.Cargar()
pv4.AcumularElementos()
pv4.AcumularMayores36()
pv4.CantidadMayores50()
End Sub

End Module

Module Module1

Public Class PruebaVector5

Private vec1(3) As Integer

Private vec2(3) As Integer
Private vecSuma(3) As Integer

Public Sub Cargar()

Console.WriteLine("Carga del primer vector.")
Dim f As Integer
For f = 0 To 3
Console.Write("Ingrese elemento:")
vec1(f) = Console.ReadLine()
Next
Console.WriteLine("Carga del segundo vector.")
For f = 0 To 3
Console.Write("Ingrese elemento:")
vec2(f) = Console.ReadLine()

Página 72 de 190
 Next
End Sub

Public Sub SumarizarVectores()

Dim f As Integer
For f = 0 To 3
vecSuma(f) = vec1(f) + vec2(f)
Next
Console.WriteLine("Vector resultante.")
For f = 0 To 3
Console.WriteLine(vecSuma(f))
Next
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim pv5 As New PruebaVector5()
pv5.Cargar()
pv5.SumarizarVectores()
End Sub

End Module

Module Module1
Public Class PruebaVector6
Private cursoa(4) As Integer
Private cursob(4) As Integer

Public Sub Cargar()

Console.WriteLine("Carga de notas del curso A")
Dim f As Integer
For f = 0 To 4
Console.Write("Ingrese nota:")
cursoa(f) = Console.ReadLine()
Next
Console.WriteLine("Carga del notas del curso B")
For f = 0 To 4
Console.Write("Ingrese nota:")
cursob(f) = Console.ReadLine()
Next
End Sub

Public Sub CalcularPromedios()

Dim suma1 As Integer = 0
Dim suma2 As Integer = 0
Dim f As Integer
For f = 0 To 4
suma1 = suma1 + cursoa(f)
suma2 = suma2 + cursob(f)
Next
Dim promedioa As Integer = suma1 / 5
Dim promediob As Integer = suma2 / 5
If promedioa > promediob Then
Console.WriteLine("El curso A tiene un promedio mayor.")
Else

Página 73 de 190
 Console.WriteLine("El curso B tiene un promedio mayor.")
End If
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim pv As New PruebaVector6()
pv.Cargar()
pv.CalcularPromedios()
End Sub

End Module

Module Module1

Public Class PruebaVector7

Private vec(9) As Integer

Public Sub Cargar()

Dim f As Integer
For f = 0 To 9
Console.Write("Ingrese elemento:")
vec(f) = Console.ReadLine()
Next
End Sub

Public Sub VerificarOrdenado()

Dim orden As Integer = 1
Dim f As Integer
For f = 0 To 8
If vec(f + 1) < vec(f) Then
orden = 0
End If
Next
If orden = 1 Then
Console.WriteLine("Esta ordenado de menor a mayor")
Else
Console.WriteLine("No esta ordenado de menor a mayor")
End If
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim pv As New PruebaVector7()
pv.Cargar()
pv.VerificarOrdenado()
End Sub

End Module

Página 74 de 190
16 - Vector - Recuperar tamaño y redimensionar

Como hemos visto cuando se define un vector indicamos entre paréntesis un valor entero que nos indica cuantos
elementos podemos almacenar, a dicho valor hay que sumarle uno ya que las componentes se enumeran a partir de
cero:
Private sueldos(4) As Integer
En la línea anterior estamos definiendo un vector con 5 componentes de tipo entera.
Luego cuando tenemos que recorrer dicho vector disponemos una estructura repetitiva For:
Public Sub Cargar()
Dim f As Integer
For f = 0 To 4
Console.Write("Ingrese importe del sueldo:")
sueldos(f) = Console.ReadLine()
Next
End Sub
Como vemos el For se repite mientras el contador f vale menos o igual a cuatro. Este estructura repetitiva es idéntica
cada vez que recorremos el vector.
Que pasa ahora si cambiamos el tamaño del vector cuando lo definimos:
Private sueldos(7) As Integer
Con esto tenemos que cambiar todos los For que recorren dicho vector. Ahora veremos que un vector al ser un
objeto tiene un método llamada GetUpperBound que retorna el valor del último índice del vector. Luego podemos
modificar todos los For con la siguiente sintaxis:
Public Sub Cargar()
Dim f As Integer
For f = 0 To sueldos.GetUpperBound(0)
Console.Write("Ingrese sueldo:")
sueldos(f) = Console.ReadLine()
Next
End Sub
Cuando llamamos a GetUpperBound debemos pasar el valor cero (ya veremos más adelante con matrices y arreglos
multidimensionales porque es este valor cero)
El problema completo utilizando el método GetUpperBound:
Module Module1

Public Class PruebaVector8

Private sueldos(4) As Integer

Public Sub Cargar()

Dim f As Integer
For f = 0 To sueldos.GetUpperBound(0)
Console.Write("Ingrese sueldo:")
sueldos(f) = Console.ReadLine()
Next
End Sub

Public Sub Imprimir()

Dim f As Integer
For f = 0 To sueldos.GetUpperBound(0)
Console.WriteLine(sueldos(f))
Next
Console.ReadKey()
End Sub
End Class

Página 75 de 190
 Sub Main()
Dim pv As New PruebaVector8()
pv.Cargar()
pv.Imprimir()
End Sub

End Module
También podemos pedir al usuario que indique el tamaño del vector en tiempo de ejecución, en estos casos se hace
imprescindible el empleo del método GetUpperBound.
Problema :
Se desea almacenar los sueldos de operarios. Cuando se ejecuta el programa se debe pedir la cantidad de sueldos a
ingresar. Luego crear un vector con dicho tamaño.
Programa:
Module Module1

Public Class PruebaVector8

Private sueldos() As Integer

Public Sub Cargar()

Dim tam As Integer
Console.Write("Cuantos empleados hay?")
tam = Console.ReadLine()
ReDim sueldos(tam - 1)
Dim f as Ingeger
For f = 0 To sueldos.GetUpperBound(0)
Console.Write("Ingrese sueldo:")
sueldos(f) = Console.ReadLine()
Next
End Sub

Public Sub Imprimir()

Dim f as Integer
For f = 0 To sueldos.GetUpperBound(0)
Console.WriteLine(sueldos(f))
Next
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim pv As New PruebaVector8()
pv.Cargar()
pv.Imprimir()
End Sub

End Module
Cuando declaramos el vector no indicamos tamaño:
Private sueldos() As Integer
Luego para la creación del mismo ingresamos una variable entera y la utilizamos el comando Redim seguido del
nombre del vector y entre paréntesis el índice final del vector a crear:
Dim tam As Integer
Console.Write("Cuantos empleados hay?")
tam = Console.ReadLine()
ReDim sueldos(tam - 1)

Página 76 de 190
Disponemos tam-1 ya que si el operador ingresa que la empresa tiene 5 empleados luego debemos crear el vector
con 5 componentes.
Luego las estructuras repetitivas las acotamos accediendo al método GetUpperBound del vector:
For f = 0 To sueldos.GetUpperBound(0)
Console.Write("Ingrese sueldo:")
sueldos(f) = Console.ReadLine()
Next
Problemas propuestos
Desarrollar un programa que permita ingresar un vector de n elementos, ingresar n por teclado. Luego imprimir la
suma de todos sus elementos
Solución
Module Module1

Public Class PruebaVector9

Private vec() As Integer

Public Sub Cargar()

Dim n As Integer
Console.Write("Cuantos elementos tiene el vector:")
n = Console.ReadLine()
ReDim vec(n - 1)
For f = 0 To vec.GetUpperBound(0)
Console.Write("Ingrese elemento:")
vec(f) = Console.ReadLine()
Next
End Sub

Public Sub AcumularElementos()

Dim suma As Integer = 0
Dim f As Integer
For f = 0 To vec.GetUpperBound(0)
suma = suma + vec(f)
Next
Console.WriteLine("La suma de los elementos es:" & suma)
Console.ReadKey()
End Sub

End Class

Sub Main()
Dim pv As New PruebaVector9()
pv.Cargar()
pv.AcumularElementos()
End Sub

End Module
17 - Vectores paralelos

Este concepto se da cuando hay una relación entre las componentes de igual subíndice (misma posición) de un
vector y otro.

Página 77 de 190
Si tenemos dos vectores de 5 elementos cada uno. En uno se almacenan los nombres de personas en el otro las
edades de dichas personas.
Decimos que el vector nombres es paralelo al vector edades si en la componente 0 de cada vector se almacena
información relacionada a una persona (Juan - 12 años)
Es decir hay una relación entre cada componente de los dos vectores.
Esta relación la conoce únicamente el programador y se hace para facilitar el desarrollo de algoritmos que procesen
los datos almacenados en las estructuras de datos.
Problema 1:
Desarrollar un programa que permita cargar 5 nombres de personas y sus edades respectivas. Luego de realizar la
carga por teclado de todos los datos imprimir los nombres de las personas mayores de edad (mayores o iguales a 18
años)
Programa:
Module Module1
Public Class PruebaVector10

Private nombres(4) As String

Private edades(4) As Integer

Public Sub Cargar()

Dim f As Integer
For f = 0 To nombres.GetUpperBound(0)
Console.Write("Ingrese nombre:")
nombres(f) = Console.ReadLine()
Console.Write("Ingrese edad:")
edades(f) = Console.ReadLine()
Next
End Sub

Public Sub MayoresEdad()

Console.WriteLine("Personas mayores de edad.")
Dim f As Integer
For f = 0 To nombres.GetUpperBound(0)
If edades(f) >= 18 Then
Console.WriteLine(nombres(f))
End If
Next
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim pv As New PruebaVector10()
pv.Cargar()
pv.MayoresEdad()
End Sub

End Module
Definimos los dos vectores de 5 elementos cada uno:
Private nombres(4) As String

Página 78 de 190
 Private edades(4) As Integer
Mediante un For procedemos a la carga de los elementos de los vectores, es común realizar la carga en el mismo For
para cargar de uno y otro al mismo tiempo:
Public Sub Cargar()
Dim f As Integer
For f = 0 To nombres.GetUpperBound(0)
Console.Write("Ingrese nombre:")
nombres(f) = Console.ReadLine()
Console.Write("Ingrese edad:")
edades(f) = Console.ReadLine()
Next
End Sub
Podemos llamar al método GetUpperBound de cualquiera de los dos vectores, ya que tienen el mismo tamaño.
Para imprimir los nombres de las personas mayores de edad verificamos cada componente del vector de edades, en
caso que sea igual o mayor a 18 procedemos a mostrar el elemento de la misma posición del otro vector:
Public Sub MayoresEdad()
Console.WriteLine("Personas mayores de edad.")
Dim f As Integer
For f = 0 To nombres.GetUpperBound(0)
If edades(f) >= 18 Then
Console.WriteLine(nombres(f))
End If
Next
Console.ReadKey()
End Sub
Problemas propuestos
Definir dos vectores paralelos de 5 elementos, en uno se almacenan los nombres de productos y en el otro sus
precios.
Permitir ingresar un valor y mostrar todos los nombres de productos que tienen un precio menor al valor ingresado.
En una empresa de 4 empleados se necesita realizar las siguientes operatorias:
a) Ingresar los nombres de los empleados con sus respectivos sueldos.
b) Imprimir los nombres de empleados que cobran menos de $2500
c) Indicar cuántos cobran más de $3500.
e) Imprimir el importe total que debe tener la empresa para abonar el sueldo a sus empleados.
Solución
Module Module1
Public Class PruebaVectorParalelo1

Private nombres(4) As String

Private precios(4) As Single

Public Sub Cargar()

Dim f As Integer
For f = 0 To nombres.GetUpperBound(0)
Console.Write("Ingrese el nombre del producto:")
nombres(f) = Console.ReadLine()
Console.Write("Ingrese el precio:")
precios(f) = Console.ReadLine()
Next
End Sub

Public Sub ConsultaProductos()

Dim valor As Single
Console.Write("Ingrese un precio de corte:")
valor = Console.ReadLine()

Página 79 de 190
 Dim f As Integer
For f = 0 To nombres.GetUpperBound(0)
If precios(f) < valor Then
Console.WriteLine("Producto:" & nombres(f) & " - " &
"Precio:" & precios(f))
End If
Next
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim pvp As New PruebaVectorParalelo1()
pvp.Cargar()
pvp.ConsultaProductos()
End Sub

End Module

Module Module1
Public Class PruebaVectorParalelo2

Private empleados(3) As String

Private sueldos(3) As Single

Public Sub Cargar()

Dim f As Integer
For f = 0 To empleados.GetUpperBound(0)
Console.Write("Ingrese el nombre del empleado:")
empleados(f) = Console.ReadLine()
Console.Write("Ingrese el sueldo de dicho empleado:")
sueldos(f) = Console.ReadLine()
Next
End Sub

Public Sub EmpleadosMenos2500()

Console.WriteLine("Listado de empleados que cobran menos de
2500")
Dim f As Integer
For f = 0 To empleados.GetUpperBound(0)
If sueldos(f) < 2500 Then
Console.WriteLine(empleados(f))
End If
Next
End Sub

Public Sub CantidadMas3500()

Dim cant As Integer = 0
Dim f As Integer
For f = 0 To empleados.GetUpperBound(0)
If sueldos(f) > 3500 Then
cant = cant + 1
End If
Next
Console.WriteLine("Cantidad de empleados que cobran más de
3500:" & cant)

Página 80 de 190
 End Sub

Public Sub GastoEnSueldos()

Dim suma As Single = 0
Dim f As Integer
For f = 0 To empleados.GetUpperBound(0)
suma = suma + sueldos(f)
Next
Console.WriteLine("Gasto total mensual en sueldos:" & suma)
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim pv As New PruebaVectorParalelo2()
pv.Cargar()
pv.EmpleadosMenos2500()
pv.CantidadMas3500()
pv.GastoEnSueldos()
End Sub

End Module
18 - Vectores - Mayor y menor elemento

Es una actividad común la búsqueda del mayor y menor elemento de un vector, lo mismo que su posición.

El mayor elemento es el 820 y se encuentra en la posición nº 2.

Problema 1:
Confeccionar un programa que permita cargar los nombres de 5 operarios y sus sueldos respectivos. Mostrar el
sueldo mayor y el nombre del operario.
Programa:
Module Module1
Public Class PruebaVector11

Private nombres(4) As String

Private sueldos(4) As Single

Public Sub Cargar()

Dim f As Integer
For f = 0 To nombres.GetUpperBound(0)
Console.Write("Ingrese el nombre del empleado:")
nombres(f) = Console.ReadLine()
Console.Write("Ingrese el sueldo:")
sueldos(f) = Console.ReadLine()
Next
End Sub

Public Sub MayorSueldo()

Dim mayor As Single
Dim pos As Integer

Página 81 de 190
 mayor = sueldos(0)
pos = 0
Dim f As Integer
For f = 1 To nombres.GetUpperBound(0)
If sueldos(f) > mayor Then
mayor = sueldos(f)
pos = f
End If
Next
Console.WriteLine("El empleado con sueldo mayor es " &
nombres(pos))
Console.WriteLine("Tiene un sueldo:" & mayor)
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim pv As New PruebaVector11()
pv.Cargar()
pv.MayorSueldo()
End Sub

End Module

Definimos los dos vectores paralelos donde almacenaremos los nombres y los sueldos de los operarios:
Private nombres(4) As String
Private sueldos(4) As Single
Cargamos sus elementos:
Public Sub Cargar()
Dim f As Integer
For f = 0 To nombres.GetUpperBound(0)
Console.Write("Ingrese el nombre del empleado:")
nombres(f) = Console.ReadLine()
Console.Write("Ingrese el sueldo:")
sueldos(f) = Console.ReadLine()
Next
End Sub
Para obtener el mayor sueldo y el nombre del operario realizar los siguientes pasos:
Inicializamos una variable mayor con la primer componente del vector sueldos:
mayor = sueldos(0)
Inicializamos una variable pos con el valor 0, ya que decimos primeramente que el mayor es la primer componente
del vector:
pos = 0
Recorremos las componentes del vector que faltan analizar, o sea, de la 1 hasta la última:
For f = 1 To nombres.GetUpperBound(0)
Accedemos a cada componente para controlar si supera lo que tiene la variable mayor:
If sueldos(f) > mayor Then
En caso de ser verdadera la condición asignamos a la variable mayor este nuevo valor sueldos[f]
mayor = sueldos(f)
y a la variable pos le cargamos la variable f que indica la componente que estamos analizando:
pos = f
Cuando salimos de la estructura repetitiva imprimimos la variable mayor que contiene el mayor sueldo y para
imprimir el nombre del operario conociendo la posición del mayor sueldo imprimimos el elemento que ocupa la
posición que indica la variable pos en el vector paralelo:
Console.WriteLine("El empleado con sueldo mayor es " & nombres(pos))

Página 82 de 190
 Console.WriteLine("Tiene un sueldo:" & mayor)
Problema propuesto
Cargar un vector de n elementos (n se carga por teclado). imprimir el menor y un mensaje si se repite dentro del
vector.
Solución
Module Module1
Public Class PruebaVector12

Private vec() As Integer

Private menor As Integer

Public Sub Cargar()

Dim n As Integer
Console.Write("Cuantos elementos desea cargar:")
n = Console.ReadLine()
ReDim vec(n - 1)
Dim f As Integer
For f = 0 To vec.GetUpperBound(0)
Console.Write("Ingrese componente:")
vec(f) = Console.ReadLine()
Next
End Sub

Public Sub MenorElemento()

menor = vec(0)
Dim f As Integer
For f = 1 To vec.GetUpperBound(0)
If vec(f) < menor Then
menor = vec(f)
End If
Next
Console.WriteLine("El elemento menor es:" & menor)
End Sub

Public Sub RepiteMenor()

Dim cant As Integer = 0
Dim f As Integer
For f = 0 To vec.GetUpperBound(0)
If vec(f) = menor Then
cant = cant + 1
End If
Next
If cant > 1 Then
Console.WriteLine("Se repite el menor en el vector.")
Else
Console.WriteLine("No se repite el menor en el vector.")
End If
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim pv As New PruebaVector12()
pv.Cargar()
pv.MenorElemento()
pv.RepiteMenor()

Página 83 de 190
 End Sub

End Module
Module Module1
Public Class PruebaVector12

Private vec() As Integer

Private menor As Integer

Public Sub Cargar()

Dim n As Integer
Console.Write("Cuantos elementos desea cargar:")
n = Console.ReadLine()
ReDim vec(n - 1)
Dim f As Integer
For f = 0 To vec.GetUpperBound(0)
Console.Write("Ingrese componente:")
vec(f) = Console.ReadLine()
Next
End Sub

Public Sub MenorElemento()

menor = vec(0)
Dim f As Integer
For f = 1 To vec.GetUpperBound(0)
If vec(f) < menor Then
menor = vec(f)
End If
Next
Console.WriteLine("El elemento menor es:" & menor)
End Sub

Public Sub RepiteMenor()

Dim cant As Integer = 0
Dim f As Integer
For f = 0 To vec.GetUpperBound(0)
If vec(f) = menor Then
cant = cant + 1
End If
Next
If cant > 1 Then
Console.WriteLine("Se repite el menor en el vector.")
Else
Console.WriteLine("No se repite el menor en el vector.")
End If
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim pv As New PruebaVector12()
pv.Cargar()
pv.MenorElemento()
pv.RepiteMenor()
End Sub

Página 84 de 190
End Module
Module Module1
Public Class PruebaVector15

Private vec() As Integer

Public Sub Cargar()

Dim cant As Integer
Console.Write("Cuantos elementos tendrá el vector:")
cant = Console.ReadLine()
ReDim vec(cant - 1)
Dim f As Integer
For f = 0 To vec.GetUpperBound(0)
Console.Write("Ingrese elemento:")
vec(f) = Console.ReadLine()
Next
End Sub

Public Sub Ordenar()

Dim f, k As Integer
For k = 0 To vec.GetUpperBound(0) - 1
For f = 0 To vec.GetUpperBound(0) - 1 - k
If vec(f) > vec(f + 1) Then
Dim aux As Integer
aux = vec(f)
vec(f) = vec(f + 1)
vec(f + 1) = aux
End If
Next
Next
End Sub

Public Sub Imprimir()

Console.WriteLine("Vector ordenados de menor a mayor.")
Dim f As Integer
For f = 0 To vec.GetUpperBound(0)
Console.WriteLine(vec(f))
Next
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim pv As New PruebaVector15()
pv.Cargar()
pv.Ordenar()
pv.Imprimir()
End Sub

End Module
19 - Vectores - Ordenamiento de sus componentes
El ordenamiento de un vector se logra intercambiando las componentes de manera que:
vec(0) <= vec(1) <= vec(2) etc.

Página 85 de 190
El contenido de la componente vec(0) sea menor o igual al contenido de la componente vec(1) y así
sucesivamente.
Si se cumple lo dicho anteriormente decimos que el vector está ordenado de menor a mayor. Igualmente
podemos ordenar un vector de mayor a menor.
Se puede ordenar tanto vectores con componentes de tipo Ingeger, Single como String. En este último
caso el ordenamiento es alfabético.

Problema 1:
Se debe crear un vector donde almacenar 5 sueldos. Ordenar el vector sueldos de menor a mayor.

Esta primera aproximación tiene por objetivo analizar los intercambios de elementos dentro del vector.
El algoritmo consiste en comparar si la primera componente es mayor a la segunda, en caso que la
condición sea verdadera, intercambiamos los contenidos de las componentes.
Vamos a suponer que se ingresan los siguientes valores por teclado:

1200

750

820

550

490

En este ejemplo: ¿es 1200 mayor a 750? La respuesta es verdadera, por lo tanto intercambiamos el
contenido de la componente 0 con el de la componente 1.
Luego comparamos el contenido de la componente 1 con el de la componente 2: ¿Es 1200 mayor a 820?
La respuesta es verdadera entonces intercambiamos.
Si hay 5 componentes hay que hacer 4 comparaciones, por eso el for se repite 4 veces.
Generalizando: si el vector tiene N componentes hay que hacer N-1 comparaciones.

Cuando f=0 f=1 f =2 f=3

750 750 750 750

1200 820 820 820

820 1200 550 550

550 550 1200 490

490 490 490 1200

Página 86 de 190
Podemos ver cómo el valor más grande del vector desciende a la última componente. Empleamos una
variable auxiliar (aux) para el proceso de intercambio:

aux = sueldos(f)

sueldos(f) = sueldos(f+1)

sueldos(f+1) = aux

Al salir del For en este ejemplo el contenido del vector es el siguiente:

750

820

550

490

1200

Analizando el algoritmo podemos comprobar que el elemento mayor del vector se ubica ahora en el último
lugar.
Podemos definir otros vectores con distintos valores y comprobar que siempre el elemento mayor queda al
final.
Pero todavía con este algoritmo no se ordena un vector. Solamente está ordenado el último elemento del
vector.
Ahora bien, con los 4 elementos que nos quedan podemos hacer el mismo proceso visto anteriormente,
con lo cual quedará ordenado otro elemento del vector. Este proceso lo repetiremos hasta que quede
ordenado por completo el vector.
Como debemos repetir el mismo algoritmo podemos englobar todo el bloque en otra estructura repetitiva.

Realicemos una prueba del siguiente algoritmo:

Cuando k = 0

f=0 f=1 f=2 f=3

750 750 750 750

1200 820 820 820

820 1200 550 550

550 550 1200 490

Página 87 de 190
 490 490 490 1200

Cuando k = 1

f=0 f=1 f =2 f=3

750 750 750 750

820 550 550 550

550 820 490 490

490 490 820 820

1200 1200 1200 1200

Cuando k = 2

f=0 f=1 f =2 f=3

550 550 550 550

750 490 490 490

490 750 750 750

820 820 820 820

1200 1200 1200 1200

Cuando k = 3

f=0 f=1 f =2 f=3

490 490 490 490

550 550 550 550

750 750 750 750

820 820 820 820

1200 1200 1200 1200

¿Porqué repetimos 4 veces el For externo?

Como sabemos cada vez que se repite en forma completa el For interno queda ordenada una componente
del vector. A primera vista diríamos que deberíamos repetir el For externo la cantidad de componentes del
vector, en este ejemplo el vector sueldos tiene 5 componentes.
Si observamos, cuando quedan dos elementos por ordenar, al ordenar uno de ellos queda el otro
automáticamente ordenado (podemos imaginar que si tenemos un vector con 2 elementos no se requiere
el For externo, porque este debería repetirse una única vez)
Una última consideración a este ALGORITMO de ordenamiento es que los elementos que se van
ordenando continuamos comparándolos.
Ejemplo: En la primera ejecución del For interno el valor 1200 queda ubicado en la posición 4 del vector.
En la segunda ejecución comparamos si el 820 es mayor a 1200, lo cual seguramente será falso.

Página 88 de 190
Podemos concluir que la primera vez debemos hacer para este ejemplo 4 comparaciones, en la segunda
ejecución del For interno debemos hacer 3 comparaciones y en general debemos ir reduciendo en uno la
cantidad de comparaciones.
Si bien el algoritmo planteado funciona, un algoritmo más eficiente, que se deriva del anterior es el
plantear un For interno con la siguiente estructura: For f=0 To 3-k
Es decir restarle el valor del contador del For externo.

Programa:
Module Module1
Public Class PruebaVector13

Private sueldos(4) As Integer

Public Sub Cargar()

Dim f As Integer
For f = 0 To 4
Console.Write("Ingrese el sueldo:")
sueldos(f) = Console.ReadLine()
Next
End Sub

Public Sub Ordenar()

Dim f, k As Integer
For k = 0 To 3
For f = 0 To 3 - k
If sueldos(f) > sueldos(f + 1) Then
Dim aux As Integer
aux = sueldos(f)
sueldos(f) = sueldos(f + 1)
sueldos(f + 1) = aux
End If
Next
Next
End Sub

Public Sub Imprimir()

Console.WriteLine("Sueldos ordenados de menor a mayor.")
For f = 0 To 4
Console.WriteLine(sueldos(f))

Página 89 de 190
 Next
Console.ReadKey()
End Sub
End Class
Sub Main()
Dim pv As New PruebaVector13()
pv.Cargar()
pv.Ordenar()
pv.Imprimir()
End Sub

End Module

También podemos ordenar vectores cuyas componentes sean de tipo String. Para esto también utilizamos
el operador >
Problema 2:
Definir un vector donde almacenar los nombres de 5 paises. Confeccionar el algoritmo de ordenamiento
alfabético.
Programa:
Module Module1
Public Class PruebaVector14

Private paises(4) As String

Public Sub Cargar()

Dim f As Integer
For f = 0 To 4
Console.Write("Ingrese el nombre del pais:")
paises(f) = Console.ReadLine()
Next
End Sub
Public Sub Ordenar()
Dim k, f As Integer
For k = 0 To 3
For f = 0 To 3 - k
If paises(f) > paises(f + 1) Then
Dim aux As String
aux = paises(f)

Página 90 de 190
 paises(f) = paises(f + 1)
paises(f + 1) = aux
End If
Next
Next
End Sub

Public Sub Imprimir()

Console.WriteLine("Paises ordenados en forma alfabética:")
Dim f As Integer
For f = 0 To 4
Console.WriteLine(paises(f))
Next
Console.ReadKey()
End Sub
End Class
Sub Main()
Dim pv As New PruebaVector14()
pv.Cargar()
pv.Ordenar()
pv.Imprimir()
End Sub
End Module

Definimos un vector de tipo String con cinco elementos:

Private paises(4) As String

Procedemos a cargar el vector:

Public Sub Cargar()

Dim f As Integer

For f = 0 To 4

Console.Write("Ingrese el nombre del pais:")

paises(f) = Console.ReadLine()

Next

End Sub

Para el ordenamiento vemos que es idéntico a trabajar con Integer o Single::

Public Sub Ordenar()

Página 91 de 190
 Dim k, f As Integer

For k = 0 To 3

For f = 0 To 3 - k

If paises(f) > paises(f + 1) Then

Dim aux As String

aux = paises(f)

paises(f) = paises(f + 1)

paises(f + 1) = aux

End If

Next

Next

End Sub

Problema propuesto
Cargar un vector de n elementos de tipo entero (n se ingresa por teclado)
Ordenar posteriormente el vector e imprimirlo
Module Module1
Public Class PruebaVector15

Private vec() As Integer

Public Sub Cargar()

Dim cant As Integer
Console.Write("Cuantos elementos tendrá el vector:")
cant = Console.ReadLine()
ReDim vec(cant - 1)
Dim f As Integer
For f = 0 To vec.GetUpperBound(0)
Console.Write("Ingrese elemento:")
vec(f) = Console.ReadLine()
Next
End Sub

Public Sub Ordenar()

Dim f, k As Integer
For k = 0 To vec.GetUpperBound(0) - 1
For f = 0 To vec.GetUpperBound(0) - 1 - k

Página 92 de 190
 If vec(f) > vec(f + 1) Then
Dim aux As Integer
aux = vec(f)
vec(f) = vec(f + 1)
vec(f + 1) = aux
End If
Next
Next
End Sub

Public Sub Imprimir()

Console.WriteLine("Vector ordenados de menor a mayor.")
Dim f As Integer
For f = 0 To vec.GetUpperBound(0)
Console.WriteLine(vec(f))
Next
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim pv As New PruebaVector15()
pv.Cargar()
pv.Ordenar()
pv.Imprimir()
End Sub

End Module

20 - Vectores - Ordenamiento con vectores paralelos

Cuando se tienen vectores paralelos y se ordena uno de ellos hay que tener la precaución de intercambiar los
elementos de los vectores paralelos.
Problema 1:
Confeccionar un programa que permita cargar los nombres de 5 alumnos y sus notas respectivas. Luego ordenar las
notas de mayor a menor. Imprimir las notas y los nombres de los alumnos.
Programa:
Module Module1

Página 93 de 190
 Public Class PruebaVector16

Private nombres(4) As String

Private notas(4) As Integer

Public Sub Cargar()

Console.WriteLine("Carga de nombres y notas")
Dim f As Integer
For f = 0 To nombres.GetUpperBound(0)
Console.Write("Ingese el nombre del alumno:")
nombres(f) = Console.ReadLine()
Console.Write("Ingrese la nota del alumno:")
notas(f) = Console.ReadLine()
Next
End Sub

Public Sub Ordenar()

Dim f, k As Integer
For k = 0 To notas.GetUpperBound(0) - 1
For f = 0 To notas.GetUpperBound(0) - 1 - k
If notas(f) < notas(f + 1) Then
Dim auxnota As Integer
auxnota = notas(f)
notas(f) = notas(f + 1)
notas(f + 1) = auxnota
Dim auxnombre As String
auxnombre = nombres(f)
nombres(f) = nombres(f + 1)
nombres(f + 1) = auxnombre
End If
Next
Next
End Sub

Public Sub Imprimir()

Console.WriteLine("Nombres de alumnos y notas de mayor a
menor")
Dim f As Integer
For f = 0 To notas.GetUpperBound(0)
Console.WriteLine(nombres(f) & " - " & notas(f))
Next
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim pv As New PruebaVector16()
pv.Cargar()
pv.Ordenar()
pv.Imprimir()
End Sub

End Module
Definimos los dos vectores de 5 elementos cada uno (comienzan a numerarse a partir de cero las componentes):
Private nombres(4) As String
Private notas(4) As Integer

Página 94 de 190
En el proceso de ordenamiento dentro de los dos for verificamos si debemos intercambiar los elementos del vector
notas:
Dim f, k As Integer
For k = 0 To notas.GetUpperBound(0) - 1
For f = 0 To notas.GetUpperBound(0) - 1 - k
If notas(f) < notas(f + 1) Then
En el caso que la nota de la posición 'f' sea menor a de la posición siguiente 'f+1' procedemos a intercambiar las
notas:
Dim auxnota As Integer
auxnota = notas(f)
notas(f) = notas(f + 1)
notas(f + 1) = auxnota
y simultáneamente procedemos a intercambiar los elementos del vector paralelo (con esto logramos que los dos
vectores continúen siendo vectores paralelos):
Dim auxnombre As String
auxnombre = nombres(f)
nombres(f) = nombres(f + 1)
nombres(f + 1) = auxnombre
Como vemos utilizamos dos auxiliares distintos porque los elementos de los dos vectores son de distinto tipo
(Integer y String)
Problema propuesto
Cargar en un vector los nombres de 5 países y en otro vector paralelo la cantidad de habitantes del mismo. Ordenar
alfabéticamente e imprimir los resultados. Por último ordenar con respecto a la cantidad de habitantes (de mayor a
menor) e imprimir nuevamente.
SOLUCION
Module Module1

Public Class PruebaVector17

Private paises(4) As String

Private habitantes(4) As Integer

Public Sub Cargar()

Dim f As Integer
Console.WriteLine("Carga de paises y habitantes")
For f = 0 To paises.GetUpperBound(0)
Console.Write("Ingese el nombre del pais:")
paises(f) = Console.ReadLine()
Console.Write("Ingrese la cantidad de habitantes:")
habitantes(f) = Console.ReadLine()
Next
End Sub

Public Sub OrdenarPorNombres()

Dim f, k As Integer
For k = 0 To paises.GetUpperBound(0) - 1
For f = 0 To paises.GetUpperBound(0) - 1 - k
If paises(f) > paises(f + 1) Then
Dim auxpais As String
auxpais = paises(f)
paises(f) = paises(f + 1)
paises(f + 1) = auxpais
Dim auxhabitante As Integer
auxhabitante = habitantes(f)
habitantes(f) = habitantes(f + 1)

Página 95 de 190
 habitantes(f + 1) = auxhabitante
End If
Next
Next
End Sub

Public Sub OrdenarPorHabitantes()

Dim f, k As Integer
For k = 0 To paises.GetUpperBound(0) - 1
For f = 0 To paises.GetUpperBound(0) - 1 - k
If habitantes(f) < habitantes(f + 1) Then
Dim auxpais As String
auxpais = paises(f)
paises(f) = paises(f + 1)
paises(f + 1) = auxpais
Dim auxhabitante As Integer
auxhabitante = habitantes(f)
habitantes(f) = habitantes(f + 1)
habitantes(f + 1) = auxhabitante
End If
Next
Next
End Sub

Public Sub Imprimir()

Dim f As Integer
For f = 0 To paises.GetUpperBound(0)

Console.WriteLine(paises(f) & " - " & habitantes(f))

Next
End Sub

End Class

Sub Main()
Dim pv As New PruebaVector17()
pv.Cargar()
pv.OrdenarPorNombres()
Console.WriteLine("Ordenados alfabéticamente")
pv.Imprimir()
pv.OrdenarPorHabitantes()
Console.WriteLine("Ordenados por cantidad de habitnates")
pv.Imprimir()
Console.ReadKey()
End Sub

End Module
21 - Estructura de datos tipo matriz

Una matriz es una estructura de datos que permite almacenar un CONJUNTO de datos del MISMO tipo.
Con un único nombre se define la matriz y por medio de DOS subíndices hacemos referencia a cada elemento de la
misma (componente)

Página 96 de 190
Hemos graficado una matriz de 3 filas y 5 columnas. Para hacer referencia a cada elemento debemos indicar primero
la fila y luego la columna, por ejemplo en la componente 1,4 se almacena el valor 97.
En este ejemplo almacenamos valores enteros. Todos los elementos de la matriz deben ser del mismo tipo (Integer,
Single, String etc.)
Las filas y columnas comienzan a numerarse a partir de cero, similar a los vectores.
Problema 1:
Crear una matriz de 3 filas por 5 columnas con elementos de tipo Integer, cargar sus componentes y luego
imprimirlas.
Programa:
Module Module1

Public Class Matriz1

Private mat(2, 4) As Integer

Public Sub Cargar()

Dim f, c As Integer
For f = 0 To 2
For c = 0 To 4
Console.Write("Ingrese componente:")
mat(f, c) = Console.ReadLine()
Next
Next
End Sub

Public Sub Imprimir()

Dim f, c As Integer
For f = 0 To 2
For c = 0 To 4
Console.Write(mat(f, c) & " ")
Next
Console.WriteLine()
Next
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim ma As New Matriz1()
ma.Cargar()
ma.Imprimir()
End Sub

End Module

Página 97 de 190
Para definir una matriz debemos disponer una coma dentro de los paréntesis. El primer valor indica filas (3 filas) y el
segundo columnas (cinco columnas):
Private mat(2, 4) As Integer
Recordar que los subíndices comienzan a numerarse desde cero.
De esta forma el compilador de Visual Basic .Net puede diferenciar los vectores de las matrices.
Luego debemos pasar a cargar sus 15 componentes (cada fila almacena 5 componentes y tenemos 3 filas)
Lo más cómodo es utilizar un For anidado, el primer For que incrementa el contador f lo utilizamos para recorrer las
filas y el contador interno llamado c lo utilizamos para recorrer las columnas.
Cada vez que se repite en forma completa el For interno se carga una fila completa, primero se carga la fila cero en
forma completa, luego la fila uno y finalmente la fila 2.
Siempre que accedemos a una posición de la matriz debemos disponer dos subíndices que hagan referencia a la fila y
columna mat(f,c):
Public Sub Cargar()
Dim f, c As Integer
For f = 0 To 2
For c = 0 To 4
Console.Write("Ingrese componente:")
mat(f, c) = Console.ReadLine()
Next
Next
End Sub
Para imprimir la matriz de forma similar utilizamos dos For para acceder a cada elemento de la matriz:
Public Sub Imprimir()
Dim f, c As Integer
For f = 0 To 2
For c = 0 To 4
Console.Write(mat(f, c) & " ")
Next
Console.WriteLine()
Next
Console.ReadKey()
End Sub
Cada vez que se ejecuta todas las vueltas del For interno tenemos en pantalla una fila completa de la matriz, por eso
pasamos a ejecutar un salto de línea (con esto logramos que en pantalla los datos aparezcan en forma matricial):
Console.WriteLine()
En pantalla tenemos como resultado:

Problema 2:
Crear y cargar una matriz de 4 filas por 4 columnas. Imprimir la diagonal principal.
x - - -
- x - -
- - x -
- - - x

Página 98 de 190
Programa:
Module Module1

Public Class Matriz2

Private mat(3, 3) As Integer

Public Sub Cargar()

Dim f, c As Integer
For f = 0 To 3
For c = 0 To 3
Console.Write("Ingrese componente:")
mat(f, c) = Console.ReadLine()
Next
Next
End Sub

Public Sub ImprimirDiagonalPrincipal()

Dim k As Integer
For k = 0 To 3
Console.Write(mat(k, k) & " ")
Next
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim ma As New Matriz2()
ma.Cargar()
ma.ImprimirDiagonalPrincipal()
End Sub

End Module
La definición, creación y carga de la matriz no varían con el ejemplo anterior.
Para imprimir la diagonal principal de la matriz lo más conveniente es utilizar un for que se repita 4 veces y disponer
como subíndice dicho contador (los elementos de la diagonal principal coinciden los valores de la fila y columna):
Public Sub ImprimirDiagonalPrincipal()
Dim k As Integer
For k = 0 To 3
Console.Write(mat(k, k) & " ")
Next
Console.ReadKey()
End Sub
Problema 3:
Crear y cargar una matriz de 3 filas por 4 columnas. Imprimir la primer fila. Imprimir la última fila e imprimir la primer
columna.
Programa:
Module Module1

Public Class Matriz3

Private mat(2, 3) As Integer

Public Sub Cargar()

Dim f As Integer

Página 99 de 190
 For f = 0 To 2
For c = 0 To 3
Console.Write("Ingrese componente:")
mat(f, c) = Console.ReadLine()
Next
Next
End Sub

Public Sub PrimerFila()

Console.WriteLine("Primer fila de la matriz:")
Dim c As Integer
For c = 0 To 3
Console.WriteLine(mat(0, c))
Next
End Sub

Public Sub UltimaFila()

Console.WriteLine("Ultima fila de la matriz:")
Dim c As Integer
For c = 0 To 3
Console.WriteLine(mat(2, c))
Next
End Sub

Public Sub PrimerColumna()

Console.WriteLine("Primer columna:")
Dim f As Integer
For f = 0 To 2
Console.WriteLine(mat(f, 0))
Next
End Sub
End Class

Sub Main()
Dim ma As New Matriz3()
ma.Cargar()
ma.PrimerFila()
ma.UltimaFila()
ma.PrimerColumna()
Console.ReadKey()
End Sub

End Module
Creamos una matriz de 3 filas y 4 columnas:
Private mat(2, 3) As Integer
Luego de cargarla el primer método que codificamos es el que imprime la primer fila. Disponemos un For para
recorrer las columnas, ya que la fila siempre será la cero. Como son cuatro los elementos de la primer fila el For se
repite esta cantidad de veces:
Public Sub PrimerFila()
Console.WriteLine("Primer fila de la matriz:")
Dim c As Integer
For c = 0 To 3
Console.WriteLine(mat(0, c))
Next
End Sub

Página 100 de 190

Para imprimir la última fila el algoritmo es similar, disponemos un for que se repita 4 veces y en el subíndice de la fila
disponemos el valor 2 (ya que la matriz tiene 3 filas):
Public Sub UltimaFila()
Console.WriteLine("Ultima fila de la matriz:")
Dim c As Integer
For c = 0 To 3
Console.WriteLine(mat(2, c))
Next
End Sub
Para imprimir la primer columna el for debe repetirse 3 veces ya que la matriz tiene 3 filas. Dejamos constante el
subíndice de la columna con el valor cero:
Public Sub PrimerColumna()
Console.WriteLine("Primer columna:")
Dim f As Integer
For f = 0 To 2
Console.WriteLine(mat(f, 0))
Next
End Sub
Cuando ejecutamos este programa tenemos un resultado similar a:

Problema propuesto
Crear una matriz de 2 filas y 5 columnas. Realizar la carga de componentes por columna (es decir primero ingresar
toda la primer columna, luego la segunda columna y así sucesivamente)
Imprimir luego la matriz.
SOLUCION
Module Module1

Public Class Matriz4

Private mat(1, 4) As Integer

Public Sub Cargar()

Console.WriteLine("Carga de la matriz por columna:")
Dim c, f As Integer
For c = 0 To 4
For f = 0 To 1
Console.Write("Ingrese componente de la fila " & f
& " y la columna " & c & " :")
mat(f, c) = Console.ReadLine()
Next
Next
End Sub

Página 101 de 190

 Public Sub Imprimir()
Dim f, c As Integer
For f = 0 To 1
For c = 0 To 4
Console.Write(mat(f, c) & " ")
Next
Console.WriteLine()
Next
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim ma As New Matriz4()
ma.Cargar()
ma.Imprimir()
End Sub

End Module
22 - Matrices - Cantidad de filas y columnas

Como hemos visto para definir y crear la matriz utilizamos la siguiente sintaxis:
Private mat(2, 4) As Integer
Como las matrices son objetos en Visual Basic .Net disponemos de un método llamado GetUpperBound(numero de
índice) que le pasamos como parámetro la dimensión y nos retorna el valor de dicha dimensión.
Para la definición de la matriz indicada arriba si accedemos a la primera dimesión con el método GetUpperBound
retorna un 2:
Console.WriteLine(mat.GetUpperBound(0))
Si accedemos a la segunda dimesión se imprime un 4:
Console.WriteLine(mat.GetUpperBound(1))
La primer dimensión son la cantidad de filas más uno y la segunda dimensión son la cantidad de columnas más uno
de la matriz.
Problema 1:
Crear una matriz de n * m filas (cargar n y m por teclado) Imprimir la matriz completa y la última fila.
Programa:
Module Module1

Public Class Matriz5

Private mat(,) As Integer

Public Sub Cargar()

Dim filas, columnas As Integer
Console.Write("Cuantas fila tiene la matriz:")
filas = Console.ReadLine()
Console.Write("Cuantas columnas tiene la matriz:")
columnas = Console.ReadLine()
ReDim mat(filas - 1, columnas - 1)
Dim f, c As Integer
For f = 0 To mat.GetUpperBound(0)
For c = 0 To mat.GetUpperBound(1)
Console.Write("Ingrese componente:")
mat(f, c) = Console.ReadLine()
Next
Next

Página 102 de 190

 End Sub

Public Sub Imprimir()

Dim f, c As Integer
For f = 0 To mat.GetUpperBound(0)
For c = 0 To mat.GetUpperBound(1)
Console.Write(mat(f, c) & " ")
Next
Console.WriteLine()
Next
End Sub

Public Sub ImprimirUltimaFila()

Dim c As Integer
Console.WriteLine("Ultima fila")
For c = 0 To mat.GetUpperBound(1)
Console.Write(mat(mat.GetUpperBound(0), c) & " ")
Next
End Sub
End Class

Sub Main()
Dim ma As New Matriz5()
ma.Cargar()
ma.Imprimir()
ma.ImprimirUltimaFila()
Console.ReadKey()
End Sub

End Module
Declaramos la matriz sin indicar el valor de cada una de las dos dimensiones:
Private mat(,) As Integer
En este ejemplo cada vez que se ejecute el programa el tamaño de la matriz lo define el usuario, para ello
ingresamos por teclado dos enteros y seguidamente procedemos a crear la matriz con dichos valores restando uno a
filas y columnas:
Dim filas, columnas As Integer
Console.Write("Cuantas fila tiene la matriz:")
filas = Console.ReadLine()
Console.Write("Cuantas columnas tiene la matriz:")
columnas = Console.ReadLine()
ReDim mat(filas - 1, columnas - 1)
Ahora las estructuras repetitivas las acotamos preguntando a la misma matriz la cantidad de filas y la cantidad de
columnas:
For f = 0 To mat.GetUpperBound(0)
For c = 0 To mat.GetUpperBound(1)
Console.Write("Ingrese componente:")
mat(f, c) = Console.ReadLine()
Next
Next
El algoritmo de impresión es idéntico al visto anteriormente con la modificación de los For:
Public Sub Imprimir()
Dim f, c As Integer
For f = 0 To mat.GetUpperBound(0)
For c = 0 To mat.GetUpperBound(1)
Console.Write(mat(f, c) & " ")

Página 103 de 190

 Next
Console.WriteLine()
Next
End Sub
Para imprimir la última fila debemos disponer un valor fijo en el subíndice de la fila, en este caso no podemos
disponer un número fijo sino preguntarle a la misma matriz el valor definido para la primer dimensión.
También el For debemos acotarlo con el segundo índice (columnas):
Public Sub ImprimirUltimaFila()
Dim c As Integer
Console.WriteLine("Ultima fila")
For c = 0 To mat.GetUpperBound(1)
Console.Write(mat(mat.GetUpperBound(0), c) & " ")
Next
End Sub
Problema 2:
Crear una matriz de n * m filas (cargar n y m por teclado) Imprimir el mayor elemento y la fila y columna donde se
almacena.
Programa:
Module Module1

Public Class Matriz6

Private mat(,) As Integer

Public Sub Cargar()

Dim filas, columnas As Integer
Console.Write("Cuantas fila tiene la matriz:")
filas = Console.ReadLine()
Console.Write("Cuantas columnas tiene la matriz:")
columnas = Console.ReadLine()
ReDim mat(filas - 1, columnas - 1)
Dim f, c As Integer
For f = 0 To mat.GetUpperBound(0)
For c = 0 To mat.GetUpperBound(1)
Console.Write("Ingrese componente:")
mat(f, c) = Console.ReadLine()
Next
Next
End Sub

Public Sub ImprimirMayor()

Dim mayor As Integer = mat(0, 0)
Dim filamay As Integer = 0
Dim columnamay As Integer = 0
Dim f, c As Integer
For f = 0 To mat.GetUpperBound(0)
For c = 0 To mat.GetUpperBound(1)
If mat(f, c) > mayor Then
mayor = mat(f, c)
filamay = f
columnamay = c
End If
Next
Next
Console.WriteLine("El elemento mayor es:" & mayor)

Página 104 de 190

 Console.WriteLine("Se encuentra en la fila:" & filamay & " y
en la columna: " & columnamay)
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim ma As New Matriz6()
ma.Cargar()
ma.ImprimirMayor()
End Sub

End Module
Para obtener el mayor elemento de la matriz y la fila y columna donde se ubica debemos inicializar una variable
mayor con el elemento de la fila cero y columna cero (esto lo hacemos suponiendo que en dicha posición se
almacena el mayor):
Dim mayor As Integer = mat(0, 0)
Dim filamay As Integer = 0
Dim columnamay As Integer = 0
Luego mediante dos for recorremos todos los elementos de la matriz y cada vez que encontramos un elemento
mayor al actual procedemos a actualizar la variable mayor y la posición donde se almacena:
For f = 0 To mat.GetUpperBound(0)
For c = 0 To mat.GetUpperBound(1)
If mat(f, c) > mayor Then
mayor = mat(f, c)
filamay = f
columnamay = c
End If
Next
Next
Fuera de los dos For procedemos a mostrar el contenido de la variable mayor y la posición donde se encuentra
dentro de la matriz:
Console.WriteLine("El elemento mayor es:" & mayor)
Console.WriteLine("Se encuentra en la fila:" & filamay & " y en la columna: " & columnamay)
Problemas propuestos
Crear una matriz de n * m filas (cargar n y m por teclado) Intercambiar la primer fila con la segundo. Imprimir luego
la matriz.
Crear una matriz de n * m filas (cargar n y m por teclado) Imprimir los cuatro valores que se encuentran en los
vértices de la misma (mat[0][0] etc.)
Module Module1
Public Class Matriz7

Private mat(,) As Integer

Public Sub Cargar()

Dim filas, columnas As Integer
Console.Write("Cuantas fila tiene la matriz:")
filas = Console.ReadLine()
Console.Write("Cuantas columnas tiene la matriz:")
columnas = Console.ReadLine()
ReDim mat(filas - 1, columnas - 1)
Dim f, c As Integer
For f = 0 To mat.GetUpperBound(0)
For c = 0 To mat.GetUpperBound(1)
Console.Write("Ingrese componente:")

Página 105 de 190

 mat(f, c) = Console.ReadLine()
Next
Next
End Sub

Public Sub Intercambiar()

Dim c As Integer
For c = 0 To mat.GetUpperBound(0)
Dim aux As Integer = mat(0, c)
mat(0, c) = mat(1, c)
mat(1, c) = aux
Next
End Sub

Public Sub Imprimir()

Dim f, c As Integer
For f = 0 To mat.GetUpperBound(0)
For c = 0 To mat.GetUpperBound(1)
Console.Write(mat(f, c) & " ")
Next
Console.WriteLine()
Next
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim ma As New Matriz7()
ma.Cargar()
ma.Intercambiar()
ma.Imprimir()
End Sub

End Module

Module Module1
Public Class Matriz8

Private mat(,) As Integer

Public Sub Cargar()

Dim filas, columnas As Integer
Console.Write("Cuantas fila tiene la matriz:")
filas = Console.ReadLine()
Console.Write("Cuantas columnas tiene la matriz:")
columnas = Console.ReadLine()
ReDim mat(filas - 1, columnas - 1)
Dim f, c As Integer
For f = 0 To mat.GetUpperBound(0)
For c = 0 To mat.GetUpperBound(1)
Console.Write("Ingrese componente:")
mat(f, c) = Console.ReadLine()
Next
Next
End Sub

Página 106 de 190

 Public Sub ImprimirVertices()

Console.WriteLine("Vértice superior izquierdo:")

Console.WriteLine(mat(0, 0))
Console.WriteLine("Vértice superior derecho:")
Console.WriteLine(mat(0, mat.GetUpperBound(1)))
Console.WriteLine("Vértice inferior izquierdo:")
Console.WriteLine(mat(mat.GetUpperBound(0), 0))
Console.WriteLine("Vértice inferior derecho:")
Console.WriteLine(mat(mat.GetUpperBound(0),
mat.GetUpperBound(1)))
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim ma As New Matriz8()
ma.Cargar()
ma.ImprimirVertices()
End Sub

End Module
23 - Matrices y vectores paralelos

Dependiendo de la complejidad del problema podemos necesitar el empleo de vectores y matrices paralelos.
Problema 1:
Se tiene la siguiente información:
· Nombres de 4 empleados.
· Ingresos en concepto de sueldo, cobrado por cada empleado, en los últimos 3 meses.
Confeccionar un programa para:
a) Realizar la carga de la información mencionada.
b) Generar un vector que contenga el ingreso acumulado en sueldos en los últimos 3 meses para cada empleado.
c) Mostrar por pantalla el total pagado en sueldos a todos los empleados en los últimos 3 meses
d) Obtener el nombre del empleado que tuvo el mayor ingreso acumulado

Programa:
Module Module1

Public Class Matriz9

Private empleados(3) As String

Private sueldos(3, 2) As Integer
Private sueldostot(3) As Integer

Public Sub Cargar()

Dim f, c As Integer
For f = 0 To empleados.GetUpperBound(0)
Console.Write("Ingrese el nombre del empleado:")
empleados(f) = Console.ReadLine()
For c = 0 To sueldos.GetUpperBound(1)
Console.Write("Ingrese sueldo:")

Página 107 de 190

 sueldos(f, c) = Console.ReadLine()
Next
Next
End Sub

Public Sub CalcularSumaSueldos()

Dim f, c As Integer
For f = 0 To sueldos.GetUpperBound(0)
Dim suma As Integer = 0
For c = 0 To sueldos.GetUpperBound(1)
suma = suma + sueldos(f, c)
Next
sueldostot(f) = suma
Next
End Sub

Public Sub ImprimirTotalPagado()

Console.WriteLine("Total de sueldos pagados por empleado.")
Dim f As Integer
For f = 0 To sueldos.GetUpperBound(0)
Console.WriteLine(empleados(f) & " - " & sueldostot(f))
Next
End Sub

Public Sub EmpleadoMayorSueldo()

Dim may As Integer = sueldostot(0)
Dim nom As String = empleados(0)
Dim f As Integer
For f = 0 To sueldostot.GetUpperBound(0)
If sueldostot(f) > may Then
may = sueldostot(f)
nom = empleados(f)
End If
Next
Console.WriteLine("El empleado con mayor sueldo es " & nom &
" que cobró en los últimos 3 meses " & may)
End Sub

End Class

Sub Main()
Dim ma As New Matriz9()
ma.Cargar()
ma.CalcularSumaSueldos()
ma.ImprimirTotalPagado()
ma.EmpleadoMayorSueldo()
Console.ReadKey()
End Sub

End Module
Para resolver este problema lo primero que hacemos es definir una matriz donde se almacenarán los sueldos
mensuales de cada empleado, un vector de tipo String donde almacenaremos los nombre de cada empleado y
finalmente definimos un vector paralelo a la matriz donde almacenaremos la suma de cada fila de la matriz:
Private empleados(3) As String
Private sueldos(3, 2) As Integer
Private sueldostot(3) As Integer

Página 108 de 190

En el método de cargar inicializamos el vector con los nombres de los empleados y la matriz paralela donde se
almacenan los últimos tres sueldos :
Public Sub Cargar()
Dim f, c As Integer
For f = 0 To empleados.GetUpperBound(0)
Console.Write("Ingrese el nombre del empleado:")
empleados(f) = Console.ReadLine()
For c = 0 To sueldos.GetUpperBound(1)
Console.Write("Ingrese sueldo:")
sueldos(f, c) = Console.ReadLine()
Next
Next
End Sub
El método sumar sueldos almacenamos en otro vector la suma de cada fila de la matriz. Mediante dos for
recorremos toda la matriz y sumamos cada fila:
Public Sub CalcularSumaSueldos()
Dim f, c As Integer
For f = 0 To sueldos.GetUpperBound(0)
Dim suma As Integer = 0
For c = 0 To sueldos.GetUpperBound(1)
suma = suma + sueldos(f, c)
Next
sueldostot(f) = suma
Next
End Sub
El método ImprimirTotalPagado tiene por objetivo mostrar los dos vectores (el de nombre de los empleados y el que
almacena la suma de cada fila de la matriz):
Public Sub ImprimirTotalPagado()
Console.WriteLine("Total de sueldos pagados por empleado.")
Dim f As Integer
For f = 0 To sueldos.GetUpperBound(0)
Console.WriteLine(empleados(f) & " - " & sueldostot(f))
Next
End Sub
Por último para obtener el nombre del empleado con mayor sueldo acumulado debemos inicializar dos variables
auxiliares con el primer elemento del vector de empleados y en otra auxiliar guardamos la primer componente del
vector sueldostot:
Public Sub EmpleadoMayorSueldo()
Dim may As Integer = sueldostot(0)
Dim nom As String = empleados(0)
Dim f As Integer
For f = 0 To sueldostot.GetUpperBound(0)
If sueldostot(f) > may Then
may = sueldostot(f)
nom = empleados(f)
End If
Next
Console.WriteLine("El empleado con mayor sueldo es " & nom & " que cobró en los últimos 3 meses
" & may)
End Sub

Problema propuesto

Página 109 de 190

Se desea saber la temperatura media trimestral de cuatro paises. Para ello se tiene como dato las temperaturas
medias mensuales de dichos paises.
Se debe ingresar el nombre del país y seguidamente las tres temperaturas medias mensuales.
Seleccionar las estructuras de datos adecuadas para el almacenamiento de los datos en memoria.
a - Cargar por teclado los nombres de los paises y las temperaturas medias mensuales.
b - Imprimir los nombres de las paises y las temperaturas medias mensuales de las mismas.
c - Calcular la temperatura media trimestral de cada país.
c - Imprimr los nombres de las provincias y las temperaturas medias trimestrales.
b - Imprimir el nombre de la provincia con la temperatura media trimestral mayor.
Module Module1
Public Class Matriz10

Private paises(3) As String

Private tempmen(3, 2) As Integer
Private temptri(3) As Integer

Public Sub Cargar()

Dim f, c As Integer
For f = 0 To paises.GetUpperBound(0)
Console.Write("Ingrese el nombre del país:")
paises(f) = Console.ReadLine()
For c = 0 To tempmen.GetUpperBound(1)
Console.Write("Ingrese temperatura mensual:")
tempmen(f, c) = Console.ReadLine()
Next
Next
End Sub

Public Sub ImprimirTempMensuales()

Dim f, c As Integer
For f = 0 To paises.GetUpperBound(0)
Console.Write("Pais:" & paises(f) & ":")
For c = 0 To tempmen.GetUpperBound(1)
Console.Write(tempmen(f, c) & " ")
Next
Console.WriteLine()
Next
End Sub

Public Sub CalcularTemperaturaTri()

Dim f, c As Integer
For f = 0 To tempmen.GetUpperBound(0)
Dim suma As Integer = 0
For c = 0 To tempmen.GetUpperBound(1)
suma = suma + tempmen(f, c)
temptri(f) = suma / 3
Next
Next
End Sub

Public Sub ImprimirTempTrimestrales()

Console.WriteLine("Temperaturas trimestrales.")
Dim f, c As Integer
For f = 0 To paises.GetUpperBound(0)
Console.WriteLine(paises(f) & " " & temptri(f))
Next

Página 110 de 190

 End Sub

Public Sub PaisMayorTemperaturaTri()

Dim may As Integer = temptri(0)
Dim nom As String = paises(0)
Dim f As Integer
For f = 0 To paises.GetUpperBound(0)
If temptri(f) > may Then
may = temptri(f)
nom = paises(f)
End If
Next
Console.WriteLine("Pais con temperatura trimestral mayor es
" & nom & " que tiene una temperatura de " & may)
End Sub

End Class

Sub Main()
Dim ma As New Matriz10()
ma.Cargar()
ma.ImprimirTempMensuales()
ma.CalcularTemperaturaTri()
ma.ImprimirTempTrimestrales()
ma.PaisMayorTemperaturaTri()
Console.ReadKey()
End Sub

End Module
24 - Matrices irregulares o escalonadas

Visual Basic .Net nos permite crear matrices irregulares o escalonadas. Se dice que una matriz es irregular si la
cantidad de elementos de cada fila varía. Luego podemos imaginar una matriz irregular:

Como podemos ver la fila cero tiene reservado dos espacios, la fila uno reserva cuatro espacios y la última fila
reserva espacio para tres componentes.
La sintaxis para declarar un atributo de tipo matriz irregular es:
Private mat()() As Integer
Primero creamos la cantidad de filas dejando vacío el espacio que indica la cantidad de columnas, en nuestro
ejemplo la matriz tiene 3 filas (disponemos un 2 ya que las filas comienzan a numerarse desde cero):
mat = New Integer(2)() {}
Luego debemos ir creando cada fila de la matriz indicando el índice de la respectiva fila:
mat(0) = New Integer(1) {}
mat(1) = New Integer(3) {}
mat(0) = New Integer(2) {}
Luego la forma para acceder a sus componentes debe ser utilizando paréntesis abiertos y cerrados para cada índice:
mat(0)(0) = 19
Dará un error si queremos cargar la tercer componente de la fila cero (esto debido a que no existe):
mat(0)(2) = 230
Luego si queremos saber la cantidad de filas que tiene la matriz:
Console.Write(mat.GetUpperBound(0))
Si queremos saber la cantidad de elementos de una determinada fila:

Página 111 de 190

Console.Write("Cantidad de elementos de la fila 0:" & mat(0).GetUpperBound(0))
Console.Write("Cantidad de elementos de la fila 1:" & mat(1).GetUpperBound(0))
Console.Write("Cantidad de elementos de la fila 2:" & mat(2).GetUpperBound(0))
Problema 1:
Confeccionaremos un programa que permita crear una matriz irregular y luego imprimir la matriz en forma
completa.
Programa:
Module Module1
Public Class MatrizIrregular1

Private mat()() As Integer

Public Sub Cargar()

Dim filas As Integer
Console.Write("Cuantas fila tiene la matriz:")
filas = Console.ReadLine()
mat = New Integer(filas - 1)() {}
Dim f, c As Integer
For f = 0 To mat.GetUpperBound(0)
Console.Write("Cuantas elementos tiene la fila " & f &
":")
Dim elemento As Integer = Console.ReadLine()
mat(f) = New Integer(elemento - 1) {}
For c = 0 To mat(f).GetUpperBound(0)
Console.Write("Ingrese componente:")
mat(f)(c) = Console.ReadLine()
Next
Next
End Sub

Public Sub Imprimir()

Dim f, c As Integer
For f = 0 To mat.GetUpperBound(0)
For c = 0 To mat(f).GetUpperBound(0)
Console.Write(mat(f)(c) & " ")
Next
Console.WriteLine()
Next
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim mi As New MatrizIrregular1()
mi.Cargar()
mi.Imprimir()
End Sub

End Module
El resultado de ejecutar este programa es:

Página 112 de 190

Declaramos una matriz irregular:
Private mat()() As Integer
Primero creamos la cantidad de filas que tendrá la matriz (en los paréntesis para las columnas no disponemos valor):
Dim filas As Integer
Console.Write("Cuantas fila tiene la matriz:")
filas = Console.ReadLine()
mat = New Integer(filas - 1)() {}
Dentro del primer For pedimos que ingrese la cantidad de elementos que tendrá cada fila y utilizamos el operador
New nuevamente, pero en este caso se están creando cada fila de la matriz (Visual Basic .Net trata a cada fila como
un vector):
For f = 0 To mat.GetUpperBound(0)
Console.Write("Cuantas elementos tiene la fila " & f & ":")
Dim elemento As Integer = Console.ReadLine()
mat(f) = New Integer(elemento - 1) {}
Dentro del For interno hacemos la carga de las componentes propiamente dicho de la matriz irregular (podemos ir
cargando cada fila a medida que las vamos creando):
For c = 0 To mat(f).GetUpperBound(0)
Console.Write("Ingrese componente:")
mat(f)(c) = Console.ReadLine()
Next
Luego imprimimos la matriz en forma completa teniendo cuidado los valores finales de cada For.
El primer For se repite tantas veces como filas tiene la matriz: mat.GetUpperBound(0) y
el For interno se repite tantas veces como elementos tiene la fila que estamos procesando
mat(f).GetUpperBound(0):
Public Sub Imprimir()
Dim f, c As Integer
For f = 0 To mat.GetUpperBound(0)
For c = 0 To mat(f).GetUpperBound(0)
Console.Write(mat(f)(c) & " ")
Next
Console.WriteLine()
Next
Console.ReadKey()
End Sub
Problemas propuestos
Confeccionar una clase para administrar una matriz irregular de 5 filas y 1 columna la primer fila, 2 columnas la
segunda fila y así sucesivamente hasta 5 columnas la última fila (crearla sin la intervención del operador)
Realizar la carga por teclado e imprimir posteriormente.

Página 113 de 190

Confeccionar una clase para administrar los días que han faltado los 3 empleados de una empresa.
Definir un vector de 3 elementos de tipo string para cargar los nombres y una matriz irregular para cargar los días
que han faltado cada empleado (cargar el número de día que faltó)
Cada fila de la matriz representan los días de cada empleado.
Mostrar los empleados con la cantidad de inasistencias.
Cuál empleado faltó menos días.
Module Module1

Public Class MatrizIrregular2

Private mat()() As Integer

Public Sub Cargar()

mat = New Integer(4)() {}
Dim f, c As Integer
For f = 0 To mat.GetUpperBound(0)
mat(f) = New Integer(f) {}
For c = 0 To mat(f).GetUpperBound(0)
Console.Write("Ingrese componente:")
mat(f)(c) = Console.ReadLine()
Next
Next
End Sub

Public Sub Imprimir()

Dim f, c As Integer
For f = 0 To mat.GetUpperBound(0)
For c = 0 To mat(f).GetUpperBound(0)
Console.Write(mat(f)(c) & " ")
Next
Console.WriteLine()
Next
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim ma As New MatrizIrregular2()
ma.Cargar()
ma.Imprimir()
End Sub

End Module

Module Module1
Public Class MatrizIrregular3

Private nombres(2) As String

Private dias()() As Integer

Public Sub Cargar()

dias = New Integer(2)() {}
Dim f, c As Integer
For f = 0 To nombres.GetUpperBound(0)
Console.Write("Ingrese el nombre del empleado:")
nombres(f) = Console.ReadLine()

Página 114 de 190

 Console.Write("Cuantas días faltó el empleado:")
Dim faltas As Integer
faltas = Console.ReadLine()
dias(f) = New Integer(faltas - 1) {}
For c = 0 To dias(f).GetUpperBound(0)
Console.Write("Ingrese nro de día:")
dias(f)(c) = Console.ReadLine()
Next
Next
End Sub

Public Sub Inasistencias()

Dim f As Integer
For f = 0 To nombres.GetUpperBound(0)
Console.WriteLine(nombres(f) & " faltó " &
(dias(f).GetUpperBound(0) + 1) & " días")
Next
End Sub

Public Sub EmpleadoMensosFaltas()

Dim faltas As Integer = dias(0).GetUpperBound(0)
Dim nom As String = nombres(0)
Dim f As Integer
For f = 1 To dias.GetUpperBound(0)
If dias(f).GetUpperBound(0) < faltas Then
faltas = dias(f).GetUpperBound(0)
nom = nombres(f)
End If
Next
Console.WriteLine("El empleado que faltó menos es " & nom &
" con " & (faltas + 1) & " faltas.")
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim ma = New MatrizIrregular3()
ma.Cargar()
ma.Inasistencias()
ma.EmpleadoMensosFaltas()
End Sub

End Module
25 - Constructor de la clase

En Visual Basic .net podemos definir un método que se ejecute inicialmente y en forma automática. Este método se
lo llama constructor de la clase.
El constructor tiene las siguientes características:
Es un procedimiento, es decir se lo define con Sub.
Su nombre debe ser New.
Es el primer método que se ejecuta.
Se ejecuta en forma automática.
Se ejecuta una única vez.
Puede tener parámetros.
Un constructor tiene por objetivo inicializar atributos o propiedades de la clase.
Problema 1:

Página 115 de 190

Se desea guardar los sueldos de 5 operarios en un vector. Realizar la creación y carga del vector en el constructor.
Programa:
Module Module1
Public Class PruebaConstructor

Private sueldos(4) As Integer

Public Sub New()

Dim f As Integer
For f = 0 To sueldos.GetUpperBound(0)
Console.Write("Ingrese el sueldo:")
sueldos(f) = Console.ReadLine()
Next
End Sub

Public Sub Imprimir()

Dim f As Integer
For f = 0 To sueldos.GetUpperBound(0)
Console.WriteLine(sueldos(f))
Next
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim op As New PruebaConstructor()
op.Imprimir()
End Sub

End Module
Como podemos ver es el mismo problema que resolvimos cuando vimos vectores. La diferencia es que hemos
sustituido el método Cargar con el constructor:
Public Sub New()
Dim f As Integer
For f = 0 To sueldos.GetUpperBound(0)
Console.Write("Ingrese el sueldo:")
sueldos(f) = Console.ReadLine()
Next
End Sub
Debe llamarse obligatoriamente New, no hay forma que no se ejecute el constructor.
La ventaja de plantear un constructor en lugar de definir un método con cualquier nombre es que se llamará en
forma automática cuando se crea un objeto de esta clase:
Dim op As New PruebaConstructor()
Cuando se crea el objeto op se llama al método New en forma automática por tener definido un constructor la clase.
Finalmente llamamos al método imprimir:
op.Imprimir()
Problema 2:
Plantear una clase llamada Alumno y definir como atributos su nombre y su edad. En el constructor realizar la carga
de datos. Definir otros dos métodos para imprimir los datos ingresados y un mensaje si es mayor o no de edad (edad
>=18)
Programa:
Module Module1

Public Class Alumno

Página 116 de 190

 Private nombre As String
Private edad As Integer

Public Sub New()

Console.Write("Ingrese nombre:")
nombre = Console.ReadLine()
Console.Write("Ingrese edad:")
edad = Console.ReadLine()
End Sub

Public Sub Imprimir()

Console.WriteLine("Nombre:" & nombre)
Console.WriteLine("Edad:" & edad)
End Sub

Public Sub EsMayorEdad()

If edad >= 18 Then
Console.Write(nombre & " es mayor de edad.")
Else
Console.Write(nombre & " no es mayor de edad.")
End If
End Sub
End Class

Sub Main()
Dim alumno1 = New Alumno()
alumno1.Imprimir()
alumno1.EsMayorEdad()
Console.ReadKey()
End Sub

End Module
Declaramos la clase Alumno, sus dos atributos y definimos el constructor:
Public Class Alumno

Private nombre As String

Private edad As Integer

Public Sub New()

Console.Write("Ingrese nombre:")
nombre = Console.ReadLine()
Console.Write("Ingrese edad:")
edad = Console.ReadLine()
End Sub
En la Main el constructor se llama en forma automática cuando creamos un objeto de la clase Alumno:
Sub Main()
Dim alumno1 = New Alumno()
Los otros dos métodos deben llamarse por su nombre y en el orden que necesitemos:
alumno1.Imprimir()
alumno1.EsMayorEdad()
Problemas propuestos
Confeccionar una clase que represente un empleado. Definir como atributos su nombre y su sueldo. En el
constructor cargar los atributos y luego en otro método imprimir sus datos y por último uno que imprima un
mensaje si debe pagar impuestos (si el sueldo supera a 3000)

Página 117 de 190

Implementar la clase operaciones. Se deben cargar dos valores enteros en el constructor, calcular su suma, resta,
multiplicación y división, cada una en un método, imprimir dichos resultados.
Module Module1

Public Class EmpleadoFabrica

Private nombre As String

Private sueldo As Single

Public Sub New()

Console.Write("Ingrese el nombre del empleado:")
nombre = Console.ReadLine()
Console.Write("Ingrese su sueldo:")
sueldo = Console.ReadLine()
End Sub

Public Sub PagaImpuestos()

If sueldo > 3000 Then
Console.Write("Debe abonar impuestos")
Else
Console.Write("No paga impuestos")
End If
Console.ReadKey()
End Sub

End Class

Sub Main()
Dim empleado1 As New EmpleadoFabrica()
empleado1.PagaImpuestos()
End Sub

End Module

Module Module1
Public Class OperacionesCalculo

Private valor1, valor2 As Integer

Public Sub New()

Console.Write("Ingrese primer valor:")
valor1 = Console.ReadLine()
Console.Write("Ingrese segundo valor:")
valor2 = Console.ReadLine()
End Sub

Public Sub Sumar()

Dim suma As Integer
suma = valor1 + valor2
Console.WriteLine("La suma es:" & suma)
End Sub

Public Sub Restar()

Dim resta As Integer
resta = valor1 - valor2

Página 118 de 190

 Console.WriteLine("La resta es:" & resta)
End Sub

Public Sub Multiplicar()

Dim multiplicacion As Integer
multiplicacion = valor1 * valor2
Console.WriteLine("La multiplicación es:" & multiplicacion)
End Sub

Public Sub Dividir()

Dim division As Integer
division = valor1 / valor2
Console.WriteLine("La división es:" & division)
End Sub

End Class

Sub Main()
Dim opera As New OperacionesCalculo()
opera.Sumar()
opera.Restar()
opera.Multiplicar()
opera.Dividir()
Console.ReadKey()
End Sub

End Module
26 - Colaboración de clases
Normalmente un problema resuelto con la metodología de programación orientada a objetos no interviene una sola
clase, sino que hay muchas clases que interactúan y se comunican.
Plantearemos un problema separando las actividades en dos clases.
Problema 1:
Un banco tiene 3 clientes que pueden hacer depósitos y extracciones. También el banco requiere que al final del día
calcule la cantidad de dinero que hay depositada.
Lo primero que hacemos es identificar las clases:
Podemos identificar la clase Cliente y la clase Banco.
Luego debemos definir los atributos y los métodos de cada clase:
Cliente
atributos
nombre
monto
métodos
constructor
Depositar
Extraer
RetornarMonto

Banco
atributos
3 Cliente (3 objetos de la clase Cliente)
métodos
constructor
Operar
DepositosTotales

Página 119 de 190

Creamos un proyecto llamado: Colaboracion1 y dentro del proyecto creamos dos clases llamadas: Cliente y Banco.
Programa:
Module Module1
Public Class Cliente

Private nombre As String

Private monto As Integer

Public Sub New(ByVal nom As String)

nombre = nom
monto = 0
End Sub

Public Sub Depositar(ByVal m As Integer)

monto = monto + m
End Sub

Public Sub Extraer(ByVal m As Integer)

monto = monto - m
End Sub

Public Function RetornarMonto() As Integer

Return monto
End Function

Public Sub Imprimir()

Console.WriteLine(nombre & " tiene depositado la suma de " &
monto)
End Sub
End Class

Public Class Banco

Private cliente1, cliente2, cliente3 As Cliente

Public Sub New()

cliente1 = New Cliente("Juan")
cliente2 = New Cliente("Ana")
cliente3 = New Cliente("Pedro")
End Sub

Public Sub Operar()

cliente1.Depositar(100)
cliente2.Depositar(150)
cliente3.Depositar(200)
cliente3.Extraer(150)
End Sub

Public Sub DepositosTotales()

Dim t As Integer = cliente1.RetornarMonto() +
cliente2.RetornarMonto() +
cliente3.RetornarMonto()
cliente1.Imprimir()
cliente2.Imprimir()
cliente3.Imprimir()
Console.WriteLine("El total de dinero en el banco es:" & t)

Página 120 de 190

 End Sub
End Class

Sub Main()
Dim banco1 As New Banco()
banco1.Operar()
banco1.DepositosTotales()
Console.ReadKey()
End Sub

End Module
Analicemos la implementación del problema.
Los atributos de una clase normalmente son privados para que no se tenga acceso directamente desde otra clase, los
atributos son modificados por los métodos de la misma clase:
Public Class Cliente

Private nombre As String

Private monto As Integer
El constructor recibe como parámetro el nombre del cliente y lo almacena en el atributo respectivo e inicializa el
atributo monto en cero:
Public Sub New(ByVal nom As String)
nombre = nom
monto = 0
End Sub
Los métodos Depositar y Extraer actualizan el atributo monto con el dinero que llega como parámetro (para
simplificar el problema no hemos validado que cuando se extrae dinero el atributo monto quede con un valor
negativo):
Public Sub Depositar(ByVal m As Integer)
monto = monto + m
End Sub

Public Sub Extraer(ByVal m As Integer)

monto = monto - m
End Sub
El método RetornarMonto tiene por objetivo comunicar al Banco la cantidad de dinero que tiene el cliente
(recordemos que como el atributo monto es privado de la clase, debemos tener un método que lo retorne):
Public Function RetornarMonto() As Integer
Return monto
End Function
Por último el método imprimir muestra nombre y el monto de dinero del cliente:
Public Sub Imprimir()
Console.WriteLine(nombre & " tiene depositado la suma de " & monto)
End Sub
Donde definimos objetos de la clase Cliente?
La respuesta a esta pregunta es que en la clase Banco definimos tres objetos de la clase Cliente.
Veamos ahora la clase Banco que requiere la colaboración de la clase Cliente.
Primero definimos tres atributos de tipo Cliente:
Public Class Banco

Private cliente1, cliente2, cliente3 As Cliente

En le constructor creamos los tres objetos (cada vez que creamos un objeto de la clase Cliente debemos pasar a su
constructor el nombre del cliente, recordemos que su monto de depósito se inicializa con cero):
Public Sub New()

Página 121 de 190

 cliente1 = New Cliente("Juan")
cliente2 = New Cliente("Ana")
cliente3 = New Cliente("Pedro")
End Sub
El método operar del banco (llamamos a los métodos Depositar y Extraer de los clientes):
Public Sub Operar()
cliente1.Depositar(100)
cliente2.Depositar(150)
cliente3.Depositar(200)
cliente3.Extraer(150)
End Sub
El método DepositosTotales obtiene el monto depositado de cada uno de los tres clientes, procede a mostrarlos y
llama al método imprimir de cada cliente para poder mostrar el nombre y depósito:
Public Sub DepositosTotales()
Dim t As Integer = cliente1.RetornarMonto() +
cliente2.RetornarMonto() +
cliente3.RetornarMonto()
cliente1.Imprimir()
cliente2.Imprimir()
cliente3.Imprimir()
Console.WriteLine("El total de dinero en el banco es:" & t)
End Sub
Por último en la Main definimos un objeto de la clase Banco (la clase Banco es la clase principal en nuestro
problema):
Sub Main()
Dim banco1 As New Banco()
banco1.Operar()
banco1.DepositosTotales()
Console.ReadKey()
End Sub
Problema 2:
Plantear un programa que permita jugar a los dados. Las reglas de juego son: se tiran tres dados si los tres salen con
el mismo valor mostrar un mensaje que "gano", sino "perdió".
Lo primero que hacemos es identificar las clases:
Podemos identificar la clase Dado y la clase JuegoDeDados.
Luego los atributos y los métodos de cada clase:
Dado
atributos
valor
métodos
constructor
Tirar
Imprimir
RetornarValor

JuegoDeDados
atributos
3 Dado (3 objetos de la clase Dado)
métodos
constructor
Jugar
Creamos un proyecto llamado: Colaboracion2 y dentro del proyecto creamos dos clases llamadas: Dado y
JuegoDeDados.

Página 122 de 190

Programa:
Module Module1

Public Class Dado

Private valor As Integer

Private Shared ale As Random

Public Sub New()

ale = New Random()
End Sub

Public Sub Tirar()

valor = ale.Next(1, 7)
End Sub

Public Sub Imprimir()

Console.WriteLine("El valor del dado es:" & valor)
End Sub

Public Function RetornarValor() As Integer

Return valor
End Function

End Class

Public Class JuegoDeDados

Private dado1, dado2, dado3 As Dado

Public Sub New()

dado1 = New Dado()
dado2 = New Dado()
dado3 = New Dado()
End Sub

Public Sub Jugar()

dado1.Tirar()
dado1.Imprimir()
dado2.Tirar()
dado2.Imprimir()
dado3.Tirar()
dado3.Imprimir()
If dado1.RetornarValor() = dado2.RetornarValor() And
dado1.RetornarValor() = dado3.RetornarValor() Then
Console.WriteLine("Ganó")
Else
Console.WriteLine("Perdió")
End If
Console.ReadKey()
End Sub

End Class

Sub Main()
Dim j = New JuegoDeDados()

Página 123 de 190

 j.Jugar()
End Sub

End Module
La clase Dado define el atributo "valor" donde almacenamos un valor aleatorio que representa el número que sale al
el dado.
Definimos otro atributo de la clase Random. Esta clase nos facilita la generación de un número aleatorio que nos
indicará el valor del dato. Como luego se crearán tres objetos de la clase dado y nosotros solo requerimos un objeto
de la clase Random luego definimos el atributo de tipo Shared, con esto todos los objetos de la clase Dado acceden
al mismo objeto de la clase Random:
Public Class Dado

Private valor As Integer

Private Shared ale As Random
En el constructor creamos el objeto de la clase Random:
Public Sub New()
ale = New Random()
End Sub
El método Tirar almacena el valor aleatorio (para generar un valor aleatorio utilizamos el método Next de la clase
Random, el mismo genera un valor entero comprendido entre los dos parámetros que le pasamos (nunca genera la
cota superior):
Public Sub Tirar()
valor = ale.Next(1, 7)
End Sub
El método Imprimir de la clase Dado muestra por pantalla el valor del dado:
Public Sub Imprimir()
Console.WriteLine("El valor del dado es:" & valor)
End Sub
Por último el método que retorna el valor del dado (se utiliza en la otra clase para ver si los tres dados generaron el
mismo valor):
Public Function RetornarValor() As Integer
Return valor
End Function
La clase JuegoDeDatos define tres atributos de la clase Dado (con esto decimos que la clase Dado colabora con la
clase JuegoDeDados):
Public Class JuegoDeDados

Private dado1, dado2, dado3 As Dado

En el constructor procedemos a crear los tres objetos de la clase Dado:
Public Sub New()
dado1 = New Dado()
dado2 = New Dado()
dado3 = New Dado()
End Sub
En el método Jugar llamamos al método Tirar de cada dado, pedimos que se imprima el valor generado y finalmente
procedemos a verificar si se ganó o no:
Public Sub Jugar()
dado1.Tirar()
dado1.Imprimir()
dado2.Tirar()
dado2.Imprimir()
dado3.Tirar()
dado3.Imprimir()
If dado1.RetornarValor() = dado2.RetornarValor() And

Página 124 de 190

 dado1.RetornarValor() = dado3.RetornarValor() Then
Console.WriteLine("Ganó")
Else
Console.WriteLine("Perdió")
End If
Console.ReadKey()
End Sub
En la Main creamos solo un objeto de la clase principal (en este caso la clase principal es el JuegoDeDados):
Sub Main()
Dim j = New JuegoDeDados()
j.Jugar()
End Sub
Problemas propuestos
Plantear una clase Club y otra clase Socio.
La clase Socio debe tener los siguientes atributos privados: nombre y la antigüedad en el club (en años). En el
constructor pedir la carga del nombre y su antigüedad. La clase Club debe tener como atributos 3 objetos de la clase
Socio. Definir una responsabilidad para imprimir el nombre del socio con mayor antigüedad en el club.
Module Module1

Public Class Socio

Private nombre As String

Private antiguedad As Integer

Public Sub New()

Console.Write("Ingrese el nombre del socio:")
nombre = Console.ReadLine()
Console.Write("Ingrese la antiguedad:")
antiguedad = Console.ReadLine()
End Sub

Public Sub Imprimir()

Console.WriteLine(nombre + " tiene una antiguedad de " &
antiguedad)
End Sub

Public Function RetornarAntiguedad() As Integer

Return antiguedad
End Function

End Class

Class Club

Private socio1, socio2, socio3 As Socio

Public Sub New()

socio1 = New Socio()
socio2 = New Socio()
socio3 = New Socio()
End Sub

Public Sub MayorAntiguedad()

Console.Write("Socio con mayor antiguedad:")

Página 125 de 190

 If socio1.RetornarAntiguedad() > socio2.RetornarAntiguedad()
And
socio1.RetornarAntiguedad() > socio3.RetornarAntiguedad()
Then
socio1.Imprimir()
Else
If socio2.RetornarAntiguedad() >
socio3.RetornarAntiguedad() Then
socio2.Imprimir()
Else
socio3.Imprimir()
End If
End If
End Sub

End Class

Sub Main()
Dim club1 = New Club()
club1.MayorAntiguedad()
Console.ReadKey()
End Sub

End Module
27 - Concepto de propiedad
Muchos lenguajes de programación orientado a objetos acceden a sus atributos a través de métodos. Esto lo vimos
en el concepto anterior cuando accedíamos al atributo monto de un cliente:
Public Sub Depositar(ByVal m As Integer)
monto = monto + m
End Sub

Public Function RetornarMonto() As Integer

Return monto
End Function
Vimos que luego llamamos a dichos métodos con la sintaxis:
cliente3.Depositar(200)
cliente3.Extraer(150)
En Visual Basic .Net normalmente este tipo de problemas se lo resuelve implementado una propiedad. Veamos el
mismo problemas resolviéndolo utilizando propiedades.
Problema 1:
El problema era : Un banco tiene 3 clientes que pueden hacer depósitos y extracciones. También el banco requiere
que al final del día calcule la cantidad de dinero que hay depositada.
Programa:
Module Module1
Class Cliente

Private _nombre As String

Private _monto As Integer

Public Property nombre() As String

Get
Return _nombre
End Get
Set(ByVal value As String)

Página 126 de 190

 _nombre = value
End Set
End Property

Public Property monto() As Integer

Get
Return _monto
End Get
Set(ByVal value As Integer)
_monto = value
End Set
End Property

Public Sub Imprimir()

Console.WriteLine(nombre & " tiene depositado la suma de " &
monto)
End Sub

End Class

Public Class Banco

Private cliente1, cliente2, cliente3 As Cliente

Public Sub New()

cliente1 = New Cliente()
cliente1.nombre = "Juan"
cliente1.monto = 0
cliente2 = New Cliente()
cliente2.nombre = "Ana"
cliente2.monto = 0
cliente3 = New Cliente()
cliente3.nombre = "Pedro"
cliente3.monto = 0
End Sub

Public Sub Operar()

cliente1.monto = cliente1.monto + 100
cliente2.monto = cliente2.monto + 150
cliente3.monto = cliente3.monto + 200
End Sub

Public Sub DepositosTotales()

Dim t As Integer = cliente1.monto + cliente2.monto +
cliente3.monto
Console.WriteLine("El total de dinero en el banco es:" & t)
cliente1.Imprimir()
cliente2.Imprimir()
cliente3.Imprimir()
End Sub
End Class

Sub Main()
Dim banco1 = New Banco()
banco1.Operar()

Página 127 de 190

 banco1.DepositosTotales()
Console.ReadKey()
End Sub

End Module
Lo más importante es entender que una propiedad es una forma de acceder al contenido de un atributo, tanto para
consultar su valor como modificarlo.

Class Cliente

Private _nombre As String

Private _monto As Integer

Public Property nombre() As String

Get
Return _nombre
End Get
Set(ByVal value As String)
_nombre = value
End Set
End Property

Public Property monto() As Integer

Get
Return _monto
End Get
Set(ByVal value As Integer)
_monto = value
End Set
End Property
Los atributos los llamamos _nombre y _monto. Las propiedades las llamamos nombre y monto. Las propiedades no
almacenan valores sino que normalmente acceden a los atributos para modificarlos o consultarlos.
La propiedad Nombre mediante el modificador set inicializa el atributo _nombre con el valor que llega del objeto:
cliente1.nombre = "Juan"
Como vemos donde definimos el objeto cliente1 accedemos a la propiedad mediante el operador punto y le
asignamos un valor (en este caso un String porque la propiedad es de tipo String)
Si queremos consultar el atributo nombre lo podemos hacer mediante la propiedad Nombre. Es común definir el
nombre que le damos al atributo con el mismo nombre que tiene la propiedad pero agregando el caracter _:
'atributo _monto
Private _monto As Integer

'propiedad monto
Public Property monto() As Integer
Get
'valor devuelto por la propiedad
Return _monto
End Get
Set(ByVal value As Integer)
'value indica el valor que se le asigna a la propiedad
_monto = value
End Set
End Property

Página 128 de 190

Podemos observar que la sintaxis para acceder a las propiedades donde definimos objetos es mucho mas intuitiva y
sencillas, por ejemplo para saber cuanto dinero hay en el banco la sintaxis con propiedades es:
Dim t As Integer = cliente1.monto + cliente2.monto + cliente3.monto
Y como la vimos anteriormente por medio de un método que retorna el monto tenemos la siguiente sintaxis:
Dim t As Integer = cliente1.RetornarMonto() +
cliente2.RetornarMonto() +
cliente3.RetornarMonto()
Lo primero que nos viene a la mente es porque no definir los atributos con el modificador Public :
Public _monto as Integer
Para luego poder consultarlos y/o modificarlos con la sintaxis:
dim t as Integer = cliente1._monto + cliente2._monto + cliente3._monto
Ahora veamos que cuando consultamos o inicializamos una propiedad en realidad lo que está sucediendo es la
ejecución de un método (Set o Get) donde podemos disponer código donde validar el valor asignado. Por ejemplo si
disponemos la restricción que el Monto siempre debe ser positivo para que se almacene, luego debemos codificar la
propiedad con la siguiente sintaxis:
Public Property monto() As Integer
Get
Return _monto
End Get
Set(ByVal value As Integer)
If (value >> 0) Then
_monto = value
Else
Console.WriteLine("No se puede tener un monto negativo.")
End If
End Set
End Property
Es decir si el valor que le asignamos a la propiedad Monto es negativo luego no se inicializa el atributo _monto con
dicho valor.
Si ejecutamos este código luego debe mostrar un mensaje indicando que "No se puede tener monto negativo":
cliente1.Monto = -100
Problema 2:
Plantear un programa que permita jugar a los dados. Las reglas de juego son: se tiran tres dados si los tres salen con
el mismo valor mostrar un mensaje que "gano", sino "perdió".
Programa:
Module Module1
Public Class Dado

Private _valor As Integer

Public Property valor() As Integer

Get
Return _valor
End Get
Private Set(value As Integer)
_valor = value
End Set
End Property

Private Shared aleatorio As Random

Public Sub New()

aleatorio = New Random()
End Sub

Página 129 de 190

 Public Sub Tirar()
valor = aleatorio.Next(1, 7)
End Sub

Public Sub Imprimir()

Console.WriteLine("El valor del dado es:" & valor)
End Sub

End Class

Public Class JuegoDeDados

Private dado1, dado2, dado3 As Dado

Public Sub New()

dado1 = New Dado()
dado2 = New Dado()
dado3 = New Dado()
End Sub

Public Sub Jugar()

dado1.Tirar()
dado1.Imprimir()
dado2.Tirar()
dado2.Imprimir()
dado3.Tirar()
dado3.Imprimir()
If dado1.valor = dado2.valor And dado1.valor = dado3.valor
Then
Console.WriteLine("Ganó")
Else
Console.WriteLine("Perdió")
End If
Console.ReadKey()
End Sub
End Class

Sub Main()
Dim j = New JuegoDeDados()
j.Jugar()
End Sub

End Module
El atributo _valor se lo accede por medio de la propiedad valor:
Private _valor As Integer

Public Property valor() As Integer

Get
Return _valor
End Get
Set(value As Integer)
_valor = value
End Set
End Property
Luego cuando queremos consultar el valor del dado desde el jugo de dados por medio de la sintaxis siguiente
podemos comparar si los tres dados tienen el mismo número:

Página 130 de 190

 If dado1.valor = dado2.valor And dado1.valor = dado3.valor Then
Console.WriteLine("Ganó")
Else
Console.WriteLine("Perdió")
End If
Algo importante es poder restringir la ejecución del set o get desde fuera de la clase, por ejemplo en este caso
queremos evitar que desde la clase JuegoDeDados se puede cambiar el valor del dado con la siguiente sintaxis:
dado1.Valor=7
La línea anterior provocará un error ya que sección del set de la propiedad la hemos definido de tipo Private (con
esto hacemos que solo los métodos de la clase puedan ejecuta el Set. La sintaxis para acceder a la propiedad Valor
desde la clase es:
Public Sub Tirar()
valor = aleatorio.Next(1, 7)
End Sub
Esto es correcto ya que el método Tirar pertenece a la clase Dado y por lo tanto puede asignarle un dato a la
propiedad valor (cuando se asigna un valor a una propiedad se ejecuta el Set)
Problemas propuestos
Plantear una clase Club y otra clase Socio.
La clase Socio debe tener los siguientes atributos privados: nombre y la antigüedad en el club (en años) Definir dos
propiedades para poder acceder al nombre y la antigüedad del socio(no permitir cargar un valor negativo en la
antigüedad). La clase Club debe tener como atributos 3 objetos de la clase Socio. Definir una responsabilidad para
imprimir el nombre del socio con mayor antigüedad en el club.
Module Module1
Public Class Socio

Private _nombre As String

Private _antiguedad As Integer

Public Property Nombre() As String

Set(ByVal value As String)
_nombre = value
End Set
Get
Return _nombre
End Get
End Property

Public Property Antiguedad() As Integer

Set(ByVal value As Integer)
If value >= 0 Then
_antiguedad = value
Else
Console.Write("No se puede asignar aun valor
negativo a la antiguedad")
End If
End Set
Get
Return _antiguedad
End Get
End Property

End Class

Public Class Club

Private socio1, socio2, socio3 As Socio

Página 131 de 190
 Public Sub New()
socio1 = New Socio()
socio1.Nombre = "Juan"
socio1.Antiguedad = 7
socio2 = New Socio()
socio2.Nombre = "Ana"
socio2.Antiguedad = 3
socio3 = New Socio()
socio3.Nombre = "Martin"
socio3.Antiguedad = 25
End Sub

Public Sub MayorAntiguedad()

If socio1.Antiguedad > socio2.Antiguedad And
socio1.Antiguedad > socio3.Antiguedad Then
Console.WriteLine("Socio com mayor antiguedad:" &
socio1.Nombre)
Else
If socio2.Antiguedad > socio3.Antiguedad Then
Console.WriteLine("Socio com mayor antiguedad:" &
socio2.Nombre)
Else
Console.WriteLine("Socio com mayor antiguedad:" &
socio3.Nombre)
End If
End If
End Sub
End Class

Sub Main()
Dim club1 As New Club()
club1.MayorAntiguedad()
Console.ReadKey()
End Sub

End Module
28 - Herencia

Vimos en el concepto anterior que dos clases pueden estar relacionadas por la colaboración. Ahora veremos otro
tipo de relaciones entre clases en Visual Basic .Net que es la Herencia.
La herencia significa que se pueden crear nuevas clases partiendo de clases existentes, que tendrá todas los
atributos, propiedades y los métodos de su 'superclase' o 'clase padre' y además se le podrán añadir otros atributos,
propiedades y métodos propios.
clase padre
Clase de la que desciende o deriva una clase. Las clases hijas (descendientes) heredan (incorporan) automáticamente
los atributos, propiedades y métodos de la la clase padre.
Subclase
Clase desciendiente de otra. Hereda automáticamente los atributos, propiedades y métodos de su superclase. Es una
especialización de otra clase. Admiten la definición de nuevos atributos y métodos para aumentar la especialización
de la clase.
Veamos algunos ejemplos teóricos de herencia:
1) Imaginemos la clase Vehículo. Qué clases podrían derivar de ella?
Vehiculo

Colectivo Moto Auto

Página 132 de 190

 FordK Renault 9
Siempre hacia abajo en la jerarquía hay una especialización (las subclases añaden nuevos atributos, propiedades y
métodos)
2) Imaginemos la clase Software. Qué clases podrían derivar de ella?
Software

DeAplicacion DeBase

ProcesadorTexto PlanillaDeCalculo SistemaOperativo

Word WordPerfect Excel Lotus123 Linux Windows

El primer tipo de relación que habíamos visto entre dos clases, es la de colaboración. Recordemos que es cuando una
clase contiene un objeto de otra clase como atributo.
Cuando la relación entre dos clases es del tipo "...tiene un..." o "...es parte de...", no debemos implementar herencia.
Estamos frente a una relación de colaboración de clases no de herencia.
Si tenemos una ClaseA y otra ClaseB y notamos que entre ellas existe una relación de tipo "... tiene un...", no debe
implementarse herencia sino declarar en la clase ClaseA un atributo de la clase ClaseB.
Por ejemplo: tenemos una clase Auto, una clase Rueda y una clase Volante. Vemos que la relación entre ellas es:
Auto "...tiene 4..." Rueda, Volante "...es parte de..." Auto; pero la clase Auto no debe derivar de Rueda ni Volante de
Auto porque la relación no es de tipo-subtipo sino de colaboración. Debemos declarar en la clase Auto 4 atributos de
tipo Rueda y 1 de tipo Volante.
Luego si vemos que dos clase responden a la pregunta ClaseA "..es un.." ClaseB es posible que haya una relación de
herencia.
Por ejemplo:
Auto "es un" Vehiculo
Circulo "es una" Figura
Mouse "es un" DispositivoEntrada
Suma "es una" Operacion
Problema 1:
Ahora plantearemos el primer problema utilizando herencia. Supongamos que necesitamos implementar dos clases
que llamaremos Suma y Resta. Cada clase tiene como atributo valor1, valor2 y resultado. Las propiedades a definir
son valor1, valor2 y resultado, el método Operar (que en el caso de la clase "Suma" suma los dos Valores y en el caso
de la clase "Resta" hace la diferencia entre Valor1 y Valor2.
Si analizamos ambas clases encontramos que muchas propiedades son idénticos. En estos casos es bueno definir una
clase padre que agrupe dichas propiedades, atributos y responsabilidades comunes.
La relación de herencia que podemos disponer para este problema es:
Operacion

Suma Resta
Solamente el método operar es distinto para las clases Suma y Resta (esto hace que no lo podamos disponer en la
clase Operacion), luego las propiedades valor1, valor2 son idénticos a las dos clases, esto hace que podamos
disponerlos en la clase Operacion. Lo mismo las propiedades valor1, valor2 y Resultado se definirán en la clase padre
Operacion.
Crear un proyecto y luego crear tres clases llamadas: Operacion, Suma y Resta:
Programa:
Module Module1

Public Class Operacion

Protected _valor1 As Integer
Protected _valor2 As Integer
Protected _resultado As Integer

Public Property valor1() As Integer

Get

Página 133 de 190

 Return _valor1
End Get
Set(ByVal value As Integer)
_valor1 = value
End Set
End Property

Public Property valor2() As Integer

Get
Return _valor2
End Get
Set(ByVal value As Integer)
_valor2 = value
End Set
End Property

Public Property resultado() As Integer

Get
Return _resultado
End Get
Set(ByVal value As Integer)
_resultado = value
End Set
End Property

End Class

Public Class Suma

Inherits Operacion

Public Sub Operar()

resultado = valor1 + valor2
End Sub

End Class

Public Class Resta

Inherits Operacion

Public Sub Operar()

resultado = valor1 - valor2
End Sub
End Class

Sub Main()
Dim suma1 As New Suma()
suma1.valor1 = 10
suma1.valor2 = 7
suma1.Operar()
Console.WriteLine("La suma de " & suma1.valor1 & " y " &
suma1.valor2 & " es " & suma1.resultado)
Dim resta1 As New Resta()
resta1.valor1 = 8
resta1.valor2 = 4
resta1.Operar()

Página 134 de 190

 Console.WriteLine("La diferencia de " & resta1.valor1 & " y " &
resta1.valor2 & " es " & resta1.resultado)
Console.ReadKey()
End Sub

End Module
La clase Operación define tres atributos y sus tres propiedades que las acceden:
Public Class Operacion
Protected _valor1 As Integer
Protected _valor2 As Integer
Protected _resultado As Integer

Public Property valor1() As Integer

Get
Return _valor1
End Get
Set(ByVal value As Integer)
_valor1 = value
End Set
End Property

Public Property valor2() As Integer

Get
Return _valor2
End Get
Set(ByVal value As Integer)
_valor2 = value
End Set
End Property

Public Property resultado() As Integer

Get
Return _resultado
End Get
Set(ByVal value As Integer)
_resultado = value
End Set
End Property

End Class

Ya veremos que definimos los atributos con este nuevo modificador de acceso (Protected) para que la subclase
tenga acceso a dichos atributos. Si los definimos Private las subclases no pueden acceder a dichos atributos.
Ahora veamos como es la sintaxis para indicar que una clase hereda de otra:
Public Class Suma
Inherits Operacion
Disponemos la palabra clave Inherits y seguidamente el nombre de la clase padre (con esto estamos indicando que
todas las propiedades de la clase Operación son también propiedades de la clase Suma.
Luego la característica que añade la clase Suma es el siguiente método:
Public Class Suma
Inherits Operacion

Página 135 de 190

 Public Sub Operar()
resultado = valor1 + valor2
End Sub

End Class
El método Operar puede acceder a las propiedades heredadas (siempre y cuando los mismos se declaren Protected,
en caso que sean Private si bien lo hereda de la clase padre solo los pueden modificar métodos de dicha clase padre)
Ahora podemos decir que la clase Suma tiene tres propiedades y un método.
Luego en el procedimiento Main creamos un objeto de la clase Suma y otro de la clase Resta:
Sub Main()
Dim suma1 As New Suma()
suma1.valor1 = 10
suma1.valor2 = 7
suma1.Operar()
Console.WriteLine("La suma de " & suma1.valor1 & " y " & suma1.valor2 & " es " & suma1.resultado)
Dim resta1 As New Resta()
resta1.valor1 = 8
resta1.valor2 = 4
resta1.Operar()
Console.WriteLine("La diferencia de " & resta1.valor1 & " y " & resta1.valor2 & " es " &
resta1.resultado)
Console.ReadKey()
End Sub
Podemos llamar tanto al método propio de la clase Suma "Operar()" como acceder a las propiedades heredadas de
la clase Operacion. Quien utilice la clase Suma solo debe conocer que métodos y propiedades públicas tiene
(independientemente que pertenezcan a la clase Suma o a una clase superior)
La lógica es similar para declarar la clase Resta.
La clase Operación agrupa en este caso un conjunto de atributos y propiedades comunes a un conjunto de subclases
(Suma, Resta). No tiene sentido definir objetos de la clase Operacion.
El planteo de jerarquías de clases es una tarea compleja que requiere un perfecto entendimiento de todas las clases
que intervienen en un problema, cuales son sus atributos, propiedades y responsabilidades.
Problema 2:
Confeccionar una clase Persona que tenga como atributos el nombre y la edad (definir las propiedades para poder
acceder a dichos atributos). Definir como responsabilidad un método para imprimir.
Plantear una segunda clase Empleado que herede de la clase Persona. Añadir un atributo sueldo ( y su propiedad) y
el método para imprimir su sueldo.
Definir un objeto de la clase Persona y llamar a sus métodos y propiedades. También crear un objeto de la clase
Empleado y llamar a sus métodos y propiedades.
Programa:
Module Module1
Public Class Persona

Protected _nombre As String

Protected _edad As Integer

Public Property nombre() As String

Set(ByVal value As String)
_nombre = value
End Set
Get
Return _nombre
End Get
End Property

Public Property edad() As Integer

Página 136 de 190

 Set(ByVal value As Integer)
_edad = value
End Set
Get
Return _edad
End Get
End Property

Public Sub Imprimir()

Console.WriteLine("Nombre:" & Nombre)
Console.WriteLine("Edad:" & edad)
End Sub
End Class

Public Class Empleado

Inherits Persona
Protected _sueldo As Single

Public Property sueldo() As Single

Set(ByVal value As Single)
_sueldo = value
End Set
Get
Return _sueldo
End Get
End Property

Public Overloads Sub Imprimir()

MyBase.Imprimir()
Console.WriteLine("Sueldo:" & sueldo)
End Sub
End Class

Sub Main()
Dim persona1 As New Persona()
persona1.nombre = "Juan"
persona1.edad = 25
Console.WriteLine("Los datos de la persona son:")
persona1.Imprimir()

Dim empleado1 As New Empleado()

empleado1.Nombre = "Ana"
empleado1.Edad = 42
empleado1.Sueldo = 2524
Console.WriteLine("Los datos del empleado son:")
empleado1.Imprimir()

Console.ReadKey()

End Sub

End Module
La clase Persona define los atributos protegidos (Protected) _nombre y _edad. Luego las propiedades públicas
nombre y edad (que acceden a los atributos para modificarlos o consultar sus valores)
El método imprimir es público para que se lo pueda llamar desde donde definimos un objeto de esta clase.

Página 137 de 190

 Public Class Persona

Protected _nombre As String

Protected _edad As Integer

Public Property nombre() As String

Set(ByVal value As String)
_nombre = value
End Set
Get
Return _nombre
End Get
End Property

Public Property edad() As Integer

Set(ByVal value As Integer)
_edad = value
End Set
Get
Return _edad
End Get
End Property

Public Sub Imprimir()

Console.WriteLine("Nombre:" & Nombre)
Console.WriteLine("Edad:" & edad)
End Sub
End Class
La clase Empleado hereda de la clase Persona y agrega un atributo llamado _sueldo y la respectiva propiedad sueldo
para acceder al atributo. Como la clase Empleado define otro método Imprimir debemos anteceder la palabra clave
Overloads (con esto indicamos que sobreescribimos el método existente en la clase padre)
Para llamar desde el método imprimir de la clase Empleado al método imprimir de la clase Persona es con la sintaxis
MyBase.Imprimir()
Public Class Empleado
Inherits Persona
Protected _sueldo As Single

Public Property sueldo() As Single

Set(ByVal value As Single)
_sueldo = value
End Set
Get
Return _sueldo
End Get
End Property

Public Overloads Sub Imprimir()

MyBase.Imprimir()
Console.WriteLine("Sueldo:" & sueldo)
End Sub
End Class
Por último en la Main creamos un objeto de la clase Persona y un objeto de la clase Empleado:
Sub Main()
Página 138 de 190
 Dim persona1 As New Persona()
persona1.nombre = "Juan"
persona1.edad = 25
Console.WriteLine("Los datos de la persona son:")
persona1.Imprimir()

Dim empleado1 As New Empleado()

empleado1.Nombre = "Ana"
empleado1.Edad = 42
empleado1.Sueldo = 2524
Console.WriteLine("Los datos del empleado son:")
empleado1.Imprimir()

Console.ReadKey()
End Sub
29 - Orden de ejecución de los constructores con herencia
Cuando tenemos constructores en las clases y subclases el orden de ejecución de los mismos es :
Primero se ejecuta el constructor de la clase Padre.
Segundo se ejecuta el constructor de la subclase.
Problema 1:
Plantear tres clases A, B, C que B herede de A y C herede de B. Definir un constructor a cada clase que muestre un
mensaje. Luego definir un objeto de la clase C.
Programa:
Module Module1
Public Class A

Public Sub New()

Console.WriteLine("Constructor de la clase A")
End Sub

End Class

Public Class B
Inherits A

Public Sub New()

Console.WriteLine("Constructor de la clase B")
End Sub

End Class

Public Class C
Inherits B

Public Sub New()

Console.WriteLine("Constructor de la clase C")
End Sub

End Class

Sub Main()
Dim obj1 As New C()

Página 139 de 190

 Console.ReadKey()
End Sub

End Module
Como se puede ver con la ejecución del programa la salida por pantalla es:
Constructor de la clase A
Constructor de la clase B
Constructor de la clase C
Es decir cuando creamos un objeto de la clase C lo primero que se ejecuta es el constructor de la clase de nivel
superior (en este caso la clase A), luego el constructor de la clase B y finalmente se ejecuta el constructor de la clase
C.
Problema 2:
Plantear tres clases A, B, C que B herede de A y C herede de B. Definir un constructor a cada clase que reciba como
parámetro un entero. Luego definir un objeto de la clase C.
Programa:
Module Module1
Public Class A

Public Sub New(ByVal a As Integer)

Console.WriteLine(a)
End Sub

End Class

Public Class B
Inherits A

Public Sub New(ByVal b As Integer)

MyBase.New(b / 2)
Console.WriteLine(b)
End Sub
End Class

Public Class C
Inherits B

Public Sub New(ByVal c As Integer)

MyBase.New(c / 2)
Console.WriteLine(c)
End Sub

End Class

Sub Main()
Dim obj1 As New C(20)
Console.ReadKey()
End Sub

End Module
Como podemos ver la clase el constructor de la clase C debe llamar en forma explícita al constructor de la clase
padre mediante la palabra clave MyBase, el nombre del constructor (New) y el valor a pasar (en este ejemplo le
pasamos el parámetro c dividido por dos):
Public Class C

Página 140 de 190

 Inherits B

Public Sub New(ByVal c As Integer)

MyBase.New(c / 2)
Console.WriteLine(c)
End Sub

End Class
En forma similar el constructor de la clase B debe llamar al constructor de la clase A:
Public Class B
Inherits A

Public Sub New(ByVal b As Integer)

MyBase.New(b / 2)
Console.WriteLine(b)
End Sub
End Class
Si ejecutamos el programa podemos ver que aparece por pantalla los números:
5
10
20
Donde definimos el objeto obj1 pasamos el valor 20, el constructor de la clase C llama al constructor de la clase B
pasando el valor 10, luego el constructor de la clase B llama al constructor de la clase C pasando el valor 5. Como
vimos anteriormente primero se ejecuta el constructor de la clase A mostrando el valor 5, seguidamente el
constructor de la clase B mostrando el valor 10 y finalmente se ejecuta el constructor de la clase A mostrando el 20.
30 - Clase parcial - Partial Class

Hasta ahora hemos visto que una clase se la implementa en forma completa dentro de un archivo. El lenguaje Visual
Basic .Net permite la implementación de una clase en dos o más archivos. Para esto hay que agregarle el modificador
Partial cuando declaramos la clase.
Este concepto es muy utilizado por el entorno del Visual Studio .Net en la generación de interfaces visuales.
Como veremos en conceptos futuros es necesario presentar "Partial Class" para su entendimiento.
Una clase parcial no es más ni menos que crear una clase completa y luego agrupar métodos y propiedades en dos o
más archivos.
Problema 1:
Plantear una clase Rectangulo, definir dos propiedades: lado1 y lado2. Definir dos métodos RetornarSuperficie y
RetornarPerimetro. Dividir la clase en dos archivos utilizando el concepto de "Partial Class".
Programa:
Archivo1.vb
Partial Class Rectangulo

Private _lado1 As Integer

Private _lado2 As Integer

Public Property lado1() As Integer

Get
Return _lado1
End Get
Set(ByVal value As Integer)
_lado1 = value
End Set
End Property

Public Property lado2() As Integer

Get

Página 141 de 190

 Return _lado2
End Get
Set(ByVal value As Integer)
_lado2 = value
End Set
End Property

End Class

Archivo2.vb
Partial Class Rectangulo

Public Function RetornarSuperficie() As Integer

Dim sup As Integer = lado1 * lado2
Return sup
End Function

Public Function RetornarPerimetro() As Integer

Dim per As Integer = lado1 * 2 + lado2 * 2
Return per
End Function

End Class

Module1.vb
Module Module1

Sub Main()
Dim rectangulo1 As New Rectangulo()
rectangulo1.lado1 = 5
rectangulo1.lado2 = 10
Console.WriteLine("La superficie del rectángulo es:" &
rectangulo1.RetornarSuperficie())
Console.WriteLine("El perímetro del rectángulo es:" &
rectangulo1.RetornarPerimetro())
Console.ReadKey()
End Sub

End Module
Para codificar este proyecto procedemos de la siguiente forma:
Seleccionamos desde el menú de opciones Archivo -> Nuevo proyecto...
En el diálogo definimos el nombre del proyecto: ClaseParcial1
Ahora tenemos que agregar los otros archivos. Presionamos el botón derecho del mouse en la ventana del
"Explorador de soluciones" sobre el nombre del proyecto ("ClaseParcial1") y seleccionamos la opción Agregar ->
Nuevo elemento.
Seleccionamos en el diálogo la plantilla "Clase" y en la parte inferior del diálogo definimos el nombre del archivo, en
nuestro caso lo llamamos "Archivo1.vb".
En este archivo planteamos la clase "Partial Class Rectangulo" que define las dos propiedades y atributos (el código
que nos generó automáticamente lo borramos)
En forma similar seguimos los pasos para crear el Archivo2.vb y codificar la clase "Partial Class Rectangulo" que
define los dos métodos.
Finalmente codificamos la clase principal en el archivo Module1.vb
En la Main creamos un objeto de la clase Rectangulo e inicializamos las propiedades y llamamos a sus métodos.
No es obligatorio que los dos archivos definan la clase como Partial, con que uno lo haga luego funciona
correctamente la compilación.

Página 142 de 190

31 - Interfaces visuales - Windows Forms

Hasta ahora hemos resuelto todos los algoritmos haciendo las salidas a través de una consola en modo texto. La
realidad que es muy común la necesidad de hacer la entrada y salida de datos mediante una interfaz más amigable
con el usuario.
En Visual Basic .Net existen varias librerías de clase para implementar interfaces visuales. Utilizaremos primero las
Windows Forms.
Para crear una aplicación que utilice esta librería debemos crear un proyecto. Los pasos son los siguientes:
Desde el menú de opciones del Visual Studio .Net seleccionamos la opción: Archivo -> Nuevo -> Proyecto...
Seleccionamos la plantilla "Aplicación de Windows Forms".

Ahora ya tenemos un esqueleto para desarrollar nuestra aplicación. Si vemos la ventana del "Explorador de
soluciones y presionamos el ícono superior para "Mostrar todos los archivos" veremos: Form1.vb y
Form1.Designer.vb:

En la parte central tenemos el Form listo para disponer controles con el mouse.

Página 143 de 190

Ahora podemos seleccionar un control visual de la ventana "Cuadro de herramientas" que se encuentra a la
izquierda (seleccionemos el control Button) y seguidamente presionemos el botón izquierdo del mouse dentro del
formulario que se encuentra en la parte central del Visual Studio .net:

Ahora podemos analizar la ventana "Propiedades" que nos muestra las propiedades del objeto seleccionado del
formulario. Podemos por ejemplo si tenemos seleccionado el botón cambiar la propiedad Text (la misma cambia la
etiqueta que muestra el botón):

Cuando ejecutamos la aplicación el resultado podemos ver que es muy distinto a la interfaz en modo texto vista
hasta el momento:

Por último vamos a ver los contenidos de los archivos generados automáticamente por el Visual Studio .Net.
Form1.Designer.vb
<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
Partial Class Form1
Inherits System.Windows.Forms.Form

'Form reemplaza a Dispose para limpiar la lista de componentes.

<System.Diagnostics.DebuggerNonUserCode()> _

Página 144 de 190

 Protected Overrides Sub Dispose(ByVal disposing As Boolean)
Try
If disposing AndAlso components IsNot Nothing Then
components.Dispose()
End If
Finally
MyBase.Dispose(disposing)
End Try
End Sub

'Requerido por el Diseñador de Windows Forms

Private components As System.ComponentModel.IContainer

'NOTA: el Diseñador de Windows Forms necesita el siguiente

procedimiento
'Se puede modificar usando el Diseñador de Windows Forms.
'No lo modifique con el editor de código.
<System.Diagnostics.DebuggerStepThrough()> _
Private Sub InitializeComponent()
Me.Button1 = New System.Windows.Forms.Button()
Me.SuspendLayout()
'
'Button1
'
Me.Button1.Location = New System.Drawing.Point(184, 217)
Me.Button1.Name = "Button1"
Me.Button1.Size = New System.Drawing.Size(75, 23)
Me.Button1.TabIndex = 0
Me.Button1.Text = "Hola Mundo"
Me.Button1.UseVisualStyleBackColor = True
'
'Form1
'
Me.AutoScaleDimensions = New System.Drawing.SizeF(6.0!, 13.0!)
Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font
Me.ClientSize = New System.Drawing.Size(284, 261)
Me.Controls.Add(Me.Button1)
Me.Name = "Form1"
Me.Text = "Form1"
Me.ResumeLayout(False)

End Sub

Friend WithEvents Button1 As Button

End Class

Este archivo nunca lo modificaremos manualmente sino será el entorno del Visual Studio .Net que lo generará a
medida que dispongamos controles visuales dentro de nuestro Form.
Form1.vb
Public Class Form1

End Class
Este archivo es donde agregaremos la lógica para nuestro formulario. Este archivo contiene parte de la clase Form1
(es parcial con el que se genera automáticamente)
32 - Cuadro de herramientas - Windows Forms

Página 145 de 190

El cuadro de herramientas contiene todas las componentes visuales que nos permiten confeccionar
nuestro formulario.
Podemos ver todos los controles visuales en forma completa:

O agrupados por su uso(Menús, datos etc.):

Problema 1:
: Desarrollar un programa que muestre un objeto de cada una de las siguientes clases: MonthCalendar,
TextBox y Button
La interfaz visual debe ser parecida a esta:

Hasta ahora solo hemos creado una interfaz visual, como podemos ver algunas componentes en tiempo de
ejecución tienen funcionalidad (el objeto de la clase MonthCalendar si ejecutamos el programa nos

Página 146 de 190

permite seleccionar una fecha, cambiar de mes etc., el control de la clase TextBox nos permite ingresar una
cadena de caracteres, pero el objeto de la clase Button cuando se presiona podemos ver que se visualiza
que es hundido con el mouse pero no hace nada):

33 - Ventana de propiedades - Windows Forms

La "ventana de propiedades" nos permite inicializar los valores de las propiedades del objeto que se encuentra
seleccionado en el formulario (Button, MonthCalendar, TextBox etc.)
Por ejemplo si disponemos dos objetos de la clase Button y seleccionamos uno de ellos podremos editar las
propiedades del mismo en la "ventana de propiedades":

A medida que seleccionamos un objeto en la ventana de "Diseño" podemos ver como se actualiza la "ventana de
propiedades", por ejemplo la propiedad Text de la clase Button permite fijar la etiqueta que muestra el botón.
El formulario también es un objeto, esto quiere decir que si lo seleccionamos luego la "ventana de propiedades" nos
muestra las propiedades de la clase Form:

Página 147 de 190

Problema propuesto
Elaborar una interfaz gráfica que muestre una calculadora (utilizar objetos de la clase Button y un objeto de la clase
TextBox donde se mostrarían los resultados y se cargarían los datos), tener en cuenta que solo se debe implementar
la interfaz y no la funcionalidad de una calculadora.

34 - Ventana de eventos - Windows Forms

La ventana de eventos coincide con la ventana de propiedades. Para activar la lista de eventos disponibles para un
objeto debemos presionar el ícono:

Página 148 de 190

Podemos observar la lista de eventos que puede reaccionar el objeto seleccionado en ese momento. Por ejemplo si
tenemos seleccionado un objeto de la clase Button el evento más común que deberemos implementar es el Click
(este evento se dispara cuando en tiempo de ejecución del programa se presiona el botón)
Para disponer el código para dicho evento debemos hacer doble clic sobre dicho evento (esto hace que se active la
ventana del editor y genere automáticamente el método asociado a dicho evento):

Problema :
Confeccionar un programa que al presionar un botón se muestre en un objeto de la clase Label el string "Hola
Mundo".
Programa:
Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Label1.Text = "Hola Mundo"
End Sub
End Class

Página 149 de 190

Hay que tener en cuenta que la clase anterior es parcial (el archivo Form1.Designer.vb contiene la definición de los
dos objetos y la inicialización de sus propiedades y evento, recordemos que este archivo no hay que modificar):
<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
Partial Class Form1
Inherits System.Windows.Forms.Form

'Form reemplaza a Dispose para limpiar la lista de componentes.

<System.Diagnostics.DebuggerNonUserCode()> _
Protected Overrides Sub Dispose(ByVal disposing As Boolean)
Try
If disposing AndAlso components IsNot Nothing Then
components.Dispose()
End If
Finally
MyBase.Dispose(disposing)
End Try
End Sub

'Requerido por el Diseñador de Windows Forms

Private components As System.ComponentModel.IContainer

'NOTA: el Diseñador de Windows Forms necesita el siguiente

procedimiento
'Se puede modificar usando el Diseñador de Windows Forms.
'No lo modifique con el editor de código.
<System.Diagnostics.DebuggerStepThrough()> _
Private Sub InitializeComponent()
Me.Label1 = New System.Windows.Forms.Label()
Me.Button1 = New System.Windows.Forms.Button()
Me.SuspendLayout()
'
'Label1
'
Me.Label1.AutoSize = True
Me.Label1.Location = New System.Drawing.Point(12, 84)
Me.Label1.Name = "Label1"
Me.Label1.Size = New System.Drawing.Size(39, 13)
Me.Label1.TabIndex = 0
Me.Label1.Text = "Label1"
'
'Button1
'
Me.Button1.Location = New System.Drawing.Point(7, 137)
Me.Button1.Name = "Button1"
Me.Button1.Size = New System.Drawing.Size(75, 23)
Me.Button1.TabIndex = 1
Me.Button1.Text = "Presionar"
Me.Button1.UseVisualStyleBackColor = True
'
'Form1
'
Me.AutoScaleDimensions = New System.Drawing.SizeF(6.0!, 13.0!)
Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font
Me.ClientSize = New System.Drawing.Size(284, 261)
Me.Controls.Add(Me.Button1)
Me.Controls.Add(Me.Label1)

Página 150 de 190

 Me.Name = "Form1"
Me.Text = "Form1"
Me.ResumeLayout(False)
Me.PerformLayout()

End Sub

Friend WithEvents Label1 As Label

Friend WithEvents Button1 As Button
End Class
Al ejecutar el programa si presionamos el botón vemos como cambia el contenido de la Label (esto debido a que en
el evento Click del botón cambiamos el valor de la propiedad Text del objeto de la clase Label):

Problema propuesto
Disponer 7 objetos de la clase Button con los días de la semana. Fijar en los atributos Text de cada botón los días de
la semana. Al presionar un botón mostrar en un objeto de la clase Label el día seleccionado.

Public Class Form1

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Label1.Text = "Lunes"
End Sub

Private Sub Button2_Click(sender As Object, e As EventArgs) Handles

Button2.Click
Label1.Text = "Martes"
End Sub

Private Sub Button3_Click(sender As Object, e As EventArgs) Handles

Button3.Click
Label1.Text = "Miércoles"
End Sub

Private Sub Button4_Click(sender As Object, e As EventArgs) Handles

Button4.Click

Página 151 de 190

 Label1.Text = "Jueves"
End Sub

Private Sub Button5_Click(sender As Object, e As EventArgs) Handles

Button5.Click
Label1.Text = "Viernes"
End Sub

Private Sub Button6_Click(sender As Object, e As EventArgs) Handles

Button6.Click
Label1.Text = "Sábado"
End Sub

Private Sub Button7_Click(sender As Object, e As EventArgs) Handles

Button7.Click
Label1.Text = "Domingo"
End Sub
End Class
35 - Controles comunes - Label

En el "cuadro de herramientas" podemos ver las componentes visuales agrupadas. En la pestaña de Controles
comunes podemos acceder a los controles visuales que normalmente toda aplicación requiere.
El primer control que vamos a analizar es la clase Label. Un control de tipo Label nos permite mostrar básicamente
un texto inicializando la propiedad Text.

Las propiedades más comunes de este control son:

Text: Es el string que muestra el control.
BackColor: Define el color de fondo del control.
ForeColor: Define el color del texto.
Font: Define la fuente del texto.
BorderStyle: Define si la label tiene un borde visible.
AutoSize: Permite o no redimensionar la label en forma automática.
Cursor: Definimos el ícono del cursor a mostrar cuando disponemos el mouse dentro del control.
Visible: Determina si el control está visible u oculto cuando ejecutamos el programa.
Problema propuesto
Crear una aplicación que muestre en 6 objetos de la clase Label con algunos nombres de controles visuales
contenidos en la pestaña de "controles comunes" del cuadro de herramientas

Página 152 de 190

36 - Controles comunes - Button

Un control común a disponer dentro de un Form son los botones, esto se hace disponiendo objetos de la clase
Button.
Problema 1:
Confeccionar un formulario que muestre tres objetos de la clase Button, disponer como etiqueta en cada botón los
valores 1,2 y 3. Cuando se presiona el botón mostrar en el título del formulario el valor de la etiqueta del botón
presionado.

Programa:
Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Text = Button1.Text
End Sub

Private Sub Button2_Click(sender As Object, e As EventArgs) Handles

Button2.Click
Text = Button2.Text
End Sub

Private Sub Button3_Click(sender As Object, e As EventArgs) Handles

Button3.Click
Text = Button3.Text
End Sub
End Class

Página 153 de 190

Para el evento Click de cada botón inicializamos la propiedad Text del Form1 con la propiedad Text del botón
presionado (como la clase Form1 hereda de la clase Form luego accedemos a la propiedad Text sin anteceder
nombre alguno: Text = Button1.Text ):
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
Text = Button1.Text
End Sub
Problema 2:
Modificar el problema anterior para que se acumulen en el título del formulario los valores de los botones
presionados.
Programa:
Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Text = Text & Button1.Text
End Sub

Private Sub Button2_Click(sender As Object, e As EventArgs) Handles

Button2.Click
Text = Text & Button2.Text
End Sub

Private Sub Button3_Click(sender As Object, e As EventArgs) Handles

Button3.Click
Text = Text & Button3.Text
End Sub
End Class
Concatenamos el valor actual de la propiedad Text del formulario con el valor de la propiedad Text del botón
respectivo con el operador &:
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
Text = Text & Button1.Text
End Sub
Problema 3:
Similar al problema anterior solo permitir mostrar hasta 10 caracteres en el título del formulario.
Programa:
Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
If Text.Length < 10 Then
Text = Text & Button1.Text
End If
End Sub

Private Sub Button2_Click(sender As Object, e As EventArgs) Handles

Button2.Click
If Text.Length < 10 Then
Text = Text & Button2.Text
End If
End Sub

Private Sub Button3_Click(sender As Object, e As EventArgs) Handles

Button3.Click
If Text.Length < 10 Then
Text = Text & Button3.Text
End If
End Sub
End Class

Página 154 de 190

Como la propiedad Text es de tipo String luego podemos acceder a la propiedad Length para conocer la cantidad de
caracteres almacenados:
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
If Text.Length < 10 Then
Text = Text & Button1.Text
End If
End Sub
Problema propuesto
Elaborar una interfaz gráfica que muestre una calculadora (utilizar objetos de la clase Button y un objeto de la clase
Label donde se muestra el valor ingresado), tener en cuenta que solo se debe implementar la interfaz y la carga de
un valor de hasta 12 dígitos.

Public Class Form1

Private Sub b0_Click(sender As Object, e As EventArgs) Handles
b0.Click
If Label1.Text.Length < 12 Then
Label1.Text = Label1.Text & b0.Text
End If
End Sub

Private Sub b1_Click(sender As Object, e As EventArgs) Handles

b1.Click
If Label1.Text.Length < 12 Then
Label1.Text = Label1.Text & b1.Text
End If
End Sub

Private Sub b2_Click(sender As Object, e As EventArgs) Handles

b2.Click
If Label1.Text.Length < 12 Then
Label1.Text = Label1.Text & b2.Text
End If

End Sub

Private Sub b3_Click(sender As Object, e As EventArgs) Handles

b3.Click
If Label1.Text.Length < 12 Then
Label1.Text = Label1.Text & b3.Text
End If

End Sub

Private Sub b4_Click(sender As Object, e As EventArgs) Handles

b4.Click
If Label1.Text.Length < 12 Then

Página 155 de 190

 Label1.Text = Label1.Text & b4.Text
End If

End Sub

Private Sub b5_Click(sender As Object, e As EventArgs) Handles

b5.Click
If Label1.Text.Length < 12 Then
Label1.Text = Label1.Text & b5.Text
End If

End Sub

Private Sub b6_Click(sender As Object, e As EventArgs) Handles

b6.Click
If Label1.Text.Length < 12 Then
Label1.Text = Label1.Text & b6.Text
End If

End Sub

Private Sub b7_Click(sender As Object, e As EventArgs) Handles

b7.Click
If Label1.Text.Length < 12 Then
Label1.Text = Label1.Text & b7.Text
End If

End Sub

Private Sub b8_Click(sender As Object, e As EventArgs) Handles

b8.Click
If Label1.Text.Length < 12 Then
Label1.Text = Label1.Text & b8.Text
End If

End Sub

Private Sub b9_Click(sender As Object, e As EventArgs) Handles

b9.Click
If Label1.Text.Length < 12 Then
Label1.Text = Label1.Text & b9.Text
End If

End Sub
End Class
37 - Controles comunes - TextBox

El control más común para la entrada de datos por teclado es el TextBox.

Problema 1:
Confeccionar un programa que permita ingresar dos valores enteros por teclado y al presionar un botón mostrar en
una Label la suma de dichos valores.

Página 156 de 190

Programa:
Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Dim valor1 As Integer
Dim valor2 As Integer
Dim suma As Integer
valor1 = TextBox1.Text
valor2 = TextBox2.Text
suma = valor1 + valor2
Label4.Text = suma
End Sub
End Class
Para saber el valor almacenado en un TextBox disponemos de la propiedad Text. Como la propiedad Text es de tipo
String al asignarla a una variable Integer automáticamente se transforma en Integer el String:
valor1 = TextBox1.Text
Sumamos los dos enteros:
suma = valor1 + valor2
Y finalmente cargamos en un objeto de la clase Label el resultado de la suma. Como la variable suma es un entero al
asignársela a la propiedad Text de la Label automáticamente se transforma en String :
Label4.Text = suma
Problema 2:
Solicitar que se ingrese una clave. Si se ingresa la cadena "abc123" mostrar un mensaje de clave correcta en caso
contrario mostrar clave incorrecta.
Utilizar un control de tipo TextBox para el ingreso de la clave y una Label para mostrar el resultado al presionar un
botón.
Inicializar la propiedad UseSystemPasswordChar con el valor true (esto hace que cuando el operador tipee
caracteres dentro del TextBox se visualicen como asteriscos)

Programa:
Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
If TextBox1.Text = "abc123" Then
Label2.Text = "Clave correcta"

Página 157 de 190

 Else
Label2.Text = "Clave incorrecta"
End If
End Sub
End Class
Para verificar si la clave es correcta comparamos la cadena cargada en el TextBox1 con la cadena "abc123".
Hay otra propiedad en la clase TextBox llamada PasswordChar, si la propiedad UseSystemPasswordChar esta
configurada con false podemos inicializar la propiedad PasswordChar con el caracter que queremos que se muestre
al ingresar datos en el TextBox. Probar de inicializarlo con el caracter '+' y veremos que en vez de aparecer asteriscos
aparecen caracteres '+'
Problema 3:
Disponer un control de tipo TextBox e inicializar la propiedad Multiline con el valor True (esto permite ingresar
múltiples líneas dentro de un TextBox)

Programa:
Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
MessageBox.Show(TextBox2.Text)
End Sub
End Class
Cuando se presiona un botón se muestra en un cuadro de mensajes (MessageBox) el texto ingresado en el TextBox2:
MessageBox.Show(TextBox2.Text)
Problema propuesto
Solicitar el ingreso de una clave de hasta 10 caracteres en un control de tipo TextBox (inicializar la propiedad
MaxLength con el valor 10)
Mostrar en un cuadro de mensajes la clave ingresada al presionar un botón.

Public Class Form1

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
MessageBox.Show(TextBox1.Text)
End Sub
End Class
38 - Controles comunes - CheckBox

El control CheckBox permite implementar un cuadro de selección (básicamente un botón de dos estados:
seleccionado o no seleccionado)
Problema 1:
Confeccionar un programa que muestre 3 objetos de la clase CheckBox con etiquetas de tres idiomas. Cuando se
presiona un botón mostrar en la barra de títulos del Form todos los CheckBox seleccionados hasta el momento.

Página 158 de 190

Programa:
Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Text = ""
If CheckBox1.Checked = True Then
Text = Text + "(Inglés)"
End If
If CheckBox2.Checked = True Then
Text = Text + "(Francés)"
End If
If CheckBox3.Checked = True Then
Text = Text + "(Alemán)"
End If
End Sub
End Class
La clase CheckBox tiene una propiedad llamada Checked (si tiene el valor true significa que el CheckBox esta
seleccionado, en caso contrario no esta seleccionado)
En el evento Click del botón primero borramos el contenido del título del Form1:
Text = ""
Y seguidamente mediante estructuras If verificamos el estado de cada CheckBox, en caso de estar seleccionado
concatenamos al título del Form1 el valor que representa ese CheckBox:
If CheckBox1.Checked = True Then
Text = Text + "(Inglés)"
End If
If CheckBox2.Checked = True Then
Text = Text + "(Francés)"
End If
If CheckBox3.Checked = True Then
Text = Text + "(Alemán)"
End If
Problema 2:
Disponer un control Label que muestre el siguiente mensaje: "Esta de acuerdo con las normas del servicio?", luego
un CheckBox y finalmente un objeto de tipo Button desactivo (propiedad Enabled con False). Cuando se tilde el
CheckBox debemos activar el botón (para esto debemos responder al evento CheckedChanged)

Página 159 de 190

Programa:
Public Class Form1
Private Sub CheckBox1_CheckedChanged(sender As Object, e As
EventArgs) Handles CheckBox1.CheckedChanged
If CheckBox1.Checked = True Then
Button1.Enabled = True
Else
Button1.Enabled = False
End If
End Sub
End Class
Debemos implementar el evento CheckedChanged del objeto CheckBox1 (preguntamos si el CheckBox se encuentra
seleccionado o no, en caso de estar seleccionado activamos el botón asignando a la propiedad Enabled el valor
True):
Private Sub CheckBox1_CheckedChanged(sender As Object, e As EventArgs) Handles
CheckBox1.CheckedChanged
If CheckBox1.Checked = True Then
Button1.Enabled = True
Else
Button1.Enabled = False
End If
End Sub
Problema propuesto
Disponer tres objetos de la clase CheckBox con nombres de navegadores web. Cuando se presione un botón mostrar
en el título del Form los programas seleccionados.
Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Text = ""
If CheckBox1.Checked = True Then
Text = Text & "(" & CheckBox1.Text & ")"
End If
If CheckBox2.Checked = True Then
Text = Text & "(" & CheckBox2.Text & ")"
End If
If CheckBox3.Checked = True Then
Text = Text & "(" & CheckBox3.Text & ")"
End If
End Sub
End Class
39 - Controles comunes - RadioButton y GroupBox

Otro control visual muy común es el RadioButton que normalmente se muestran un conjunto de RadioButton y
permiten la selección de solo uno de ellos.
Problema 1:
Confeccionar un programa que muestre 3 objetos de la clase RadioButton que permitan configurar el ancho y alto
del Form. Cuando se presione un botón actualizar el ancho y alto.

Página 160 de 190

Programa:
Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
If RadioButton1.Checked = True Then
Width = 640
Height = 480
Else
If RadioButton2.Checked = True Then
Width = 800
Height = 600
Else
If RadioButton3.Checked = True Then
Width = 1024
Height = 768
End If
End If
End If
End Sub
End Class
Todos los controles que se disponen dentro de un Form están asociados, es decir que cuando seleccionamos uno se
desmarca la actual.
El control RadioButton tiene una propiedad llamada Checked que almacena true o false, por eso que por medio de
un conjunto de if verificamos cual de los radio esta seleccionado:
If RadioButton1.Checked = True Then
Width = 640
Height = 480
Else
If RadioButton2.Checked = True Then
Width = 800
Height = 600
Else
If RadioButton3.Checked = True Then
Width = 1024
Height = 768
End If
End If
End If
Para cambiar el ancho y alto del Form accedemos a las propiedades Width y Height.
Problema 2:
Página 161 de 190
Desarrollar una interfaz visual que muestre dos grupos independientes de RadioButton, en uno permitir seleccionar
si es hombre o mujer y en el otro si es mayor o menor de edad. Mostrar un mensaje de la selección al presionar un
botón

Debemos disponer dos objetos de la clase GroupBox y dentro de cada uno de ellos dos objetos de tipo RadioButton,
con esto logramos que cada grupo sea independiente.
Programa:
Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Dim seleccionado As String = ""
If RadioButton1.Checked = True Then
seleccionado = seleccionado + "(hombre)"
Else
If RadioButton2.Checked = True Then
seleccionado = seleccionado + "(mujer)"
End If
End If
If RadioButton3.Checked = True Then
seleccionado = seleccionado + "(mayor)"
Else
If RadioButton4.Checked = True Then
seleccionado = seleccionado + "(menor)"
End If
End If
MessageBox.Show(seleccionado)
End Sub
End Class
Problema propuesto
Permitir el ingreso de dos números en controles de tipo TextBox y mediante dos controles de tipo RadioButton
permitir seleccionar si queremos sumarlos o restarlos. Al presionar un botón mostrar en el título del Form el
resultado de la operación.

Public Class Form1

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Dim valor1 As Integer
Dim valor2 As Integer
valor1 = TextBox1.Text
valor2 = TextBox2.Text
If RadioButton1.Checked = True Then
Dim suma As Integer
suma = valor1 + valor2
Text = suma

Página 162 de 190

 Else
If RadioButton2.Checked = True Then
Dim resta As Integer
resta = valor1 - valor2
Text = resta
End If
End If
End Sub
End Class

40 - Controles comunes - ComboBox

El control ComboBox permite seleccionar un String de una lista.

Para inicializar los string que contendrá el ComboBox debemos acceder a la propiedad Items
Un evento muy útil con este control es cuando el operador selecciona un Item de la lista. Para capturar la selección
de un item debemos codificar el evento SelectedIndexChanged.
Problema 1:
Cargar en un ComboBox los nombres de varios colores. Al seleccionar alguno mostrar en la barra de título del Form
el String seleccionado.
Programa:
Public Class Form1
Private Sub ComboBox1_SelectedIndexChanged(sender As Object, e As
EventArgs) Handles ComboBox1.SelectedIndexChanged
Text = ComboBox1.Text
End Sub
End Class
Cuando se selecciona un string de la lista se dispara el evento SelectedIndexChanged y procedemos a extraer el texto
seleccionado del ComboBox y lo mostramos en el título del Form:
Text = ComboBox1.Text
Problema 2:
Disponer tres controles de tipo ComboBox con valores entre 0 y 255 (cada uno representa la cantidad de rojo, verde
y azul). Luego al presionar un botón pintar el fondo del Form con el color que se genera combinando los valores de
los ComboBox.

Hay un evento muy importante en la clase Form llamado Load (seleccionemos el formulario y generemos dicho
evento) Este evento se dispara cuando se carga el formulario con todos los controles visuales. En este evento
cargaremos los tres ComboBox con los números.
Programa:
Public Class Form1
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles
MyBase.Load
Dim f As Integer
For f = 0 To 255
ComboBox1.Items.Add(f)
ComboBox2.Items.Add(f)
ComboBox3.Items.Add(f)
Next
ComboBox1.SelectedIndex = 0
ComboBox2.SelectedIndex = 0

Página 163 de 190

 ComboBox3.SelectedIndex = 0
End Sub

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles

Button1.Click
Dim rojo As Integer = ComboBox1.Text
Dim verde As Integer = ComboBox2.Text
Dim azul As Integer = ComboBox3.Text
BackColor = Color.FromArgb(rojo, verde, azul)
End Sub
End Class
La carga manual de cada ComboBox nos haría perder mucho tiempo en tiempo de diseño por lo que lo hacemos
mediante un algoritmo. Cuando se carga el Form se ejecuta el evento Load donde mediante un For procedemos a
añadir los 256 valores:
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
Dim f As Integer
For f = 0 To 255
ComboBox1.Items.Add(f)
ComboBox2.Items.Add(f)
ComboBox3.Items.Add(f)
Next
La propiedad Items del ComboBox tiene un método llamado Add que añade un elemento a la lista.
Luego para dejar seleccionado por defecto el primer item añadido iniciamos la propiedad SelectedIndex:
ComboBox1.SelectedIndex = 0
ComboBox2.SelectedIndex = 0
ComboBox3.SelectedIndex = 0
En el evento Click del botón procedemos a extraer el valor seleccionado de cada ComboBox:
Dim rojo As Integer = ComboBox1.Text
Dim verde As Integer = ComboBox2.Text
Dim azul As Integer = ComboBox3.Text
Para cambiar el color de fondo del Form actualizamos la propiedad BackColor. El color lo generamos llamando al
método estático FromArgb de la clase Color:
BackColor = Color.FromArgb(rojo, verde, azul)
Problema propuesto
Solicitar el ingreso del nombre de una persona y seleccionar de un control ComboBox un país. Al presionar un botón
mostrar en la barra del título del Form el nombre ingresado y el país seleccionado.
Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Text = TextBox1.Text & " - " & ComboBox1.Text
End Sub
End Class
41 - Intalacion del motor de base de datos SQL Server

Procederemos a instalar el motor de base de datos SQL Server con el objetivo de confeccionar aplicaciones
en Visual Basic .Net que puedan acceder a una base de datos (si ya tiene instalado el SQL Server puede
obviar este concepto)
Vamos a utilizar la versión SQL Server Express que la podemos descargar en forma gratuita del sitio
de Microsoft.
Descargaremos el SQL Server de 64bit (si tiene un sistema operativo con dichas características):

Página 164 de 190

Y también descargaremos el Microsoft® SQL Server Management Studio, que nos permitirá administrar las
bases de datos (crearlas por ejemplo):

Ejecutamos el primer archivo que descargamos (Motor de base de datos SQL Server)
SQLEXPR_x64_ESN.exe y seguimos las instrucciones que nos propone el diálogo (Elegimos nueva
instalación independiente):

En el siguiente diálogo aceptamos los términos y condiciones:

El siguiente diálogo muestra si el equipo tiene todo el software necesario o nos indica que hacer (por
ejemplo reiniciar el equipo):

El siguiente paso nos invita a activar las actualizaciones automáticas (podemos o no tildar):

Página 165 de 190

En la "Selección de características" dejamos los datos por defecto:

También dejaremos por defecto los valores para la identificación de instancia:

Página 166 de 190

Datos por defecto para la "Configuración del Servidor":

No cambiamos datos la "Configuración del Motor de Base de Datos:

Luego de este paso ya tenemos instalado el SQL Server en nuestro equipo:

Página 167 de 190

42 - Instalación del SQL Server Management Studio

En el concepto anterior descargamos e instalamos el motor de base de datos SQL Server. Por otro lado
también descargamos el SQL Server Management Studio que nos permitirá administrar las bases de datos.
Procedemos a ejecutar el archivo que descargamos y aparece el "Centro de instalación de SQL Server",
elegimos "Nueva instalación independiente de SQL Server o agregar características a una instalación
existente" (tengamos en cuenta que estamos agregando características al SQL Server que ya instalamos):

En tipo de instalación dejamos por defecto "Realización de una nueva instalación de SQL Server":

Aceptamos los términos de licencia:

Página 168 de 190

Por defecto dejamos la selección de características:

Finalmente ya tenemos las herramientas de administración instaladas:

43 - Ejecución del SQL Server Management Studio

Desde el menú de inicio de Windows podemos acceder al SQL Server Management Studio:

Cuando iniciamos el programa aparece un diálogo donde debemos ingresar "Nombre del Servidor" y la
"Autenticación":

Página 169 de 190

Ya luego de la conexión al servidor podemos por ejemplo proceder a crear nuestra primer base de datos,
presionamos el botón derecho del mouse estando posicionado en "Base de datos" y elegimos "Nueva base
de datos...":

Elegiremos como nombre para la base de datos a crear: "base1":

Ahora seleccionamos la "base1" y presionamos el botón derecho del mouse sobre "tablas" y elegimos la
primer opción "tabla":

Página 170 de 190

Vamos a crear una tabla llamada "articulos" que la definiremos con tres campos:
codigo int primary key identidad
descripcion varchar 50
precio float
El primer campo lo creamos:

Los tres campos que definimos son:

Y presionando el ícono siguiente definimos el nombre de la tabla:

Página 171 de 190

Asignamos como nombre a la tabla "articulos":

Para ejecutar comando SQL sobre una determinada base de datos procedemos a posicionar la flecha del
mouse sobre una base de datos, por ejemplo "base1" y presionamos el botón derecho del mouse
seleccionando "Nueva consulta":

En la ventana de consultas podemos escribir y ejecutar comandos SQL:

Si escribimos luego del comando insert un select podemos ver el registro añadido:

Página 172 de 190

44 - SqlConnection: Conexión con el SQL Server

Desde .Net disponemos de un conjunto de clases para conectarnos y pedir al SQL Server que ejecute
comandos.
El primer paso es conectarnos con nuestro servidor de base de datos que instalamos en los conceptos
anteriores y vimos como podemos comunicarnos utilizando el Microsoft SQL Server Management Studio.
Problema
Confeccionar una aplicación que permita conectarnos con nuestro servidor de base de datos y seleccionar
una determinada base de datos. Luego de la conexión cerrar la misma.
Para conectarnos con el servidor y seleccionar una base de datos debemos utilizar la clase SqlConnection:
Dim conexion As SqlConnection
conexion = New SqlConnection("server=DIEGO-PC\
SQLEXPRESS;database=base1;integrated security = true")
El String que le pasamos al constructor del SqlConnection le indicamos como primer dato el nombre de
nuestro servidor, en su máquina lo puede ubicar cuando arranca el SQL Server Management Studio:

El segundo dato que se le pasa es el nombre de la base de datos con la que nos comunicaremos, en
nuestro caso creamos previamente la base de datos "base1" y finalmente el último dato obligatorio es
indicar "integrated security = true", esto hace que se utilice el usuario propio de Windows y no
necesitemos por el momento crear otros usuarios propios de SQL Server.
Creemos un nuevo proyecto en Visual Studio y demos como nombre: BaseDeDatos1. La interfaz visual es
un simple botón:

Página 173 de 190

El código fuente es:
Imports System.Data.SqlClient

Public Class Form1

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Dim conexion As SqlConnection
conexion = New SqlConnection("server=DIEGO-PC\
SQLEXPRESS;database=base1;integrated security = true")
conexion.Open()
MessageBox.Show("Se abrió la conexión con el servidor SQL Server
y se seleccionó la base de datos")
conexion.Close()
MessageBox.Show("Se cerró la conexión.")
End Sub
End Class
Lo primero que hacemos es incluir el espacio de nombres:
Imports System.Data.SqlClient
Este espacio de nombres agrupa un conjunto de clases orientadas a conectarse con el SQL Server, si no las
importamos no se pueden utilizar.
Este espacio de nombres define la clase SqlConnection.
Para el evento Click del button1 definimos y creamos un objeto de la clase SqlConnection, el nombre del
servidor es el que podemos ver desde el SQL Server Management Studio:
Dim conexion As SqlConnection
conexion = New SqlConnection("server=DIEGO-PC\
SQLEXPRESS;database=base1;integrated security = true")
Abrimos la conexión:
conexion.Open()
Mostramos un mensaje que la conexión se abrió:
MessageBox.Show("Se abrió la conexión con el servidor SQL Server
y se seleccionó la base de datos")
Cerramos la conexión:
conexion.Close()
Mostramos finalmente un mensaje del cierre de la conexión:
MessageBox.Show("Se cerró la conexión.")
Si aparece algún error es que especificó en forma incorrecta la cadena de conexión, por ejemplo si
disponemos un nombre equivocado de servidor por ejemplo:
conexion = New
SqlConnection("server=************;database=base1;integrated security =
true")
Luego debe detenerse nuestro programa indicando donde ocurrió el error:

Página 174 de 190

También ocurrirá un error si disponemos un nombre de base de datos inexistente:

Si todo está correcto podemos seguir con los próximos conceptos para pedir que SQL Server ejecute
comando y recuperar los resultados.
45 - SqlCommand (insert): Insertar registro

Vimos en el concepto anterior como conectarnos al servidor de SQL Server desde Visual Basic .Net y
seleccionar una base de datos. Veremos ahora como pedir que el SQL Server ejecute un comando
"INSERT".
Trabajaremos con la base de datos "base1" que creamos en conceptos anteriores y con la tabla "articulos"
que también creamos previamente con la estructura:
codigo int primary key identidad
descripcion varchar 50
precio float
Problema
Implementar una interfaz visual para el alta o carga de registros en la tabla artículos.
Crearemos un proyecto llamado "basededatos2" con la siguiente interfaz visual:

El código fuente de la aplicación para efectuar altas es:

Imports System.Data.SqlClient

Página 175 de 190

Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Dim conexion As SqlConnection
conexion = New SqlConnection("server=DIEGO-PC\SQLEXPRESS ;
database=base1 ; integrated security = true")
conexion.Open()
Dim descri As String = TextBox1.Text
Dim precio As String = TextBox2.Text
Dim cadena As String = "insert into
articulos(descripcion,precio) values ('" & descri & "'," & precio & ")"
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
comando.ExecuteNonQuery()
MessageBox.Show("Los datos se guardaron correctamente")
TextBox1.Text = ""
TextBox2.Text = ""
conexion.Close()
End Sub
End Class
Importamos el espacio de nombres que contiene las clases SqlConnection y SqlCommand:
Imports System.Data.SqlClient
Lo primero que hacemos para el evento Click del botón es definir y crear un objeto de la clase
SqlConnection y proceder a abrir la conexión:
Dim conexion As SqlConnection
conexion = New SqlConnection("server=DIEGO-PC\SQLEXPRESS ;
database=base1 ; integrated security = true")
conexion.Open()
Tenemos que guardar en la variable cadena un comando INSERT válido tomando los datos ingresados en
los dos TextBox:
Dim descri As String = TextBox1.Text
Dim precio As String = TextBox2.Text
Dim cadena As String = "insert into
articulos(descripcion,precio) values ('" & descri & "'," & precio & ")"
Como el campo descripción es de tipo varchar debemos incluir las comillas simples:
'" & descri & "'
Y como el precio es float no incluimos las comillas simples:
" & precio & "
Si cargamos por teclado por ejemplo el producto: manzanas y con un precio : 20, luego la variable cadena
tiene el valor:
insert into articulos(descripcion,precio) values ('manzanas',20)
Como podemos ver es una forma sencilla de elaborar un comando SQL siempre y cuando tengamos pocos
campos que iniciar.
Creamos un objeto de la clase SqlCommand y le pasamos al constructor un String con el comando SQL y la
referencia a la conexión.
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
Seguidamente llamamos al método ExecuteNonQuery que procede a comunicarse con el servidor para que
se ejecute el comando SQL configurado en la línea anterior:
comando.ExecuteNonQuery();
Ejecutemos el programa y realicemos la carga de un artículo:

Página 176 de 190

Por el momento la única forma que tenemos para consultar la tabla "articulos" es abrir el "Microsoft SQL
Server Management Studio" seleccionar la base de datos "base1" y luego presionar el botón derecho del
mouse eligiendo la opción "Seleccionar las primeras 1000 filas":

Y de esta forma poder ver los registros que almacena la tabla "articulos":

46 - SqlCommand (select): Listar registros

Vimos el concepto anterior como enviar datos al servidor para que se efectúe un insert en una tabla.
Veremos ahora como recuperar los datos almacenados en una tabla para mostrarlos en pantalla.
Problema
Imprimir por pantalla todos los registros contenidos en la tabla articulos.
Para recuperar datos de una tabla tenemos que utilizar el comando SQL select indicando el nombre de la
tabla de donde se recuperan los datos y los campos propiamente dichos.
Crear un proyecto llamado: BaseDeDatos3 y definir la siguiente interfaz visual:
Un objeto de la clase Button.

Página 177 de 190

Un objeto de la clase TextBox (propiedad Multiline: true y ScrollBar:
Vertical

En el evento Click del botón procedemos a recuperar los datos de la tabla articulos y los mostramos dentro
del TextBox.
Imports System.Data.SqlClient

Public Class Form1

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Dim conexion As SqlConnection
conexion = New SqlConnection("server=DIEGO-PC\SQLEXPRESS ;
database=base1 ; integrated security = true")
conexion.Open()
Dim cadena As String = "select codigo, descripcion, precio from
articulos"
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
Dim registros As SqlDataReader
registros = comando.ExecuteReader()
Do While registros.Read() = True
TextBox1.AppendText(registros("codigo"))
TextBox1.AppendText(" - ")
TextBox1.AppendText(registros("descripcion"))
TextBox1.AppendText(" - ")
TextBox1.AppendText(registros("precio"))
TextBox1.AppendText(vbCrLf)
Loop
conexion.Close()
End Sub
End Class
Recordar que siempre debemos importar es espacio de nombres:
Imports System.Data.SqlClient
Donde se declaran las clases SqlConnection, SqlCommand etc.
Lo primero que hacemos es configurar la cadena de conexión y abrirla:
Dim conexion As SqlConnection
conexion = New SqlConnection("server=DIEGO-PC\SQLEXPRESS ;
database=base1 ; integrated security = true")
conexion.Open()
El comando SQL para recuperar todas la filas de la tabla articulos es:
Dim cadena As String = "select codigo, descripcion, precio from
articulos"
Seguidamente seguimos con la creación del objeto de la clase SqlCommand pasando el String con el
comando SQL y la referencia a la conexión:
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
Lo nuevo aparece cuando queremos recuperar los datos que genera el SQL Server. Para esto llamamos al
método ExecuteReader del objeto SqlCommand:

Página 178 de 190

 Dim registros As SqlDataReader
registros = comando.ExecuteReader()
Este método retorna un objeto de la clase SqlDataReader que almacena el resultado del comando SQL
select.
Para acceder a cada fila retornada por el comando SQL select debemos disponer una estructura repetitiva
Do While y llamar en cada vuelta del ciclo al método Read:
Do While registros.Read() = True
TextBox1.AppendText(registros("codigo"))
TextBox1.AppendText(" - ")
TextBox1.AppendText(registros("descripcion"))
TextBox1.AppendText(" - ")
TextBox1.AppendText(registros("precio"))
TextBox1.AppendText(vbCrLf)
Loop
Imaginemos que el comando SQL select retorna 5 filas. Cada llamada a Read avanza un puntero al siguiente
registro y dentro del Do While lo recuperamos mediante el objeto registros y mediante un subíndice
indicamos el nombre de campo de la tabla a recuperar.
Por ejemplo si la tabla articulos estuviera vacía la primera vez que se ejecuta el Do While el método Read
retorna false.
El resultado de ejecutar este programa con la tabla articulos conteniendo 5 filas:

Para que se muestren un registro debajo del otro dentro del TextBox debemos insertar un salto de línea
con la constante llamada vbCrLf:
TextBox1.AppendText(vbCrLf)
47 - SqlCommand (select): Consultar registros

En el concepto anterior recuperamos todos los registros de una tabla. Ahora veremos como podemos
rescatar uno en particular.
Problema
Implementar la consulta de un artículo ingresando por teclado el código y recuperando la descripción y el
precio.
Crear un proyecto llamado: BaseDatos4 y definir la siguiente interfaz visual:
5 objeto de la clase Label.
1 objeto de la clase Button.
1 objeto de la clase TextBox.

En el evento Click procedemos a buscar el código del artículo ingresado en el TextBox. El código fuente es:
Imports System.Data.SqlClient

Página 179 de 190

Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Dim conexion As SqlConnection
conexion = New SqlConnection("server=DIEGO-PC\SQLEXPRESS ;
database=base1 ; integrated security = true")
conexion.Open()
Dim cod As String = TextBox1.Text
Dim cadena As String = "select descripcion, precio from
articulos where codigo=" & cod
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
Dim registro As SqlDataReader
registro = comando.ExecuteReader()
Label4.Text = ""
Label5.Text = ""
If registro.Read() = True Then
Label4.Text = registro("descripcion")
Label5.Text = registro("precio")
Else
MessageBox.Show("No existe un artículo con el código
ingresado")
End If
conexion.Close()
End Sub
End Class
Importamos el espacio de nombres:
Imports System.Data.SqlClient
En el evento Click del botón "Buscar" procedemos a conectarnos con el motor de base de datos y abrir la
conexión:
Dim conexion As SqlConnection
conexion = New SqlConnection("server=DIEGO-PC\SQLEXPRESS ;
database=base1 ; integrated security = true")
conexion.Open()
Seguidamente confeccionamos un String con el comando SQL select para recuperar la descripción y el
precio del artículo cuyo código coincide con el valor ingresado por teclado:
Dim cod As String = TextBox1.Text
Dim cadena As String = "select descripcion, precio from
articulos where codigo=" & cod
Creamos un objeto de la clase SqlCommand pasando el comando SQL y la referencia a la conexión:
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
Recuperamos un objeto de la clase SqlDataReader que retorna el objeto de la clase SqlCommand mediante
el llamando al método EcecuteReader:
Dim registro As SqlDataReader
registro = comando.ExecuteReader()
Si el resultado del comando select recuperó un registro de la tabla articulos luego la llamada al método
Read se verifica verdadero y procedemos a mostrar el resultado por pantalla:
If registro.Read() = True Then
Label4.Text = registro("descripcion")
Label5.Text = registro("precio")
En el caso que hayamos ingresado un código inexistente procedemos a mostrar un mensaje por el Else:
Else

Página 180 de 190

 MessageBox.Show("No existe un artículo con el código
ingresado")
End If
La interfaz en funcionamiento es:

48 - SqlCommand (delete): Borrar registro

Otra de las actividades comunes con los datos es la eliminación de filas de una tabla. Para eliminar
registros de una tabla debemos emplear el comando SQL delete.
Problema
Implementar una aplicación que permita consultar un artículo por su código. Luego de mostrarlo activar un
botón para poder eliminarlo.
Crear un proyecto llamado: BaseDatos5 y definir la siguiente interfaz visual:
5 objeto de la clase Label.
2 objeto de la clase Button (disponer la propiedad Enabled del
botón de borrado en false para que empiece
desactivo)
1 objeto de la clase TextBox.

El código fuente para resolver la consulta y borrado es:

Imports System.Data.SqlClient

Public Class Form1

Private conexion As New SqlConnection("server=DIEGO-PC\SQLEXPRESS ;

database=base1 ; integrated security = true")

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles

Button1.Click
conexion.Open()
Dim cod As String = TextBox1.Text
Dim cadena As String = "select descripcion, precio from
articulos where codigo=" & cod
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
Dim registro As SqlDataReader

Página 181 de 190

 registro = comando.ExecuteReader()
If registro.Read() Then
Label4.Text = registro("descripcion")
Label5.Text = registro("precio")
Button2.Enabled = True
Else
MessageBox.Show("No existe un artículo con el código
ingresado")
End If
conexion.Close()
End Sub

Private Sub Button2_Click(sender As Object, e As EventArgs) Handles

Button2.Click
conexion.Open()
Dim cod As String = TextBox1.Text
Dim cadena As String = "delete from articulos where codigo=" &
cod
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
Dim cant As Integer
cant = comando.ExecuteNonQuery()
If cant = 1 Then
Label4.Text = ""
Label5.Text = ""
MessageBox.Show("Se borró el artículo")
Else
MessageBox.Show("No existe un artículo con el código
ingresado")
End If
conexion.Close()
Button2.Enabled = False
End Sub
End Class
Primero indicamos el espacio de nombres relacionado a la comunicación con SQL Server:
Imports System.Data.SqlClient
Como en los dos métodos utilizamos el objeto SqlConnection lo definimos como un atributo de la clase
Form1 y lo creamos:
Private conexion As New SqlConnection("server=DIEGO-PC\SQLEXPRESS ;
database=base1 ; integrated security = true")
El algoritmo de consulta es idéntico al concepto que vimos anteriormente (solo modificamos la propiedad
Enabled del button2):
conexion.Open()
Dim cod As String = TextBox1.Text
Dim cadena As String = "select descripcion, precio from
articulos where codigo=" & cod
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
Dim registro As SqlDataReader
registro = comando.ExecuteReader()
If registro.Read() Then
Label4.Text = registro("descripcion")
Label5.Text = registro("precio")
Button2.Enabled = True
Else

Página 182 de 190

 MessageBox.Show("No existe un artículo con el código
ingresado")
End If
conexion.Close()
Lo nuevo aparece en el borrado del artículo que acabamos de consultar, primer confeccionamos un String
con el comando delete:
Dim cod As String = TextBox1.Text
Dim cadena As String = "delete from articulos where codigo=" &
cod
Luego procedemos a crear un objeto de la clase SqlCommand pasando el comando SQL de borrado con la
referencia de la conexión:
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
Llamamos seguidamente al método ExecuteNonQuery que se comunica con el SQL Server para que ejecute
el comando configurado previamente y retorna la cantidad de registros afectados (en este caso retorna la
cantidad de registros borrados):
Dim cant As Integer
cant = comando.ExecuteNonQuery()
Si retorna un uno significa que se borró el artículo con el código ingresado:
If cant = 1 Then
Label4.Text = ""
Label5.Text = ""
MessageBox.Show("Se borró el artículo")
En pantalla tenemos la siguiente interfaz luego de borrar un artículo existente:

49 - SqlCommand (update): Modificar registro

Vimos hasta ahora el alta (carga), consulta (búsqueda) y baja (borrado). Ahora veremos como modificar
datos de una fila de la tabla.
Para modificar datos debemos utilizar el comando SQL update.
Problema
Implementar una aplicación que permita consultar un artículo por su código. Luego mostrar en dos
TextBox la descripción y el precio actual. Permitir modificar la descripción y precio dejando registrado
dicho cambio en la tabla de la base de datos al presionar un botón.
Crear un proyecto llamado: BaseDeDatos6 y definir la siguiente interfaz visual:
3 objeto de la clase Label.
2 objeto de la clase Button (disponer la propiedad Enabled del
botón de modificación en false para que
empiece desactivo)
3 objeto de la clase TextBox.

Página 183 de 190

El código fuente para resolver la consulta y modificación es:
Imports System.Data.SqlClient

Public Class Form1

Private conexion As New SqlConnection("server=DIEGO-PC\SQLEXPRESS ;

database=base1 ; integrated security = true")

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles

Button1.Click
conexion.Open()
Dim cod As String = TextBox1.Text
Dim cadena As String = "select descripcion, precio from
articulos where codigo=" & cod
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
Dim registro As SqlDataReader
registro = comando.ExecuteReader()
If registro.Read() Then
TextBox2.Text = registro("descripcion")
TextBox3.Text = registro("precio")
Button2.Enabled = True
Else
MessageBox.Show("No existe un artículo con el código
ingresado")
End If
conexion.Close()
End Sub

Private Sub Button2_Click(sender As Object, e As EventArgs) Handles

Button2.Click
conexion.Open()
Dim cod As String = TextBox1.Text
Dim descri As String = TextBox2.Text
Dim precio As String = TextBox3.Text
Dim cadena As String = "update articulos set descripcion='" &
descri & "', precio=" & precio & " where codigo=" & cod
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
Dim cant As Integer
cant = comando.ExecuteNonQuery()
If cant = 1 Then
MessageBox.Show("Se modificaron los datos del artículo")
TextBox1.Text = ""
TextBox2.Text = ""
TextBox3.Text = ""
Else

Página 184 de 190

 MessageBox.Show("No existe un artículo con el código
ingresado")
End If
conexion.Close()
Button2.Enabled = False
End Sub
End Class
Primero indicamos el uso del espacio de nombres relacionado a la comunicación con SQL Server:
Imports System.Data.SqlClient
Como en los dos métodos utilizamos el objeto SqlConnection lo definimos como un atributo de la clase
Form1:
Public Class Form1

Private conexion As New SqlConnection("server=DIEGO-PC\SQLEXPRESS ;

database=base1 ; integrated security = true")

El algoritmo de consulta es idéntico al concepto que vimos anteriormente (salvo que los datos rescatados
los mostramos en TextBox):
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
conexion.Open()
Dim cod As String = TextBox1.Text
Dim cadena As String = "select descripcion, precio from
articulos where codigo=" & cod
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
Dim registro As SqlDataReader
registro = comando.ExecuteReader()
If registro.Read() Then
TextBox2.Text = registro("descripcion")
TextBox3.Text = registro("precio")
Button2.Enabled = True
Else
MessageBox.Show("No existe un artículo con el código
ingresado")
End If
conexion.Close()
End Sub
En el evento Click de la modificación procedemos a configurar un String con el comando SQL update
rescatando los datos de los tres TextBox:
Dim cod As String = TextBox1.Text
Dim descri As String = TextBox2.Text
Dim precio As String = TextBox3.Text
Dim cadena As String = "update articulos set descripcion='" &
descri & "', precio=" & precio & " where codigo=" & cod
Seguidamente creamos un objeto de la clase SqlCommand pasando al constructor el String con el comando
update y la referencia a la conexión:
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
Llamamos al método ExecuteNonQuery para que se ejecute el comando update por parte del SQL Server y
nos retorne la cantidad de registros afectados:
Dim cant As Integer
cant = comando.ExecuteNonQuery()
Si retorna un uno significa que se efectuó la modificación:
If registro.Read() Then

Página 185 de 190

 TextBox2.Text = registro("descripcion")
TextBox3.Text = registro("precio")
Button2.Enabled = True
En pantalla tenemos la siguiente interfaz luego de modificar un artículo:

50 - SqlCommand : Pasando parámetros

Hemos visto que podemos formar un comando SQL para enviarlo a SQL Server generando un String
concatenando los datos que ingresa el operador por teclado:
Dim descri As String = TextBox1.Text
Dim precio As String = TextBox2.Text
Dim cadena As String = "insert into
articulos(descripcion,precio) values ('" & descri & "'," & precio & ")"
Esta metodología tiene el inconveniente cuando hay que elaborar comandos SQL con muchos campos
(imaginemos que tenemos que elaborar un insert con una tabla que tiene más de 10 campos)
Para solventar esta dificultad se introduce el concepto de parámetros dentro del comando SQL.
Problema 1
Implementar una interfaz visual para el alta de registros en la tabla artículos utilizando parámetros en el
comando insert.
Crearemos un proyecto llamado "BaseDeDatos7" con la siguiente interfaz visual:

El código fuente de la aplicación para efectuar altas es:

Imports System.Data.SqlClient

Public Class Form1

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Dim conexion As SqlConnection
conexion = New SqlConnection("server=DIEGO-PC\SQLEXPRESS ;
database=base1 ; integrated security = true")
conexion.Open()
Dim cadena As String = "insert into
articulos(descripcion,precio) values (@descripcion,@precio)"
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
comando.Parameters.Add("@descripcion", SqlDbType.VarChar)
comando.Parameters.Add("@precio", SqlDbType.Float)
comando.Parameters("@descripcion").Value = TextBox1.Text
comando.Parameters("@precio").Value = TextBox2.Text
comando.ExecuteNonQuery()
MessageBox.Show("Los datos se guardaron correctamente")

Página 186 de 190

 TextBox1.Text = ""
TextBox2.Text = ""
conexion.Close()
End Sub
End Class
Para trabajar con parámetros dentro de comandos SQL debemos disponer el caracter @ y un nombre en
los lugares donde se sustituye en tiempo de ejecución con el dato que carga el operador.
En nuestro ejemplo debemos parametrizar la descripción y el precio del artículo:
Dim cadena As String = "insert into
articulos(descripcion,precio) values (@descripcion,@precio)"
Es importante notar que no disponemos las camillas simple cuando un parámetro es de tipo varchar. Solo
indicamos nombres de parámetros y no tipo de parámetros.
Luego si debemos llamar al método Add de la propiedad Parameters del objeto de la clase SqlCommand
indicando cada parámetro y de que tipo se trata (con esto la clase SqlCommand conocerá si tiene que
disponer las comillas simples o no):
comando.Parameters.Add("@descripcion", SqlDbType.VarChar)
comando.Parameters.Add("@precio", SqlDbType.Float)
Luego que creamos los dos parámetros debemos inicializar sus valores mediante la propiedad Parameters
y accediendo como subíndice al nombre de parámetro respectivo:
comando.Parameters("@descripcion").Value = TextBox1.Text
comando.Parameters("@precio").Value = TextBox2.Text
Finalmente llamamos al método ExecuteNonQuery para enviar al Sql Server el comando Sql respectivo
(previamente el objeto comando de la clase SqlCommand se encarga de sustituir los parámetros por los
valores asignados y según el tipo de dato del parámetros añadir las comillas simples)
Problema 2
Implementar la consulta de un artículo ingresando por teclado el código y recuperando la descripción y el
precio. Definir un parámetro para la consulta
Crear un proyecto llamado: BaseDeDatos8 y definir la siguiente interfaz visual:
5 objeto de la clase Label.
1 objeto de la clase Button.
1 objeto de la clase TextBox.

En el evento Click procedemos a buscar el código del artículo ingresado en el TextBox. El código fuente es:
Imports System.Data.SqlClient

Public Class Form1

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Dim conexion As SqlConnection
conexion = New SqlConnection("server=DIEGO-PC\SQLEXPRESS ;
database=base1 ; integrated security = true")
conexion.Open()
Dim cadena As String = "select descripcion, precio from
articulos where codigo=@codigo"
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
comando.Parameters.Add("@codigo", SqlDbType.Int)
comando.Parameters("@codigo").Value = TextBox1.Text

Página 187 de 190

 Dim registro As SqlDataReader
registro = comando.ExecuteReader()
Label4.Text = ""
Label5.Text = ""
If registro.Read() = True Then
Label4.Text = registro("descripcion")
Label5.Text = registro("precio")
Else
MessageBox.Show("No existe un artículo con el código
ingresado")
End If
conexion.Close()
End Sub
End Class
Definimos el String con el comando select insertando un parámetro llamado @codigo:
Dim cadena As String = "select descripcion, precio from
articulos where codigo=@codigo"
Creamos e inicializamos el parámetro @codigo:
comando.Parameters.Add("@codigo", SqlDbType.Int)
comando.Parameters("@codigo").Value = TextBox1.Text
El resto de la aplicación no cambia con respecto a lo que vimos en conceptos anteriores.
Problema 3
Implementar una aplicación que permita consultar un artículo por su código. Luego de mostrarlo activar un
botón para poder eliminarlo. Definir parámetros tanto para la consulta como para el borrado.
Crear un proyecto llamado: PruebaBaseDatos9 y definir la siguiente interfaz visual:
5 objeto de la clase Label.
2 objeto de la clase Button (disponer la propiedad Enabled del
botón de borrado en false para que empiece
desactivo)
1 objeto de la clase TextBox.

El código fuente para resolver la consulta y borrado es:

Imports System.Data.SqlClient

Public Class Form1

Private conexion As New SqlConnection("server=DIEGO-PC\SQLEXPRESS ;

database=base1 ; integrated security = true")

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles

Button1.Click
conexion.Open()
Dim cadena As String = "select descripcion, precio from
articulos where codigo=@codigo"
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
comando.Parameters.Add("@codigo", SqlDbType.Int)
comando.Parameters("@codigo").Value = TextBox1.Text
Dim registro As SqlDataReader

Página 188 de 190

 registro = comando.ExecuteReader()
If registro.Read() = True Then
Label4.Text = registro("descripcion")
Label5.Text = registro("precio")
Button2.Enabled = True
Else
MessageBox.Show("No existe un artículo con el código
ingresado")
End If
conexion.Close()
End Sub

Private Sub Button2_Click(sender As Object, e As EventArgs) Handles

Button2.Click
conexion.Open()
Dim cadena As String = "delete from articulos where
codigo=@codigo"
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
comando.Parameters.Add("@codigo", SqlDbType.Int)
comando.Parameters("@codigo").Value = TextBox1.Text
Dim cant As Integer
cant = comando.ExecuteNonQuery()
If cant = 1 Then
Label4.Text = ""
Label5.Text = ""
MessageBox.Show("Se borró el artículo")
Else
MessageBox.Show("No existe un artículo con el código
ingresado")
End If
conexion.Close()
Button2.Enabled = False
End Sub
End Class
Problema 4
Implementar una aplicación que permita consultar un artículo por su código. Luego mostrar en dos
TextBox la descripción y el precio actual. Permitir modificar la descripción y precio dejando registrado
dicho cambio en la tabla de la base de datos al presionar un botón. Utilizar parámetros en los comandos
SQL en la consulta y borrado
Crear un proyecto llamado: BaseDeDatos10 y definir la siguiente interfaz visual:
3 objeto de la clase Label.
2 objeto de la clase Button (disponer la propiedad Enabled del
botón de modificación en false para que
empiece desactivo)
3 objeto de la clase TextBox.

El código fuente para resolver la consulta y modificación es:

Página 189 de 190
Imports System.Data.SqlClient

Public Class Form1

Private conexion As New SqlConnection("server=DIEGO-PC\SQLEXPRESS ;
database=base1 ; integrated security = true")

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles

Button1.Click
conexion.Open()
Dim cadena As String = "select descripcion, precio from
articulos where codigo=@codigo"
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
comando.Parameters.Add("@codigo", SqlDbType.Int)
comando.Parameters("@codigo").Value = TextBox1.Text
Dim registro As SqlDataReader
registro = comando.ExecuteReader()
If registro.Read() = True Then
TextBox2.Text = registro("descripcion")
TextBox3.Text = registro("precio")
Button2.Enabled = True
Else
MessageBox.Show("No existe un artículo con el código
ingresado")
End If
conexion.Close()
End Sub

Private Sub Button2_Click(sender As Object, e As EventArgs) Handles

Button2.Click
conexion.Open()
Dim cadena As String = "update articulos set
descripcion=@descripcion, precio=@precio where codigo=@codigo"
Dim comando As SqlCommand
comando = New SqlCommand(cadena, conexion)
comando.Parameters.Add("@codigo", SqlDbType.Int)
comando.Parameters("@codigo").Value = TextBox1.Text
comando.Parameters.Add("@descripcion", SqlDbType.VarChar)
comando.Parameters("@descripcion").Value = TextBox2.Text
comando.Parameters.Add("@precio", SqlDbType.Float)
comando.Parameters("@precio").Value = TextBox3.Text
Dim cant As Integer
cant = comando.ExecuteNonQuery()
If cant = 1 Then
MessageBox.Show("Se modificaron los datos del artículo")
TextBox1.Text = ""
TextBox2.Text = ""
TextBox3.Text = ""
Else
MessageBox.Show("No existe un artículo con el código
ingresado")
End If
conexion.Close()
Button2.Enabled = False
End Sub
End Class

Página 190 de 190