Visual INTRODUCCION PMN

Programación y Métodos Numéricos 2020 A \1.
Fundamentos \ Ismael Véliz Vilca -1-
1 Tabla de contenido
CAPITULO I FUNDAMENTOS DE PROGRAMACIÓN..................................................1
1.1 CONCEPTO DE SISTEMAS.-...........................................................................1
Definición de sistemas.-..............................................................................................1
Elementos o componentes de un sistema..................................................................1
1.2 CONCEPTOS DE PROGRAMACION Y APLICACIONES..................................2
Programa.....................................................................................................................2
Programación..............................................................................................................2
Lenguajes de programación........................................................................................2
1.3 METODOLOGIA DE LA PROGRAMACION........................................................2
análisis.........................................................................................................................2
diseño..........................................................................................................................3
codificación..................................................................................................................3
ejecución......................................................................................................................3
prueba..........................................................................................................................3
mantenimiento.............................................................................................................3
1.4 ALGORITMOS.....................................................................................................3
diagramas de flujo.......................................................................................................3
Representación gráfica de los algoritmos.-.................................................................4
Pseudocódigo..............................................................................................................4
Ejercicios visual logic DFD.........................................................................................5
1.5 PROGRAMA EN VISUAL BASIC 2015...............................................................5
Ejercicios.....................................................................................................................7
1.6 LENGUAJE DE PROGRAMACION VISUAL BASIC DE VISUAL ESTUDIO
2015 7
MOTIVOS....................................................................................................................7
Visual Basic 2008 (VB 9.0)..........................................................................................8
Visual Basic 2010 (VB 10.0)........................................................................................8
Visual Basic 2012 (VB 10.0)........................................................................................8
Visual Basic 2015 (VB 10.0)........................................................................................8
Ejemplo del programa de 4 operaciones en visual basic 2010...................................8
1.7 . LA ESTRUCTURA DE UN PROGRAMA VISUAL BASIC 2015......................14
Estructura de un programa de Visual Basic..............................................................14
Elementos de programación en el nivel de archivo..................................................15
Instrucciones Option..................................................................................................15
Instrucciones Imports..............................................................................................15
Instrucciones Namespace.......................................................................................15
Instrucciones de compilación condicional...............................................................15
Programación y Métodos Numéricos 2020 A \1.Fundamentos \ Ismael Véliz Vilca -2-
Elementos de programación en el nivel de espacio de nombres.............................16
Elementos de programación en el nivel de módulo..................................................16
1.8 Procedimiento Main( ) como procedimiento de entrada al programa...............16
1.9 REGLAS DE ESCRITURA DE UN PROGRAMA VISUAL BASIC....................17
1.10 PALABRAS RESERVADAS,TIPOS DE DATOS, CONSTANTES Y
VARIABLES..................................................................................................................17
Palabras reservadas..................................................................................................17
Palabras clave reservadas........................................................................................17
Palabras clave no reservadas...................................................................................19
Identificadores...........................................................................................................19
Constantes.................................................................................................................19
1.11 - VARIABLES.-...............................................................................................20
Declaración de variable en Visual Basic...................................................................20
Declarar el tipo de datos............................................................................................20
Asignar valores..........................................................................................................21
Denominación............................................................................................................21
Avisos del IDE sobre errores en el código................................................................21
Lugar de la declaración.............................................................................................22
Tipificación.................................................................................................................22
¿para qué necesitamos asignar tipo a las variables?”..............................................22
Declaración múltiple en línea....................................................................................23
Asignación de valor...................................................................................................23
Valor inicial................................................................................................................25
Declaración obligatoria..............................................................................................26
Option Explicit a nivel de proyecto............................................................................27
Option Explicit a nivel de fichero...............................................................................28
Tipificación obligatoria...............................................................................................28
Opción por defecto....................................................................................................29
1.12 TIPOS DE DATOS EN VISUAL BASIC 2010.................................................32
Resumen de tipos de datos (Visual Basic)...............................................................32
Funciones de conversión de tipos (Visual Basic)......................................................33
1.13 OPERADORES...............................................................................................35
Resumen de operadores (Visual Basic)....................................................................36
Precedencia de operadores......................................................................................37
 Espera el operador.............................................................................................37
 Operadores de concatenación y aritméticos......................................................37
 Operadores de comparación............................................................................37
 Operadores lógicos y bit a bit.............................................................................37
1.14 APLICACION DE CONSOLA..........................................................................37
Creación de un proyecto de tipo aplicación de consola............................................38
La clase Console.......................................................................................................38
1.15 ESCRITURA DE INFORMACIÓN..................................................................38
¿Cuál es la diferencia entre el Writeline y el Write?.................................................39
¿Qué son los flujos de salida con formato?..............................................................40
Cadenas con formato numérico estándar.................................................................41
Ejemplo de Cadenas con formato numérico estándar..............................................44
Formatos compuestos...............................................................................................44
Sintaxis de elemento de formato...............................................................................45
Cadenas con formato numérico personalizado.........................................................46
Ejemplo de El especificador personalizado "0" y “#”.....................................47
Escritura de múltiples valores en la misma línea......................................................48
1.16 LECTURA DE INFORMACIÓN......................................................................50
Cuál es la diferencia entre el Read y el Readline?...................................................51
1.17 AYUDA DE VISUAL BASIC...........................................................................52
1.18 PROBLEMAS RESUELTOS...........................................................................52
Problema C101 Escriba el programa hola mundo en visual basic 2010.................52
Problema C102.Calcule una formula (una estrada y una salida)............................54
Problema C103 . Calcular el area del triángulo ( 2 entradas y una salida”)............54
Problema C104 Ingreso de una variable tipo cadena .............................................54
Problema C105 Precedencia de operaciones...........................................................55
Problema C106 Ejemplo de salida con formato y espacios...................................55
Problema C107. Ejemplo de ,caracteres de escape.................................................56
Problema C108. Ejemplo de readkey........................................................................56
Problema C109 Ejemplo de Especificador de formato de punto fijo ("F")...............57
Problema C110 Ejemplo de Especificador de formato de punto fijo ("#")...............57
1.19 PROBLEMAS PROPUESTOS.......................................................................58
PARTE I FUNDAMENTOS DE LENGUAJE DE PROGRAMACION
CON VISUAL BASIC 2015
CAPITULO I FUNDAMENTOS DE PROGRAMACIÓN
1.1 CONCEPTO DE SISTEMAS.-
Definición de sistemas.-
Un sistema (del latín systēma, y este del griego σύστημα sýstēma 'reunión, conjunto,

agregado') es un conjunto de componentes que se relacionan con al menos algún otro
componente; puede ser material o conceptual.1 Todos los sistemas tienen composición,
estructura y entorno, pero solo los sistemas materiales tienen mecanismo, y solo
algunos sistemas materiales tienen figura (forma).
http://www.alegsa.com.ar/Dic/sistema.php
Un sistema (system). Es un conjunto de partes o elementos organizadas y relacionadas

que interactúan entre sí para lograr un objetivo. Los sistemas reciben (entrada) datos,
energía o materia del ambiente y proveen (salida) información, energía o materia.
Un sistema puede ser físico o concreto (una computadora, un televisor, un humano) o

puede ser abstracto o conceptual (un software)
Cada sistema existe dentro de otro más grande, por lo tanto un sistema puede estar
formado por subsistemas y partes, y a la vez puede ser parte de un supersistema.
Elementos o componentes de un sistema
En el siguiente diagrama se muestra los elementos o componentes de un sistema
ENTRADA PROCESO SALIDA
RETROALIMENTACION
Figura. 1.1 Esquema simplificado de un sistema
Elementos
1. Entrada (INPUT) insumo, sensor.(lectura)

2. Salida (OUTPUT) producto, actuador(escritura)
3. Proceso o fenómenos( controlador).
4. Ambiente o mundo de las cosas próximas.
5. Retroalimentación (Feeback).- Retroinformación compara el producto con un criterio
En informática podemos distinguir dos clases de elementos:
Hardware : es la parte física del ordenador, todos los elementos que se pueden
“tocar”, por ejemplo el teclado, la pantalla, el procesador, etc.
Software : son los programas, sistemas operativos y datos que se utilizan en el
ordenador (la parte que no se puede “tocar”).
1.2 CONCEPTOS DE PROGRAMACION Y APLICACIONES
Programa.
La definición de la RAE es: Conjunto unitario de instrucciones que permite a un
ordenador realizar funciones diversas, como el tratamiento de textos, el diseño de
gráficos, la resolución de problemas matemáticos, el manejo de bancos de datos, etc.
Pero normalmente se entiende por programa un conjunto de instrucciones ejecutables
por un ordenador.
Programación
La programación consiste en pasar algoritmos a algún lenguaje de ordenador a fin de
que pueda ser entendido por el ordenador. La programación de ordenadores comienza
en los años 50 y su evolución ha pasado por diversos pasos.
Lenguajes de programación
 Los lenguajes de programación permiten codificar algoritmos en el ordenador. Son

una serie de símbolos e instrucciones de acuerdo con una sintaxis que facilita su
posterior traducción a código entendible por el ordenador,
En realidad los ordenadores sólo reconocen un lenguaje formado por los unos y ceros
Del código binario. Según la disposición de esos unos y ceros entenderá unas
Instrucciones u otras. De esa forma hay lenguajes más próximos al lenguaje de las
Computadores (lenguajes de bajo nivel) y lenguajes más próximos al lenguaje
humano (lenguajes de alto nivel)
1.3 METODOLOGIA DE LA PROGRAMACION
Independientemente de la metodología utilizada suele haber una serie de pasos

Comunes a todas ellas (relacionados con el ciclo de vida de la aplicación):
análisis
El análisis estudia los requisitos que ha de cumplir la aplicación. El resultado del

análisis es una hoja de especificaciones en la que aparecen los requerimientos de la
aplicación. Esta hoja es redactada por el o la analista, la persona responsable del
proceso de creación de la aplicación.
En la creación de algoritmos sencillos, el análisis consistiría únicamente en:

 Determinar las entradas. Es decir, los datos que posee el algoritmo cuando
comienza su ejecución. Esos datos permiten obtener el resultado.
 Determinar las salidas. Es decir, los datos que obtiene el algoritmo como
resultado. Lo que el algoritmo devuelve al usuario.
 Determinar el proceso. Se estudia cuál es el proceso que hay que realizar.
diseño
En esta fase se crean esquemas que simbolizan a la aplicación. Estos esquemas los
elaboran analistas. Gracias a estos esquemas se simboliza la aplicación. Estos
esquemas en definitiva se convierten en la documentación fundamental para plasmar
en papel lo que el programador debe hacer.
En estos esquemas se pueden simbolizar: la organización de los datos de la aplicación,

el orden de los procesos que tiene que realizar la aplicación, la estructura física (en
cuanto a archivos y carpetas) que utilizará la aplicación, etc.
La creación de estos esquemas se puede hacer en papel, o utilizar una herramienta

CASE para hacerlo.
codificación
Escritura de la aplicación utilizando un lenguaje de programación (C, Pascal, C++,

Java,...). Normalmente la herramienta utilizada en el diseño debe ser compatible con el
Lenguaje que se utilizará para codificar. Es decir si se utiliza un lenguaje orientado a
objetos, la herramienta de diseño debe ser una herramienta que permita utilizar
objetos.
ejecución
Tras la escritura del código, mediante un software especial se traduce a código

interpretable por el ordenador (código máquina). En este proceso pueden detectarse
errores en el código que impiden su transformación. En ese caso el software encargado
de la traducción (normalmente un compilador o un intérprete) avisa de esos errores
para que el programador los pueda corregir.
prueba
Se trata de testear la aplicación para verificar que su funcionamiento es el correcto.

Para ello se comprueban todas las entradas posibles, comprobando que las salidas son
las correspondientes.
mantenimiento
En esta fase se crea la documentación del programa (paso fundamental en la creación

De aplicaciones). Gracias a esa documentación se pueden corregir futuros errores o
Renovar el programa para incluir mejoras detectadas, operaciones que también se
Realizan en esta fase.
1.4 ALGORITMOS
Según la RAE: conjunto ordenado y finito de operaciones que permite hallar la

Solución de un problema en notaciones para el diseño de algoritmos
diagramas de flujo
 Es el esquema más viejo de la informática. Se trata de una notación que pretende
facilitar la escritura o la comprensión de algoritmos. Gracias a ella se esquematiza
el flujo del algoritmo.
 Fue muy útil al principio y todavía se usa como apoyo para explicar ciertos
algoritmos.
 Si los algoritmos son complejos, este tipo de esquemas no son adecuados.
 No obstante cuando el problema se complica, resulta muy complejo de realizar y de
entender.
 De ahí que actualmente, sólo se use con fines educativos y no en la práctica.
 Pero sigue siendo interesante en el aprendizaje de la creación de algoritmos.
 Los diagramas utilizan símbolos especiales que ya están normalizados por
organismos de estandarización como ANSI e ISO.
Representación gráfica de los algoritmos.-
Documento
Inicio o Fin Decisió n
Proceso Datos
Entrada manual
Conector
Visualización Bucle o ciclo de proceso
Datos
Sub-Programa
guardados Flujo de Diagrama
Figura 1.4.2.- Representación gráfica de los algoritmos.
Pseudocódigo.
Considerado como un lenguaje falso, el pseudocódigo es un Inicio

lenguaje intermedio entre nuestro lenguaje y el de programación, se
escribe la lógica de programación con el lenguaje español
Problema.- Intercambiar dos variables N1, N2

Análisis. (Especificaciones)- entrada a=10 b=20
Salida a=20 b=10 Temp <---- N1
Programación (algoritmo) N1<--- N2
Pseudocódigo N2<----Temp
paso1. Iniciar
paso2 ingresar las dos variables y guardarlos en N1 y N2
N1,N2
Fin
paso3 realizar el intercambio
3.1 Crear una variable temporal
3.2 poner el valor de N1 en temporal
3.3 Poner el valor de N2 en N1
3.4 poner el valor de temporal en N2
Paso 4 mostrar el contenido de N1 y N2
Paso 5 terminar
Elaborar diagrama de flujo, prueba de datos y programa
https://mega.nz/file/QFohyLQR#icXSOwFdGcuMvGlV6jNIPFfXPglAV6yTVaWeAZ7jjtY
Ejercicios visual logic DFD
enlace para descargar https://freedfd.uptodown.com/windows

1. Sumar dos números usar visual logic
Visual Logic Textbook versión 1.0

https://www.visuallogic.org/
Visual Logic www.visuallogic.org
1.5 PROGRAMA EN VISUAL BASIC 2017

Programación y Métodos Numéricos 2020 A \1.Fundamentos \ Ismael Véliz Vilca - 10 -
1. Ingrese nuevo proyecto en Visual Basic y luego aplicación de consola
2. Aparece lo siguiente
3. Escriba el siguiente codigo
Module Module1
Sub Main()
Dim n1 As Integer
Dim n2 As Integer
Dim temp As Integer
Console.Write("ingrese el primer numero n1 ")
n1 = Console.ReadLine()
Console.Write("ingrese el segundo numero n2 ")
Console.WriteLine(" Valores antiguos de n1 ={0} y n2={1}", n1, n2)
temp = n1
n1 = n2
n2 = temp
Console.WriteLine(" Valores nuevos de n1 ={0} y n2={1}", n1, n2)
Console.ReadLine()
End Sub
End Module
4. Para ejecutar
Presione F5 o el siguiente icono
5. La ejecución es
Ejercicios.
Elaborar el Pseudocódigo y su diagrama de flujo para:
1. Sumar dos Números,

2. Sumar tres Números,3 y luego 5 Números
1. Sumar n Números
2. Encontrar el mayor de dos números
3. Encontrar el mayor de 10 números.
4. Encontrar el mayor, menor y promedio de n números.
5. Intercambiar dos variables.
6. Mostrar la serie 1,2,3,4,5,.... N;
7. Encontrar el factorial de un número
8. Calcular los valores de una función, dado el límite inicial, límite final y el
incremento
9. Elaborar una tabla de Multiplicar de 1 al 12
10. Elaborar el algoritmo y el programa para sacar la nota final del curso
11. Proponer un problema interesante y resolverlo
1.6 LENGUAJE DE PROGRAMACION VISUAL BASIC DE VISUAL

ESTUDIO 2017
MOTIVOS
Se enseñara este lenguaje porque es parecido a lo enseñado en semestres anteriores

Y por que se usara en el curso de sistemas de información y trabaja con Microsoft
Office sobre todo para realizar macros en Excel
Paradigma: Dirigida por eventos Apareció en: 1993 (vs 1997)

Diseñado por: Microsoft Corporation
Última versión estable: visual estudio 2013(12 nov del 2013)
Genero: Entorno de desarrollo integrado
Implementaciones: Visual Studio .NET, Mono
Sistema operativo: Windows
Plataforma x86-64 itnium
Web: http://www.microsoft.com/net
Licencia propietaria
Estado actual con soporte
Extensiones comunes bs, frm,exe,vbp
Microsoft Visual Studio es un entorno de desarrollo integrado (IDE, por sus siglas en

inglés) para sistemas operativos Windows. Soporta múltiples lenguajes de
programación tales como C++, C#, Visual Basic .NET, F#, Java, Python, Ruby, PHP; al
igual que entornos de desarrollo web como ASP.NET MVC, Django, et., a lo cual
sumarle las nuevas capacidades online bajo Windows Azure en forma del editor
Monaco.
Visual Studio permite a los desarrolladores crear aplicaciones, sitios y aplicaciones

web, así como servicios web en cualquier entorno que soporte la plataforma .NET (a
partir de la versión .NET 2002). Así se pueden crear aplicaciones que se comuniquen
entre estaciones de trabajo, páginas web, dispositivos móviles, dispositivos embebidos,
consolas (la xbox 360 y xbox one), etc.
Visual Basic .NET (VB.NET) es un lenguaje de programación orientado a objetos que

se puede considerar una evolución de Visual Basic implementada sobre
el framework .NET. Su introducción resultó muy controvertida, ya que debido a cambios
significativos en el lenguaje VB.NET no es retrocompatible con Visual Basic, pero el
manejo de las instrucciones es similar a versiones anteriores de Visual Basic,
facilitando así el desarrollo de aplicaciones más avanzadas con herramientas
modernas.
La gran mayoría de programadores de VB.NET utilizan el entorno de desarrollo

integrado Microsoft Visual Studio en alguna de sus versiones (desde el primer Visual
Studio .NET hasta Visual Studio .NET 2013, que es la última versión de Visual Studio
para la plataforma .NET), aunque existen otras alternativas, como SharpDevelop (que
además es libre).
Al igual que con todos los lenguajes de programación basados en .NET, los programas
escritos en VB .NET requieren el Framework .NET o Mono para ejecutarse.
Visual Basic 2008 (VB 9.0)
Para esta versión se añadieron varias novedades, incluyendo:

 Soporte para LINQ
 Expresiones lambda
 Literales XML
Visual Basic 2010 ofrece soporte para entorno de ejecución dinámico..

VB 2010 forma parte de Microsoft Silverlight. visual basic es un lenguaje de
programacion que permite realizar diferentes programas de registro anudados.
Ejemplo del programa de 4 operaciones en visual basic 2010
1 LENGUAJE VISUAL BASIC 2015 EN MODO CONSOLA
Module Module1
Sub Main()
Dim n1 As Integer
Dim n2 As Integer
Console.WriteLine(" La suma de los numeros es {0}", n1 + n2)
Console.WriteLine(" La resta de los numeros es {0}", n1 - n2)
Console.WriteLine(" El producto de los numeros es {0}", n1 * n2)
Console.WriteLine(" La Division real de los numeros es {0}", n1 / n2)
Console.WriteLine("La Division entera de los numeros es {0}", n1 \ n2)
Console.WriteLine(" El modulo de de los numeros es {0}", Int(n1) Mod Int(n2))
Console.ReadLine()
End Sub
End Module
Al poner
Option Explicit On
Option Strict On
Arroja el siguiente error
Presione doble clic sobre la parte sombreada
Y aparece
Presione Reemplazar Console.Readine y se soluciona el problema

El programa se convierte en
Module Module1
Sub Main()
Dim n1 As Integer
Dim n2 As Integer
n1 = CInt(Console.ReadLine())
Console.ReadLine()
End Sub
End Module
En modo formulario (Calculadora elemental
1. Inicie Nuevo proyecto aplicaciones Windows Forms
2. Aparecera lo siguiente (entorno de desarrollo IDE)
3. Diseñe el formulario de la siguiente manera

4 Cambie sus propiedades de acuerdo al siguiente cuadro
Propieda
Control d Valor
Label1 Text MNICALCULADORA ELEMENTAL
Label2 Text
Label3 Text =
TextBox1 Name txtOper1
Text 2
TextBox2 Name txtOper2
Text 3
TextBox3 Name txtResult
Text
Button1 Name btnSuma
Text +
Button2 Name btnResta
Text -
Button3 Name btnMultiplicacion
Text *
Button4 Name btnDivision
Text /
4. Agregue el siguiente código
Public Class Form1

Dim n1 As Single, n2 As Single, res As Single
Private Sub BtnSuma_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles BtnSuma.Click
n1 = Val(TxtOper1.Text)
res = n1 + n2
TxtResultado.Text = res
Label2.Text = "+"
End Sub
Private Sub BtnResta_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles BtnResta.Click
res = n1 - n2
Label2.Text = "-"
End Sub
Private Sub BtnMultiplicacion_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles BtnMultiplicacion.Click
res = n1 * n2
Label2.Text = "*"
End Sub
Private Sub BtnDivision_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles BtnDivision.Click
res = n1 / n2
Label2.Text = "/"
End Sub
End Class
6.Ejecute el programa y vera el siguiente resultado
Nota. Escriba el código para el botón suma y para los demás botones solo modifique la
parte de res=n1+n2 y label2.text=”+” a la correspondiente operación( -,*./)
Manejo de varios controles con un solo procedimiento

Modifique el código para con un solo procedimiento de evento maneje los cuatro
botones
Public Class Form1

Dim n1 As Single, n2 As Single, res As Single
Private Sub Operacion(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles BtnSuma.Click, BtnResta.Click, BtnMultiplicacion.Click,
BtnDivision.Click
Select Case sender.text
Case "+" : res = n1 + n2
Case "-" : res = n1 - n2
Case "*" : res = n1 * n2
Case "/" : res = n1 / n2
End Select
Label2.Text = sender.text
End Sub
End Class
Nota. Puede escoger tambien la propiedad name
Select Case sender.name

Case "btnSuma" : res = n1 + n2
Ejercicio Nro 2 Agrega las funciones de factorial, potencia, residuo, división enteral,
funciones trigonométricas, logarítmicas, potencia, .mostrar fecha , mostrar hora y otras
funciones de la calculadora
El código de la calculadora seria
Nota. El asistente de IntelliSense de visual estudio nos muestra los componentes de

la clase que hemos creado (suma), además visual Basic 2010 nos permite trabajar
jerárquicamente o sea se puede esconder parte del programa con el signo menos (-) y
expandir con el (+) . De esa manera los programas se minimizan,
1.7 . LA ESTRUCTURA DE UN PROGRAMA VISUAL BASIC 2015

Estructura de un programa de Visual Basic
Un programa de Visual Basic se crea a partir de bloques de creación

estándar. Una solución consta de uno o varios proyectos. Un proyecto a su vez puede
contener uno o más ensamblados. Cada ensamblado se compila a partir de uno o
varios archivos de código fuente. El archivo de código fuente proporciona la definición e
implementación de clases, estructuras, módulos e interfaces, que en última instancia
contienen todo el código.
Elementos de programación en el nivel de archivo
Al iniciar un proyecto o archivo y abrir el editor de código, verá que ya hay código en el
lugar que le corresponde y en el orden correcto. Cualquier código que escriba debe
seguir la siguiente secuencia:
1. Instrucciones Option
2. Instrucciones Imports
3. Instrucciones Namespace y elementos del nivel de espacio de nombres
Si escribe instrucciones en un orden distinto, pueden producirse errores de

compilación.
Un programa también puede contener instrucciones de compilación

condicional. Pueden incluirse en el archivo de código fuente entre las instrucciones de
la secuencia anterior.
Instrucciones Option
Las instrucciones Option establecen reglas de base para el código subsiguiente, y de

esta forma ayudan a prevenir errores de sintaxis y de lógica. Option Explicit
(Instrucción, Visual Basic) garantiza que se declaran todas las variables y que se
escriben correctamente, lo que reduce el tiempo de depuración. La instrucción Option
Strict (Instrucción) ayuda a reducir errores de lógica y pérdidas de datos que puedan
producirse al trabajar entre variables de diferentes tipos de datos. Option Compare
(Instrucción) especifica la manera en que se comparan las cadenas entre sí, según sus
valores Binary o Text.
Instrucciones Imports
Puede incluir Instrucción Imports (Tipo y espacio de nombres de .NET) para importar

nombres definidos fuera del proyecto. Las instrucciones Imports permiten que el
código haga referencia a clases y otros tipos definidos en el espacio de nombres
importado sin tener que calificarlos. Puede utilizar tantas instrucciones Imports como
sea necesario.
Instrucciones Namespace
Los espacios de nombres ayudan a organizar y clasificar los elementos de

programación para facilitar la agrupación y el acceso. Utiliza Namespace
(Instrucción) para clasificar las instrucciones siguientes dentro de un espacio de
nombres determinado.
Instrucciones de compilación condicional
Las instrucciones de compilación condicional pueden aparecer prácticamente en

cualquier parte del archivo de código fuente. Determinan que partes del código se
incluyan o excluyan en tiempo de compilación en función de ciertas
condiciones. También puede utilizarlas para depurar la aplicación, ya que el código
condicional se ejecuta únicamente en modo de depuración.
Elementos de programación en el nivel de espacio de nombres
Las clases, estructuras y módulos contienen todo el código del archivo de código
fuente. Son elementos del nivel de espacio de nombres, que pueden aparecer dentro
de un espacio de nombres o en el nivel del archivo de código fuente. Contienen las
declaraciones de todos los demás elementos de programación. Las interfaces, que
definen firmas de elemento pero no proporcionan ninguna implementación, también
aparecen en el nivel de módulo. Para obtener más información sobre los elementos del
nivel de módulo, vea los siguientes temas:
 Instrucción Class (Visual Basic)

 Structure (Instrucción)
 Module (Instrucción)
 Instrucción Interface (Visual Basic)
Los elementos de datos en el nivel de espacio de nombres son las enumeraciones y los
delegados.
Elementos de programación en el nivel de módulo
Los procedimientos, operadores, propiedades y eventos son los únicos elementos de

programación que pueden contener código ejecutable (instrucciones que realizan
acciones en tiempo de ejecución). Son elementos del nivel de módulo del
programa. Para obtener más información sobre los elementos del nivel de
procedimiento, vea los siguientes temas:
 Function (Instrucción, Visual Basic)

 Sub (Instrucción, Visual Basic)
 Declare (Instrucción)
 Operator (Instrucción)
 Property (Instrucción)
 Event (Instrucción)
Los elementos de datos en el nivel de módulo son las variables, las constantes, las
enumeraciones y los delegados.
1.8 Procedimiento Main( ) como procedimiento de entrada al programa
Todo programa necesita una rutina o procedimiento de entrada, que sea el primero que
se ejecute. En VB.NET ese procedimiento recibe el nombre especial Main( ), y debe
estar contenido dentro de un módulo de código, como muestra el Código
Module Module1
Sub Main()
End Sub
End Module
En el caso de una aplicación de consola creada desde VS.NET, se crea un módulo de

forma automática que contiene un procedimiento Main( ) vacío. Dentro de este
procedimiento escribiremos el código de los próximos ejemplos.
El procedimiento Main es el primer código que se ejecuta cuando se ha cargado su

aplicación. Main actúa como punto de partida y control general de la aplicación. Hay
cuatro variedades de Main:
 Sub Main()
 Sub Main(ByVal cmdArgs() As String)
 Function Main() As Integer
 Function Main(ByVal cmdArgs() As String) As Integer
1.9 REGLAS DE ESCRITURA DE UN PROGRAMA VISUAL BASIC
Cuando se nombran procedures, constants, variablesy arguments en un module de

Visual Basic, use las siguientes reglas:
 Debe usar una letra como el primer carácter.

 No puede usar un espacio, punto (.), signo de exclamación (!) o los caracteres
@, &, $, # en el nombre.
 Nombre no puede superar los 255 caracteres de largo.
 Por lo general, no debería usar los nombres que son los mismos como el
functions, statements y methods en Visual Basic.
 No puede repetir los nombres dentro del mismo nivel de scope. Por ejemplo, se
pueden declarar dos variables denominadas age dentro del mismo
procedimiento. Sin embargo, se pueden declarar una variable privada
denominada age y una variable procedure-level denominado age dentro del
mismo módulo.
 Nota Visual Basic no distingue mayúsculas de minúsculas, pero conserva el uso

de mayúsculas en la instrucción donde se declara el nombre.
Nota : para poner y quitar comentarios visual Basic utilice
1.10 PALABRAS RESERVADAS,TIPOS DE DATOS, CONSTANTES Y

VARIABLES
Palabras reservadas
Palabras clave del lenguaje Visual Basic
En las tablas siguientes se muestran todas las palabras clave del lenguaje Visual Basic.
Palabras clave reservadas
Las palabras clave siguientes están reservadas, lo que significa que no se pueden

utilizar como nombres para los elementos de programación, como son las variables o
los procedimientos. Puede omitir esta restricción incluyendo el nombre entre corchetes
([ ]).
Nota . No se recomienda utilizar nombres de escape porque pueden complicar la

lectura del código y llevar a errores imperceptibles difíciles de encontrar.
AddHandler AddressOf Alias And

AndAlso As Boolean ByRef
Byte ByVal Call Case
Catch CBool CByte CChar
CDate CDec CDbl Char
CInt Class CLng CObj
Const Continue CSByte CShort
CSng CStr CType CUInt
CULng CUShort Date Decimal
Declare Default Delegate Dim
DirectCast Do Double Each
Else ElseIf End EndIf
Enum Erase Error Event
Exit False Finally For
Friend Function Get GetType
GetXMLNamespace Global GoSub GoTo
Handles If If() Implements
Imports (tipo y espacio de Imports (espacio de
In Inherits
nombres de .NET) nombres XML)
Integer Interface Is IsNot
Let Lib Like Long
Loop Me Mod Module
MustInherit MustOverride MyBase MyClass
Namespace Narrowing New Next
Not Nothing NotInheritable NotOverridable
Object Of On Operator
Option Optional Or OrElse
Overloads Overridable Overrides ParamArray
Partial Private Property Protected
Public RaiseEvent ReadOnly ReDim
REM RemoveHandler Resume Return
SByte Select Set Shadows
Shared Short Single Static
Step Stop String Structure
Sub SyncLock Then Throw
To True Try TryCast
TypeOf Variant Wend UInteger
ULong UShort Using When
While Widening With WithEvents
WriteOnly Xor #Const #Else
#ElseIf #End #If =
& &= * *=
/ /= \ \=
^ ^= + +=
>> (Operador, >>= (Operador,
- -=
Visual Basic) Visual Basic)
<< <<=
Nota EndIf, GoSub, Variant y Wend se conservan como palabras clave reservadas,
aunque ya no se usan en Visual Basic. El significado de la palabra clave Let ha
cambiado. Ahora se usa Let en consultas LINQ. Para obtener más información, vea Let
(Cláusula, Visual Basic).
Palabras clave no reservadas
Las palabras clave siguientes no están reservadas, lo que significa que se pueden
utilizar como nombres para los elementos de programación. Sin embargo, no es
recomendable utilizarlas, puesto que pueden complicar la lectura del código y provocar
errores casi imperceptibles y difíciles de encontrar.
Agregad Assembl
Ansi Auto
o y
Binary Compare Custom Distinct
Equals Explicit From Agrupar por
Group
Into IsFalse IsTrue
Join
Key
Join (Visual Mid Off
Basic)
Order By Preserve Skip Skip While
Strict Take Take Text
While
Unicode Until Dónde #ExternalSource
#Region
Identificadores
Nombres usados para referirse a las variables, las funciones etiquetas y otros objetos
definidos por el usuario.
los identificadores de Visual Basic .NET deben cumplir los estándares de Unicode 3.0,
Report 15 y Annex 7, con la diferencia de que los identificadores pueden comenzar con
un carácter de subrayado (conector). Si un identificador comienza con un carácter de
subrayado, debe contener al menos un carácter identificador para eliminar la
ambigüedad de la continuación de línea.
La longitud máxima del identificador es de 16383 caracteres.
Constantes
Al igual que las variables, una constante es un elemento del lenguaje que guarda un
valor, pero que en este caso y como su propio nombre indica, dicho valor será
permanente a lo largo de la ejecución del programa, no pudiendo ser modificado.
Para declarar una constante, debemos utilizar la palabra clave Const, debiendo al
mismo tiempo establecer el tipo de dato y asignarle valor.
Module Module1
Sub Main()
Const Color As String = "Azul"
Const Valor As Double = 120.48
End Sub
End Module
La tipificación de una constante se rige, al igual que las variables, por la configuración
que tengamos establecida para la instrucción Option Strict.
Si intentamos asignar un valor a una constante después de su asignación inicial, el IDE

nos subrayará la línea con un aviso de error de escritura, y se producirá igualmente un
error si intentamos ejecutar el programa.
1.11 - VARIABLES.-
Son posiciones o Áreas de memoria y que tipo de dato almacenan(nombres que se

asigna a una posición de memoria).
Una variable es un identificador del programa que guarda un valor que puede ser
modificando durante el transcurso de dicha aplicación.
Declaración de variable en Visual Basic
La declaración de una variable es el proceso por el cual comunicamos al compilador

que vamos a crear una nueva variable en el programa.
Una variable se declara para especificar su nombre y sus características. La instrucción

de declaración para variables es Instrucción Dim (Visual Basic). Su ubicación y
contenido determinan las características de la variable.
Dim Mivalor As Integer
Declarar el tipo de datos
La cláusula As de la instrucción de declaración permite definir el tipo de datos o de

objetos de la variable que se está declarando. Se puede especificar cualquiera de los
siguientes tipos para una variable:
 Un tipo de datos básico, como Boolean, Long o Decimal.

 Un tipo de datos compuesto, como una matriz o una estructura.
 Un tipo de objeto o clase, definido en su aplicación o en otra aplicación
 Clase de .NET Framework, como Label o TextBox
 Un tipo de interfaz, como IComparable o IDisposable
Se pueden declarar varias declarar distintas variables en la misma instrucción sin

necesidad de repetir el tipo de datos. En las instrucciones siguientes, las
variables i, j y k se declaran como tipo Integer, l y m como Long, y x e y como Single:
Module Module1
Sub Main()
Dim i, j, k As Integer
Dim l, m As Long, x, y As Single
Console.ReadLine()
End Sub
End Module
Asignar valores
Para efectuar cálculos y asignar el resultado a una variable, se utilizan instrucciones de

asignación, como se muestra en el ejemplo siguiente.
Module Module1
Sub Main()
Dim i As Integer = 2, suma = 0
suma = suma + 1
End Sub
End Module
Denominación
Respecto al nombre de la variable, debe empezar por letra, y no puede ser ninguna de
las palabras reservadas del lenguaje, ni contener caracteres como operadores u otros
símbolos especiales.
Avisos del IDE sobre errores en el código
Al declarar una variable con un nombre incorrecto, o si se produce otro tipo de error en
la escritura del código, el propio IDE se encarga de avisarnos que existe un problema
subrayando el fragmento de código conflictivo y mostrando una viñeta informativa al
situar sobre dicho código el cursor. Ver
Estos avisos constituyen una gran ayuda, ya que permiten al programador observar
problemas en la escritura del código, antes incluso de ejecutar el programa.
Existen multitud de avisos de muy diversa naturaleza, teniendo en cuenta que la tónica
general consiste en que el código problemático quedará subrayado por el IDE hasta
que no modifiquemos la línea en cuestión y la escribamos correctamente.
Lugar de la declaración
Podemos declarar variables en muy diversos lugares del código. El punto en el que
declaremos una variable será determinante a la hora del ámbito o accesibilidad a esa
variable desde otros puntos del programa.
Tipificación
La tipificación de una variable es la operación por la cual, al declarar una variable,

especificamos qué clase de valores o tipo de datos vamos a poder almacenar en dicha
variable.
En VB.NET utilizamos la palabra clave As seguida del nombre del tipo de datos, para
establecer el tipo de una variable.
Module Module1
Sub Main()
Dim Valor As String ' cadena de caracteres
Dim Cuenta As Integer ' numérico entero
Dim FhActual As Date ' fecha
End Sub
End Module
Si al declarar una variable no indicamos el tipo, por defecto tomará Object, que
corresponde al tipo de datos genérico en el entorno del CLR, y admite cualquier valor.
Según la información que acabamos de ver, si declaramos una variable de tipo Byte e
intentamos asignarle el valor 5899 se va a producir un error, ya que no se encuentra en
el intervalo de valores permitidos para esa variable. Esto puede llevar al lector a
preguntar: “¿por qué no utilizar siempre Object y poder usar cualquier valor?, o mejor
¿para qué necesitamos asignar tipo a las variables?”.
El motivo de tipificar las variables reside en que cuando realizamos una declaración, el
CLR debe reservar espacio en la memoria para los valores que pueda tomar la
variable, como puede ver el lector en la tabla anterior, no requiere el mismo espacio en
memoria una variable Byte que una Date. Si además, declaramos todas las variables
como Object, los gastos de recursos del sistema serán mayores que si establecemos el
tipo adecuado para cada una, ya que como el CLR no sabe el valor que puede
tomar en cada ocasión la variable, debe realizar un trabajo extra de adecuación,
consumiendo una mayor cantidad de recursos.
Una correcta tipificación de las variables redundará en un mejor aprovechamiento de

las capacidades del sistema y en un código más veloz en ejecución. Cuantos más
programas se diseñen optimizando en este sentido, el sistema operativo ganará en
rendimiento beneficiándose el conjunto de aplicaciones que estén en ejecución.
VS.NET dispone de una ayuda al asignar el tipo a una variable, que nos muestra la lista
de tipos disponibles para poder seleccionar uno sin tener que escribir nosotros el
nombre. Al terminar de escribir la palabra As, aparecerá dicha lista, en la que pulsando
las primeras letras del tipo a buscar, se irá situando en los más parecidos. Una vez
encontrado, pulsaremos la tecla Enter o Tab para tomarlo.
Declaración múltiple en línea
En el caso de que tengamos que declarar más de una variable del mismo tipo,
podemos declararlas todas en la misma línea, separando cada una con una coma e
indicando al final de la lista el tipo de dato que van a tener, como vemos en el Código
fuente
Dim Nombre, Apellidos, Ciudad As String
En esta técnica de declaración, todas las variables de la línea tienen el mismo tipo de
dato, ya que no es posible declarar múltiples variables en la misma línea que tengan
distintos tipos de dato.
Asignación de valor
Para asignar un valor a una variable utilizaremos el operador de asignación: el signo

igual ( = ), situando a su izquierda la variable a asignar, y a su derecha el valor.
Module Module1
Sub Main()
Dim Valor As String = "hola" ' cadena de caracteres
Dim Nota As Integer = 12 ' numérico entero
Dim sueldo As Single = 2000 ' numero real
Dim Fechactual As Date = #12/2/2010# ' fecha
Console.WriteLine("{0}", Fechactual)
Console.ReadLine()
End Sub
End Module
Según el tipo de dato de la variable, puede ser necesario el uso de delimitadores para
encerrar el valor que vamos a asignar.
 Tipos numéricos. Las variables de tipos de datos numéricos no necesitan

delimitadores, se asigna directamente el número correspondiente. Si
necesitamos especificar decimales, utilizaremos el punto ( . ) como carácter
separador para los decimales
 Cadenas de caracteres. En este caso es preciso encerrar la cadena entre
comillas dobles ( " ).
 Fechas. Al asignar una fecha a una variable de este tipo, podemos encerrar
dicho valor entre el signo de almohadilla ( # ) o comillas dobles ( " ). El formato
de fecha a utilizar depende del delimitador. Cuando usemos almohadilla la fecha
tendrá el formato Mes/Día/Año; mientras que cuando usemos comillas dobles el
formato será Día/Mes/Año.
 Las fechas pueden contener además información horario que especificaremos
en el formato Hora:Minutos:Segundos FranjaHoraria. En el caso de que no
indiquemos la franja horaria (AM/PM) y si estamos utilizando el signo almohadilla
como separador, el entorno insertará automáticamente los caracteres de franja
horaria correspondientes.
 Tipos lógicos. Las variables de este tipo sólo pueden tener el valor True
(Verdadero) o False (Falso).
 Además de asignar valores como acabamos de explicar, podemos asignar el
contenido de una variable a otra o el resultado de una expresión, como veremos
más adelante en el apartado dedicado a operadores. El Código fuente 54
muestra unos ejemplos de asignación a variables, que después visualizamos en
la consola.
Module Module1
Sub main()
Dim Precio As Double = 1234
Dim Valor As String = "producto1"
Dim FhActual As Date
Dim FhNueva As Date
Dim FhCompletaUno As Date
Dim FhCompletaDos As Date
Dim FhHora As Date
Dim Correcto As Boolean = True
Valor = "Producto2"
FhActual = #5/20/2001# ' mes/día/año
FhNueva = "25/10/2001" ' dia/mes/año
FhCompletaUno = #10/18/2005 8:30:00 AM#
FhCompletaDos = "7/11/2006 18:22:00"
FhHora = #5:40:00 PM#
Console.WriteLine("Variable Precio: {0}", Precio)
Console.WriteLine("Variable Valor: {0}", Valor)
Console.WriteLine("Variable FhActual: {0}", FhActual)
Console.WriteLine("Variable FhNueva: {0}", FhNueva)
Console.WriteLine("Variable FhCompletaUno: {0}", FhCompletaUno)
Console.WriteLine("Variable FhCompletaDos: {0}", FhCompletaDos)
Console.WriteLine("Variable FhHora: {0}", FhHora)
Console.WriteLine("Variable Correcto: {0}", Correcto)
Console.ReadLine()
End Sub
End Module
Otra cualidad destacable en este apartado de asignación de valores, reside en que
podemos declarar una variable y asignarle valor en la misma línea de código, como
vemos en el Código fuente 55
Dim Valor As String = "mesa"
Dim ImporteFac As Integer = 875
Valor inicial
Toda variable declarada toma un valor inicial por defecto, a no ser que realicemos una
asignación de valor en el mismo momento de la declaración. A continuación se
muestran algunos valores de inicio en función del tipo de dato que tenga la variable:
 Numérico. Cero ( 0 ).
 Cadena de caracteres. Cadena vacía ( "" ).
 Fecha. 01/01/0001 0:00:00.
 Lógico. Falso (False).
 Objeto. Valor nulo (Nothing).
El Código fuente 56 muestra un ejemplo de valores iniciales.
Module Module1
Sub Main()
Dim Nota As Integer
Dim Valor As String
Dim Fecha As Date
Dim ValorLogico As Boolean
Dim Objeto As Object
Console.WriteLine("Variable Nota: {0}", Nota)
Console.WriteLine("Variable FhActual: {0}", Fecha)
Console.WriteLine("Variable ValorLogico: {0}", ValorLogico)
Console.WriteLine("Variable UnObjeto: {0}", Objeto)
Console.ReadLine()
End Sub
End Module
Debemos tener en cuenta al ejecutar estas líneas, que en los casos de las variables de
tipo cadena y objeto, no se mostrará nada, ya que se considera que están inicializadas
pero vacías.
Por otro lado podemos, inversamente, inicializar una variable que ya tiene valor,
asignándole la palabra clave Nothing; con ello, la variable pasa a tener el valor por
defecto o inicial. Ver el Código fuente 57.
Module Module1
Sub Main()
Dim Nota As Single = 12
Dim Fecha As Date
Dim ValorLogico As Boolean = True
Nota = Nothing
Fecha = "10/6/2010"
' inicializar variables
Nota = Nothing
Fecha = Nothing
ValorLogico = Nothing
Console.WriteLine("Variable Valor: {0}", Nota)
Console.WriteLine("Variable FhActual: {0}", Fecha)
Console.WriteLine("Variable ValorLogico: {0}", ValorLogico)
Console.ReadLine()
End Sub
End Module
Declaración obligatoria
Es obligatorio, por defecto, la declaración de todas las variables que vayamos a utilizar
en el código.
En el caso de que intentemos utilizar una variable no declarada, se producirá un error.

La declaración de variables proporciona una mayor claridad al código, ya que de esta
forma, sabremos en todo momento si un determinado identificador corresponde a una
variable de nuestro procedimiento, de un parámetro, etc.
Mediante la instrucción Option Explicit, y sus modificadores On/Off, podemos requerir o

no la declaración de variables dentro del programa.
 Option Explicit On. Hace obligatoria la declaración de variables. Opción por

defecto.
 Option Explicit Off. Hace que no sea obligatoria la declaración de variables.
Podemos aplicar esta instrucción para que tenga efecto a nivel de proyecto y a nivel de
fichero de código.
Option Explicit a nivel de proyecto.
Para establecer Option Explicit a nivel de proyecto, debemos abrir la ventana

Explorador de soluciones, hacer clic en el nombre del proyecto, y a continuación pulsar
el botón de propiedades en esa misma ventana. Esto mostrará la ventana de
propiedades del proyecto, en cuyo panel izquierdo haremos clic sobre el elemento
Generar. Finalmente abriremos la lista desplegable del elemento Option Explicit,
seleccionaremos un valor (On, Off) y pulsaremos Aplicar y Aceptar. Ver Figura 168.
Con la declaración obligatoria desactivada podríamos escribir código como el mostrado

en el Código
Sub Main()
Valor = "coche"
MiDato = 984
Console.WriteLine("Variable MiDato: {0}", MiDato)
Console.ReadLine()
End Sub
En el ejemplo ante rior,no hemos declarado las variables en Main( ). Al estar Option
Explicit Off esto no produce error, y el CLR al detectar un identificador sin declarar, crea
una nueva variable internamente.
Mucho más fácil que tener que declarar las variables ¿verdad?. Pues precisamente
esta facilidad es uno de los graves problemas de no declarar variables. En un
procedimiento de prueba con poco código, esto no supone una importante
contrariedad. Sin embargo pensemos un momento, que en lugar de un pequeño
procedimiento, se trata de una gran aplicación con muchas líneas de código,
procedimientos, y cientos de variables.
Si volvemos a activar Option Explicit On, inmediatamente sabremos que algo va mal,
ya que toda variable no declarada, quedará subrayada por el IDE como un error de
escritura. Las ventajas son evidentes.
Option Explicit a nivel de fichero.

Para establecer la declaración obligatoria a nivel de fichero, debemos situarnos al
comienzo del fichero de código y escribir la instrucción Option Explicit con el
modificador correspondiente. El Código fuente 59 muestra un ejemplo de cómo
desactivar esta característica en el fichero de código actual.
Module Module1
Sub Main()
nota = 12
' mostrar variables en la consola
Console.WriteLine("Variable Valor: {0}", Nota)
Console.ReadLine()
End Sub
End Module
Option Explicit a nivel de fichero, nos permite establecer el modo de declaración de

variables sólo para ese fichero en el que lo utilizamos, independientemente del tipo de
obligatoriedad en declaración de variables establecido de forma general para el
proyecto.
Por todo lo anteriormente comentado, a pesar de la engañosa facilidad y flexibilidad de

Option Explicit Off, nuestra recomendación es tener configurado siempre Option Explicit
On a nivel de aplicación, nos ahorrará una gran cantidad de problemas.
Tipificación obligatoria
Cuando declaramos una variable, no es obligatorio por defecto, establecer un tipo de

dato para la misma. Igualmente, al asignar por ejemplo, una variable numérica a una de
cadena, se realizan automáticamente las oportunas conversiones de tipos, para
transformar el número en una cadena de caracteres. Veamos un ejemplo en el Código
fuente 60.
Option Explicit On
Option Strict Off
Module Module1
Sub Main()
' no es necesario tipificar la variable, tipificación implícita,
' la variable Valor se crea con el tipo Object
Dim Valor
Valor = "AREQUIPA"
Console.WriteLine("Variable Valor en cadena: {0}", Valor)
Valor = 12
Console.WriteLine("Variable Valor en numero: {0}", Valor)
Valor = True
Console.WriteLine("Variable Valor en booleano: {0}", Valor)
Console.ReadLine()
End Sub
End Module
Como ya comentábamos en el apartado anterior, si no asignamos el tipo de dato

adecuado al declarar una variable, el CLR le asigna el tipo Object, lo que afecta
negativamente al rendimiento de la aplicación.
La instrucción Option Strict, junto a sus modificadores On/Off, nos permite establecer si
en el momento de declarar variables, será obligatoria su tipificación. También
supervisa la obligatoriedad de realizar una conversión de tipos al efectuar asignaciones
entre variables, o de expresiones a variables.
 Option Strict On. Hace obligatoria la tipificación de variables y la conversión de

tipos explícita.
 Option Strict Off. Hace que no sea obligatoria la tipificación de variables. La

conversión de entre tipos distinta en asignaciones y expresiones es realizada
automáticamente por el entorno.
Opción por defecto.
Podemos configurar Option Strict a nivel de proyecto y de fichero de código, de igual

forma que con Option Explicit. En el caso de configurar a nivel de proyecto, deberemos
abrir la ventana de propiedades del proyecto, y en su apartado Generar, establecer el
valor correspondiente en la lista desplegable Option Strict. Ver Figura 169.
Si configuramos a nivel de fichero de código, escribiremos esta instrucción en la

cabecera del fichero con el modificador oportuno. Consulte el lector el anterior apartado
para un mayor detalle sobre el acceso a esta ventana de propiedades del proyecto.
En el ejemplo del Código fuente 61, establecemos Option Strict On a nivel de fichero de
código, y a partir de ese momento, no podremos asignar un tipo de dato Double a un
Integer, o un valor numérico a una variable String, por exponer un par de casos de los
más comunes. El código erróneo será marcado por el IDE como un error de sintaxis, e
igualmente se producirá un error si intentamos ejecutar el programa.
Sub Main()
' no es necesario tipificar la variable, tipificación implícita,
' la variable Valor se crea con el tipo Object
Dim Valor As Integer
Dim cadena As String
Valor = 12
Console.WriteLine("Variable Valor en numero: {0}", Valor)
cadena = Valor
Console.WriteLine("Variable Valor en cadena: {0}", Valor)
Console.ReadLine()
End Sub
Option Explicit On
Option Strict Off
Module Module1
Sub Main()
Dim Valor As Integer
Dim control As Boolean
Dim fecha As Date
fecha = #1/1/2001#
Valor = fecha
Console.WriteLine("Variable Valor en fecha: {0}", Valor)
Console.ReadLine()
End Sub
End Module
Si queremos que no se produzcan errores de conversión en el anterior código fuente,

tendremos que emplear las funciones de conversión de tipo que proporciona el
lenguaje. En este caso utilizaremos CInt( ), a la que pasamos un valor numérico como
parámetro, y devuelve un tipo numérico Integer; y CStr( ), que convierte a String el
valor que pasemos como parámetro. Veamos el resultado en el Código fuente 62.
Option Explicit On
Option Strict On
Module Module1
Sub Main()
Dim cadena = "3.1416"
Dim Sueldo As Single
Sueldo = CSng(cadena)
Console.WriteLine(" cadena convertida a numero real{0} ", Sueldo)
Console.WriteLine(" cadena convertida a valor booleano{0} ", CBool(cadena))
Console.WriteLine(" cadena convertida a fecha {0} ", CDate(cadena))
Console.WriteLine(" Numero real convertido a cadena {0} ", CStr(Sueldo))
Console.ReadLine()
End Sub
End Module
Establecer Option Strict On requiere un mayor trabajo por parte del programador, ya
que ha de ser más cuidadoso y escribir un código más correcto y preciso, lo cual es
muy conveniente. Sin embargo, ya que la opción por defecto en este sentido es Option
Strict Off, los ejemplos realizados a lo largo de este texto se ajustarán en este
particular a dicha configuración, con ello ganamos en comodidad, ya que evitaremos la
obligación de realizar conversiones de tipos en muy diversas situaciones.
Module Module1
Public n3 As Char
Private n5 As Boolean
Sub Main()
Dim n1 As Integer
Dim n2 As Single = 10
Dim n4 As String
End Sub
End Module
1.12 TIPOS DE DATOS EN VISUAL BASIC 2010
Un tipo de datos en es la manera como el compilador almacena la información en la

memoria
Resumen de tipos de datos (Visual Basic)
En la tabla siguiente se muestran los tipos de datos de Visual Basic .NET, los tipos
compatibles con Common Language Runtime, su asignación de almacenamiento
nominal y sus intervalos de valores.
Estructura
de tipo Asignación de
Tipo de Visual
Common almacenamient Intervalo de valores
Basic
Language o nominal
Runtime
En función de la
Boolean Boolean plataforma de True o False
implementación
Byte Byte 1 byte 0 a 255 (sin signo)
Char (carácter
Char 2 bytes 0 a 65535 (sin signo)
individual)
0:00:00 (medianoche) del 1 de enero de
date DateTime 8 bytes 0001 a 11:59:59 p.m. del 31 de
diciembre de 9999.
0 a +/-
79.228.162.514.264.337.593.543.950.3
35 (+/-7,9... E+28) † sin separador
decimal; 0 a +/-
7,9228162514264337593543950335
Decimal Decimal 16 bytes con 28 posiciones a la derecha del
decimal;
el número distinto de cero más
pequeño es +/-
0,0000000000000000000000000001
(+/-1E-28)†
-1,79769313486231570E+308 a
†
-4,94065645841246544E-324 para los
Double (punto
valores negativos;
flotante de Double 8 bytes
4,94065645841246544E-324 a
precisión doble)
1,79769313486231570E+308 † para los
valores positivos
-2.147.483.648 a 2.147.483.647 (con
Integer Int32 4 bytes
signo)
-9.223.372.036.854.775.808 a
Long (entero
Int64 8 bytes 9.223.372.036.854.775.807
largo)
(9,2...E+18 †) (con signo)
4 bytes en
plataforma de
32 bits Cualquier tipo puede almacenarse en
object Object (clase)
8 bytes en una variable de tipo Object
plataforma de
64 bits
SByte SByte 1 byte -128 a 127 (con signo)
Short (entero
Int16 2 bytes -32.768 a 32.767 (con signo)
corto)
-3,4028235E+38 a -1,401298E-
Single (punto
45 † para los valores negativos;
flotante de Single 4 bytes
1,401298E-45 a 3,4028235E+38 † para
precisión sencilla)
los valores positivos
En función de la
String (longitud 0 a 2.000 millones de caracteres
String (clase) plataforma de
variable) Unicode aprox.
implementación
UInteger UInt32 4 bytes 0 a 4.294.967.295 (sin signo)
0 a 18.446.744.073.709.551.615
ULong UInt64 8 bytes
(1,8...E+19 †) (sin signo)
Cada miembro de la estructura tiene un
User- (hereda En función de la intervalo de valores determinado por su
Defined(estructur de ValueType plataforma de tipo de datos y es independiente de los
a) ) implementación intervalos de valores correspondientes
a los demás miembros.
UShort UInt16 2 bytes 0 a 65.535 (sin signo)
†
En notación científica, E hace referencia a una potencia de 10. Por consiguiente,
3,56E+2 significa 3.56 x 102 ó 356 y 3,56E-2 significa 3.56 / 102 ó 0,0356.
Funciones de conversión de tipos (Visual Basic)
Estas funciones se compilan en línea, es decir, el código de conversión forma parte del
código que evalúa la expresión. A veces no se produce una llamada a un
procedimiento para realizar la conversión, lo que mejora el rendimiento. Cada función
convierte una expresión a un tipo de datos específico.
CBool(expression)
CByte(expression)
CChar(expression)
CDate(expression)
CDbl(expression)
CDec(expression)
CInt(expression)
CLng(expression)
CObj(expression)
CSByte(expression)
CShort(expression)
CSng(expression)
CStr(expression)
CUInt(expression)
CULng(expression)
CUShort(expression)
Parte
expression
Obligatorio. Cualquier expresión del tipo de datos de origen.
Tipo de datos del valor devuelto
El nombre de función determina el tipo de datos del valor devuelto, como se muestra en
la tabla siguiente.
Nombre
Tipo de datos
de la Intervalo de valores del argumento expression
devuelto
función
Boolean (Tipo de
CBool Cualquier expresión numérica, Char o String válida.
datos, Visual Basic)
Byte (Tipo de datos,
CByte 0 a 255 (sin signo); las partes fraccionarias se redondean.1
Visual Basic)
Cualquier expresión Char o String válida; sólo se convierte
Char (Tipo de datos,
CChar el primer carácter de String; el valor puede estar
Visual Basic)
comprendido entre 0 y 65535 (sin signo).
Date (Tipo de datos,
CDate Cualquier representación válida de fecha y hora.
Visual Basic)
de -1,79769313486231570E+308 a
Double (Tipo de -4,94065645841246544E-324 para valores negativos; de
CDbl
datos, Visual Basic) 4,94065645841246544E-324 a
1,79769313486231570E+308 para valores positivos.
+/-79.228.162.514.264.337.593.543.950.335 para números
a partir de cero, es decir, números sin decimales. Para
Decimal (Tipo de números con 28 posiciones decimales, el intervalo es +/-
CDec
datos, Visual Basic) 7,9228162514264337593543950335. El menor número
posible distinto de cero es
0,0000000000000000000000000001 (+/-1E-28).
Integer (Tipo de de -2.147.483.648 a 2.147.483.647; las partes
CInt
datos, Visual Basic) fraccionarias se redondean.1
de -9.223.372.036.854.775.808 a
Long (Tipo de datos,
CLng 9.223.372.036.854.775.807; las partes fraccionarias se
Visual Basic)
redondean.1
Object (Tipo de
CObj Cualquier expresión válida.
datos)
SByte (Tipo de
CSByte de -128 a 127; las partes fraccionarias se redondean.1
Short (Tipo de datos, de -32.768 a 32.767; las partes fraccionarias se
CShort
Visual Basic) redondean.1
De -3,402823E+38 a –1,401298E-45 para valores
Single (Tipo de
CSng negativos; de 1,401298E-45 a 3,402823E+38 para valores
positivos.
Los valores devueltos para CStr dependen del
String (Tipo de datos,
CStr argumento expression. Vea Valores devueltos para la
Visual Basic)
función CStr (Visual Basic).
UInteger (Tipo de de 0 a 4.294.967.295 (sin signo); las partes fraccionarias
CUInt
datos) se redondean.1
ULong (Tipo de de 0 a 18.446.744.073.709.551.615 (sin signo); las partes
CULng
datos, Visual Basic) fraccionarias se redondean.1
UShort (Tipo de de 0 a 65.535 (sin signo); las partes fraccionarias se
CUShort
datos, Visual Basic) redondean.1
Ejemplo de conversión Cint
Option Explicit On
Option Strict On
Module Module1
Sub Main()
Const pi As Single = 3.1416
Dim n1 As Integer
n1 = CInt(pi)
Console.Write("valor de n1 {0} ", n1)
Console.ReadLine()
End Sub
End Module
1.13 OPERADORES
Los operadores se utilizan para manipular datos: ejecutan cálculos, buscar igualdades,
realizan asignaciones, trabajan con variables y se encargan de muchas tareas que los
programadores nunca llevan a cabo.
Un operador es un elemento de código que realiza una operación en uno o más

elementos de código que contienen valores. Los elementos de valor incluyen variables,
constantes, literales, propiedades, valores devueltos de
procedimientos Function y Operator y expresiones.
Una expresión es una serie de elementos de valor combinados con operadores, que
produce un nuevo valor. Los operadores actúan sobre los elementos de valor
realizando cálculos, comparaciones y otras operaciones.
Resumen de operadores (Visual Basic)
Acción Elemento del lenguaje

Operadores aritméticos ^, –, *, /, \, Mod, +, =
Asignación =, ^=, *=, /=, \=, +=, -=, &=
Comparación =, <>, <, >, <=, >=, Like, Is
Concatenación &, +
Operadores lógicos y bit a
Not, And, Or, Xor, AndAlso, OrElse
bit
Operaciones varias AddressOf, GetType
Operadores Matemáticos
Operador Descripción Ejemplo
+ Adición x= y + z
- Sustracción x= y - z
* Multiplicación x= y * z
/ División x= y / z
\ Division entera x= y\ z
mod modulo x= y mdo z
Operadores de asignación
= Asignación n= 10
+= asignación suma n+= 3 equivale n=n+3
-= asignación resta n-= 3 equivale n=n-3
*= asignación producto n*= 3 equivale n=n*3
/= asignación cociente n/= 3 equivale n=n/3
Operadores lógicos
and AND Lógico if(X and 0xFF) {...}

or OR Lógico if(X or| FF ) {...}
Operadores relacionales
= Igual que if(x= 10) {...}

<>= No igual que if(x <> 10) {...}
< Menor que if(< 10) {...}
> Mayor que if(x> 10) {...}
<= Menor o igual que if(x<= 10) {...}
>= Mayor o igual que if(x>= 10) {...}
-------------------------------------------------------------------------
en resultado falso = 0 verdadero <>0
Operadores unarios
+=1 Operador de incremento (lo mismo que x=x+1)

-=1 Operador de decremento (lo mismo que x=x-1)
Precedencia de operadores
Cuando aparecen varias operaciones en una expresión, cada parte se evalúa y se

resuelve en un orden predeterminado conocido como prioridad de operador.
Reglas de prioridad
Cuando las expresiones contienen operadores de más de una categoría, dichos

operadores se evalúan de acuerdo con las siguientes reglas:
 Los operadores con la misma prioridad se evalúan de izquierda a derecha en el

orden en que aparecen en la expresión.
Orden de prioridad
Los operadores se evalúan en el siguiente orden de prioridad:
 Espera el operador
 Operadores de concatenación y aritméticos
 Exponenciación (^)
 Identidad y negación unarios (+, –)
 Multiplicación y división de punto flotante (*, /)
 División de número entero (\)
 Módulo aritmético (Mod)
 Suma y resta (+, –)
 Concatenación de cadenas (&)
 Desplazamiento de bits aritmético (<<, >>)
 Operadores de comparación
 Todos los operadores de comparación
(=, <>, <, <=, >, >=, Is, IsNot, Like, TypeOf...Is)
 Operadores lógicos y bit a bit
 Negación (Not)
 Conjunción (And, AndAlso)
 Disyunción inclusiva (Or, OrElse)
 Disyunción exclusiva (Xor)
Ejemplo de precedencia de operadores
Paso 1 Y = 2*5*5 + 3*5+7 ; Multiplicación mas a la izquierda

Paso 2 Y = 10*5 +3*5 +7 ; Multiplicación mas a la izquerda
Paso 3 Y = 50 + 3*5 +7; Multiplicación antes que la suma
Paso 4 Y = 50+15 + 7 ; Suma mas a la izquierda
Paso 5 Y = 65+7; Ultima operación de suma
Paso 6 Y = 72 ; Asignación
1.14 APLICACION DE CONSOLA

Una aplicación de consola es aquella que se ejecuta dentro de una ventana de línea de
comandos. Este tipo de ventana recibe diferentes denominaciones: Símbolo del
sistema, Sesión MS-DOS, Ventana de línea de comandos, etc
Las aplicaciones de consola son muy útiles cuando necesitamos realizar pruebas que
no impliquen el uso del modo gráfico del sistema operativo: formularios, controles,
imágenes, etc., ya que consumen menos recursos y su ejecución es más veloz.
Creación de un proyecto de tipo aplicación de consola
Para crear una aplicación de consola básica, después de iniciar el IDE de VS.NET, y
seleccionar el menú para crear un nuevo proyecto, elegiremos Aplicación de consola
en el panel derecho de la ventana Nuevo proyecto. El resto de opciones de esta
ventana se configuran igual que para una aplicación con formularios Windows. Ver
Figura
La clase Console
Esta clase se encuentra dentro del espacio de nombres System, y nos proporciona a
través de sus métodos, acceso a la consola para mostrar u obtener información del
usuario.
Debido a que los miembros de esta clase se encuentran compartidos (shared), no es

necesario crear una instancia previa de la misma en una variable, pudiendo ejecutar
directamente sus métodos sobre el objeto Console
1.15 ESCRITURA DE INFORMACIÓN
Para mostrar texto utilizaremos el método WriteLine( ) del objeto Console. Este
método escribe en la línea actual de la consola el valor que le pasemos como
parámetro, añadiendo automáticamente las marcas de retorno de carro y nueva línea,
por lo que la siguiente escritura se realizará en una nueva línea.
Module Module1
Sub Main()
Dim n1 As Integer
Dim n2 As Integer
Console.ReadLine()
End Sub
End Module
Write( ) es otro método que nos permite también escribir valores en la consola. Su uso
es igual que WriteLine( ), aunque debemos tener en cuenta que Write( ) no separa los
valores a mostrar. Veamos un ejemplo en el Código fuente
¿Cuál es la diferencia entre el Writeline y el Write?
La diferencia es que el Write escribe y no pasa a la línea siguiente, mientras que

Writeline escribe toda la línea pasando a la línea siguiente un ejemplo es el siguiente:
Module Module1
Sub Main()
Dim Nombre As String
System.Console.WriteLine("Digite Su Nombre: ")
Nombre = System.Console.ReadLine
System.Console.WriteLine("Su nombre es {0}: ", Nombre)
Console.ReadLine()
End Sub
End Module
Entonces esto a nivel de consola quedaría así

Mientras que si ocupo el Write seria así:

Module Module1
Sub Main()
System.Console.Write("Digite Su Nombre: ")
Nombre = System.Console.ReadLine
System.Console.WriteLine("Su nombre es {0}: ", Nombre)
Console.ReadLine()
End Sub
End Module
Entonces esto a nivel de consola quedaría así:
¿Qué son los flujos de salida con formato?
Un flujo con formato no sería más que el siguiente ejemplo:
Module Module1
Sub Main()
Dim Nombre As String = "Benjamin"
Dim Edad As Byte = 21
Dim Apellido As String = "Zepeda"
Console.WriteLine("Su nombre completo es: {0} {1} y tiene {2} años ", Nombre,
Apellido, Edad)
Console.ReadLine()
End Sub
End Module
Entonces esto a nivel de consola quedaría así:
*Es de recordar que el orden debe ser el mismo, si le hemos aplicado al corchete {0}
{1} entonces la primer variable ira en el puesto 0, la segunda variable en el puesto 1 y
así sucesivamente.
Entonces:
Posición: Posición 0,1,2 y así sucesivamente.
Ancho (Opcional): Mínimo Numero de posiciones para la salida, pero si el ancho se
omite entonces o especificamos un valor máximo entonces el ancho incrementa
automáticamente.
Tipo (Opcional): Es uno de los caracteres mostrado en la tabla de abajo.
Decimales (Opcional): Aquí se especifica el número de dígitos a mostrar en el caso de
enteros o de decimales en el caso de fraccionarios.
Cadenas con formato numérico estándar
Las cadenas de formato numérico estándar se utilizan para dar formato a tipos
numéricos comunes. Una cadena de formato numérico estándar presenta la forma Axx,
dondeA es un carácter alfabético que recibe el nombre de especificador de
formato y xx es un entero opcional que recibe el nombre de especificador de
precisión. El especificador de precisión está comprendido entre el 0 y el 99 y afecta al
número de dígitos del resultado. Cualquier cadena de formato numérico que contenga
más de un carácter alfabético, incluido el espacio en blanco, se interpreta como una
cadena de formato numérico personalizado.
En la tabla siguiente se describen los especificadores de formato numérico estándar y

se muestran los resultados de ejemplo generados por cada especificador de
Especificad
Nombre Descripción Ejemplos
or de formato
123,456 ("C", en-
Resultado: un valor de divisa.
US) -> $123,46
Compatible con: todos los tipos 123,456 ("C", fr-
numéricos. FR) -> 123,46 €
Especificador de precisión: número 123,456 ("C", ja-
de dígitos decimales. JP) -> ¥123
Especificador de precisión
"C" o "c" Moneda
predeterminado: definido -123,456 ("C3",
porSystem.Globalization.NumberForm en-US) -> ($123,456)
atInfo.
Más información: Especificador de -123,456 ("C3", fr-
formato de divisa ("C"). FR) -> -123,456 €
-123,456 ("C3", ja-
JP) -> -¥123,456
Resultado: dígitos enteros con signo
1234 ("D") -> 1234
negativo opcional.
-1234 ("D6") ->
Compatible con: solo tipos enteros.
-001234
Especificador de precisión: número
"D" o "d" Decimal mínimo de dígitos.
predeterminado: número mínimo de
dígitos necesarios.
Más información: Especificador de
formato decimal ("D").
1052,0329112756
Exponenci Resultado: notación exponencial. ("E", en-US) ->
"E" o "e" 1,052033E+003
al (científico)
Compatible con: todos los tipos 1052,0329112756
("e", fr-FR) ->
numéricos.
1,052033e+003
-1052,0329112756
Especificador de precisión: número
("e2", en-US) ->
de dígitos decimales.
-1,05e+003
-1052,0329112756
("E2", fr_FR) ->
predeterminado: 6.
-1,05E+003
formato exponencial ("E").
Resultado: dígitos integrales y 1234,567 ("F", en-
decimales con signo negativo opcional. US) -> 1234,57
Compatible con: todos los tipos 1234,567 ("F", de-
numéricos. DE) -> 1234,57
Especificador de precisión: número 1234 ("F1", en-US)
de dígitos decimales. -> 1234,0
"F" o "f" Punto fijo
predeterminado: definido 1234 ("F1", de-DE)
porSystem.Globalization.NumberForm -> 1234,0
atInfo.
Más información: Especificador de -1234,56 ("F4", en-
formato de punto fijo ("F"). US) -> -1234,5600
-1234,56 ("F4", de-
DE) -> -1234,5600
Resultado: notación de punto fijo o -123,456 ("G", en-
científica, la que sea más compacta. US) -> -123,456
Compatible con: todos los tipos 123,456 ("G", sv-
numéricos. SE) -> -123,456
Especificador de precisión: número 123,4546 ("G4",
de dígitos significativos. en-US) -> 123,5
123,4546 ("G4",
"G" o "g" General predeterminado: depende del tipo
sv-SE) -> 123,5
numérico.
-1.234567890e-25
("G", en-US) ->
formato general ("G").
-1,23456789E-25
-1,234567890e-25
("G", sv-SE) ->
-1,23456789E-25
Resultado: dígitos integrales y
decimales, separadores de grupos y un 1234,567 ("N", en-
separador decimal con signo negativo US) -> 1,234,57
opcional.
Compatible con: todos los tipos 1234,567 ("N", ru-
numéricos. RU) -> 1 234,57
Especificador de precisión: número 1234 ("N1", en-
deseado de decimales. US) -> 1.234,0
"N" o "n" Número
predeterminado: definido 1234 ("N1", ru-RU)
porSystem.Globalization.NumberForm -> 1 234,0
atInfo.
Más información: Especificador de -1234,56 ("N3",
formato numérico ("N"). en-US) -> -1,234,560
-1234,56 ("N3", ru-
RU) -> -1 234,560
"P" o "p" Percent Resultado: número multiplicado por 1 ("P", en-US) ->
100 y mostrado con un símbolo de
100,00 %
porcentaje.
Compatible con: todos los tipos 1 ("P", fr-FR) ->
numéricos. 100,00 %
Especificador de precisión: número -0,39678 ("P1", en-
deseado de decimales. US) -> -39,7 %
predeterminado: definido -0,39678 ("P1", fr-
porSystem.Globalization.NumberForm FR) -> -39,7 %
atInfo.
formato de porcentaje ("P").
123456789,12345
Resultado: cadena que puede
678 ("R") ->
aplicar acciones de ida y vuelta (round-
123456789,1234567
trip) a un número idéntico.
8
-
1234567890,123456
Acción de Compatible
"R" o "r" 78 ("R") ->
ida y vuelta con: Single, Double y BigInteger.
-1234567890,123456
7
Especificador de precisión: se omite.
formato de operación de ida y vuelta
("R").
Resultado: cadena hexadecimal. 255 ("X") -> FF
Compatible con: solo tipos enteros. -1 ("x") -> ff
Hexadecim Especificador de precisión: número
"X" o "x" 255 ("x4") -> 00ff
al de dígitos en la cadena de resultado.
-1 ("X4") -> 00FF
formato hexadecimal ("X").
Cualquier Especificad Resultado:
otro carácter or Produce FormatException en tiempo
único desconocido de ejecución.
Ejemplo de Cadenas con formato numérico estándar
Module Module1
Sub main()
Console.WriteLine("FORMATOS EN MODO CONSOLA ")
Console.WriteLine(" Moneda {0:9:C2}", 4.5)
Console.WriteLine("Moneda {0:9:C2}", -4.5)
Console.WriteLine("Enteros {0:D5}", 45)
Console.WriteLine("Enteros {0:5:D}", 45)
Console.WriteLine("Cientifico {0:E}", 450000)
Console.WriteLine("Coma Fija{0:F2}", 45)
Console.WriteLine("Coma fija {0:F0}", 45)
Console.WriteLine("Coma fija {0,8:f2}", 45)
Console.WriteLine("Coma fija {0,8:F2}", 145.3)
Console.WriteLine(" General {0:G}", 4, 5)
Console.WriteLine("Numerico {0:N}", 4500000)
Console.WriteLine(" %{0:P}", 1.2345)
Console.WriteLine(" hexadecimal{0:X}", 450)
Console.WriteLine("Hexadecimal {0:x}", &HFF7&)
Console.ReadLine()
End Sub
End Module
Formatos compuestos
La característica de formato compuesto de .NET Framework toma una lista de objetos y

una cadena de formato compuesto como entrada. Una cadena de formato compuesto
está formada por texto fijo combinado con marcadores de posición indizados, que
reciben el nombre de elementos de formato, y que se corresponden con los objetos de
la lista. La operación de formato genera una cadena de resultado compuesta por el
texto fijo original combinado con la representación de cadena de los objetos de la lista.
Sintaxis de elemento de formato
Cada elemento de formato presenta la siguiente sintaxis, formada por los siguientes
componentes:
{ index[,alignment][:formatString]}
Las llaves ("{" y "}") son necesarias.
Index (Componente)
El componente index obligatorio, denominado también especificador de parámetros, es

un número que empieza por 0, que identifica un elemento correspondiente de la lista de
objetos. O sea, el elemento de formato cuyo especificador de parámetro es 0 da
formato al primer objeto de la lista, el elemento de formato cuyo especificador de
parámetro es 1 da formato al segundo objeto de la lista, etc.
Los elementos de formato múltiple se pueden referir al mismo elemento de la lista de

objetos mediante la especificación del mismo especificador de parámetro. Por ejemplo,
se puede dar formato al mismo valor numérico en formato hexadecimal, científico y de
número mediante la especificación de una cadena de formato compuesto como ésta:
"{0:X} {0:E} {0:N}".
Cada elemento de formato puede hacer referencia a cualquier objeto de la lista. Por

ejemplo, si existen tres objetos, se puede dar formato al segundo, primero y tercer
objeto mediante la especificación de una cadena de formato compuesto como ésta: "{1}
{0} {2}". Un objeto al que no hace referencia ningún elemento de formato se omite.Se
produce una excepción en tiempo de ejecución si un especificador de parámetro
designa un elemento fuera de los límites de la lista de objetos.
Alignment (Componente)
El componente opcional alignment es un entero con signo que indica el ancho de

campo con formato preferido. Si el valor de alignment es menor que la longitud de la
cadena con formato, se omite alignment y se utiliza la longitud de la cadena con
formato como el ancho de campo. Los datos con formato del campo están alineados a
la derecha si alignment es positivo y, a la izquierda, si alignment es negativo. Si hace
falta relleno, se utiliza un espacio en blanco. Si se especifica alignment, es necesaria la
coma.
Format String (Componente)
El componente formatString opcional es una cadena de formato adecuada para el tipo

de objeto al que se da formato.
Llaves de escape
Las llaves de apertura y de cierre se interpretan como el inicio y el final de un elemento

de formato. Por lo tanto, debe utilizar una secuencia de escape para que se muestre
una llave de apertura o de cierre literal. Especifique dos llaves de apertura ("{{") en el
texto fijo para que se muestre una llave de apertura ("{"), o dos llaves de cierre ("}}")
para que se muestre una llave de cierre ("}"). Las llaves de un elemento de formato se
interpretan secuencialmente, en el orden en que se encuentran. No se admite la
interpretación de llaves anidadas.
Cadenas con formato numérico personalizado
Puede crear una cadena de formato numérico personalizado, formada por uno o varios
especificadores numéricos personalizados, para definir cómo debe darse formato a los
datos numéricos. Una cadena de formato numérico personalizado es cualquier cadena
que no sea una cadena de formato numérico estándar.
Especificador
Nombre Descripción Ejemplos
de formato
Reemplaza el cero con el dígito

1234.5678
Marcador de correspondiente si hay alguno presente;
"0" ("00000") ->
posición cerode lo contrario, el cero aparece en la
01235
cadena de resultado.
Reemplaza el símbolo "#" por el dígito
Marcador de
correspondiente si hay alguno presente; 1234.5678
"#" posición de
de lo contrario, no aparece ningún dígito ("#####") -> 1235
dígito.
en la cadena de resultado.
Separador Determina la ubicación del separador 0.45678 ("0.00",
"."
decimal decimal en la cadena de resultado. en-US) -> 0.46
Separador de Actúa como separador de grupos y Especificador de
"," grupos y como especificador de escala separador de
escala numérica. Como separador de grupos, grupos:
inserta un carácter separador de grupos
adaptado entre cada grupo. Como
numérica especificador de escala numérica, divide
un número por 1000 por cada coma
especificada.
2147483647
("##,#", en-US) ->
2,147,483,647
Marcador de Multiplica un número por 100 e inserta
0.3697 ("%#0.00",
"%" posición de un símbolo de porcentaje adaptado en
en-US) -> %36.97
porcentaje. la cadena de resultado.
0.3697 ("##.0 %",

el-GR) -> 37,0 %
Marcador de Multiplica un número por 1000 e inserta 0.03697
"‰" posición de un símbolo de "por mil" adaptado en la ("#0.00‰", en-US)
"por mil" cadena de resultado. -> 36.97‰
Si va seguido al menos de un 0 (cero),
da formato al resultado usando notación
exponencial. El modelo de mayúsculas
de "E" o "e" indica el modelo de
mayúsculas del símbolo de exponente
en la cadena de resultado. El número de
Notación 987654 ("#0.0e0")
"E0" ceros que siguen al carácter "E" o "e"
exponencial -> 98.8e4
determina el número mínimo de dígitos
en el exponente. Un signo más (+)
indica que un carácter de signo precede
siempre al exponente. Un signo menos
(-) indica que un carácter de signo solo
precede a los exponentes negativos.
Hace que el carácter siguiente se
987654
Carácter de interprete como un literal en lugar de
\ ("\###00\#") ->
escape como un especificador de formato
#987654#
personalizado.
Delimitador Indica que los caracteres que encierra
68 ("# ' grados'")
'string' de cadena se deben copiar en la cadena de
-> 68 grados
literal resultado sin modificar.
Define secciones con cadenas de 12.345 ("#0.0#;
Separador de
; formato diferentes para los números (#0.0#);-\0-") ->
secciones
positivos, negativos y cero. 12.35
Todos los
El carácter se copia en la cadena de
Otros demás 68 ("# °") -> 68 °
resultado sin modificar.
caracteres
en las secciones siguientes se proporciona información detallada sobre cada uno de los
especificadores de formato numérico personalizado.
Ejemplo de El especificador personalizado "0" y “#”

Module Module1
Sub main()
Dim value As Double
value = 1.2
Console.WriteLine(value.ToString("0.00")) ' Displays 1.20
Console.WriteLine(value.ToString("00.00")) ' Displays 01.20
Console.WriteLine(value.ToString("00,00")) ' Displays 01,20
Console.WriteLine(value.ToString(" #0.000"))
value = 0.086
Console.WriteLine(value.ToString("#0.##%")) ' Displays 8.6%
value = 86000
Console.WriteLine(value.ToString("0.###E+0")) ' Displays 8.6E+4
value = 1234567890
Console.WriteLine(value.ToString("#,#")) ' Displays 1,234,567,890
Console.WriteLine(value.ToString("#,##0,,")) ' Displays 1,235
Console.ReadLine()
End Sub
End Module
También puede aplicar Format
Module Module1
Sub main()
Dim value As Double
value = 1.234
Console.WriteLine("{0}", value.ToString("0.00"))
Console.WriteLine("{0}", Format(value, "00.00"))
Console.WriteLine("{0}", value.ToString("00,00").PadRight(10))
Console.WriteLine("{0}", value.ToString("00,00").PadLeft(10))
Console.ReadLine()
End Sub
End Module
Escritura de múltiples valores en la misma línea
Al utilizar WriteLine( ) o Write( ) ocurrirá con frecuencia que en el texto a mostrar

debamos incluir valores que se encuentran en variables o expresiones, por lo que
tendremos que realizar una combinación e la cadena de texto principal con los demás
elementos para obtener la cadena final que mostraremos al usuario. Esto lo podemos
hacer empleando dos técnicas:
Concatenación. Concatenando a la cadena principal las variables que contienen

los valores a mostrar. Ver Código
Module Module1
Sub main()
' concatenar múltiples valores ' declarar variables
Dim Nota As Integer
' asignar valor a las variables
Nombre = "Juan"
Nota = 17
Console.WriteLine("El alumno " & Nombre & " Tiene " & Nota & " de nota")
Console.ReadLine()
End Sub
End Module
Parámetros sustituibles.
Pasando como primer parámetro la cadena a mostrar, y añadiendo tantos parámetros

adicionales como valores debamos mostrar en la cadena principal. En la cadena
principal indicaremos el lugar en donde visualizaremos los parámetros poniendo su
número entre los símbolos de llave “{ }”. El Código fuente muestra la misma situación
del ejemplo anterior pero utilizando esta técnica. El resultado final en la
consola es el mismo que el del ejemplo anterior.
Module Module1
Sub main()
Dim Nota As Integer
Nombre = "Juan"
Nota = 17
Console.WriteLine("El alumno {0} Tiene {1} de nota", Nombre, Nota)
Console.ReadLine()
End Sub
End Module
Como habrá comprobado el lector, los parámetros sustituibles comienzan a numerarse

por cero, no estando obligados a mostrarlos en el mismo orden en el que los hemos
situado en la llamada al método. El Código fuente 45 muestra dos ejemplos de
sustitución de parámetros, uno de ellos con el mismo orden en el que se han situado
en WriteLine( ), y otro con un orden distinto.
Module Module1
Sub main()
Dim Nota As Integer
Nombre = "Juan"
Nota = 17
Console.WriteLine("El alumno {1} Tiene {0} de nota", Nota, Nombre)
Console.ReadLine()
End Sub
End Module
Al ejecutar este fuente, la consola mostrará el aspecto de la Figura 164.
1.16 LECTURA DE INFORMACIÓN
Para obtener el texto escrito por el usuario en la línea actual de la consola y hasta la
pulsación de [INTRO] podemos utilizar el método ReadLine( ) del objeto Console.
El Código fuente 46 muestra como volcamos a una variable el contenido de la línea

escrita por el usuario y posteriormente exponemos su contenido, también a través de
la consola.
Module Module1
Sub main()
' declaramos una variable para volcar el contenido de una línea de la consola
Dim LineaTexto As String
Console.Write("Ingrese un texto")
LineaTexto = Console.ReadLine() ' el texto se pasa a la variable
' ahora mostramos lo que hemos escrito
Console.WriteLine()
Console.WriteLine("El usuario ha escrito la siguiente línea:")
Console.WriteLine(LineaTexto)
' aquí evitamos cerrar la consola, ' así podemos ver mejor el resultado
Console.ReadLine()
End Sub
End Module
Read( ) es otro método del objeto Console que permite también la lectura del
dispositivo de entrada de la consola, pero en este caso devuelve el código de una sola
tecla pulsada por el usuario. Para ilustrar el uso de este método tenemos el ejemplo del
Código fuente 47, en el que después de pulsar varias teclas, nos introducimos en un
bucle que va extrayendo cada uno de sus códigos, que volvemos a
transformar en el carácter correspondiente a la tecla pulsada.
Cuál es la diferencia entre el Read y el Readline?

Que el Readline lee toda una línea de texto mientras para el Read podemos usar
conversiones para que leamos por ejemplo son un carácter.
Module Module1
Sub main()
Dim CodTecla As Integer, nombretecla As Object
Console.WriteLine("Pulsar varerias teclas")
Console.WriteLine()
While True
' tomar los códigos de las teclas uno a uno
CodTecla = Console.Read() ' si se ha pulsado intro, salir
If CodTecla = 13 Then
Exit While
End If
Console.WriteLine("Código de tecla pulsada: {0}", CodTecla)
' convertir el código al caracter de la tecla
NombreTecla = Chr(CodTecla)
Console.WriteLine("Tecla pulsada: {0}", NombreTecla)
End While
Console.WriteLine("Ejemplo terminado, pulse intro")
Console.ReadLine()
End Sub
End Module
1.17 AYUDA DE VISUAL BASIC
Para tener ayuda consulte en internet en la ayuda MSDN de visual estudio 2010
1.18 PROBLEMAS RESUELTOS
Problema C101 Escriba el programa hola mundo en visual basic 2010
Tipo de proyecto Visual Basic\Aplicación de consola

Nombre del proyecto ConsoleApplication1
Escriba el siguiente codigo
Module Module1
Sub Main()
Console.WriteLine(" INGENIERIA INDUSTRIAL 2014")
Console.ReadLine()
End Sub
End Module
Ejecución
Con control + A se selecciona , control +*c se copia y control + V pega
Para capturar la pantalla de salida use Allt Print Screen
Problema C102.Calcule una formula (una estrada y una salida)

por ejemplo se ingresa el radio de un circulo el programa debe a obtener el area del
circulo de acuerdo a la fórmula Area= pi*radio 2
Module Module1
Sub Main()
Dim radio, Area As Single
Console.Write(" Ingrese radio del circulo ")
radio = Console.ReadLine())
Area =Math.PI * radio * radio)
Console.Write(" El Area es {0} ", Area)
Console.ReadLine()
End Sub
End Module
Ejecute con F5
Puede capturar la pantalla de salida con alt+imp pantallla y despues control+ v

Problema C103 . Calcular el area del triángulo ( 2 entradas y una salida”)
Module Module1
Sub Main()
Dim base, Altura, Area As Single
Console.Write(" Ingrese base del triangulo ")
base = Console.ReadLine()
Console.Write(" Ingrese altura del triangulo ")
Altura = Console.ReadLine()
Area = base * Altura / 2
Console.Write(" El Area es {0} ", Area)
Console.ReadLine()
End Sub
End Module
Salida
Problema C104 Ingreso de una variable tipo cadena .

Ingrese su nombre y la computadora que le salude
Module Module1
Sub Main()
Dim nombre As String
Console.Write(" Ingrese su nombre ")
nombre = Console.ReadLine()
Console.Write(" Hola {0} ", nombre)
Console.ReadLine()
End Sub
End Module
Salida
Problema C105 Precedencia de operaciones
Module Module1
Sub Main()
Dim x = 10, y = 20, z As Single
z = CSng(x + y / 2)
Console.WriteLine("caso 1 valor de z= {0} ", z)
z = CSng((x + y) / 2)
Console.WriteLine("caso 2 valor de z = {0} ", z)
Console.ReadLine()
End Sub
End Module
Salida
Problema C106 Ejemplo de salida con formato y espacios
Module Module1
Sub Main()
Dim x As Integer = 10
Dim y As Single = 3.1416
Console.WriteLine("X sin formato= {0} ", x)
Console.WriteLine("X con 10 espacios izquierdo = {0} ", x.ToString.PadLeft(10))
Console.WriteLine("X con 10 espacios derecho = {0} ", x.ToString.PadRight(10))
Console.WriteLine("Y sin formato {0} ", y)
Console.WriteLine("X con 8 espacios derecha y cuatro decimales = {0} ",
Format(y, "####0.0000".ToString.PadRight(8)))
Console.WriteLine("X con 8 espacios izquierda y dos = {0} ", Format(y,
"####0.00".ToString.PadLeft(8)))
Console.ReadLine()
End Sub
End Module
Problema C107. Ejemplo de ,caracteres de escape

Para escribir caracteres de escape
vbCrLf retorno de carro y salto de linea
vbCr retorno de carro
vbTab tabulador
también se puede escribir como codio ASCCI por ejmeplo para el tabulador de debe
escribir chr(9)
Module Module1
Sub Main()
Console.WriteLine(" Hola {0} Hola {1}Hola {2} Hola {0} Hola ", vbTab, vbCrLf,
vbCrLf)
Console.ReadLine()
End Sub
End Module
Problema C108. Ejemplo de readkey
Module Module1
Sub Main()
Dim cki As ConsoleKeyInfo
' Prevent example from ending if CTL+C is pressed.
Console.TreatControlCAsInput = True
Console.WriteLine("Press any combination of CTL, ALT, and SHIFT, and a
console key.")
Console.WriteLine("Press the Escape (Esc) key to quit: " + vbCrLf)
Do
cki = Console.ReadKey()
Console.Write(" --- You pressed ")
If (cki.Modifiers And ConsoleModifiers.Alt) <> 0 Then Console.Write("ALT+")
If (cki.Modifiers And ConsoleModifiers.Shift) <> 0 Then
Console.Write("SHIFT+")
If (cki.Modifiers And ConsoleModifiers.Control) <> 0 Then
Console.Write("CTL+")
Console.WriteLine(cki.Key.ToString)
Loop While cki.Key <> ConsoleKey.Escape
End Sub
End Module
Problema C109 Ejemplo de Especificador de formato de punto fijo ("F")
Imports System
Imports System.Globalization
Module Module1
Sub main()
Dim integerNumber As Integer
integerNumber = 17843
Console.WriteLine(integerNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 17843.00
integerNumber = -29541
Console.WriteLine(integerNumber.ToString("F3", CultureInfo.InvariantCulture))
' Displays -29541.000
Dim doubleNumber As Double
doubleNumber = 18934.1879
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 18934.19
Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture))
' Displays 18934
doubleNumber = -1898300.1987
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture))
' Displays -1898300.2
Console.WriteLine(doubleNumber.ToString("F3", _
CultureInfo.CreateSpecificCulture("es-ES")))
' Displays -1898300,199
Console.ReadLine()
End Sub
End Module
Problema C110 Ejemplo de Especificador de formato de punto fijo ("#")
Imports System
Imports System.Globalization
Module Module1
Sub main()
Dim value As Double
value = 1.2
Console.WriteLine(value.ToString("#.##", CultureInfo.InvariantCulture))
' Displays 1.2
value = 123
Console.WriteLine(value.ToString("#####")) ' Displays 123
value = 123456
Console.WriteLine(value.ToString("[##-##-##]")) ' Displays [12-34-56]
value = 1234567890
Console.WriteLine(value.ToString("#")) ' Displays 1234567890
Console.WriteLine(value.ToString("(###) ###-####"))
' Displays (123) 456-7890
Console.ReadLine()
End Sub
End Module
Problema C111 se Ingresa El nombre del trabajador y el sueldo bruto. Se deecuenta

15% d eimpuesto por quinta categoria y 2% por Afp. Elborar un progrgrma en visual
Basic para calcular el suelto de la forma
Module Module1
Dim nombreTrab As String
Dim Sbruto As Single
Dim D5 As Single = 0.15
Dim Des5 As Single
Dim afp As Single = 0.02
Dim Dafp, tdesc, Sneto As Single
Sub Main()
Console.Write("INGRESE nombre trabajador ")
nombreTrab = Console.ReadLine
Console.Write("INGRESE sueldo trabajador ")
Sbruto = Console.ReadLine
Des5 = Sbruto * D5
Dafp = Sbruto * afp
tdesc = Des5 + Dafp
Sneto = Sbruto - tdesc
Console.WriteLine("BOLETA TRABAJADOR")
Console.WriteLine("==============")
Console.WriteLine("Nombre " & nombreTrab)
Console.WriteLine("Sbruto " & Sbruto)
Console.WriteLine("DESCUENTOS ")
Console.WriteLine("QUINTA CATEG " & Des5)
Console.WriteLine("AFP " & Dafp)
Console.WriteLine("TOTAL DESC " & tdesc)
Console.WriteLine("SUELDO NETO " & Sneto)
Console.ReadLine()
End Sub
End Module
Convertir un numero decimal a base a binario ,octal y hexadecimal
0 a cualquier base
Module Module1
Sub Main()
Dim nro As Integer = 254
cadena = Convert.ToString(nro, 16)
Dim byteValue2 As Byte = &HC9
Console.WriteLine("a a Decimal " & Convert.ToString(nro, 10))
Console.WriteLine("a binario " & Convert.ToString(nro, 2))
Console.WriteLine("a OCTAL " & Convert.ToString(nro, 8))
Console.WriteLine("a Hexadecimal " & Convert.ToString(nro, 16))
Console.WriteLine(" en hexadecimal " & Hex(nro))
Console.WriteLine(" en Octal " & Oct(nro))
Console.ReadLine()
End Sub
End Module
Operaciones Booleanas
Module Module1
Sub Main()
Dim P, Q, R As Boolean
P = True
Q = False
Console.WriteLine(" {0} {1} and {2} ", P, Q, P And Q)
Console.WriteLine(" {0} {1} and {2} ", P, Q, P Or Q)
Console.WriteLine(" {0} {1} and {2} ", P, Q, P Xor Q)
Dim A As UInt16 = 6
Dim B As UInt16 = 11
Console.WriteLine(" {0} AND {1} = {2} ", A, B, A And B)
Console.WriteLine(" {0} Or {1} = {2} ", A, B, A Or B)
Console.WriteLine(" {0} XOr {1} = {2} ", A, B, A Xor B)
Console.WriteLine(" {0} not {1} ", A, Not A)
Console.ReadLine()
End Sub
End Module
1.19 PROBLEMAS PROPUESTOS
1) Pruebe todos los ejemplos

2) Elaborar una programa para calcular una formula ejemplo se ingresan 3 notas que
calcule el promedio de las notas
3) Probar los operadores y su precedencia
4) Pruebe la función console.write y console.writeline con diferentes formatos y
codigos de escape
5) Pruebe la funcion console.read y console.readline como leer diferentes tipos de
datos
6) Pruebe las funcions predefinidas math. consola.etc
7) Pruebe ejercicios en programación visual. las 4 operaciones convertir consola modo
formulario
8. pruebe todos los ejercicios resueltos
CLAVE DE VISUAL BASIC 2010

YCFHQ9DWCYDKV88T2TMHG7BHP
|

Visual INTRODUCCION PMN

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Visual INTRODUCCION PMN

Cargado por

Copyright:

Formatos disponibles

Programación y Métodos Numéricos 2020 A \1.

Fundamentos \ Ismael Véliz Vilca -1-

PARTE I FUNDAMENTOS DE LENGUAJE DE PROGRAMACION

CON VISUAL BASIC 2015

CAPITULO I FUNDAMENTOS DE PROGRAMACIÓN

1.1 CONCEPTO DE SISTEMAS.-

Un sistema (del latín systēma, y este del griego σύστημα sýstēma 'reunión, conjunto,

Un sistema (system). Es un conjunto de partes o elementos organizadas y relacionadas

Un sistema puede ser físico o concreto (una computadora, un televisor, un humano) o

Elementos o componentes de un sistema

En el siguiente diagrama se muestra los elementos o componentes de un sistema

ENTRADA PROCESO SALIDA

Figura. 1.1 Esquema simplificado de un sistema

1. Entrada (INPUT) insumo, sensor.(lectura)

En informática podemos distinguir dos clases de elementos:

1.2 CONCEPTOS DE PROGRAMACION Y APLICACIONES

 Los lenguajes de programación permiten codificar algoritmos en el ordenador. Son

1.3 METODOLOGIA DE LA PROGRAMACION

Independientemente de la metodología utilizada suele haber una serie de pasos

El análisis estudia los requisitos que ha de cumplir la aplicación. El resultado del

En la creación de algoritmos sencillos, el análisis consistiría únicamente en:

En estos esquemas se pueden simbolizar: la organización de los datos de la aplicación,

La creación de estos esquemas se puede hacer en papel, o utilizar una herramienta

Escritura de la aplicación utilizando un lenguaje de programación (C, Pascal, C++,

Tras la escritura del código, mediante un software especial se traduce a código

Se trata de testear la aplicación para verificar que su funcionamiento es el correcto.

En esta fase se crea la documentación del programa (paso fundamental en la creación

Según la RAE: conjunto ordenado y finito de operaciones que permite hallar la

Representación gráfica de los algoritmos.-

Figura 1.4.2.- Representación gráfica de los algoritmos.

Considerado como un lenguaje falso, el pseudocódigo es un Inicio

Problema.- Intercambiar dos variables N1, N2

Elaborar diagrama de flujo, prueba de datos y programa

Ejercicios visual logic DFD

enlace para descargar https://freedfd.uptodown.com/windows

1. Sumar dos números usar visual logic

Visual Logic Textbook versión 1.0

Visual Logic www.visuallogic.org

1.5 PROGRAMA EN VISUAL BASIC 2017

1. Ingrese nuevo proyecto en Visual Basic y luego aplicación de consola

3. Escriba el siguiente codigo

Presione F5 o el siguiente icono

Elaborar el Pseudocódigo y su diagrama de flujo para:

1. Sumar dos Números,

1.6 LENGUAJE DE PROGRAMACION VISUAL BASIC DE VISUAL

Se enseñara este lenguaje porque es parecido a lo enseñado en semestres anteriores

Paradigma: Dirigida por eventos Apareció en: 1993 (vs 1997)

Microsoft Visual Studio es un entorno de desarrollo integrado (IDE, por sus siglas en

Visual Studio permite a los desarrolladores crear aplicaciones, sitios y aplicaciones

Visual Basic .NET (VB.NET) es un lenguaje de programación orientado a objetos que

La gran mayoría de programadores de VB.NET utilizan el entorno de desarrollo

Visual Basic 2008 (VB 9.0)

Para esta versión se añadieron varias novedades, incluyendo:

Visual Basic 2010 (VB 10.0)

Visual Basic 2010 ofrece soporte para entorno de ejecución dinámico..

Visual Basic 2012 (VB 10.0)

Visual Basic 2015 (VB 10.0)

Ejemplo del programa de 4 operaciones en visual basic 2010

1 LENGUAJE VISUAL BASIC 2015 EN MODO CONSOLA

Presione doble clic sobre la parte sombreada

Presione Reemplazar Console.Readine y se soluciona el problema

En modo formulario (Calculadora elemental