You are on page 1of 47

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

PROGRAMACIÓN

PRESENTADO A

JAIME RUBIANO LLORENTE

PRESENTADO POR

ANDRES VARGAS ROBLES

CODIGO: 1049633545

JOSÉ ANGEL GUERRERO MONTAÑEZ.

CÓDIGO: 11210714

BRAYER DUVAN TRIANA BELLO

CÓDIGO: 1073179004

JHON JAMER BOLIVAR

CODIGO:

GRUPO 201416_2

UNIVERSIDAD NACIONAL ABIERTA Y DISTANCIA - UNAD.

CURSO: VISUAL BASIC BÁSICO 201416A_474

OCTUBRE DE 2018
CONTENIDO

CONTENIDO ................................................................................................................................... 2
INTRODUCTION ............................................................................................................................. 3
OBJETIVOS ..................................................................................................................................... 4
Actividad identificación ................................................................................................................. 5
Link video casos de uso ............................................................................................................... 16
Actividad identificación ............................................................................................................... 17
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

Actividad identificación

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

Sintaxis en una sola línea:

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

Forma anidada

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

MessageBox.Show(mensaje, "Resultado", MessageBoxButtons.OKCancel,


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’

If-Else Anidado

Dim departamento, ciudad, mensaje As String


departamento = Selectdepartamento.Text
ciudad = ComboBoxDias.Text
If (departamento = "Cundinamarca") Then
If (Ciudad = "Bogota") 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

MessageBox.Show(mensaje, "Resultado", MessageBoxButtons.OKCancel,


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

Diagrama de flujo While

Inicio

Desde i = i + 1

Falso

Realiza suma
de cantidades

Verdadero

Hasta cumplir condición <5

Public Class Form1


Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
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

Diagrama de flujo Do While

Inicio

Desde i = i + 1

Falso

Realiza suma de
cantidades
Verdadero

Hasta cumplir condición i

i=i+1

Fin
Public Class Form1
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
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
For Anidada:
Se puede anidar bucles for uno dentro de otro, pero cada bucle debe tener una variable
única de contador

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

Lee el valor asignado

Realiza suma de N
cantidades

Imprime

Todos los valores

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
Diagrama de flujo For anidada

Inicio

Desde a = 1 a
Val

Lee el valor asignado

Instrucción 1

Realiza suma de N
cantidades y Conteo

Desde i = 1 a
Val

Lee el valor asignado

Instrucción 2, 3 y 4

Imprime

Todos los valores

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

Valor 1 Valor 2 Valor 3 Valor 4

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
MsgBox("El dia es SABADO")
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

Leer cantidad

¿Es verdadera la condición?


No Si
Realiza suma
de cantidades

Imprime

Adhiere nueva
cantidad
Sub agregar()

ComboBox1.Items.Add(40)
ComboBox1.Items.Add(80)
ComboBox1.Items.Add(150)
ComboBox1.Items.Add(300)
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

Link video: https://youtu.be/ce1cKfWDW9o


APORTES: ANDRES RENE VARGAS ROBLES

Actividad identificación

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

Sintaxis en una sola línea:

If condition Then [ statements ] [ Else [


elsestatements ] ]

Forma anidada

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

Condicionales Anidados

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
BUCLES ANIDADOS

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)

Contadores

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


constante en cada vuelta.
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.

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:

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

paraCada ELEMENTO de COLECCIÓN


hacer
instrucciones
fin paraCada

LINK DE VIDEO DIAGRAMA DE CLASES:


https://www.youtube.com/watch?v=IHwiLQkA7I4
APORTES: BRAYAN TRIANA

Actividad

 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 class EstructuraCondicionalAnidada1 {


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

 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”);
}

 Estructura bucle for simple y anidada

For counter [ As datatype ] = start To end [ Step step ]


[ 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

Anidada
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á
anidada

#include <iostream>
using namespace std;

//Lo que antes era la estructura Cliente,


//Ahora se llama Persona.
struct Persona{
char nombre[20], apellido[20];
int edad, numeroIdentificacion;
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
//Solicitados!
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 edad" << endl;


cin >> nuevoIngreso.persona.edad;

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;

system("cls"); //Borra la pantalla.

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


cout << "\nApellido: " << nuevoIngreso.persona.apellido;
cout << "\nEdad: " << nuevoIngreso.persona.edad;
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:
msgbox("El dia es SABADO")
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

For Each element [ As datatype ] In group


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

Repite un grupo de instrucciones para cada elemento de una colección.

' 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
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
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
Ciclo for simple y anidado
Sintaxis
Public Class Form1
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
'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
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
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
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
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
video]. Recuperado de https://www.youtube.com/watch?v=broPkjHSh0M
 Fernández, C. (2009). Visual Basic: básico. Madrid, ES: RA-MA Editorial.
Capítulo 4 entrada y salida estándar. Recuperado de
http://bibliotecavirtual.unad.edu.co:2077/lib/unadsp/reader.action?ppg=52&docI
D=11046605&tm=1480460037723
 Rubiano. J. (2016). Conocimiento entorno teórico [OVI]. Recuperado de
http://hdl.handle.net/10596/9380
 Tutorialesprogramacioya. estructuras condicionales anidadas. Recuperado de
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
 Estructura bucle for simple y anidada. Recuperado de
http://lineadecodigo.com/java/bucle-for-each-en-java/
 Estructura bucle for simple y anidada recuperado de
https://msdn.microsoft.com/es-es/library/5ebk1751(v=vs.120).aspx
 Rubiano. J. (2016). Material de apoyo unidad 2. Recuperado
dehttp://hdl.handle.net/10596/9361
 Tutorial Visual Basic .NET - Parte 3. (2013). Arreglos. [Archivo de
video]. Recuperado de https://www.youtube.com/watch?v=broPkjHSh0M
 Fernández, C. (2009). Visual Basic: básico. Madrid, ES: RA-MA Editorial.
Capítulo 4 entrada y salida estándar. Recuperado
dehttp://bibliotecavirtual.unad.edu.co:2077/lib/unadsp/reader.action?ppg=52&d
ocID=11046605&tm=1480460037723
 Fernández, C. (2009). Visual Basic: básico. Madrid, ES: RA-MA Editorial.
Capítulo 5 Sentencias de control. Recuperado
dehttp://bibliotecavirtual.unad.edu.co:2077/lib/unadsp/reader.action?ppg=52&d
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
dehttp://bibliotecavirtual.unad.edu.co:2077/lib/unadsp/reader.action?ppg=52&d
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
fokyyea . Recuperado de: https://www.youtube.com/watch?v=_li1p-1u3J4

 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:
https://www.youtube.com/watch?v=ce1cKfWDW9o