You are on page 1of 47

# UNIDAD 2: PASO 2 – IDENTIFICAR LAS ESTRUCTURAS BÁSICAS DE

PROGRAMACIÓN

## ANDRES VARGAS ROBLES

CODIGO: 1049633545

CÓDIGO: 11210714

## BRAYER DUVAN TRIANA BELLO

CÓDIGO: 1073179004

CODIGO:

GRUPO 201416_2

## CURSO: VISUAL BASIC BÁSICO 201416A_474

OCTUBRE DE 2018
CONTENIDO

CONTENIDO ................................................................................................................................... 2
INTRODUCTION ............................................................................................................................. 3
OBJETIVOS ..................................................................................................................................... 4
Link video casos de uso ............................................................................................................... 16
Conclutions .................................................................................................................................. 45
INTRODUCTION

The following work aims to start and further develop the themes of Unit 2 of the Basic
Visual Basic course in which resources should be consulted for this unit, perform an
exploration of the basic programming structures, logic, application syntax basic visual
as conditioning structures. If it is simple and nested, While and do structures, loop
structure for simple and nested, case and loop structures For each presentation of these
structures, in addition to this is an identification of the basic concepts of software design
tools in such a way how it has become the activity guide and thus generate the analysis,
understanding and acquisition of new knowledge by the student.
OBJETIVOS

Generales

## Conocimiento en estructuras básicas de la programación en Visual Basic mediante el

manejo del diagrama de flujo, sintaxis y conceptos de las herramientas.

Específico
 Identifica las estructuras y manejo de conceptos de la programación en visual
Basic.

##  Identifica conceptos básicos de herramientas de diseño de software.

APORTES: JOSE ANGEL GUERRERO

## Estructuras de condicionales If else simples y anidadas

Se entiende que la estructura If-Else consiste en tener un condicional simple de la forma
if (Si se cumple) y con bifurcación If – Else (Si y si no se cumple). La vía que puede
llegar a tomar el programa que se esté creando queda dependiendo de si se cumple o no
se cumple la condición correspondiente al caso que se esté manejando.

## Sintaxis en múltiple línea:

If condition [ Then ]
[ statements ]
[ ElseIf elseifcondition [ Then ]
[ elseifstatements ] ]
[ Else
[ elsestatements ] ]
End If

## If condition Then [ statements ] [ Else [ elsestatements ] ]

If condition [ Then ]
If condition [ Then ]
End If
End If
Diagrama de flujo If-Else

Inicio

Leer
departamento

Es
Sí Cundinamarca? No

Imprimir Imprimir
‘Estamos en el ‘Estamos en
centro del país’ Boyacá’

If-Else Simple

## Dim departamento, mensaje As String

departamento = Selectdepartamento.Text
If (departamento = "Cundinamarca") Then
mensaje = "Estamos en el centro del pais"
Else
mensaje = "Estamos en Boyaca"
End If

MessageBoxIcon.Asterisk)
Diagrama de flujo de If-Else anidado

Inicio

Leer
departamento

Sí No
Es
Cundinamarca
?
Imprimir
Es
Bogota? ‘Estas en Boyacá
Sí No
debe seguir
Imprimir Imprimir conduciendo’

## ‘Has llegado a tu ‘Estas en Tunja

destino’ aun no llegas al
destino’

## Dim departamento, ciudad, mensaje As String

departamento = Selectdepartamento.Text
If (departamento = "Cundinamarca") Then
mensaje = "Has llegado a tu destino"
Else
mensaje = "Estas en Tunja aun no llegas al destino"
End If
Else
mensaje = "Estas en Boyaca debe seguir conduciendo"
End If

MessageBoxIcon.Asterisk)
Estructuras While y do While
Esta estructura permite repetir sentencias y dependen de que se pueda validar como
Sintaxis
While condition
[ statements ]
[ Continue While ]
[ statements ]
[ Exit While ]
[ statements ]
End While

Inicio

Desde i = i + 1

Falso

Realiza suma

## Public Class Form1

Dim i As Integer = 0

While i < 5
MsgBox("Posiscion =" & i.ToString)
i=i+1

End While
End Sub
End Class
Do While
En esta estructura se puede anidar dentro de sí misma o dentro de otras estructuras pero
se debe verificar la instrucción disponga de una codificación de salida valida
Sintaxis
Do { While | Until } condition
[ statements ]
[ Continue Do ]
[ statements ]
[ Exit Do ]
[ statements ]
Loop
-Or-
Do
[ statements ]
[ Continue Do ]
[ statements ]
[ Exit Do ]
[ statements ]
Loop { While | Until } condition

Inicio

Desde i = i + 1

Falso

Realiza suma de

## Hasta cumplir condición i

i=i+1

Fin
Public Class Form1
Dim i As Integer = 0

Do
MsgBox(i)
i=i+1
Loop While i < 3

End Sub
End Class

## Estructura bucle for simple y anidada

Esta estructura es de las más usadas puesto que permite repetir secuencias de
instrucciones en especial si se conoce la cantidad exacta de veces que se debe ejecutar
una instrucción sin importar si es compuesta o simple
Se puede anidar bucles for uno dentro de otro, pero cada bucle debe tener una variable

Sintaxis:
For counter [ As datatype ] = start To end [ Step step ]
[ statements ]
[ Continue For ]
[ statements ]
[ Exit For ]
[ statements ]
Next [ counter ]
Diagrama de flujo For simple

Inicio

Desde a = 1 a
Val

Realiza suma de N

Imprime

## Public Class Form1

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
For a = 1 To Val(TextBox1.Text)
Label1.Text = Label1.Text & " - " & a
Next
MsgBox(" numeros consecutivos de 1 al escogido")
End Sub
End Class

Inicio

Desde a = 1 a
Val

Instrucción 1

Realiza suma de N

Desde i = 1 a
Val

Instrucción 2, 3 y 4

Imprime

## Public Class Form1

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles
Button1.Click
Dim sueldo As String
Dim titulo As String
Dim suma As Integer = 0
Dim sueldo2 As Double = 0
Dim sueldo3 As Double = 0
Dim sueldo4 As Double = 0
titulo = " ¿Cuanto ganas?"
For a = 1 To 4
For i = 1 To 1
sueldo = InputBox(titulo, "introduzca valor")
If sueldo > 0 Then
suma = suma + 1
MsgBox(" valor correcto")
End If
If sueldo > 100 And sueldo > 0 Then
sueldo2 = sueldo2 + 1
TextBox1.Text = sueldo2
End If

## If sueldo < 100 And sueldo > 0 Then

sueldo3 = sueldo3 + 1
TextBox2.Text = sueldo2
End If

## If sueldo = 100 Then

sueldo4 = sueldo4 + 1
TextBox3.Text = sueldo4
End If
Next i
TextBox4.Text = suma
Next a
End Sub
End Class
Estructuras Case
La estructura de control Case es una estructura de selección múltiple con ella podemos
evaluar una variable además de realizar acciones dependiendo del valor de esta variable,
su funcionamiento se basa en una variable que puede tomar varios valores pero solo uno
a la vez, no obstante dependiendo del valor que tome la variable se llevara a cabo el
proceso que corresponda.
Sintaxis
Select Case (variable)
Case (valor 1):
(Acción para caso valor 1)
Case (valor 2):
(Acción para caso valor 2)
Case (valor3) :
(Acción para caso valor 3)
Case (valor 4):
(Acción para caso valor 4)
Case Else:
Aacción en caso de que no se cumpla ningun anterior caso)
End Select
Diagrama de Flujo

Variable

## Instrucción 1 Instrucción 2 Instrucción 3 Instrucción 4

Dim dia
dia = InputBox("dime un dia de la semana")
Select Case dia
Case 1
MsgBox("El dia es LUNES")
Case 2
MsgBox("El dia es MARTES")
Case 3
MsgBox("El dia es MIERCOLES")
Case 4
MsgBox("El dia es JUEVES")
Case 5
MsgBox("El dia es VIERNES")
Case 6
Case 7
MsgBox("El dia es DOMINGO")
Case Else
MsgBox("Tiene que ser un dia de la semana en número, del 1 al 7")
End Select
Bucles For Each
La estructura de control FOR EACH sirve para moverse por los elementos de una
estructura de datos y ordenar y sumar colecciones, como podría ser un vector, y realizar
acciones para cada una de los elementos que allí se encuentran y por ende para que este
funcione debe haber más de un elemento en el grupo y se puede usar en array list
Sintaxis
For Each element [ As datatype ] In group
[ statements ]
[ Continue For ]
[ statements ]
[ Exit For ]
[ statements ]
Next [ element ]

## Diagrama flujo For Each

Inicio

No Si
Realiza suma

Imprime

Sub agregar()

End Sub
Sub sumar()
Dim total As Integer
For Each elementos In ListBox1.Items
total += elementos.ToString
Next
TextBox1.Text = total
End Sub

## Link video casos de uso

APORTES: ANDRES RENE VARGAS ROBLES

## Estructuras de condicionales If else simples y anidadas

Selección simple o condicional: Es una estructura de control que permite ejecutar un
grupo de acciones dependiendo de alguna condición lógica. Las estructuras de control
permiten controlar el flujo del programa para determinar cuáles acciones se ejecutan y
cuáles no. En este tipo de estructura se ejecutan un conjunto de acciones si y sólo si, se
cumple o se hace verdadera la condición.
La notación que usaremos es:
If <condición> then
... Endif
Sintaxis en múltiple línea:

If condition [ Then ]
[ statements ]
[ ElseIf elseifcondition [ Then ]
[ elseifstatements ] ]
[ Else
[ elsestatements ] ]
End If

## If condition Then [ statements ] [ Else [

elsestatements ] ]

If condition [ Then ]
If condition [ Then ]
End If
End If
Selección doble o condicional doble
La estructura selectiva simple es muy fácil de usar y muy común, pero en ocasiones
tenemos necesidad de decirle al programa para si no se cumple una condición que nos
realice una determinada tarea y si se cumple nos haga otra. El punto principal de esta
estructura es que es posible también indicar que acciones llevar a cabo en caso de que
la condición sea falsa

## La notación que usaremos es:

If <condición> then
...
else
...
endif

Es posible también anidar varios condicionales para expresar condiciones más complejas.
Decimos que una estructura condicional es anidada cuando por la rama del verdadero o el
falso de una estructura condicional hay otra estructura condicional
ESTRUCTURA WHILE

## (condición o expresión) instrucciones; es seguramente la más utilizada. La sentencia, o grupo

de sentencias o in

## EJEMPLO X: Imprimir en pantalla la palabra “Hola”, mientras se presione en número 1

#include<stdio.h>

main()
{
int num;
printf ("Ingrese un numero: ");
scanf("%d",&num);
while (num == 1)
{ printf ("\n Hola\n\n");
printf ("Ingrese otro numero: ");
scanf("%d",&num);
}
system("PAUSE");
return 0;
}
ESTRUCTURA DO WHILE

Una variación de la sentencia while es: do instrucciones while (condición o expresión); En ella
la sentencia se ejecuta al menos una vez, antes de que se evalúe la expresión condiciona

ESTRUCTURA FOR

La estructura for permite realizar un tipo de repeticiones (también llamadas bucles) esto lo
hace de una forma muy sencilla. No obstante, su definición formal no es tan sencilla como la
de un if():

## La idea del funcionamiento de un bucle for es la siguiente: "mientras la condición indicada se

siga cumpliendo, repite la ejecución de las instrucciones definidas dentro del for. Además,
después de cada repetición, actualiza el valor de las variables que se utilizan en la condición"

## El diagrama de flujo escrito en pseudocódigo es aproximadamente el siguiente:

Inicio

SUMA 0
1: leer N
Si N = 0 entonces
Escribir SUMA
Ir_a fin
Si_no
Suma suma + N
FIN_SI
IR_A 1
FIN

Un bucle puede anidarse dentro de otro como se vio en clase con los condicionales anidados
(un si fin_si dentro de otro si Fin_si)

## Un contador es una variable cuyo valor se incrementa o decremento en una cantidad

La siguiente figura
ESTRUCTURAS CASE

La estructura case es una estructura de control que permite la realizar comparaciones (de
arriba a abajo) de una variable con los patrones que hemos escrito dentro de la estructura.
Cuando el valor de la variable es igual al de un patrón, la secuencia de código que haya dentro
de ese comando se ejecutará.
Al final de cada estructura insertamos los caracteres; para salir de la estructura case que
finaliza con la palabra esac. Como vemos, el final de la estructura es la misma palabra puesta
del revés, igual que sucede con la estructura alternativa if.

CASE (valor3):

CASE ELSE:

## Acción en caso de que no se cumpla ningún anterior caso)

END SELECT

Ejemplo:
BUCLES FOR EACH

La estructura de control FOR EACH sirve para moverse por los elementos de una estructura de
datos, como podría ser un vector, y realizar acciones para cada una de los elementos.

Sintaxis

hacer
instrucciones

## LINK DE VIDEO DIAGRAMA DE CLASES:

APORTES: BRAYAN TRIANA

##  Estructuras de condicionales If else simples y anidadas

if(condición 1)
sentencia 1
else if (condición 2)
sentencia 2
Se conoce como estructura condicional es anidada cuando la rama es verdadera o falso
se encuentra otra condicional

import java.util.Scanner;

public static void main(String[] ar) {
int nota1,nota2,nota3;
System.out.print("Ingrese primer nota:");
System.out.print("Ingrese segunda nota:");
System.out.print("Ingrese tercer nota:");
int promedio=(nota1 + nota2 + nota3) / 3;
if (promedio>=7) {
} else {
if (promedio>=4) {
System.out.print("Regular");
} else {
}
}
}
}

##  Estructuras While y do While

WHILE:

while (condición){
//sentencias a ejecutar
}

## cuando queremos repetir la ejecución de unas sentencias un número indefinido de veces,

siempre que se cumpla una condición.
#include<stdio.h>
#include<stdlib.h>
void main()
{
int num=0;
int suma=0;
while(num<=10)
{
suma = suma + num;
num++;
}
printf(“Suma = %d\n”,suma);
system(“pause”);
}

DO-WHILE

do {
//sentencias del bucle
} while (condición)

## Se utiliza generalmente cuando no sabemos cuantas veces se habrá de ejecutar el bucle,

igual que el bucle WHILE, con la diferencia de que sabemos seguro que el bucle por lo
menos se ejecutará una vez.
void main()
{
int num=0;
int suma=0;
do
{
suma = suma + num;
num++;
} while(num<=10);
printf(“Suma = %d\n”,suma);
system(“pause”);
}

[ statements ]
[ Continue For ]
[ statements ]
[ Exit For ]
[ statements ]
Next [ counter ]

## Repite un grupo de instrucciones un número especificado de veces.

For indexA = 1 To 3
' Create a new StringBuilder, which is used
' to efficiently build strings.
Dim sb As New System.Text.StringBuilder()

## ' Append to the StringBuilder every third number

' from 20 to 1 descending.
For indexB = 20 To 1 Step -3
sb.Append(indexB.ToString)
sb.Append(" ")
Next indexB

## ' Display the line.

Debug.WriteLine(sb.ToString)
Next indexA
' Output:
' 20 17 14 11 8 5 2
' 20 17 14 11 8 5 2
' 20 17 14 11 8 5 2

Public Sub sumRows(ByVal a(,) As Double, ByRef r() As Double)
Dim i, j As Integer
For i = 0 To UBound(a, 1)
r(i) = 0
For j = 0 To UBound(a, 2)
If a(i, j) > 0 Then
r(i) = r(i) + a(i, j)
End If
Next j
Next i
End Sub
Cuando una instrucción de control se coloca dentro de otra, se dice que está

#include <iostream>
using namespace std;

## //Lo que antes era la estructura Cliente,

//Ahora se llama Persona.
struct Persona{
char nombre[20], apellido[20];
long telefono;
};

## //Una estructura para representar la

//Fecha de nacimiento de una persona.
struct Fecha{
int dia,mes,anio;
};

## //Esta estructura representa el registro

//De una persona a una centro educativo.
//¡Dentro de ella están todos lo campos
struct Registro{
Persona persona;
Fecha fec;
};

int main(){
Registro nuevoIngreso;
cout << "Ingrese el nombre" << endl;
cin.getline(nuevoIngreso.persona.nombre,20);

## cout << "Ingrese apellido" << endl;

cin.getline(nuevoIngreso.persona.apellido,20);

## cout << "Ingrese numero de identificacion" << endl;

cin >> nuevoIngreso.persona.numeroIdentificacion;

## cout << "Ingrese telefono" << endl;

cin >> nuevoIngreso.persona.telefono;

## cout << "Ingrese dia de nacimiento" << endl;

cin >> nuevoIngreso.fec.dia;

## cout << "Ingrese mes de nacimiento" << endl;

cin >> nuevoIngreso.fec.mes;

## cout << "Ingrese anio de nacimiento" << endl;

cin >> nuevoIngreso.fec.anio;

## cout << "Nombre: " << nuevoIngreso.persona.nombre;

cout << "\nApellido: " << nuevoIngreso.persona.apellido;
cout << "\nNumero de identificacion: " <<
nuevoIngreso.persona.numeroIdentificacion;
cout << "\nTelefono: " << nuevoIngreso.persona.telefono;
cout << "\nDia de nacimiento: " << nuevoIngreso.fec.dia;
cout << "\nMes de nacimiento: " << nuevoIngreso.fec.mes;
cout << "\nAnio de nacimiento: " << nuevoIngreso.fec.anio;
cout << endl << endl << endl;
return 0;
}

 Estructuras case

## SELECT CASE (variable)

CASE (valor1):
(acción para caso valor1)
CASE (valor3):
(acción para caso valor2)
CASE (valor3):
(acción para caso valor3)
CASE ELSE:
(accion en caso de que no se cumpla ningun anterior caso)
END SELECT

## Con la estructura de control CASE podemos evaluar una variable y realizar

acciones dependiendo del valor de esta.

dim dia
dia = inputbox ("dime un dia de la semana")
SELECT CASE dia
CASE 1:
msgbox("El dia es LUNES")
CASE 2:
msgbox("El dia es MARTES")
CASE 3:
msgbox("El dia es MIERCOLES")
CASE 4:
msgbox("El dia es JUEVES")
CASE 5:
msgbox("El dia es VIERNES")
CASE 6:
CASE 7:
msgbox("El dia es DOMINGO")
CASE ELSE:
msgbox("Tiene que ser un dia de la semana en número, del 1 al 7")
END SELECT

[ statements ]
[ Continue For ]
[ statements ]
[ Exit For ]
[ statements ]
Next [ element ]

## ' Create a list of strings by using a

' collection initializer.
Dim lst As New List(Of String) _
From {"abc", "def", "ghi"}

## ' Iterate through the list.

For Each item As String In lst
Debug.Write(item & " ")
Next
Debug.WriteLine("")
'Output: abc def ghi
APORTES JHON JAMER BOLIVAR

## Public Class Form1

Private Sub textnum1_TextChanged(sender As Object, e As EventArgs) Handles
textnum1.TextChanged

End Sub

## Private Sub consultar_Click(sender As Object, e As EventArgs) Handles

consultar.Click
Dim num1, num2 As Integer

num1 = textnum1.Text
num2 = textnum2.Text

## If (num1 < num2) Then

MsgBox("valor 1 menos que valor 2")

## ElseIf (num1 = num2) Then

MsgBox("valor 1 igual a valor 2")
Else
MsgBox("valor 1 mayor que numero 2")

End If
End Sub
End Class
Aquí iniciamos el código como un código publico, definiendo las variables num1 y
num2 como enteros, aquí les doy un valor de impresión como lo es el text y
dado asi la declaración de las variables empezamos en el sistema como if “si” el
valor numero 1, es menor que el valor número 2 y le damos una impresión que
aparezca en pantalla con el “msgbox” y el usuario podrá escribir los números en
el sistema los cuales se evalauran en el sistema escrito en el form.1 ya que de
ahí se hizo el formulario y se programó. También mostramos en el sistema un if
anidado en donde se hace de forma selectiva en el cual a la manera de cambiar os
valores se muestra si el valor numero1 es igual, menor o mayor el que valor
número 1.
Public Class Form1
Dim i As Integer = 0
'Do
' MsgBox("Ciclo Do =" + i.ToString)
' i = i + 1
'Loop While i < 3

'i = 0

## 'Do While i < 3

' MsgBox("ciclo do while =" + i.ToString)
' i = i + 1
'Loop

'i = 0

'While i < 3
' MsgBox("ciclo while=" + i.ToString)
' i += 1
'End While

Dim arreglo(5)
Do While i < 5
arreglo(i) = i + 1
i += 1
Loop
i = 0
While i < 5
MsgBox("arreglo(" + i.ToString + ")=" + arreglo(i).ToString)
i = i + 1
End While

End Sub
End Class
Sintaxis
Public Class Form1
'Dim i As Integer
'For i = 0 To 4
'MsgBox(i)
'Dim arreglo(10) As Integer
'Dim i As Integer
Dim i As Integer
Dim j As Integer

For i = 0 To 2
MsgBox("ciclo externo i=" + i.ToString)
For j = 0 To 3
MsgBox("Ciclo interno j =" + j.ToString)

Next
'arreglo(i) = i + 1
'MsgBox("arreglo(" + i.ToString + ") = " + arreglo(i).ToString)

Next
End Sub
End Class
Public Class Form1
Dim n1, n2 As Integer
n1 = InputBox("Digita 1,2, o 3")
Select Case n1

Case 1
n2 = InputBox("Digia un valor")
MsgBox("n2 = " + n2.ToString)

Case 2
n2 = 35
MsgBox("n2 = " + n2.ToString)

End Select
End Sub
End Class
Public Class Form1
Dim numberSeq() As Integer = {1, 2, 3, 4, 5}

Dim n2 As Integer
n2 = InputBox("Digita un valor")
For Each number As Integer In numberSeq
MsgBox("Es valido")
Next

End Sub
End Class
Conclutions

 It can be said that it is important to manage the programming structures for the
proper development of any application, the course teaches us how to manage
these structures which allow us to achieve a better efficiency of the system we
are managing. Data structures do not only represent information, They also have
an internal behavior, and are governed by certain rules and restrictions given by
the way it is built internally.
 In conclusion the design of the software is important for a correct creation of
certain software, starting with the use cases, the lles will allow to know which
actors will be related to the creation of this, in addition to the analysis and its
correct planning to achieve an excellent product
 It highlights the importance of knowing and understanding the operation of each
programming structure which allows to make programming code of higher
quality and better efficiency
 It concludes the importance of a detailed planning with which we can define
which are the points that must be developed providing an appropriate solution to
each proposed exercise.
 In this course we were able to know the importance of the structures, by means
of examples and the management of flowchart with data management and to
follow some rules like the syntax so that the result is what was expected, driving
visual basic with refence improving their knowledge for a greater efficiency.
REFERENCIAS

##  Rubiano. J. (2016). Material de apoyo unidad 2. Recuperado de

http://hdl.handle.net/10596/9361
 Tutorial Visual Basic .NET - Parte 3. (2013). Arreglos. [Archivo de
 Fernández, C. (2009). Visual Basic: básico. Madrid, ES: RA-MA Editorial.
D=11046605&tm=1480460037723
 Rubiano. J. (2016). Conocimiento entorno teórico [OVI]. Recuperado de
http://hdl.handle.net/10596/9380
http://www.tutorialesprogramacionya.com/javaya/detalleconcepto.php?codigo=8
1&punto=&inicio
 Desarrolloweb.bucles while y do while. recuperado de
https://www.desarrolloweb.com/articulos/567.php
 https://docs.microsoft.com/es-es/dotnet/visual-basic/programming-
guide/language-features/control-flow/nested-control-structures
 Estructuras case. recuerdo de https://desarrolloweb.com/articulos/estructura-
case-vbscript.html
https://msdn.microsoft.com/es-es/library/5ebk1751(v=vs.120).aspx
dehttp://hdl.handle.net/10596/9361
 Tutorial Visual Basic .NET - Parte 3. (2013). Arreglos. [Archivo de
 Fernández, C. (2009). Visual Basic: básico. Madrid, ES: RA-MA Editorial.
ocID=11046605&tm=1480460037723
 Fernández, C. (2009). Visual Basic: básico. Madrid, ES: RA-MA Editorial.
Capítulo 5 Sentencias de control. Recuperado
ocID=11046605&tm=1480460037723
 OVA Unidad 2 - Fundamentos de programación

##  Rubiano. J. (2016). Conocimiento entorno teórico [OVI]. Recuperado

dehttp://hdl.handle.net/10596/9380
 Recursos educativos adicionales para el curso

##  Fernández, C. (2009). Visual Basic: básico. Madrid, ES: RA-MA Editorial.

Capítulo 7 Matrices y estructuras. Recuperado
ocID=11046605&tm=1480460037723
 Estructura de bucles (Visual Basic) Recuperado de:
https://docs.microsoft.com/es-es/dotnet/visual-basic/programming-
guide/language-features/control-flow/loop-structures
 USO DEL FOR EACH EN VISUAL BASIC by fokyyea PEDRO HERRERA
KU (2011. diciembre 20). USO DEL FOR EACH EN VISUAL BASIC by

 For Each...Next Statement (Visual Basic) Recuperado de:
https://docs.microsoft.com/en-us/dotnet/visual-basic/language-
reference/statements/for-each-next-statement
 Instrucción While...End While (Visual Basic) Recuperado de:
https://msdn.microsoft.com/es-es/library/zh1f56zs(v=vs.120).aspx
 Ciclo While tripod Recuperado de:
http://visualbasic.ar.tripod.com/ciclowhile.html
 Estructura repetitiva Do While (Visual Basic) Recuperado de:
http://www.tutorialesprogramacionya.com/visualbasicya/detalleconcepto.php?co
digo=9&punto=9&inicio=0
 Instrucción Do...Loop (Visual Basic) Recuperado de:
https://msdn.microsoft.com/es-
xl/library/windows/apps/xaml/eked04a7(v=vs.120).aspx
 Instrucción For...Next (Visual Basic) Recuperado de:
https://msdn.microsoft.com/es-ar/library/5z06z1kb(v=vs.120).aspx
 Estructuras de bucles (Visual Basic) Recuperado de:
https://docs.microsoft.com/es-es/dotnet/visual-basic/programming-
guide/language-features/control-flow/loop-structures
 Tema 2: Diagrama Casos de usos. Jose Angel Guerrero Montañez (2018.
Octubre 21). Tema 2: Diagrama Casos de usos. Recuperado de: