PMN2019-1 Introduccion-Pmn

Programación y Métodos Numéricos 2019 A \1.
Fundamentos \ Ismael Véliz Vilca -1-
1 Tabla de contenido
CAPITULO I FUNDAMENTOS DE PROGRAMACIÓN ................................................. 4
1.1 CONCEPTO DE SISTEMAS.- .......................................................................... 4
Definición de sistemas.-............................................................................................. 4
Elementos o componentes de un sistema ................................................................. 4
1.2 CONCEPTOS DE PROGRAMACION Y APLICACIONES ................................. 5
Programa. .................................................................................................................. 5
Programación ............................................................................................................ 5
Lenguajes de programación ...................................................................................... 5
1.3 METODOLOGIA DE LA PROGRAMACION ....................................................... 5
análisis....................................................................................................................... 5
diseño ........................................................................................................................ 6
codificación ................................................................................................................ 6
ejecución ................................................................................................................... 6
prueba ....................................................................................................................... 6
mantenimiento ........................................................................................................... 6
1.4 ALGORITMOS ................................................................................................... 6
diagramas de flujo ..................................................................................................... 6
Representación gráfica de los algoritmos.-................................................................ 7
Pseudocódigo. ........................................................................................................... 7
Ejercicios visual logic DFD ....................................................................................... 8
1.5 PROGRAMA EN VISUAL BASIC 2015 ............................................................ 10
Ejercicios. ................................................................................................................ 11
1.6 LENGUAJE DE PROGRAMACION VISUAL BASIC DE VISUAL ESTUDIO
2015 12
MOTIVOS ................................................................................................................ 12
Visual Basic 2008 (VB 9.0) ...................................................................................... 12
Visual Basic 2010 (VB 10.0) .................................................................................... 13
Visual Basic 2012 (VB 10.0) .................................................................................... 13
Visual Basic 2015 (VB 10.0) .................................................................................... 13
Ejemplo del programa de 4 operaciones en visual basic 2010 ................................ 13
1.7 . LA ESTRUCTURA DE UN PROGRAMA VISUAL BASIC 2015 ..................... 18
Estructura de un programa de Visual Basic............................................................. 19
Elementos de programación en el nivel de archivo ................................................. 19
Instrucciones Option ................................................................................................ 19
Instrucciones Imports ............................................................................................ 20
Instrucciones Namespace ..................................................................................... 20
Instrucciones de compilación condicional.............................................................. 20
Programación y Métodos Numéricos 2019 A \1.Fundamentos \ Ismael Véliz Vilca -2-
Elementos de programación en el nivel de espacio de nombres ............................ 20
Elementos de programación en el nivel de módulo ................................................ 20
1.8 Procedimiento Main( ) como procedimiento de entrada al programa ............. 21
1.9 REGLAS DE ESCRITURA DE UN PROGRAMA VISUAL BASIC ................... 21
1.10 PALABRAS RESERVADAS,TIPOS DE DATOS, CONSTANTES Y
VARIABLES ............................................................................................................... 22
Palabras reservadas ............................................................................................... 22
Palabras clave reservadas ...................................................................................... 22
Palabras clave no reservadas ................................................................................. 23
Identificadores ........................................................................................................ 23
Constantes.............................................................................................................. 24
1.11 - VARIABLES.- ............................................................................................ 24
Declaración de variable en Visual Basic ................................................................. 25
Declarar el tipo de datos ......................................................................................... 25
Asignar valores ....................................................................................................... 25
Denominación ......................................................................................................... 26
Avisos del IDE sobre errores en el código .............................................................. 26
Lugar de la declaración........................................................................................... 26
Tipificación .............................................................................................................. 26
¿para qué necesitamos asignar tipo a las variables?”. ........................................... 27
Declaración múltiple en línea .................................................................................. 27
Asignación de valor................................................................................................. 28
Valor inicial ............................................................................................................. 29
Declaración obligatoria ........................................................................................... 31
Option Explicit a nivel de proyecto. ......................................................................... 31
Option Explicit a nivel de fichero. ............................................................................ 32
Tipificación obligatoria ............................................................................................ 33
Opción por defecto.................................................................................................. 34
1.12 TIPOS DE DATOS EN VISUAL BASIC 2010 ............................................... 36
Resumen de tipos de datos (Visual Basic) ............................................................. 36
Funciones de conversión de tipos (Visual Basic) .................................................... 38
1.13 OPERADORES ............................................................................................ 40
Resumen de operadores (Visual Basic).................................................................. 40
Precedencia de operadores .................................................................................... 41
Espera el operador .......................................................................................... 41
Operadores de concatenación y aritméticos .................................................... 41
Operadores de comparación ......................................................................... 42
Operadores lógicos y bit a bit .......................................................................... 42
1.14 APLICACION DE CONSOLA ....................................................................... 42
Creación de un proyecto de tipo aplicación de consola ........................................... 42
La clase Console ..................................................................................................... 43
1.15 ESCRITURA DE INFORMACIÓN ................................................................. 43
¿Cuál es la diferencia entre el Writeline y el Write? ................................................ 44
¿Qué son los flujos de salida con formato? ............................................................. 45
Cadenas con formato numérico estándar ................................................................ 45
Ejemplo de Cadenas con formato numérico estándar ............................................. 48
Formatos compuestos ............................................................................................. 49
Sintaxis de elemento de formato ............................................................................. 49
Cadenas con formato numérico personalizado ....................................................... 50
Ejemplo de El especificador personalizado "0" y “#” .................................... 52
Escritura de múltiples valores en la misma línea ..................................................... 53
1.16 LECTURA DE INFORMACIÓN ..................................................................... 55
Cuál es la diferencia entre el Read y el Readline? .................................................. 55
1.17 AYUDA DE VISUAL BASIC ......................................................................... 56
1.18 PROBLEMAS RESUELTOS ......................................................................... 56
Problema C101 Escriba el programa hola mundo en visual basic 2010 ................. 57
Problema C102.Calcule una formula (una estrada y una salida) ............................ 58
Problema C103 . Calcular el area del triángulo ( 2 entradas y una salida”) ............ 58
Problema C104 Ingreso de una variable tipo cadena . ........................................... 58
Problema C105 Precedencia de operaciones ......................................................... 59
Problema C106 Ejemplo de salida con formato y espacios .................................. 59
Problema C107. Ejemplo de ,caracteres de escape ................................................ 60
Problema C108. Ejemplo de readkey ...................................................................... 60
Problema C109 Ejemplo de Especificador de formato de punto fijo ("F") ............... 61
Problema C110 Ejemplo de Especificador de formato de punto fijo ("#") ............... 61
1.19 PROBLEMAS PROPUESTOS ...................................................................... 64
PARTE I FUNDAMENTOS DE LENGUAJE DE PROGRAMACION
CON VISUAL BASIC 2015
CAPITULO I FUNDAMENTOS DE PROGRAMACIÓN
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”).
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)
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.
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.-
Inicio o Fin Decisión Documento
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 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
Análisis. (Especificaciones)- entrada a=10 b=20 Inicio
Salida a=20 b=10
Programación (algoritmo)
Pseudocódigo N1, N2
paso1. Iniciar
paso2 ingresar las dos variables y guardarlos en N1 y N2 Temp <---- N1
paso3 realizar el intercambio N1<--- N2
3.1 Crear una variable temporal N2<----Temp
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
N1,N2
Paso 4 mostrar el contenido de N1 y N2
Paso 5 terminar
Elaborar diagrama de flujo, prueba de datos y programa Fin

Ejercicios visual logic DFD
1. Sumar dos números usar visual logic

Programación y Métodos Numéricos 2019 A \1.Fundamentos \ Ismael Véliz Vilca - 10 -
PROGRAMA EN VISUAL BASIC 2015
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
LENGUAJE DE PROGRAMACION VISUAL BASIC DE VISUAL ESTUDIO 2015
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
Option Explicit On
Option Strict On
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
Control Propiedad 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,
. 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.
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
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
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.
Agregado Ansi Assembly Auto

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
Take
Strict 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.
- 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
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 almacenamie Intervalo de valores
Basic
Language nto nominal
Runtime
En función de
Boolean Boolean la plataforma True o False
de
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
date DateTime 8 bytes de 0001 a 11:59:59 p.m. del 31 de
diciembre de 9999.
0 a +/-
79.228.162.514.264.337.593.543.95
0.335 (+/-7,9... E+28) † sin separador
decimal; 0 a +/-
7,922816251426433759354395033
Decimal Decimal 16 bytes 5 con 28 posiciones a la derecha del
decimal;
el número distinto de cero más
pequeño es +/-
0,000000000000000000000000000
1 (+/-1E-28)†
-1,79769313486231570E+308 a -
4,94065645841246544E-324 † para
Double (punto
los 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
Object (clas 32 bits Cualquier tipo puede almacenarse
object
e) 8 bytes en 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
precisión †
3,4028235E+38 para los valores
sencilla)
positivos
En función de
la plataforma
String (longitud String (clase 0 a 2.000 millones de caracteres
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
En función de
un intervalo de valores determinado
User- (hereda la plataforma
por su tipo de datos y es
Defined(estructu de ValueTyp de
independiente de los intervalos de
ra) e) implementació
valores correspondientes a los
n
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
CBool de datos, Cualquier expresión numérica, Char o String válida.
Visual Basic)
Byte (Tipo de
CByte datos, Visual 0 a 255 (sin signo); las partes fraccionarias se redondean.1
Basic)
Char (Tipo de Cualquier expresión Char o String válida; sólo se convierte
CChar datos, Visual el primer carácter de String; el valor puede estar
Basic) comprendido entre 0 y 65535 (sin signo).
Date (Tipo de
CDate datos, Visual Cualquier representación válida de fecha y hora.
Basic)
de -1,79769313486231570E+308 a -
Double (Tipo
4,94065645841246544E-324 para valores negativos; de
CDbl de datos,
4,94065645841246544E-324 a
Visual Basic)
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
números con 28 posiciones decimales, el intervalo es +/-
CDec de datos,
7,9228162514264337593543950335. El menor número
Visual Basic)
posible distinto de cero es
0,0000000000000000000000000001 (+/-1E-28).
Integer (Tipo
de -2.147.483.648 a 2.147.483.647; las partes fraccionarias
CInt de datos,
se redondean.1
Visual Basic)
Long (Tipo de de -9.223.372.036.854.775.808 a
CLng datos, Visual 9.223.372.036.854.775.807; las partes fraccionarias se
Basic) redondean.1
Object (Tipo de
CObj Cualquier expresión válida.
datos)
SByte (Tipo de
CSByte datos, Visual de -128 a 127; las partes fraccionarias se redondean.1
Basic)
Short (Tipo de
de -32.768 a 32.767; las partes fraccionarias se
CShort datos, Visual
redondean.1
Basic)
Single (Tipo de De -3,402823E+38 a –1,401298E-45 para valores
CSng datos, Visual negativos; de 1,401298E-45 a 3,402823E+38 para valores
Basic) positivos.
String (Tipo de Los valores devueltos para CStr dependen del
CStr datos, Visual argumento expression. Vea Valores devueltos para la
Basic) función CStr (Visual Basic).
UInteger (Tipo de 0 a 4.294.967.295 (sin signo); las partes fraccionarias se
CUInt
de datos) redondean.1
ULong (Tipo
de 0 a 18.446.744.073.709.551.615 (sin signo); las partes
CULng de datos,
fraccionarias se redondean.1
Visual Basic)
UShort (Tipo
de 0 a 65.535 (sin signo); las partes fraccionarias se
CUShort de datos,
redondean.1
Visual Basic)
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
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
^, –, *, /, \, Mod, +, =
aritméticos
Asignación =, ^=, *=, /=, \=, +=, -=, &=
Comparación =, <>, <, >, <=, >=, Like, Is
Concatenación &, +
Operadores lógicos
Not, And, Or, Xor, AndAlso, OrElse
y bit a bit
Operaciones varias AddressOf, GetType
Operadores Matemáticos
Operador Descripción Ejemplo
Operadores matemáticos
+ 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
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
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
Especifica
dor de Nombre Descripción Ejemplos
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: 123,456 ("C", ja-
número de dígitos decimales. JP) -> ¥123
Especificador de precisión
-123,456 ("C3",
"C" o "c" Moneda predeterminado: definido
en-US) ->
porSystem.Globalization.NumberFo
($123,456)
rmatInfo.
-123,456 ("C3",
Más información: Especificador
fr-FR) -> -123,456
de formato de divisa ("C").
€
-123,456 ("C3",
ja-JP) -> -¥123,456
Resultado: dígitos enteros con 1234 ("D") ->
signo negativo opcional. 1234
Compatible con: solo tipos -1234 ("D6") -> -
enteros. 001234
Especificador de precisión:
"D" o "d" Decimal número mínimo de dígitos.
predeterminado: número mínimo de
dígitos necesarios.
de formato decimal ("D").
1052,032911275
Resultado: notación exponencial. 6 ("E", en-US) ->
1,052033E+003
1052,032911275
Compatible con: todos los tipos
6 ("e", fr-FR) ->
numéricos.
1,052033e+003
Exponenci -
"E" o "e"
al (científico) Especificador de precisión: 1052,0329112756
número de dígitos decimales. ("e2", en-US) -> -
1,05e+003
-
Especificador de precisión 1052,0329112756
predeterminado: 6. ("E2", fr_FR) -> -
1,05E+003
de formato exponencial ("E").
Resultado: dígitos integrales y
1234,567 ("F",
decimales con signo negativo
en-US) -> 1234,57
opcional.
Compatible con: todos los tipos 1234,567 ("F",
numéricos. de-DE) -> 1234,57
Especificador de precisión: 1234 ("F1", en-
número de dígitos decimales. US) -> 1234,0
"F" o "f" Punto fijo predeterminado: definido 1234 ("F1", de-
porSystem.Globalization.NumberFo DE) -> 1234,0
rmatInfo.
-1234,56 ("F4",
en-US) -> -
de formato de punto fijo ("F").
1234,5600
-1234,56 ("F4",
de-DE) -> -
1234,5600
Resultado: notación de punto fijo
-123,456 ("G",
o científica, la que sea más
en-US) -> -123,456
compacta.
Compatible con: todos los tipos 123,456 ("G", sv-
numéricos. SE) -> -123,456
Especificador de precisión: 123,4546 ("G4",
número de dígitos significativos. en-US) -> 123,5
"G" o "g" General 123,4546 ("G4",
predeterminado: depende del tipo
sv-SE) -> 123,5
numérico.
-1.234567890e-
25 ("G", en-US) ->
de formato general ("G").
-1,23456789E-25
-1,234567890e-
25 ("G", sv-SE) -> -
1,23456789E-25
Resultado: dígitos integrales y
decimales, separadores de grupos 1234,567 ("N",
y un separador decimal con signo en-US) -> 1,234,57
negativo opcional.
Compatible con: todos los tipos 1234,567 ("N",
numéricos. ru-RU) -> 1 234,57
Especificador de precisión: 1234 ("N1", en-
"N" o "n" Número número deseado de decimales. US) -> 1.234,0
predeterminado: definido 1234 ("N1", ru-
porSystem.Globalization.NumberFo RU) -> 1 234,0
rmatInfo.
-1234,56 ("N3",
en-US) -> -
de formato numérico ("N").
1,234,560
-1234,56 ("N3",
ru-RU) -> -1
234,560
Resultado: número multiplicado
1 ("P", en-US) ->
por 100 y mostrado con un símbolo
100,00 %
de porcentaje.
Compatible con: todos los tipos 1 ("P", fr-FR) ->
numéricos. 100,00 %
Especificador de precisión: -0,39678 ("P1",
"P" o "p" Percent número deseado de decimales. en-US) -> -39,7 %
predeterminado: definido -0,39678 ("P1",
porSystem.Globalization.NumberFo fr-FR) -> -39,7 %
rmatInfo.
de formato de porcentaje ("P").
123456789,1234
Resultado: cadena que puede
5678 ("R") ->
aplicar acciones de ida y vuelta
123456789,123456
(round-trip) a un número idéntico.
78
-
1234567890,12345
Compatible
Acción de 678 ("R") -> -
"R" o "r" con: Single, Double y BigInteger.
ida y vuelta 1234567890,12345
67
Especificador de precisión: se
omite.
de formato de operación de ida y
vuelta ("R").
Resultado: cadena hexadecimal. 255 ("X") -> FF
Compatible con: solo tipos
-1 ("x") -> ff
enteros.
Hexadeci Especificador de precisión:
"X" o "x"
mal número de dígitos en la cadena de 255 ("x4") -> 00ff
resultado.
-1 ("X4") -> 00FF
de formato hexadecimal ("X").
Cualquier Especifica Resultado:
otro carácter dor Produce FormatException en
único desconocido tiempo 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

correspondiente si hay alguno 1234.5678
Marcador de
"0" presente; de lo contrario, el cero ("00000") ->
posición cero
aparece en la cadena de 01235
resultado.
Reemplaza el símbolo "#" por el
Marcador de dígito correspondiente si hay
1234.5678
"#" posición de alguno presente; de lo contrario,
("#####") -> 1235
dígito. no aparece ningún dígito en la
cadena de resultado.
Determina la ubicación del
Separador 0.45678 ("0.00",
"." separador decimal en la cadena
decimal en-US) -> 0.46
de resultado.
Actúa como separador de grupos
y como especificador de escala
numérica. Como separador de
Separador de
grupos, inserta un carácter Especificador de
grupos y
"," separador de grupos adaptado separador de
escala
entre cada grupo. Como grupos:
numérica
especificador de escala numérica,
divide un número por 1000 por
cada coma especificada.
2147483647
("##,#", en-US) ->
2,147,483,647
Multiplica un número por 100 e
Marcador de
inserta un símbolo de porcentaje 0.3697 ("%#0.00",
"%" posición de
adaptado en la cadena de en-US) -> %36.97
porcentaje.
resultado.
0.3697 ("##.0 %",
el-GR) -> 37,0 %
Multiplica un número por 1000 e
Marcador de 0.03697
inserta un símbolo de "por mil"
"‰" posición de ("#0.00‰", en-
adaptado en la cadena de
"por mil" US) -> 36.97‰
resultado.
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
Notación 987654 ("#0.0e0")
"E0" mayúsculas del símbolo de
exponencial -> 98.8e4
exponente en la cadena de
resultado. El número de ceros
que siguen al carácter "E" o "e"
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
\ ("\###00\#") ->
escape de como un especificador de
#987654#
formato personalizado.
Delimitador Indica que los caracteres que
68 ("# ' grados'") -
'string' de cadena encierra se deben copiar en la
> 68 grados
literal cadena de resultado sin modificar.
Define secciones con cadenas de
12.345
Separador de formato diferentes para los
; ("#0.0#;(#0.0#);-
secciones números positivos, negativos y
\0-") -> 12.35
cero.
Todos los
El carácter se copia en la cadena
Otros demás 68 ("# °") -> 68 °
de 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.

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
AYUDA DE VISUAL BASIC
Para tener ayuda consulte en internet en la ayuda MSDN de visual estudio 2010
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*radio2
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. Sed ecuenta
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
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 printf con diferentes formatos y codigos de escape
5) Pruebe la funcion scan como leer diferentes tipos de numeros
6) Pruebe las funcions cin y cout
7) Pruebe ejercicios en programación visual
CLAVE DE VISUAL BASIC 2010

YCFHQ9DWCYDKV88T2TMHG7BHP
|

PMN2019-1 Introduccion-Pmn

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

PMN2019-1 Introduccion-Pmn

Transféré par

Droits d'auteur :

Formats disponibles

Programación y Métodos Numéricos 2019 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

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:

CONCEPTOS DE PROGRAMACION Y APLICACIONES

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

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

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. Para

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

 Es el esquema más viejo de la informática. Se trata de una notación que pretende

Representación gráfica de los algoritmos.-

Inicio o Fin Decisión Documento

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

Considerado como un lenguaje falso, el pseudocódigo es un lenguaje intermedio entre

Elaborar diagrama de flujo, prueba de datos y programa Fin

1. Sumar dos números usar visual logic

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,

LENGUAJE DE PROGRAMACION VISUAL BASIC DE VISUAL ESTUDIO 2015

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

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

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

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

Control Propiedad Valor

4. Agregue el siguiente código

Public Class Form1

Private Sub BtnResta_Click(ByVal sender As System.Object, ByVal e As

6.Ejecute el programa y vera el siguiente resultado

Manejo de varios controles con un solo procedimiento

Public Class Form1